Ñò
ûãtHc
@ s› d Z d d k l Z d d k Z d d k l Z l Z l Z d d d d d d
d g Z d Z d
e
f d „ ƒ YZ d e f d „ ƒ YZ
e
i Z e
i Z e
i Z e
i Z e
i Z e
i Z e
i Z e
i Z e
i Z e
i Z e
i Z d „ Z d e f d „ ƒ YZ d e f d „ ƒ YZ y d d k l Z Wn e j
o n Xe i Z d „ Z! d
e f d „ ƒ YZ" e" d ƒ Z# d e f d „ ƒ YZ$ d S( s# Core classes for markup processing.iÿÿÿÿ( t chainN( t plaintextt
stripentitiest striptagst Streamt Markupt escapet unescapet Attrst Namespacet QNames restructuredtext ent StreamEventKindc B s# e Z d Z g Z h Z d „ Z RS( s# A kind of event on a markup stream.c C s | i i | t i | | ƒ ƒ S( N( t
_instancest
setdefaultt strt __new__( t clst val( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR s ( t __name__t
__module__t __doc__t __slots__R R ( ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR s c B s
e Z d Z d d g Z e d ƒ Z e d ƒ Z e d ƒ Z e d ƒ Z e d ƒ Z e d ƒ Z
e d ƒ Z e d
ƒ Z e d ƒ Z
e d ƒ Z e d
ƒ Z d d „ Z d „ Z d „ Z d „ Z d d d d „ Z d d d „ Z d d „ Z d „ Z d „ Z d „ Z RS( s. Represents a stream of markup events.
This class is basically an iterator over the events.
Stream events are tuples of the form::
(kind, data, position)
where ``kind`` is the event kind (such as `START`, `END`, `TEXT`, etc),
``data`` depends on the kind of event, and ``position`` is a
``(filename, line, offset)`` tuple that contains the location of the
original element or text in the input. If the original location is unknown,
``position`` is ``(None, -1, -1)``.
Also provided are ways to serialize the stream to text. The `serialize()`
method will return an iterator over generated strings, while `render()`
returns the complete generated text at once. Both accept various parameters
that impact the way the stream is serialized.
t eventst
serializert STARTt ENDt TEXTt XML_DECLt DOCTYPEt START_NSt END_NSt START_CDATAt END_CDATAt PIt COMMENTc C s | | _ | | _ d S( s: Initialize the stream with a sequence of markup events.
:param events: a sequence or iterable providing the events
:param serializer: the default serialization method to use for this
stream
:note: Changed in 0.5: added the `serializer` argument
N( R R ( t selfR R ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __init__E s c C s
t | i ƒ S( N( t iterR ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __iter__Q s c C s t t | | ƒ ƒ d | i ƒS( s° Override the "bitwise or" operator to apply filters or serializers
to the stream, providing a syntax similar to pipes on Unix shells.
Assume the following stream produced by the `HTML` function:
>>> from genshi.input import HTML
>>> html = HTML('''Hello, world!
''')
>>> print html
Hello, world!
A filter such as the HTML sanitizer can be applied to that stream using
the pipe notation as follows:
>>> from genshi.filters import HTMLSanitizer
>>> sanitizer = HTMLSanitizer()
>>> print html | sanitizer
Hello, world!
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
>>> print html | sanitizer | uppercase
HELLO, WORLD!
Serializers can also be used with this notation:
>>> from genshi.output import TextSerializer
>>> output = TextSerializer()
>>> print html | sanitizer | uppercase | output
HELLO, WORLD!
Commonly, serializers should be used at the end of the "pipeline";
using them somewhere in the middle may produce unexpected results.
:param function: the callable object that should be applied as a filter
:return: the filtered stream
:rtype: `Stream`
R ( R t _ensureR ( R# t function( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __or__T s ,c G s t t i | f | ƒ S( sL Apply filters to the stream.
This method returns a new stream with the given filters applied. The
filters must be callables that accept the stream object as parameter,
and return the filtered stream.
The call::
stream.filter(filter1, filter2)
is equivalent to::
stream | filter1 | filter2
:param filters: one or more callable objects that should be applied as
filters
:return: the filtered stream
:rtype: `Stream`
( t reducet operatort or_( R# t filters( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt filter‚ s s utf-8c K sb d d k l } | d j o | i p d } n | i d | | } | | d | d | d | ƒS( sà Return a string representation of the stream.
Any additional keyword arguments are passed to the serializer, and thus
depend on the `method` parameter value.
:param method: determines how the stream is serialized; can be either
"xml", "xhtml", "html", "text", or a custom serializer
class; if `None`, the default serialization method of
the stream is used
:param encoding: how the output string should be encoded; if set to
`None`, this method returns a `unicode` object
:param out: a file-like object that the output should be written to
instead of being returned as one big string; note that if
this is a file or socket (or similar), the `encoding` must
not be `None` (that is, the output must be encoded)
:return: a `str` or `unicode` object (depending on the `encoding`
parameter), or `None` if the `out` parameter is provided
:rtype: `basestring`
:see: XMLSerializer, XHTMLSerializer, HTMLSerializer, TextSerializer
:note: Changed in 0.5: added the `out` parameter
iÿÿÿÿ( t encodet xmlt methodt encodingt outN( t
genshi.outputR/ t NoneR t serialize( R# R1 R2 R3 t kwargsR/ t generator( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt render˜ s
c C s) d d k l } | | ƒ i | | | ƒ S( s> Return a new stream that contains the events matching the given
XPath expression.
>>> from genshi import HTML
>>> stream = HTML('foobar')
>>> print stream.select('elem')
foobar
>>> print stream.select('elem/text()')
foobar
Note that the outermost element of the stream becomes the *context
node* for the XPath test. That means that the expression "doc" would
not match anything in the example above, because it only tests against
child elements of the outermost element:
>>> print stream.select('doc')
You can use the "." expression to match the context node itself
(although that usually makes little sense):
>>> print stream.select('.')
foobar
:param path: a string containing the XPath expression
:param namespaces: mapping of namespace prefixes used in the path
:param variables: mapping of variable names to values
:return: the selected substream
:rtype: `Stream`
:raises PathSyntaxError: if the given path expression is invalid or not
supported
iÿÿÿÿ( t Path( t genshi.pathR: t select( R# t patht
namespacest variablesR: ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR< µ s !R0 c K sJ d d k l } | d j o | i p d } n | | | t | ƒ ƒ S( s² Generate strings corresponding to a specific serialization of the
stream.
Unlike the `render()` method, this method is a generator that returns
the serialized output incrementally, as opposed to returning a single
string.
Any additional keyword arguments are passed to the serializer, and thus
depend on the `method` parameter value.
:param method: determines how the stream is serialized; can be either
"xml", "xhtml", "html", "text", or a custom serializer
class; if `None`, the default serialization method of
the stream is used
:return: an iterator over the serialization results (`Markup` or
`unicode` objects, depending on the serialization method)
:rtype: ``iterator``
:see: XMLSerializer, XHTMLSerializer, HTMLSerializer, TextSerializer
iÿÿÿÿ( t get_serializerR0 N( R4 R@ R5 R R' ( R# R1 R7 R@ ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR6 Ù s
c C s
| i ƒ S( N( R9 ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __str__ò s c C s | i d d ƒ S( NR2 ( R9 R5 ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __unicode__õ s c C s | S( N( ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __html__ø s N( R R R R R R R R R R R R R R R! R" R5 R$ R& R) R. R9 R< R6 RA RB RC ( ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR # s. . $ c c s¹ t | ƒ } | i ƒ } t | ƒ t j p t | ƒ d j o\ xT t | g | ƒ D]@ } t | d ƒ o | i ƒ } n t t | ƒ d f } | VqQ Wd S| Vx | D] } | Vq¦ Wd S( s@ Ensure that every item on the stream is actually a markup event.i t totupleiÿÿÿÿN( Niÿÿÿÿiÿÿÿÿ( R% t nextt typet tuplet lenR t hasattrRD R t unicodeR5 ( t streamt event( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR' s & c B sV e Z d Z g Z d „ Z d „ Z d „ Z d „ Z d „ Z d d „ Z
d „ Z RS( s? Immutable sequence type that stores the attributes of an element.
Ordering of the attributes is preserved, while access by name is also
supported.
>>> attrs = Attrs([('href', '#'), ('title', 'Foo')])
>>> attrs
Attrs([('href', '#'), ('title', 'Foo')])
>>> 'href' in attrs
True
>>> 'tabindex' in attrs
False
>>> attrs.get('title')
'Foo'
Instances may not be manipulated directly. Instead, the operators ``|`` and
``-`` can be used to produce new instances that have specific attributes
added, replaced or removed.
To remove an attribute, use the ``-`` operator. The right hand side can be
either a string or a set/sequence of strings, identifying the name(s) of
the attribute(s) to remove:
>>> attrs - 'title'
Attrs([('href', '#')])
>>> attrs - ('title', 'href')
Attrs()
The original instance is not modified, but the operator can of course be
used with an assignment:
>>> attrs
Attrs([('href', '#'), ('title', 'Foo')])
>>> attrs -= 'title'
>>> attrs
Attrs([('href', '#')])
To add a new attribute, use the ``|`` operator, where the right hand value
is a sequence of ``(name, value)`` tuples (which includes `Attrs`
instances):
>>> attrs | [('title', 'Bar')]
Attrs([('href', '#'), ('title', 'Bar')])
If the attributes already contain an attribute with a given name, the value
of that attribute is replaced:
>>> attrs | [('href', 'http://example.org/')]
Attrs([('href', 'http://example.org/')])
c C s- x& | D] \ } } | | j o t Sq Wd S( s² Return whether the list includes an attribute with the specified
name.
:return: `True` if the list includes the attribute
:rtype: `bool`
N( t True( R# t namet attrt _( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __contains__U s
c C s t t i | | | ƒ ƒ S( s Return a slice of the attributes list.
>>> attrs = Attrs([('href', '#'), ('title', 'Foo')])
>>> attrs[1:]
Attrs([('title', 'Foo')])
( R RG t __getslice__( R# t it j( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyRR ` s c
C s½ t g } | D]* \ } } | | j o | | | f q q ~ ƒ } t g } | D]% \ } } | | | i | | ƒ f qR ~ g } | D]* \ } } | | j o | | | f qˆ qˆ ~ ƒ S( sÚ Return a new instance that contains the attributes in `attrs` in
addition to any already existing attributes.
:return: a new instance with the merged attributes
:rtype: `Attrs`
( t dictR t get(
R# t attrst _[1]t ant avt replt _[2]t snt svt _[3]( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR) i s D9c C s> | p d Sd d i g } | D] } | t | ƒ q ~ ƒ S( Ns Attrs()s Attrs([%s])s , ( t joint repr( R# RX t item( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __repr__t s c C s_ t | t ƒ o
| f } n t g } | D]* \ } } | | j o | | | f q+ q+ ~ ƒ S( sö Return a new instance with all attributes with a name in `names` are
removed.
:param names: the names of the attributes to remove
:return: a new instance with the attribute removed
:rtype: `Attrs`
( t
isinstancet
basestringR ( R# t namesRX RN R ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __sub__y s
c C s- x& | D] \ } } | | j o | Sq W| S( s Return the value of the attribute with the specified name, or the
value of the `default` parameter if no such attribute is found.
:param name: the name of the attribute
:param default: the value to return when the attribute does not exist
:return: the attribute value, or the `default` value if that attribute
does not exist
:rtype: `object`
( ( R# RN t defaultRO t value( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyRV … s
c C s5 t d i g } | D] } | | d q ~ ƒ d f S( s\ Return the attributes as a markup event.
The returned event is a `TEXT` event, the data is the value of all
attributes joined together.
>>> Attrs([('href', '#'), ('title', 'Foo')]).totuple()
('TEXT', u'#Foo', (None, -1, -1))
:return: a `TEXT` event
:rtype: `tuple`
u i iÿÿÿÿN( Niÿÿÿÿiÿÿÿÿ( R R` R5 ( R# RX t x( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyRD ” s N( R R R R RQ RR R) Rc Rg R5 RV RD ( ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR s 3 c B sŒ e Z d Z g Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z e
d „ Z e
d „ Z e
e ƒ Z d „ Z e d
„ Z d „ Z RS( se Marks a string as being safe for inclusion in HTML/XML output without
needing to be escaped.
c C s t t | ƒ t t | ƒ ƒ ƒ S( N( R RJ R ( R# t other( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __add__© s c C s t t t | ƒ ƒ t | ƒ ƒ S( N( R RJ R ( R# Rk ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __radd__¬ s c C s t | t ƒ o. t t | i ƒ t t | i ƒ ƒ ƒ ƒ } n< t | t t f ƒ o t t t | ƒ ƒ } n
t | ƒ } t t
i | | ƒ ƒ S( N( Rd RU t zipt keyst mapR t valuest listRG R RJ t __mod__( R# t args( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyRs ¯ s . c C s t t | ƒ | ƒ S( N( R RJ ( R# t num( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __mul__¸ s c C s t | t | ƒ ƒ S( N( R RJ ( R# Ru ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __rmul__» s c C s d | i i t | ƒ f S( Ns <%s %r>( t __class__R RJ ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyRc ¾ s c C s@ t t | ƒ i g } | D] } | t | d | ƒq ~ ƒ ƒ S( sA Return a `Markup` object which is the concatenation of the strings
in the given sequence, where this `Markup` object is the separator
between the joined elements.
Any element in the sequence that is not a `Markup` instance is
automatically escaped.
:param seq: the sequence of strings to join
:param escape_quotes: whether double quote characters in the elements
should be escaped
:return: the joined `Markup` object
:rtype: `Markup`
:see: `escape`
t quotes( R RJ R` R ( R# t seqt
escape_quotesRX Rb ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR` Á s c C sŸ | p | ƒ St | ƒ | j o | St | d ƒ o t | i ƒ ƒ St | ƒ i d d ƒ i d d ƒ i d d ƒ } | o | i d d ƒ } n | | ƒ S(
sæ Create a Markup instance from a string and escape special characters
it may contain (<, >, & and ").
>>> escape('"1 < 2"')
If the `quotes` parameter is set to `False`, the " character is left
as is. Escaping quotes is generally only required for strings that are
to be used in attribute values.
>>> escape('"1 < 2"', quotes=False)
:param text: the text to escape
:param quotes: if ``True``, double quote characters are escaped in
addition to the other special characters
:return: the escaped `Markup` string
:rtype: `Markup`
RC t &s &t s >t "s "( RF RI R RC RJ t replace( R t textRy ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR Ó s c C sF | p d St | ƒ i d d ƒ i d d ƒ i d d ƒ i d d ƒ S(
sù Reverse-escapes &, <, >, and " and returns a `unicode` object.
>>> Markup('1 < 2').unescape()
u'1 < 2'
:return: the unescaped string
:rtype: `unicode`
:see: `genshi.core.unescape`
u s "R s >R~ s <R} s &R| ( RJ R€ ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR ö s
c C s t t | d | ƒƒ S( sÑ Return a copy of the text with any character or numeric entities
replaced by the equivalent UTF-8 characters.
If the `keepxmlentities` parameter is provided and evaluates to `True`,
the core XML entities (``&``, ``'``, ``>``, ``<`` and
``"``) are not stripped.
:return: a `Markup` instance with entities removed
:rtype: `Markup`
:see: `genshi.util.stripentities`
t keepxmlentities( R R ( R# R‚ ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR s c C s t t | ƒ ƒ S( sÅ Return a copy of the text with all XML/HTML tags removed.
:return: a `Markup` instance with all tags removed
:rtype: `Markup`
:see: `genshi.util.striptags`
( R R ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR s ( R R R R Rl Rm Rs Rv Rw Rc RM R` R t classmethodR t FalseR R ( ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR £ s ! ( R c C s t | t ƒ p | S| i ƒ S( sp Reverse-escapes &, <, >, and " and returns a `unicode` object.
>>> unescape(Markup('1 < 2'))
u'1 < 2'
If the provided `text` object is not a `Markup` instance, it is returned
unchanged.
>>> unescape('1 < 2')
'1 < 2'
:param text: the text to unescape
:return: the unescsaped string
:rtype: `unicode`
( Rd R R ( R ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR & s c B s€ e Z d Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z
d „ Z e Z d
„ Z
d „ Z d „ Z RS(
sü Utility class creating and testing elements with a namespace.
Internally, namespace URIs are encoded in the `QName` of any element or
attribute, the namespace URI being enclosed in curly braces. This class
helps create and test these strings.
A `Namespace` object is instantiated with the namespace URI.
>>> html = Namespace('http://www.w3.org/1999/xhtml')
>>> html
>>> html.uri
u'http://www.w3.org/1999/xhtml'
The `Namespace` object can than be used to generate `QName` objects with
that namespace:
>>> html.body
QName(u'http://www.w3.org/1999/xhtml}body')
>>> html.body.localname
u'body'
>>> html.body.namespace
u'http://www.w3.org/1999/xhtml'
The same works using item access notation, which is useful for element or
attribute names that are not valid Python identifiers:
>>> html['body']
QName(u'http://www.w3.org/1999/xhtml}body')
A `Namespace` object can also be used to test whether a specific `QName`
belongs to that namespace using the ``in`` operator:
>>> qname = html.body
>>> qname in html
True
>>> qname in Namespace('http://www.w3.org/2002/06/xhtml2')
False
c C s% t | ƒ | j o | St i | ƒ S( N( RF t objectR ( R t uri( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR c s c C s
| i f S( N( R† ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __getnewargs__h s c C s | i S( N( R† ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __getstate__k s c C s
| | _ d S( N( R† ( R# R† ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __setstate__n s c C s t | ƒ | _ d S( N( RJ R† ( R# R† ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR$ q s c C s | i | i j S( N( t namespaceR† ( R# t qname( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyRQ t s c C s | | j S( N( ( R# Rk ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __ne__w s c C s. t | t ƒ o | i | i j S| i | j S( N( Rd R R† ( R# Rk ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __eq__z s c C s t | i d | ƒ S( Nu }( R
R† ( R# RN ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt __getitem__ s c C s d | i S( Ns ( R† ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyRc ƒ s c C s | i i d ƒ S( Ns utf-8( R† R/ ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyRA † s c C s | i S( N( R† ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyRB ‰ s ( R R R R R‡ Rˆ R‰ R$ RQ RŒ R RŽ t __getattr__Rc RA RB ( ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR ; s ' s$ http://www.w3.org/XML/1998/namespacec B s5 e Z d Z d d g Z d „ Z d „ Z d „ Z RS( sÄ A qualified element or attribute name.
The unicode value of instances of this class contains the qualified name of
the element or attribute, in the form ``{namespace-uri}local-name``. The
namespace URI can be obtained through the additional `namespace` attribute,
while the local name can be accessed through the `localname` attribute.
>>> qname = QName('foo')
>>> qname
QName(u'foo')
>>> qname.localname
u'foo'
>>> qname.namespace
>>> qname = QName('http://www.w3.org/1999/xhtml}body')
>>> qname
QName(u'http://www.w3.org/1999/xhtml}body')
>>> qname.localname
u'body'
>>> qname.namespace
u'http://www.w3.org/1999/xhtml'
RŠ t localnamec C sª t | ƒ | j o | S| i d ƒ i d d ƒ } t | ƒ d j o5 t i | d | ƒ } t t | ƒ \ | _ | _ n, t i | | ƒ } d t | ƒ | _ | _ | S( sä Create the `QName` instance.
:param qname: the qualified name as a string of the form
``{namespace-uri}local-name``, where the leading curly
brace is optional
u {u }i u {%sN(
RF t lstript splitRH RJ R Rp RŠ R R5 ( R R‹ t partsR# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR ª s c C s | i d ƒ f S( Nt {( R‘ ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR‡ ½ s c C s d t i | i d ƒ ƒ S( Ns QName(%s)R” ( RJ Rc R‘ ( R# ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyRc À s ( R R R R R R‡ Rc ( ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyR
‘ s
(% R t itertoolsR R+ t genshi.utilR R R t __all__t
__docformat__R R R… R R R R R R R R R R R! R" R' RG R RJ R t genshi._speedupst ImportErrorR R R t
XML_NAMESPACER
( ( ( s1 /usr/lib64/python2.6/site-packages/genshi/core.pyt s> Ù „| S