genshi/mirror: genshi/core.py comparison

comparison genshi/core.py @ 958:6fc92535c888 experimental-performance-improvement-exploration

Be more careful about what is passed into streams as events and remove many uses of _ensure as a result. An ATTRS event is added for handling Attributes returned by gensh.path.select().

author	hodgestar
date	Tue, 13 Mar 2012 03:03:02 +0000
parents	417787b9b9a7
children

comparison

equal deleted inserted replaced

-:51ab60299647
+:6fc92535c888
 >>> print(html | sanitizer)
 <p>Hello, world!</p>
 Filters can be any function that accepts and produces a stream (where
 a stream is anything that iterates over events):
 >>> def uppercase(stream):
 ...     for kind, data, pos in stream:
 ...         if kind is TEXT:
 ...             data = data.upper()
 ...         yield kind, data, pos
 :param function: the callable object that should be applied as a filter
 :return: the filtered stream
 :rtype: `Stream`
 """
-return Stream(_ensure(function(self)), serializer=self.serializer)
+# TODO: this is horribly slow because is has to guess whether
+#       the function passed in is something that produces stream
+#       events or something that produces a sequence of strings.
+#       Sequences of strings are converted back to a sequence of
+#       stream events (and then back to text when rendered).
+events = _possible_text_iterator_to_stream(function(self))
+return Stream(events, serializer=self.serializer)
 def filter(self, *filters):
 """Apply filters to the stream.
 This method returns a new stream with the given filters applied. The
 :see: XMLSerializer, XHTMLSerializer, HTMLSerializer, TextSerializer
 """
 from genshi.output import get_serializer
 if method is None:
 method = self.serializer or 'xml'
-return get_serializer(method, **kwargs)(_ensure(self))
+return get_serializer(method, **kwargs)(self)
 def __str__(self):
 return self.render()
 def __unicode__(self):
 END_CDATA = Stream.END_CDATA
 PI = Stream.PI
 COMMENT = Stream.COMMENT
-def _ensure(stream):
+def _text_event(text):
-"""Ensure that every item on the stream is actually a markup event."""
+return (TEXT, unicode(text), (None, -1, -1))
-stream = iter(stream)
-event = stream.next()
+def _text_to_stream(text):
+yield _text_event(text)
+def _possible_text_iterator_to_stream(textiter_or_stream):
+it = iter(textiter_or_stream)
+event = it.next()
 # Check whether the iterable is a real markup event stream by examining the
 # first item it yields; if it's not we'll need to do some conversion
-if type(event) is not tuple or len(event) != 3:
+if type(event) is not tuple:
-for event in chain([event], stream):
+yield TEXT, unicode(event), (None, -1, -1)
-if hasattr(event, 'totuple'):
+for event in it:
-event = event.totuple()
+yield TEXT, unicode(event), (None, -1, -1)
-else:
-event = TEXT, unicode(event), (None, -1, -1)
-yield event
 return
 # This looks like a markup event stream, so we'll just pass it through
 # unchanged
 yield event
-for event in stream:
+for event in it:
 yield event
 class Attrs(tuple):
 """Immutable sequence type that stores the attributes of an element.
 >>> attrs | [('href', 'http://example.org/')]
 Attrs([('href', 'http://example.org/')])
 """
 __slots__ = []
+ATTRS = StreamEventKind('ATTRS')
 def __contains__(self, name):
 """Return whether the list includes an attribute with the specified
 name.
 for attr, value in self:
 if attr == name:
 return value
 return default
-def totuple(self):
+def toevent(self):
 """Return the attributes as a markup event.
-The returned event is a `TEXT` event, the data is the value of all
+The returned event is an `ATTRS` event, the data is the Attr object.
-attributes joined together.
+>>> a = Attrs([('href', '#'), ('title', 'Foo')])
->>> Attrs([('href', '#'), ('title', 'Foo')]).totuple()
+>>> a.toevent()
-('TEXT', '#Foo', (None, -1, -1))
+('ATTRS', Attrs([('href', '#'), ('title', 'Foo')]), (None, -1, -1))
-:return: a `TEXT` event
+:return: an `ATTR` event
 :rtype: `tuple`
 """
-return TEXT, ''.join([x[1] for x in self]), (None, -1, -1)
+return self.ATTRS, self, (None, -1, -1)
+def concatenate_values(self):
+"""Return the values of the attributes concatenated into a string.
+>>> a = Attrs([('href', '#'), ('title', 'Foo')])
+>>> a.concatenate_values()
+'#Foo'
+:return: the concatenated attribute values
+:rtype: `str`
+"""
+return ''.join([x[1] for x in self])
+ATTRS = Attrs.ATTRS
 class Markup(unicode):
 """Marks a string as being safe for inclusion in HTML/XML output without
 needing to be escaped.

Mercurial > genshi > mirror

comparison genshi/core.py @ 958:6fc92535c888 experimental-performance-improvement-exploration