w:id d Z ddlmZ ddlZddlmZ ddlZddlmZm Z m
Z
ddl m Z m
Z
g dZdZ G d d
e Z G d d e Zej Zej Zej Zej Zej Zej Zej Zej Zej Z ej Z ej Z d
Z G d de Z! G d de
Z" ddl#m"Z" n # e$$ r Y nw xY we"j% Z%d Z& G d de Z' e'd Z( G d de
Z)dS )z#Core classes for markup processing. )reduceN)chain)
stringrepr string_types text_type)
stripentities striptags)StreamMarkupescapeunescapeAttrs NamespaceQNamezrestructuredtext enc e Zd ZdZg Zi Zd ZdS )StreamEventKindz#A kind of event on a markup stream.c j | j |t | | S N)
_instances
setdefaultstr__new__)clsvals C/var/www/html/trac/venv/lib/python3.11/site-packages/genshi/core.pyr zStreamEventKind.__new__" s( ~((ckk#s.C.CDDD N)__name__
__module__ __qualname____doc__ __slots__r r r r r r s8 --IJE E E E Er r c P e Zd ZdZddgZ ed Z ed Z ed Z ed Z ed Z
ed Z ed
Z ed Z
ed Z ed
Z ed ZddZd Zd Zd Zd dZd dZd dZd Zd Zd 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 " || _ || _ 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% s r __init__zStream.__init__H s $r c * t | j S r )iterr$ r2 s r __iter__zStream.__iter__T s DK r c Z t t || | j S )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% )r2 functions r __or__z
Stream.__or__W s* X ghhtnn--$/JJJJr c > t t j | f|z 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_)r2 filterss r filterz
Stream.filter s ( hlTGg$5666r c ` ddl m} | | j pd} | j dd|i|} ||||| S )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)rD encodingoutr" )
genshi.outputrB r% serialize)r2 rD rE rF kwargsrB generators r renderz
Stream.render s\ . )((((( >_-F"DN;;&;F;; visKKKKr c N 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.pathrM select)r2 path
namespaces variablesrM s r rO z
Stream.select s7 B %$$$$$tDzz z9===r rC c b ddl m} | | j pd} ||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_serializerNrC )rG rT r% r9 )r2 rD rI rT s r rH zStream.serialize sO ( 100000 >_-F/~~f////
>>>r c * | S r rK r6 s r __str__zStream.__str__ s {{}} r c . | d S )N)rE rV r6 s r __unicode__zStream.__unicode__ s {{D{)))r c | S r r" r6 s r __html__zStream.__html__ s r r )NNN)NN)rC )r r r r r! r r& r' r( r) r* r+ r, r- r. r/ r0 r3 r7 r; r@ rK rO rH rW rY r[ r" r r r
r
& s & <(I OG $ $E
/%
C ?6 " "D z**H oi((G z**H
_X
&
&F!/-00K ,,I B oi((G
%
%
%
%! ! !,K ,K ,K\7 7 7,L L L L:"> "> "> ">H? ? ? ?2 * * * r r
c # K t | } t | }n# t $ r Y dS w xY wt | t ust | dk rVt
|g| D ]B}t |d r| }nt t | df}|V CdS |V | D ]}|V dS )z@Ensure that every item on the stream is actually a markup event.N totupleNr` ) r5 next
StopIterationtypetuplelenr hasattrr^ r( r )streamevents r r9 r9 s
&\\FV
E{{% 3u::??E7F++ Eui((
?
i . .>KKKK KKK s #
11c H e Zd ZdZg Zd Zd Zd Zd Zd Z d Z
d d Z d
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 ( | D ]\ }}||k r dS dS )zReturn whether the list includes an attribute with the specified
name.
:return: `True` if the list includes the attribute
:rtype: `bool`
TFr" )r2 nameattr_s r __contains__zAttrs.__contains__\ s1 GD!t||tt ur c t | | }t | t u 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')])
)rd __getitem__rc slicer )r2 iitemss r rp zAttrs.__getitem__h s; !!$** 77e << r c T t t | || S )zReturn a slice of the attributes list.
>>> attrs = Attrs([('href', '#'), ('title', 'Foo')])
>>> attrs[1:]
Attrs([('title', 'Foo')])
)r rd __getslice__)r2 rr js r ru zAttrs.__getslice__v s$ U''a33444r c t d |D t fd|D t fd D fd|D z 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 g | ] \ }}||
S r r" ).0anavs r
z Attrs.__or__.. s ;;;VR
b
r c * g | ]\ }}|v | ||fS r r" )ry rz r{ r2 s r r| z Attrs.__or__.. s5 : : :VR ::". R*8..r c N g | ]!\ }}|v | || f"S r" )get)ry snsvremovereplaces r r| z Attrs.__or__.. sD + + +FB6)) 7;;r2../)))r c . g | ]\ }}|v |v
||fS r" r" )ry rz r{ r r2 s r r| z Attrs.__or__.. s= > > >62r4 Bf,<,< 2h,<,<, > > > >U > > >> ? ? ?r c N | sdS dd d | D z S )NzAttrs()z Attrs([%s])z, c , g | ]}t | S r" )repr)ry items r r| z"Attrs.__repr__.. s )F)F)F$t**)F)F)Fr )joinr6 s r __repr__zAttrs.__repr__ s5 9 tyy)F)F)F)F)F G GGGr c j t t rft fd| 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 & g | ]
\ }}|v ||fS r" r" )ry rk r namess r r| z!Attrs.__sub__.. s+ MMMidC4u;L;LtSk;L;L;Lr )
isinstancer r )r2 r s `r __sub__z
Attrs.__sub__ sA e\ * * HEMMMM4MMMNNNr Nc * | D ]\ }}||k r|c S |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" )r2 rk defaultrl values r r z Attrs.get s3 KD%t|| r c P t d d | 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 g | ]
}|d S ) r" )ry xs r r| z!Attrs.totuple.. s 1 1 1qad 1 1 1r r_ )r( r r6 s r r^ z
Attrs.totuple s, RWW 1 1D 1 1 122NBBr r )
r r r r r! rn rp ru r; r r r r^ r" r r r r & s 2 2f I
5 5 5? ? ? H H H
O
O
O
C C C C Cr r c l e Zd ZdZg Zd Zd Zd Zd ZeZ d Z
ddZ e dd Z
d
Zdd Zd
ZdS )r zeMarks a string as being safe for inclusion in HTML/XML output without
needing to be escaped.
c ` t t j | t | S r r r __add__r r2 others r r zMarkup.__add__ s# i'fUmm<<===r c ` t t j t | | S r r r s r __radd__zMarkup.__radd__ s# i'u
t<<===r c
t |t rUt t | t t
| }nNt |t t f r#t t t
| }nt | }t t j | | S r ) r r zipkeysmapr valueslistrd r r __mod__)r2 argss r r zMarkup.__mod__ s dD ! ! DIIKKVT[[]])C)CDDEEDD
tUm
,
, VT**++DD$<)rc r r r r6 s r r zMarkup.__repr__ s/ JJ / / /1CD1I1I1I1IJJr Tc d fd|D }t t j | | 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 2 g | ]}t | S ))quotes)r )ry r
escape_quotess r r| z Markup.join.. s& LLL];;;LLLr )r r r )r2 seqr
escaped_itemss ` r r z Markup.join s9 MLLLLLL
inT=99:::r c \ |s
| S t | | u r|S t |d r | | S | dd dd dd }|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`
r[ &&r <r >"")rc rf r[ r )r textr s r r z
Markup.escape s * 355L :: K 4 $ $ (3t}}'' '||C))GC((GC((
.<<W--Ds4yyr c | sdS t | dd dd dd dd 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 )r r r6 s r r
zMarkup.unescape s\ 2&&w44 &wvs 3 3 &wvs 3 3 &ww 4 4 5r Fc > t t | | S )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 )r2 r s r r zMarkup.stripentities s mD/JJJKKKr c : 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 r6 s r r zMarkup.striptags. s ioo&&&r N)T)F)r r r r r! r r r r __rmul__r r classmethodr r
r r r" r r r r s I> > >> > >5 5 54 4 4HK K K; ; ; ;$ [ D5 5 5" L L L L ' ' ' ' 'r r )r c X t | t s| 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 s r r
r
A s) dF # # ==??r c e Zd ZdZd Zd Zd Zd Zd Zd Z d Z
d Z d
Z e Z
d Zej d d
k rd Znd Zd Zd ZdS )r a 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
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 \ t | | u r|S t | S r )rc objectr )r uris r r zNamespace.__new__~ s* 99 J~~c"""r c | j fS r r r6 s r __getnewargs__zNamespace.__getnewargs__ s {r c | j S r r r6 s r __getstate__zNamespace.__getstate__ xr c || _ d S r r r2 r s r __setstate__zNamespace.__setstate__ s
r c . t | | _ d S r )r r r s r r3 zNamespace.__init__ s S>>r c " |j | j k S r ) namespacer )r2 qnames r rn zNamespace.__contains__ s $(**r c | |k S r r" r s r __ne__zNamespace.__ne__ s 5= r c b t |t r| j |j k S | j |k S r )r r r r s r __eq__zNamespace.__eq__ s0 eY ' ' )8uy( (x5 r c 6 t | j dz |z S )N})r r )r2 rk s r rp zNamespace.__getitem__ s TX^d*+++r c * t | j S r )hashr r6 s r __hash__zNamespace.__hash__ s DH~~ r r c Z t | j dt | j dS N())rc r r r r6 s r r zNamespace.__repr__ s, #Dzz 2 2 2Jtx4H4H4H4HI Ir c @ t | j d| j dS r )rc r r r6 s r r zNamespace.__repr__ s" #Dzz 2 2 2DHHH= =r c 6 | j d S )Nzutf-8)r rB r6 s r rW zNamespace.__str__ s xw'''r c | j S r r r6 s r rY zNamespace.__unicode__ r r N)r r r r r r r r r3 rn r r rp __getattr__r sys version_infor rW rY r" r r r r V s & &N# # #
" " "+ + +! ! !! ! !
, , , K a J J J J > > >( ( ( r r z$http://www.w3.org/XML/1998/namespacec X e Zd ZdZddgZd Zd Zej d dk rd Z d
S 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 t | | u r|S | d }| dd }t | dk r;t j | d|z }t
t | \ |_ |_ n1t j | | }dt | c|_ |_ |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) rc lstripsplitre r r r r r )r r partsr2 s r r z
QName.__new__ s ;;# L S!! C## u::>> $S%%-88D-0E-B-B *DNDNN $S%00D-19U3C3C *DNDN r c . | d fS )Nr )r r6 s r r zQName.__getnewargs__ s C ""r r r c v t | j dt | d dS Nr r r )rc r r r r6 s r r zQName.__repr__ s6 #Dzz 2 2 2Jt{{3?O?O4P4P4P4PQ Qr c \ t | j d| d dS r )rc r r r6 s r r zQName.__repr__ s. #Dzz 2 2 2DKK4D4D4D4DE Er N)
r r r r r! r r r r r r" r r r r s , k*I (# # # a R R R R R F F F F Fr r )*r functoolsr r itertoolsr r=
genshi.compatr r r genshi.utilr r __all__
__docformat__r r r r
r& r' r( r) r* r+ r, r- r. r/ r0 r9 rd r r genshi._speedups ImportErrorr r
r
XML_NAMESPACEr r" r r r s * )
= = = = = = = = = = 0 0 0 0 0 0 0 0 %
E E E E Ec E E EV V V V VV V V Vr j
{ ?
. ? Y
. 4UC UC UC UC UCE UC UC UCpw' w' w' w' w'Y w' w' w't ''''''' D
*W W W W W W W Wv @AA
6F 6F 6F 6F 6FI 6F 6F 6F 6F 6Fs 8B? ?CC