B
$ @ sV d Z ddddddddd d
d d d
ddddddddddgZdZddlZddlZddlZddlZddlZddlZddl Z dd l
m Z G d d
d
e Z
d d ZG d d dZi fd dZdSd!dZdTd"d ZeZG d#d
d
ZG d$d dZe jd%d& ZdUd'd(Zd)d* Zd+Zy eeZW n e k
r* Y nX d,d- Z d.d/ Z ee e d0Z d1d Z d2d3d4d5d6d7d8d9Z!e!e _!d:d; Z"dd? Z$d@dA Z%dVdBdCdDdZ&G dEdF dFej'Z(dWdBdCdGdZ)dHd Z*dXdId Z+dYdJdZ,G dKd dZ-dZdLdZ.d[dMdZ/e.Z0d\dNdZ1G dOd dZ2dPgZ3G dQd dZ4yeZ5ddRl6T W n e7k
rP Y nX dS )]a Lightweight XML support for Python.
XML is an inherently hierarchical data format, and the most natural way to
represent it is with a tree. This module has two classes for this purpose:
1. ElementTree represents the whole XML document as a tree and
2. Element represents a single node in this tree.
Interactions with the whole document (reading and writing to/from files) are
usually done on the ElementTree level. Interactions with a single XML element
and its sub-elements are done on the Element level.
Element is a flexible container object designed to store hierarchical data
structures in memory. It can be described as a cross between a list and a
dictionary. Each Element has a number of properties associated with it:
'tag' - a string containing the element's name.
'attributes' - a Python dictionary storing the element's attributes.
'text' - a string containing the element's text content.
'tail' - an optional string containing text after the element's end tag.
And a number of child elements stored in a Python sequence.
To create an element instance, use the Element constructor,
or the SubElement factory function.
You can also use the ElementTree class to wrap an element structure
and convert it to and from XML.
CommentdumpElement ElementTree
fromstringfromstringlist iselement iterparseparse
ParseErrorPIProcessingInstructionQName
SubElementtostring tostringlist TreeBuilderVERSIONXMLXMLID XMLParser
XMLPullParserregister_namespacez1.3.0 N ) ElementPathc @ s e Zd ZdZdS )r
zAn error when parsing an XML document.
In addition to its exception value, a ParseError contains
two extra attributes:
'code' - the specific exception code
'position' - the line and column of the error
N)__name__
__module__ __qualname____doc__ r r :/opt/alt/python37/lib64/python3.7/xml/etree/ElementTree.pyr
i s c C s
t | dS )z2Return True if *element* appears to be an Element.tag)hasattr)elementr r r r w s c @ s
e Zd ZdZdZdZdZdZi fddZdd Z dd Z
d d
Z d d Z d
d Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Zd d Zd d Zd9d!d"Zd:d#d$Zd;d%d&Zdd3d4Z d?d5d6Z!d7d8 Z"dS )@r ah An XML element.
This class is the reference implementation of the Element interface.
An element's length is its number of subelements. That means if you
want to check if an element is truly empty, you should check BOTH
its length AND its text attribute.
The element tag, attribute names, and attribute values can be either
bytes or strings.
*tag* is the element name. *attrib* is an optional dictionary containing
element attributes. *extra* are additional element attributes given as
keyword arguments.
Example form:
text...tail
Nc K sD t |ts td|jjf | }|| || _|| _g | _ d S )Nzattrib must be dict, not %s)
isinstancedict TypeError __class__r copyupdater! attrib _children)selfr! r* extrar r r __init__ s
zElement.__init__c C s d| j j| jt| f S )Nz<%s %r at %#x>)r' r r! id)r, r r r __repr__ s zElement.__repr__c C s | ||S )zCreate a new element with the same type.
*tag* is a string containing the element name.
*attrib* is a dictionary containing the element attributes.
Do not call this method, use the SubElement factory function instead.
)r' )r, r! r* r r r makeelement s zElement.makeelementc C s0 | | j| j}| j|_| j|_| |dd< |S )zReturn copy of current element.
This creates a shallow copy. Subelements will be shared with the
original tree.
N)r1 r! r* texttail)r, elemr r r r( s
z Element.copyc C s
t | jS )N)lenr+ )r, r r r __len__ s zElement.__len__c C s t jdtdd t| jdkS )NzyThe behavior of this method will change in future versions. Use specific 'len(elem)' or 'elem is not None' test instead. )
stacklevelr )warningswarn
FutureWarningr5 r+ )r, r r r __bool__ s
zElement.__bool__c C s
| j | S )N)r+ )r, indexr r r __getitem__ s zElement.__getitem__c C s || j |< d S )N)r+ )r, r= r# r r r __setitem__ s zElement.__setitem__c C s | j |= d S )N)r+ )r, r= r r r __delitem__ s zElement.__delitem__c C s | | | j| dS )a Add *subelement* to the end of this element.
The new element will appear in document order after the last existing
subelement (or directly after the text, if it's the first subelement),
but before the end tag for this element.
N)_assert_is_elementr+ append)r,
subelementr r r rB s
zElement.appendc C s( x|D ]}| | qW | j| dS )zkAppend subelements from a sequence.
*elements* is a sequence with zero or more elements.
N)rA r+ extend)r, elementsr# r r r rD s
zElement.extendc C s | | | j|| dS )z(Insert *subelement* at position *index*.N)rA r+ insert)r, r= rC r r r rF s
zElement.insertc C s t |ts tdt|j d S )Nzexpected an Element, not %s)r$ _Element_Pyr& typer )r, er r r rA s
zElement._assert_is_elementc C s | j | dS )a Remove matching subelement.
Unlike the find methods, this method compares elements based on
identity, NOT ON tag value or contents. To remove subelements by
other means, the easiest way is to use a list comprehension to
select what elements to keep, and then use slice assignment to update
the parent element.
ValueError is raised if a matching element could not be found.
N)r+ remove)r, rC r r r rJ s
zElement.removec C s t jdtdd | jS )z`(Deprecated) Return all subelements.
Elements are returned in document order.
zaThis method will be removed in future versions. Use 'list(elem)' or iteration over elem instead.r7 )r8 )r9 r: DeprecationWarningr+ )r, r r r getchildren s
zElement.getchildrenc C s t | ||S )a Find first matching element by tag name or path.
*path* is a string having either an element tag or an XPath,
*namespaces* is an optional mapping from namespace prefix to full name.
Return the first matching element, or None if no element was found.
)r find)r, path
namespacesr r r rM " s z Element.findc C s t | |||S )a Find text for first matching element by tag name or path.
*path* is a string having either an element tag or an XPath,
*default* is the value to return if the element was not found,
*namespaces* is an optional mapping from namespace prefix to full name.
Return text content of first matching element, or default value if
none was found. Note that if an element is found having no text
content, the empty string is returned.
)r findtext)r, rN defaultrO r r r rP - s zElement.findtextc C s t | ||S )a Find all matching subelements by tag name or path.
*path* is a string having either an element tag or an XPath,
*namespaces* is an optional mapping from namespace prefix to full name.
Returns list containing all matching elements in document order.
)r findall)r, rN rO r r r rR ; s zElement.findallc C s t | ||S )a Find all matching subelements by tag name or path.
*path* is a string having either an element tag or an XPath,
*namespaces* is an optional mapping from namespace prefix to full name.
Return an iterable yielding all matching elements in document order.
)r iterfind)r, rN rO r r r rS F s zElement.iterfindc C s | j g | _d | _| _dS )zReset element.
This function removes all subelements, clears all attributes, and sets
the text and tail attributes to None.
N)r* clearr+ r2 r3 )r, r r r rT Q s
z
Element.clearc C s | j ||S )ag Get element attribute.
Equivalent to attrib.get, but some implementations may handle this a
bit more efficiently. *key* is what attribute to look for, and
*default* is what to return if the attribute was not found.
Returns a string containing the attribute value, or the default if
attribute was not found.
)r* get)r, keyrQ r r r rU \ s z Element.getc C s || j |< dS )zSet element attribute.
Equivalent to attrib[key] = value, but some implementations may handle
this a bit more efficiently. *key* is what attribute to set, and
*value* is the attribute value to set it to.
N)r* )r, rV valuer r r seti s z Element.setc C s
| j S )zGet list of attribute names.
Names are returned in an arbitrary order, just like an ordinary
Python dict. Equivalent to attrib.keys()
)r* keys)r, r r r rY s s z Element.keysc C s
| j S )zGet element attributes as a sequence.
The attributes are returned in arbitrary order. Equivalent to
attrib.items().
Return a list of (name, value) tuples.
)r* items)r, r r r rZ | s z
Element.itemsc c sH |dkr d}|dks | j |kr$| V x | jD ]}||E dH q,W dS )a Create tree iterator.
The iterator loops over the element and all subelements in document
order, returning all elements with a matching tag.
If the tree structure is modified during iteration, new or removed
elements may or may not be included. To get a stable set, use the
list() function on the iterator, and loop over the resulting list.
*tag* is what tags to look for (default is to return all elements)
Return an iterator containing all the matching elements.
*N)r! r+ iter)r, r! rI r r r r\ s z Element.iterc C s t jdtdd t| |S )NzbThis method will be removed in future versions. Use 'elem.iter()' or 'list(elem.iter())' instead.r7 )r8 )r9 r: PendingDeprecationWarninglistr\ )r, r! r r r getiterator s
zElement.getiteratorc c s\ | j }t|ts |dk r dS | j}|r,|V x*| D ]"}| E dH |j}|r2|V q2W dS )zCreate text iterator.
The iterator loops over the element and all subelements in document
order, returning all inner text.
N)r! r$ strr2 itertextr3 )r, r! trI r r r ra s
zElement.itertext)N)NN)N)N)N)N)N)#r r r r r! r* r2 r3 r. r0 r1 r( r6 r< r> r? r@ rB rD rF rA rJ rL rM rP rR rS rT rU rX rY rZ r\ r_ ra r r r r r | s@
c K s, | }|| | ||}| | |S )a Subelement factory which creates an element instance, and appends it
to an existing parent.
The element tag, attribute names, and attribute values can be either
bytes or Unicode strings.
*parent* is the parent element, *tag* is the subelements name, *attrib* is
an optional directory containing element attributes, *extra* are
additional attributes given as keyword arguments.
)r( r) r1 rB )parentr! r* r- r# r r r r s
c C s t t}| |_|S )zComment element factory.
This function creates a special element which the standard serializer
serializes as an XML comment.
*text* is a string containing the comment string.
)r r r2 )r2 r# r r r r s c C s& t t}| |_|r"|jd | |_|S )a* Processing Instruction element factory.
This function creates a special element which the standard serializer
serializes as an XML comment.
*target* is a string containing the processing instruction, *text* is a
string containing the processing instruction contents, if any.
)r r r2 )targetr2 r# r r r r s
c @ sZ e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dd Z
dd Z dd Z dS )r
a Qualified name wrapper.
This class can be used to wrap a QName attribute value in order to get
proper namespace handing on output.
*text_or_uri* is a string containing the QName value either in the form
{uri}local, or if the tag argument is given, the URI part of a QName.
*tag* is an optional argument which if given, will make the first
argument (text_or_uri) be interpreted as a URI, and this argument (tag)
be interpreted as a local name.
Nc C s |rd||f }|| _ d S )Nz{%s}%s)r2 )r, Z text_or_urir! r r r r. s zQName.__init__c C s | j S )N)r2 )r, r r r __str__ s z
QName.__str__c C s d| j j| jf S )Nz<%s %r>)r' r r2 )r, r r r r0 s zQName.__repr__c C s
t | jS )N)hashr2 )r, r r r __hash__ s zQName.__hash__c C s t |tr| j|jkS | j|kS )N)r$ r
r2 )r, otherr r r __le__ s
z QName.__le__c C s t |tr| j|jk S | j|k S )N)r$ r
r2 )r, ri r r r __lt__ s
z QName.__lt__c C s t |tr| j|jkS | j|kS )N)r$ r
r2 )r, ri r r r __ge__ s
z QName.__ge__c C s t |tr| j|jkS | j|kS )N)r$ r
r2 )r, ri r r r __gt__ s
z QName.__gt__c C s t |tr| j|jkS | j|kS )N)r$ r
r2 )r, ri r r r __eq__ s
z QName.__eq__)N)
r r r r r. rf r0 rh rj rk rl rm rn r r r r r
s
c @ s e Zd ZdZd ddZdd Zdd Zd d d
Zd d d Zd d
dZ d!ddZ
d"ddZ d#ddZ d$ddZ
d%ddddZdd ZdS )&r a% An XML element hierarchy.
This class also provides support for serialization to and from
standard XML.
*element* is an optional root element node,
*file* is an optional file handle or file name of an XML file whose
contents will be used to initialize the tree with.
Nc C s || _ |r| | d S )N)_rootr )r, r# filer r r r. * s zElementTree.__init__c C s | j S )z!Return root element of this tree.)ro )r, r r r getroot0 s zElementTree.getrootc C s
|| _ dS )zReplace root element of this tree.
This will discard the current contents of the tree and replace it
with the given element. Use with care!
N)ro )r, r# r r r _setroot4 s zElementTree._setrootc C s d}t |ds t|d}d}zZ|dkrHt }t |drH||| _| jS x |d}|sZP || qJW | | _| jS |r| X dS )a= Load external XML document into element tree.
*source* is a file name or file object, *parser* is an optional parser
instance that defaults to XMLParser.
ParseError is raised if the parser fails to parse the document.
Returns the root element of the given source document.
FreadrbTN _parse_wholei )r" openr ru ro rs feedclose)r, sourceparser close_sourcedatar r r r > s&
zElementTree.parsec C s | j |S )zCreate and return tree iterator for the root element.
The iterator loops over all elements in this tree, in document order.
*tag* is a string with the tag name to iterate over
(default is to return all elements).
)ro r\ )r, r! r r r r\ c s
zElementTree.iterc C s t jdtdd t| |S )NzbThis method will be removed in future versions. Use 'tree.iter()' or 'list(tree.iter())' instead.r7 )r8 )r9 r: r] r^ r\ )r, r! r r r r_ p s
zElementTree.getiteratorc C s: |dd dkr,d| }t jd| tdd | j||S )a\ Find first matching element by tag name or path.
Same as getroot().find(path), which is Element.find()
*path* is a string having either an element tag or an XPath,
*namespaces* is an optional mapping from namespace prefix to full name.
Return the first matching element, or None if no element was found.
Nr /.zThis search is broken in 1.3 and earlier, and will be fixed in a future version. If you rely on the current behaviour, change it to %rr7 )r8 )r9 r: r; ro rM )r, rN rO r r r rM y s
zElementTree.findc C s< |dd dkr,d| }t jd| tdd | j|||S )ae Find first matching element by tag name or path.
Same as getroot().findtext(path), which is Element.findtext()
*path* is a string having either an element tag or an XPath,
*namespaces* is an optional mapping from namespace prefix to full name.
Return the first matching element, or None if no element was found.
Nr r} r~ zThis search is broken in 1.3 and earlier, and will be fixed in a future version. If you rely on the current behaviour, change it to %rr7 )r8 )r9 r: r; ro rP )r, rN rQ rO r r r rP s
zElementTree.findtextc C s: |dd dkr,d| }t jd| tdd | j||S )aa Find all matching subelements by tag name or path.
Same as getroot().findall(path), which is Element.findall().
*path* is a string having either an element tag or an XPath,
*namespaces* is an optional mapping from namespace prefix to full name.
Return list containing all matching elements in document order.
Nr r} r~ zThis search is broken in 1.3 and earlier, and will be fixed in a future version. If you rely on the current behaviour, change it to %rr7 )r8 )r9 r: r; ro rR )r, rN rO r r r rR s
zElementTree.findallc C s: |dd dkr,d| }t jd| tdd | j||S )ag Find all matching subelements by tag name or path.
Same as getroot().iterfind(path), which is element.iterfind()
*path* is a string having either an element tag or an XPath,
*namespaces* is an optional mapping from namespace prefix to full name.
Return an iterable yielding all matching elements in document order.
Nr r} r~ zThis search is broken in 1.3 and earlier, and will be fixed in a future version. If you rely on the current behaviour, change it to %rr7 )r8 )r9 r: r; ro rS )r, rN rO r r r rS s
zElementTree.iterfindT)short_empty_elementsc C s |s
d}n|t kr td| |s4|dkr0d}nd}| }t||}|dkr|sd|dkr|dkr|} |dkrd dl}
|
} |d
| f |d krt|| j n,t| j|\} } t | }
|
|| j| | |d W dQ R X dS )
a Write element tree to a file as XML.
Arguments:
*file_or_filename* -- file name or a file object opened for writing
*encoding* -- the output encoding (default: US-ASCII)
*xml_declaration* -- bool indicating if an XML declaration should be
added to the output. If None, an XML declaration
is added if encoding IS NOT either of:
US-ASCII, UTF-8, or Unicode
*default_namespace* -- sets the default XML namespace (for "xmlns")
*method* -- either "xml" (default), "html, "text", or "c14n"
*short_empty_elements* -- controls the formatting of elements
that contain no content. If True (default)
they are emitted as a single self-closed
tag, otherwise they are emitted as a pair
of start/end tags
xmlzunknown method %rc14nzutf-8zus-asciiN)zutf-8zus-asciiunicoder r z$
r2 )r )
_serialize
ValueErrorlower _get_writerlocaleZgetpreferredencoding_serialize_textro _namespaces)r, file_or_filenameencodingZxml_declarationdefault_namespacemethodr Z enc_lowerwriteZdeclared_encodingr qnamesrO Z serializer r r r s2
zElementTree.writec C s | j |ddS )Nr )r )r )r, rp r r r
write_c14n s zElementTree.write_c14n)NN)N)N)N)N)NN)N)N)NNNN)r r r r r. rq rr r r\ r_ rM rP rR rS r r r r r r r s"
%
5c c s" y
| j }W nP tk
rZ |dkr.t| d}nt| d|dd}| |j V W d Q R X Y nX |dkrl|V nt }t| tjr| }nft| tjrt | }|
|j nBt }dd |_ ||_ y| j
|_
| j|_W n tk
r Y nX tj||ddd}|
|j |j V W d Q R X d S ) Nr wxmlcharrefreplace)r errorsc S s dS )NTr r r r r 4 z _get_writer..
)r r newline)r AttributeErrorrv
contextlib ExitStackr$ ioBufferedIOBase RawIOBaseBufferedWritercallbackdetachwritableseekabletell
TextIOWrapper)r r r rp stackr r r r s>
r c s d d ii rd < fdd}x| D ]} | j}t|tr\|jkr||j n.add_qname)
r\ r! r$ r
r2 r` r r r rZ )r4 r r r! rV rW r2 r )r rO r r r F s4
r c K s |j }|j}|tkr$| d| n|tkr<| d| nt|| }|d kr|r\| t| x |D ]}t| ||d |d qbW n0| d| t| } | s|rD|rx@t| dd dD ](\}
} | rd| } | d | t |
f qW xZt| D ]N\} }
t
| t r | j} t
|
t r$||
j }
nt |
}
| d
|| |
f qW |sZt |sZ|s| d |rt| t| x |D ]}t| ||d |d qzW | d | d n| d
|j
r| t|j
d S )Nz z)r .)rV :z
xmlns%s="%s"z %s="%s">z)r! r2 r r
_escape_cdata_serialize_xmlr^ rZ sorted_escape_attribr$ r
r5 r3 ) r r4 r rO r kwargsr! r2 rI rZ vkr r r r sT
r )
ZareabaseZbasefontbrcolframeZhrZimginputZisindexlinkmetaZparamc K s |j }|j}|tkr(| dt| n|tkrD| dt| n||| }|d kr|rd| t| x|D ]}t| ||d qjW n<| d| t| }|s|rH|rx@t| dd dD ](\} }
|
rd|
}
| d|
t | f qW xZt|D ]N\}
} t
|
t r|
j}
t
| t r(|| j } nt | } | d ||
| f qW | d
|
} |r| d ksr| d kr|| | n | t| x |D ]}t| ||d qW | tkr| d
| d
|jr| t|j d S )Nz zr c S s | d S )Nr r )r r r r r r z!_serialize_html..)rV r z
xmlns%s="%s"z %s="%s"r ZscriptZstylez| dd} | S ttfk
r` t| Y nX d S )N&z&r z<r z>)replacer& r r )r2 r r r r % s r c C s yd| kr| dd} d| kr*| dd} d| kr>| dd} d| krR| dd} d | krf| d d
} d | krz| d d
} d
| kr| d
d } d
| kr| d
d} | S ttfk
r t| Y nX d S )Nr z&r z<r z>"z"z
r
z
z )r r& r r )r2 r r r r 5 s( r c C sf y@d| kr| dd} d| kr*| dd} d| kr>| dd} | S ttfk
r` t| Y nX d S )Nr z&r z>r z")r r& r r )r2 r r r r Q s r T)r c C s6 |dkrt nt }t| j||||d | S )a Generate string representation of XML element.
All subelements are included. If encoding is "unicode", a string
is returned. Otherwise a bytestring is returned.
*element* is an Element instance, *encoding* is an optional output
encoding defaulting to US-ASCII, *method* is an optional output which can
be one of "xml" (default), "html", "text" or "c14n".
Returns an (optionally) encoded string containing the XML data.
r )r r )r StringIOBytesIOr r getvalue)r# r r r streamr r r r ` s c @ s8 e Zd ZdZdd Zdd Zdd Zdd Zd
d Zd S )
_ListDataStreamz7An auxiliary stream accumulating into a list reference.c C s
|| _ d S )N)lst)r, r r r r r. u s z_ListDataStream.__init__c C s dS )NTr )r, r r r r x s z_ListDataStream.writablec C s dS )NTr )r, r r r r { s z_ListDataStream.seekablec C s | j | d S )N)r rB )r, br r r r ~ s z_ListDataStream.writec C s
t | jS )N)r5 r )r, r r r r s z_ListDataStream.tellN) r r r r r. r r r r r r r r r s s r c C s& g }t |}t| j||||d |S )N)r r )r r r )r# r r r r r r r r r s
c C sL t | tst| } | jtjdd | j}|r<|d dkrHtjd dS )a# Write element tree or element structure to sys.stdout.
This function should be used for debugging only.
*elem* is either an ElementTree, or a single Element. The exact output
format is implementation dependent. In this version, it's written as an
ordinary XML file.
r )r r N)r$ r r sysstdoutrq r3 )r4 r3 r r r r s
c C s t }|| | |S )zParse XML document into element tree.
*source* is a filename or file object containing XML data,
*parser* is an optional parser instance defaulting to XMLParser.
Return an ElementTree instance.
)r r )ry rz treer r r r s c sf t ||d fddG fdddtjj}| d_~d tdsbtd d
S ) aJ Incrementally parse XML document into ElementTree.
This class also reports what's going on to the user based on the
*events* it is initialized with. The supported events are the strings
"start", "end", "start-ns" and "end-ns" (the "ns" events are used to get
detailed namespace information). If *events* is omitted, only
"end" events are reported.
*source* is a filename or file object containing XML data, *events* is
a list of events to report back, *parser* is an optional parser instance.
Returns an iterator providing (event, elem) pairs.
)events_parserc 3 sb zNx, E d H d} | s"P | qW } E d H |_W d r\ X d S )Ni @ ) read_eventsrs rw _close_and_return_rootrootrx )r| r )r{ it
pullparserry r r iterator s
ziterparse..iteratorc s e Zd Z jZdS )z$iterparse..IterParseIteratorN)r r r __next__r )r r r IterParseIterator s r NFrs rt T)r collectionsabcIteratorr r" rv )ry r rz r r )r{ r r r ry r r s
c @ s< e Zd Zd
ddddZdd Zdd Zd d
Zd d ZdS )r N)r c C s< t | _|ptt d| _|d kr(d}| j| j| d S )N)re )end)r deque
_events_queuer r r
_setevents)r, r r r r r r. s
zXMLPullParser.__init__c
C sZ | j dkrtd|rVy| j | W n. tk
rT } z| j| W dd}~X Y nX dS )z Feed encoded data to parser.Nz!feed() called after end of stream)r r rw SyntaxErrorr rB )r, r| excr r r rw s
zXMLPullParser.feedc C s | j }d | _ |S )N)r rx )r, r r r r r s
z$XMLPullParser._close_and_return_rootc C s | dS )zFinish feeding data to parser.
Unlike XMLParser, does not return the root element. Use
read_events() to consume elements from XMLPullParser.
N)r )r, r r r rx s zXMLPullParser.closec c s2 | j }x&|r,| }t|tr$|q|V qW dS )zReturn an iterator over currently available (event, elem) pairs.
Events are consumed from the internal event queue as they are
retrieved from the iterator.
N)r popleftr$ Exception)r, r eventr r r r s
zXMLPullParser.read_events)N)r r r r. rw r rx r r r r r r s
c C s" |st t d}|| | S )a Parse XML document from string constant.
This function can be used to embed "XML Literals" in Python code.
*text* is a string containing XML data, *parser* is an
optional parser instance, defaulting to the standard XMLParser.
Returns an Element instance.
)re )r r rw rx )r2 rz r r r r s
c C sV |st t d}|| | }i }x&| D ]}|d}|r0|||< q0W ||fS )a Parse XML document from string constant for its IDs.
*text* is a string containing XML data, *parser* is an
optional parser instance, defaulting to the standard XMLParser.
Returns an (Element, dict) tuple, in which the
dict maps element id:s to elements.
)re r/ )r r rw rx r\ rU )r2 rz r Zidsr4 r/ r r r r ' s
c C s0 |st t d}x| D ]}|| qW | S )zParse XML document from sequence of string fragments.
*sequence* is a list of other sequence, *parser* is an optional parser
instance, defaulting to the standard XMLParser.
Returns an Element instance.
)re )r r rw rx )Zsequencerz r2 r r r r ? s
c @ sB e Zd ZdZdddZdd Zdd Zd d
Zd d Zd
d Z dS )r a Generic element structure builder.
This builder converts a sequence of start, data, and end method
calls to a well-formed element structure.
You can use this class to build an element structure using a custom XML
parser, or a parser for some other XML-like format.
*element_factory* is an optional element factory which is called
to create new Element instances, as necessary.
Nc C s. g | _ g | _d | _d | _|d kr$t}|| _d S )N)_data_elem_last_tailr _factory)r, Zelement_factoryr r r r. ^ s zTreeBuilder.__init__c C s. t | jdkstd| jdk s(td| jS )z;Flush builder buffers and return toplevel document Element.r zmissing end tagsNzmissing toplevel element)r5 r AssertionErrorr )r, r r r rx g s zTreeBuilder.closec C sf | j rb| jd k r\d| j }| jr@| jjd ks6td|| j_n | jjd ksTtd|| j_g | _ d S )Nr zinternal error (tail)zinternal error (text))r r joinr r3 r r2 )r, r2 r r r _flushm s
zTreeBuilder._flushc C s | j | dS )z Add text to current element.N)r rB )r, r| r r r r| y s zTreeBuilder.datac C sF | | || | _}| jr0| jd | | j| d| _|S )zOpen new element and return it.
*tag* is the element name, *attrs* is a dict containing element
attributes.
r r )r r r r rB r )r, r! Zattrsr4 r r r start} s zTreeBuilder.startc C s@ | | j | _| jj|ks4td| jj|f d| _| jS )zOClose and return current Element.
*tag* is the element name.
z&end tag mismatch (expected %s, got %s)r )r r popr r! r r )r, r! r r r r s zTreeBuilder.end)N)
r r r r r. rx r r| r r r r r r r Q s
sentinelc @ sl e Zd ZdZeddfddZdd Zdd Zd d
Zd d Z d
d Z
dd Z dd Z e Z
dd Zdd ZdS )r a Element structure builder for XML source data based on the expat parser.
*html* are predefined HTML entities (deprecated and not supported),
*target* is an optional target object which defaults to an instance of the
standard TreeBuilder class, *encoding* is an optional encoding string
which if given, overrides the encoding specified in the XML file:
http://www.iana.org/assignments/character-sets
Nc C sV |t k rtjdtdd yddlm} W n> tk
rf y dd l}W n tk
r` tdY nX Y nX ||d}|d krt }| | _
| _ | | _ | _
|j| _i | _| j|_t|dr| j|_t|d r| j|_t|d
r|j|_t|d r|j|_t|d r |j |_ d
|_ d
|_ d
|_ d | _!i | _"yd|j# | _$W n t%k
rP Y nX d S )Nz.The html argument of XMLParser() is deprecatedr7 )r8 r )expatz7No module named expat; use SimpleXMLTreeBuilder insteadr r r r| commentpir zExpat %d.%d.%d)& _sentinelr9 r: rK xml.parsersr ImportErrorZpyexpatZ ParserCreater rz r re _targeterror_error_names_defaultZDefaultHandlerExpandr" _startStartElementHandler_endEndElementHandlerr| ZCharacterDataHandlerr ZCommentHandlerr Z ProcessingInstructionHandlerZ buffer_textordered_attributesspecified_attributes_doctypeentity version_infoversionr )r, r re r r rz r r r r. sN
zXMLParser.__init__c C s | j }|j}x|D ]}|dkrDd|_d|_||| jfdd}||_q|dkrf||| jfdd}||_q|dkr||fdd}||_q|d kr||fd
d}||_ qt
d | qW d S ) Nr r c S s |||| |f d S )Nr )r! Z attrib_inr rB r r r r handler s z%XMLParser._setevents..handlerr c S s |||| f d S )Nr )r! r rB r r r r r s zstart-nsc S s ||| p
d|pdff d S )Nr r )r r r rB r r r r s zend-nsc S s ||d f d S )Nr )r r rB r r r r s zunknown event %r) r rB r r r r r r ZStartNamespaceDeclHandlerZEndNamespaceDeclHandlerr )r, Z events_queueZevents_to_reportrz rB Z
event_namer r r r r s(
zXMLParser._seteventsc C s& t |}|j|_|j|jf|_|d S )N)r
codelinenooffsetZposition)r, rW errr r r _raiseerror s zXMLParser._raiseerrorc C sF y| j | }W n2 tk
r@ |}d|kr2d| }|| j |< Y nX |S )Nr r )r KeyError)r, rV namer r r _fixname s zXMLParser._fixnamec C sV | j }||}i }|rHx0tdt|dD ] }||d |||| < q(W | j||S )Nr r7 r )r ranger5 re r )r, r! Z attr_listZfixnamer* ir r r r s zXMLParser._startc C s | j | |S )N)re r r )r, r! r r r r s zXMLParser._endc C s |d d }|dkry | j j}W n tk
r4 d S X y|| j|dd W nZ tk
r ddlm} |d|| jj | jj
f }d|_ | jj |_ | jj
|_
|Y nX nD|dkr|d d d
krg | _n"| jd k r|d krd | _d S | }|sd S | j| t| j}|d kr| jd }|d
krb|dkrb| j\}}} }
| r| dd } n*|dkr|dkr| j\}}}
d } nd S t| j dr| j || |
dd n:| j| jkr| || |
dd | || |
dd d | _d S )Nr r r r )r z'undefined entity %s: line %d, column %d r z " s ) A
0 t4
=2 2
05
I Y