o
!bd @ sH d Z ddlmZ ddlZddlmZ ddlZddlZddlm Z ddl
m Z m Z g dZ
dZG d d
d
eZG d d d eZejZejZejZejZejZejZejZejZejZej Z ej Z d
d Z G dd de Z G dd dej!Z"zddl#m"Z" W n e$y Y nw e"j%Z%dd Z&G dd deZ'e'dZ(G dd dej!Z)dS )z#Core classes for markup processing. )reduceN)chain)
stringrepr)
stripentities striptags)StreamMarkupescapeunescapeAttrs NamespaceQNamezrestructuredtext enc @ s e Zd ZdZg Zi Zdd ZdS )StreamEventKindz#A kind of event on a markup stream.c C s | j |t| |S N)
_instances
setdefaultstr__new__)clsval r -/usr/lib/python3/dist-packages/genshi/core.pyr $ zStreamEventKind.__new__N)__name__
__module__ __qualname____doc__ __slots__r r r r r r r s
r c @ s e Zd ZdZddgZedZedZedZedZ edZ
ed Z ed
Z ed Z
ed Zed
ZedZd%ddZdd Zdd Zdd Zd&ddZd'ddZd(d d Zd d Zd!d" Zd#d$ ZdS ))r a. 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.
events
serializerSTARTENDTEXTXML_DECLDOCTYPESTART_NSEND_NS START_CDATA END_CDATAPICOMMENTNc C s || _ || _dS )a: 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 )selfr r r r r __init__J s
zStream.__init__c C
t | jS r )iterr r+ r r r __iter__V
zStream.__iter__c C s t t|| | jdS )a 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!
''', encoding='utf-8')
>>> 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 _ensurer )r+ functionr r r __or__Y s ,z
Stream.__or__c G s t tj| f| S )aL 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`
)r operatoror_)r+ filtersr r r filter s z
Stream.filterc K sB ddl m} |du r| jpd}| jdd|i|}|||||dS )a 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
r )encodeNxmlmethod)r; encodingoutr )
genshi.outputr9 r serialize)r+ r; r< r= kwargsr9 generatorr r r render s
z
Stream.renderc C s ddl m} ||| ||S )aT Return a new stream that contains the events matching the given
XPath expression.
>>> from genshi import HTML
>>> stream = HTML('foobar', encoding='utf-8')
>>> 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
r )Path) genshi.pathrC select)r+ path
namespaces variablesrC r r r rE s !z
Stream.selectr: c K s6 ddl m} |du r| jpd}||fi |t| S )a 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
r )get_serializerNr: )r> rI r r2 )r+ r; r@ rI r r r r? s
zStream.serializec C s | S r rB r/ r r r __str__ zStream.__str__c C s | j d dS )N)r< rJ r/ r r r __unicode__ zStream.__unicode__c C s | S r r r/ r r r __html__ s zStream.__html__r )NNN)NN)r: )r r r r r r r r! r" r# r$ r% r& r' r( r) r* r, r0 r4 r8 rB rE r? rK rM rO r r r r r ( s0
.
$ r c c s t | } zt| }W n
ty Y dS w t|tus"t|dkrBt|g| D ]}t|dr4| }nt t
|df}|V q(dS |V | D ]}|V qGdS )z@Ensure that every item on the stream is actually a markup event.N totupleNrS ) r. next
StopIterationtypetuplelenr hasattrrQ r" six text_type)streameventr r r r2 s$
r2 c @ sV e Zd ZdZg Zdd Zdd Zdd Zdd Zd
d Z d d
Z
dddZ dd Z dS )r a? 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 | D ] \}}||kr
dS qdS )zReturn whether the list includes an attribute with the specified
name.
:return: `True` if the list includes the attribute
:rtype: `bool`
TFr )r+ nameattr_r r r __contains__^ s
zAttrs.__contains__c C s$ t | |}t|tu rt|S |S )zReturn an item or slice of the attributes list.
>>> attrs = Attrs([('href', '#'), ('title', 'Foo')])
>>> attrs[1]
('title', 'Foo')
>>> attrs[1:]
Attrs([('title', 'Foo')])
)rW __getitem__rV slicer )r+ iitemsr r r rb j s zAttrs.__getitem__c C s t t| ||S )zReturn a slice of the attributes list.
>>> attrs = Attrs([('href', '#'), ('title', 'Foo')])
>>> attrs[1:]
Attrs([('title', 'Foo')])
)r rW __getslice__)r+ rd jr r r rf x s zAttrs.__getslice__c sT t dd |D tfdd|D t fddD fdd|D S )a) Return a new instance that contains the attributes in `attrs` in
addition to any already existing attributes. Any attributes in the new
set that have a value of `None` are removed.
:return: a new instance with the merged attributes
:rtype: `Attrs`
c S s g | ]
\}}|d u r|qS r r .0anavr r r
s z Attrs.__or__..c s( g | ]\}}| v r|d ur||fqS r r rh r/ r r rl c s( g | ]\}}| vr| ||fqS r )get)ri snsv)removereplacer r rl s c s( g | ]\}}|vr| vr||fqS r r rh )rq r+ r r rl rm )setdictr )r+ attrsr )rq rr r+ r r4 s
z Attrs.__or__c C s | sdS dd dd | D S )NzAttrs()z Attrs([%s])z, c S s g | ]}t |qS r )reprri itemr r r rl z"Attrs.__repr__..)joinr/ r r r __repr__ s zAttrs.__repr__c s( t tjr f t fdd| D S )zReturn 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`
c s g | ] \}}| vr||fqS r r )ri r^ r namesr r rl s z!Attrs.__sub__..)
isinstancerZ string_typesr )r+ r} r r| r __sub__ s z
Attrs.__sub__Nc C s" | D ] \}}||kr| S q|S )a 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 )r+ r^ defaultr_ valuer r r rn s
z Attrs.getc C s t ddd | D dfS )a[ 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', '#Foo', (None, -1, -1))
:return: a `TEXT` event
:rtype: `tuple`
c S s g | ]}|d qS ) r )ri xr r r rl ry z!Attrs.totuple..rR )r" rz r/ r r r rQ s z
Attrs.totupler )
r r r r r ra rb rf r4 r{ r rn rQ r r r r r ( s 3
r c @ sr e Zd ZdZg Zdd Zdd Zdd Zdd ZeZ d
d Z
dd
dZ e dddZ
dd ZdddZdd ZdS )r zeMarks a string as being safe for inclusion in HTML/XML output without
needing to be escaped.
c C s t tj| t|S r r rZ r[ __add__r r+ otherr r r r r zMarkup.__add__c C s t tjt|| S r r r r r r __radd__ r zMarkup.__radd__c C s` t |trtt| tt| }nt |ttfr#ttt|}nt|}t t
j | |S r )
r~ rt zipkeysmapr valueslistrW r rZ r[ __mod__)r+ argsr r r r s
zMarkup.__mod__c C s t tj| |S r )r rZ r[ __mul__)r+ numr r r r zMarkup.__mul__c C s dt | jtj| f S )Nz<%s %s>)rV r rZ r[ r{ r/ r r r r{ s zMarkup.__repr__Tc s$ fdd|D }t tj| |S )aA 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`
c s g | ]}t | d qS ))quotes)r rw
escape_quotesr r rl s z Markup.join..)r rZ r[ rz )r+ seqr
escaped_itemsr r r rz s z Markup.joinc C sd |s| S t || u r
|S t|dr| | S |dddddd}|r.|dd }| |S )
a 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`
rO &&<<>>"")rV rY rO rr )r textr r r r r s
z
Markup.escapec C s2 | sdS t | dddddddd S )
zReverse-escapes &, <, >, and " and returns a `unicode` object.
>>> Markup('1 < 2').unescape()
'1 < 2'
:return: the unescaped string
:rtype: `unicode`
:see: `genshi.core.unescape`
r r r r r r r r r )rZ r[ rr r/ r r r r
s
zMarkup.unescapeFc C s t t| |dS )a 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`
)keepxmlentities)r r )r+ r r r r r " s zMarkup.stripentitiesc C s t t| S )zReturn 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/ r r r r 0 s zMarkup.striptagsN)T)F)r r r r r r r r r __rmul__r{ rz classmethodr r
r r r r r r r s
"
r )r c C s t | ts| S | S )ao Reverse-escapes &, <, >, and " and returns a `unicode` object.
>>> unescape(Markup('1 < 2'))
'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`
)r~ r r
)r r r r r
C s
r
c @ s e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd d
Z dd Z
dd Z dd Z e Z
dd Zejd dkr>> html = Namespace('http://www.w3.org/1999/xhtml')
>>> html
Namespace('http://www.w3.org/1999/xhtml')
>>> html.uri
'http://www.w3.org/1999/xhtml'
The `Namespace` object can than be used to generate `QName` objects with
that namespace:
>>> html.body
QName('http://www.w3.org/1999/xhtml}body')
>>> html.body.localname
'body'
>>> html.body.namespace
'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('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 || u r|S t| S r )rV objectr )r urir r r r s
zNamespace.__new__c C s | j fS r r r/ r r r __getnewargs__ rL zNamespace.__getnewargs__c C | j S r r r/ r r r __getstate__ zNamespace.__getstate__c C s
|| _ d S r r r+ r r r r __setstate__ r1 zNamespace.__setstate__c C s t || _d S r )rZ r[ r r r r r r, s zNamespace.__init__c C s |j | jkS r ) namespacer )r+ qnamer r r ra rN zNamespace.__contains__c C s
| |k S r r r r r r __ne__ r1 zNamespace.__ne__c C s t |tr | j|jkS | j|kS r )r~ r r r r r r __eq__ s
zNamespace.__eq__c C s t | jd | S )N})r
r )r+ r^ r r r rb r zNamespace.__getitem__c C r- r )hashr r/ r r r __hash__ r1 zNamespace.__hash__r c C s dt | jt| jf S )N%s(%s))rV r r r r/ r r r r{ zNamespace.__repr__c C s dt | j| jf S )N%s(%r))rV r r r/ r r r r{ s c C s | j dS )Nzutf-8)r r9 r/ r r r rK rN zNamespace.__str__c C r r r r/ r r r rM r zNamespace.__unicode__N)r r r r r r r r r, ra r r rb __getattr__r sys version_infor{ rK rM r r r r r X s$ '
r z$http://www.w3.org/XML/1998/namespacec @ sJ e Zd ZdZddgZdd Zdd Zejd d kr d
d Z d
S d d Z d
S )r
a 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('foo')
>>> qname.localname
'foo'
>>> qname.namespace
>>> qname = QName('http://www.w3.org/1999/xhtml}body')
>>> qname
QName('http://www.w3.org/1999/xhtml}body')
>>> qname.localname
'body'
>>> qname.namespace
'http://www.w3.org/1999/xhtml'
r localnamec C s t || u r|S |d}|dd}t|dkr.tj| d| }ttj|\|_|_ |S tj| |}dt||_|_ |S )zCreate 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
{r r z{%sN)
rV lstripsplitrX rZ r[ r r r r )r r partsr+ r r r r s
z
QName.__new__c C s | dfS )Nr )r r/ r r r r rN zQName.__getnewargs__r r c C s dt | jt| df S )Nr r )rV r r r r/ r r r r{ s zQName.__repr__c C s dt | j| df S )Nr r )rV r r r/ r r r r{ r N)
r r r r r r r r r r{ r r r r r
s r
)*r functoolsr r itertoolsr r5 rZ
genshi.compatr genshi.utilr r __all__
__docformat__r r r r r r! r" r# r$ r% r& r' r( r) r* r2 rW r r[ r genshi._speedups ImportErrorr r
r
XML_NAMESPACEr
r r r r sL
Z z [