mirror of https://github.com/python/cpython
2089 lines
72 KiB
Python
2089 lines
72 KiB
Python
"""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.
|
|
|
|
"""
|
|
|
|
#---------------------------------------------------------------------
|
|
# Licensed to PSF under a Contributor Agreement.
|
|
# See http://www.python.org/psf/license for licensing details.
|
|
#
|
|
# ElementTree
|
|
# Copyright (c) 1999-2008 by Fredrik Lundh. All rights reserved.
|
|
#
|
|
# fredrik@pythonware.com
|
|
# http://www.pythonware.com
|
|
# --------------------------------------------------------------------
|
|
# The ElementTree toolkit is
|
|
#
|
|
# Copyright (c) 1999-2008 by Fredrik Lundh
|
|
#
|
|
# By obtaining, using, and/or copying this software and/or its
|
|
# associated documentation, you agree that you have read, understood,
|
|
# and will comply with the following terms and conditions:
|
|
#
|
|
# Permission to use, copy, modify, and distribute this software and
|
|
# its associated documentation for any purpose and without fee is
|
|
# hereby granted, provided that the above copyright notice appears in
|
|
# all copies, and that both that copyright notice and this permission
|
|
# notice appear in supporting documentation, and that the name of
|
|
# Secret Labs AB or the author not be used in advertising or publicity
|
|
# pertaining to distribution of the software without specific, written
|
|
# prior permission.
|
|
#
|
|
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
|
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
|
|
# ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
|
|
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
|
|
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
|
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
|
|
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
# OF THIS SOFTWARE.
|
|
# --------------------------------------------------------------------
|
|
|
|
__all__ = [
|
|
# public symbols
|
|
"Comment",
|
|
"dump",
|
|
"Element", "ElementTree",
|
|
"fromstring", "fromstringlist",
|
|
"indent", "iselement", "iterparse",
|
|
"parse", "ParseError",
|
|
"PI", "ProcessingInstruction",
|
|
"QName",
|
|
"SubElement",
|
|
"tostring", "tostringlist",
|
|
"TreeBuilder",
|
|
"VERSION",
|
|
"XML", "XMLID",
|
|
"XMLParser", "XMLPullParser",
|
|
"register_namespace",
|
|
"canonicalize", "C14NWriterTarget",
|
|
]
|
|
|
|
VERSION = "1.3.0"
|
|
|
|
import sys
|
|
import re
|
|
import warnings
|
|
import io
|
|
import collections
|
|
import collections.abc
|
|
import contextlib
|
|
|
|
from . import ElementPath
|
|
|
|
|
|
class ParseError(SyntaxError):
|
|
"""An 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
|
|
|
|
"""
|
|
pass
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
|
def iselement(element):
|
|
"""Return True if *element* appears to be an Element."""
|
|
return hasattr(element, 'tag')
|
|
|
|
|
|
class Element:
|
|
"""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:
|
|
<tag attrib>text<child/>...</tag>tail
|
|
|
|
"""
|
|
|
|
tag = None
|
|
"""The element's name."""
|
|
|
|
attrib = None
|
|
"""Dictionary of the element's attributes."""
|
|
|
|
text = None
|
|
"""
|
|
Text before first subelement. This is either a string or the value None.
|
|
Note that if there is no text, this attribute may be either
|
|
None or the empty string, depending on the parser.
|
|
|
|
"""
|
|
|
|
tail = None
|
|
"""
|
|
Text after this element's end tag, but before the next sibling element's
|
|
start tag. This is either a string or the value None. Note that if there
|
|
was no text, this attribute may be either None or an empty string,
|
|
depending on the parser.
|
|
|
|
"""
|
|
|
|
def __init__(self, tag, attrib={}, **extra):
|
|
if not isinstance(attrib, dict):
|
|
raise TypeError("attrib must be dict, not %s" % (
|
|
attrib.__class__.__name__,))
|
|
self.tag = tag
|
|
self.attrib = {**attrib, **extra}
|
|
self._children = []
|
|
|
|
def __repr__(self):
|
|
return "<%s %r at %#x>" % (self.__class__.__name__, self.tag, id(self))
|
|
|
|
def makeelement(self, tag, attrib):
|
|
"""Create 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.
|
|
|
|
"""
|
|
return self.__class__(tag, attrib)
|
|
|
|
def copy(self):
|
|
"""Return copy of current element.
|
|
|
|
This creates a shallow copy. Subelements will be shared with the
|
|
original tree.
|
|
|
|
"""
|
|
warnings.warn(
|
|
"elem.copy() is deprecated. Use copy.copy(elem) instead.",
|
|
DeprecationWarning
|
|
)
|
|
return self.__copy__()
|
|
|
|
def __copy__(self):
|
|
elem = self.makeelement(self.tag, self.attrib)
|
|
elem.text = self.text
|
|
elem.tail = self.tail
|
|
elem[:] = self
|
|
return elem
|
|
|
|
def __len__(self):
|
|
return len(self._children)
|
|
|
|
def __bool__(self):
|
|
warnings.warn(
|
|
"The behavior of this method will change in future versions. "
|
|
"Use specific 'len(elem)' or 'elem is not None' test instead.",
|
|
FutureWarning, stacklevel=2
|
|
)
|
|
return len(self._children) != 0 # emulate old behaviour, for now
|
|
|
|
def __getitem__(self, index):
|
|
return self._children[index]
|
|
|
|
def __setitem__(self, index, element):
|
|
if isinstance(index, slice):
|
|
for elt in element:
|
|
self._assert_is_element(elt)
|
|
else:
|
|
self._assert_is_element(element)
|
|
self._children[index] = element
|
|
|
|
def __delitem__(self, index):
|
|
del self._children[index]
|
|
|
|
def append(self, subelement):
|
|
"""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.
|
|
|
|
"""
|
|
self._assert_is_element(subelement)
|
|
self._children.append(subelement)
|
|
|
|
def extend(self, elements):
|
|
"""Append subelements from a sequence.
|
|
|
|
*elements* is a sequence with zero or more elements.
|
|
|
|
"""
|
|
for element in elements:
|
|
self._assert_is_element(element)
|
|
self._children.append(element)
|
|
|
|
def insert(self, index, subelement):
|
|
"""Insert *subelement* at position *index*."""
|
|
self._assert_is_element(subelement)
|
|
self._children.insert(index, subelement)
|
|
|
|
def _assert_is_element(self, e):
|
|
# Need to refer to the actual Python implementation, not the
|
|
# shadowing C implementation.
|
|
if not isinstance(e, _Element_Py):
|
|
raise TypeError('expected an Element, not %s' % type(e).__name__)
|
|
|
|
def remove(self, subelement):
|
|
"""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.
|
|
|
|
"""
|
|
# assert iselement(element)
|
|
self._children.remove(subelement)
|
|
|
|
def find(self, path, namespaces=None):
|
|
"""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.
|
|
|
|
"""
|
|
return ElementPath.find(self, path, namespaces)
|
|
|
|
def findtext(self, path, default=None, namespaces=None):
|
|
"""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.
|
|
|
|
"""
|
|
return ElementPath.findtext(self, path, default, namespaces)
|
|
|
|
def findall(self, path, namespaces=None):
|
|
"""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.
|
|
|
|
"""
|
|
return ElementPath.findall(self, path, namespaces)
|
|
|
|
def iterfind(self, path, namespaces=None):
|
|
"""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.
|
|
|
|
"""
|
|
return ElementPath.iterfind(self, path, namespaces)
|
|
|
|
def clear(self):
|
|
"""Reset element.
|
|
|
|
This function removes all subelements, clears all attributes, and sets
|
|
the text and tail attributes to None.
|
|
|
|
"""
|
|
self.attrib.clear()
|
|
self._children = []
|
|
self.text = self.tail = None
|
|
|
|
def get(self, key, default=None):
|
|
"""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.
|
|
|
|
"""
|
|
return self.attrib.get(key, default)
|
|
|
|
def set(self, key, value):
|
|
"""Set 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.
|
|
|
|
"""
|
|
self.attrib[key] = value
|
|
|
|
def keys(self):
|
|
"""Get list of attribute names.
|
|
|
|
Names are returned in an arbitrary order, just like an ordinary
|
|
Python dict. Equivalent to attrib.keys()
|
|
|
|
"""
|
|
return self.attrib.keys()
|
|
|
|
def items(self):
|
|
"""Get element attributes as a sequence.
|
|
|
|
The attributes are returned in arbitrary order. Equivalent to
|
|
attrib.items().
|
|
|
|
Return a list of (name, value) tuples.
|
|
|
|
"""
|
|
return self.attrib.items()
|
|
|
|
def iter(self, tag=None):
|
|
"""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.
|
|
|
|
"""
|
|
if tag == "*":
|
|
tag = None
|
|
if tag is None or self.tag == tag:
|
|
yield self
|
|
for e in self._children:
|
|
yield from e.iter(tag)
|
|
|
|
def itertext(self):
|
|
"""Create text iterator.
|
|
|
|
The iterator loops over the element and all subelements in document
|
|
order, returning all inner text.
|
|
|
|
"""
|
|
tag = self.tag
|
|
if not isinstance(tag, str) and tag is not None:
|
|
return
|
|
t = self.text
|
|
if t:
|
|
yield t
|
|
for e in self:
|
|
yield from e.itertext()
|
|
t = e.tail
|
|
if t:
|
|
yield t
|
|
|
|
|
|
def SubElement(parent, tag, attrib={}, **extra):
|
|
"""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.
|
|
|
|
"""
|
|
attrib = {**attrib, **extra}
|
|
element = parent.makeelement(tag, attrib)
|
|
parent.append(element)
|
|
return element
|
|
|
|
|
|
def Comment(text=None):
|
|
"""Comment 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.
|
|
|
|
"""
|
|
element = Element(Comment)
|
|
element.text = text
|
|
return element
|
|
|
|
|
|
def ProcessingInstruction(target, text=None):
|
|
"""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.
|
|
|
|
"""
|
|
element = Element(ProcessingInstruction)
|
|
element.text = target
|
|
if text:
|
|
element.text = element.text + " " + text
|
|
return element
|
|
|
|
PI = ProcessingInstruction
|
|
|
|
|
|
class QName:
|
|
"""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.
|
|
|
|
"""
|
|
def __init__(self, text_or_uri, tag=None):
|
|
if tag:
|
|
text_or_uri = "{%s}%s" % (text_or_uri, tag)
|
|
self.text = text_or_uri
|
|
def __str__(self):
|
|
return self.text
|
|
def __repr__(self):
|
|
return '<%s %r>' % (self.__class__.__name__, self.text)
|
|
def __hash__(self):
|
|
return hash(self.text)
|
|
def __le__(self, other):
|
|
if isinstance(other, QName):
|
|
return self.text <= other.text
|
|
return self.text <= other
|
|
def __lt__(self, other):
|
|
if isinstance(other, QName):
|
|
return self.text < other.text
|
|
return self.text < other
|
|
def __ge__(self, other):
|
|
if isinstance(other, QName):
|
|
return self.text >= other.text
|
|
return self.text >= other
|
|
def __gt__(self, other):
|
|
if isinstance(other, QName):
|
|
return self.text > other.text
|
|
return self.text > other
|
|
def __eq__(self, other):
|
|
if isinstance(other, QName):
|
|
return self.text == other.text
|
|
return self.text == other
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
|
class ElementTree:
|
|
"""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.
|
|
|
|
"""
|
|
def __init__(self, element=None, file=None):
|
|
# assert element is None or iselement(element)
|
|
self._root = element # first node
|
|
if file:
|
|
self.parse(file)
|
|
|
|
def getroot(self):
|
|
"""Return root element of this tree."""
|
|
return self._root
|
|
|
|
def _setroot(self, element):
|
|
"""Replace root element of this tree.
|
|
|
|
This will discard the current contents of the tree and replace it
|
|
with the given element. Use with care!
|
|
|
|
"""
|
|
# assert iselement(element)
|
|
self._root = element
|
|
|
|
def parse(self, source, parser=None):
|
|
"""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.
|
|
|
|
"""
|
|
close_source = False
|
|
if not hasattr(source, "read"):
|
|
source = open(source, "rb")
|
|
close_source = True
|
|
try:
|
|
if parser is None:
|
|
# If no parser was specified, create a default XMLParser
|
|
parser = XMLParser()
|
|
if hasattr(parser, '_parse_whole'):
|
|
# The default XMLParser, when it comes from an accelerator,
|
|
# can define an internal _parse_whole API for efficiency.
|
|
# It can be used to parse the whole source without feeding
|
|
# it with chunks.
|
|
self._root = parser._parse_whole(source)
|
|
return self._root
|
|
while True:
|
|
data = source.read(65536)
|
|
if not data:
|
|
break
|
|
parser.feed(data)
|
|
self._root = parser.close()
|
|
return self._root
|
|
finally:
|
|
if close_source:
|
|
source.close()
|
|
|
|
def iter(self, tag=None):
|
|
"""Create 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).
|
|
|
|
"""
|
|
# assert self._root is not None
|
|
return self._root.iter(tag)
|
|
|
|
def find(self, path, namespaces=None):
|
|
"""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.
|
|
|
|
"""
|
|
# assert self._root is not None
|
|
if path[:1] == "/":
|
|
path = "." + path
|
|
warnings.warn(
|
|
"This 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 %r" % path,
|
|
FutureWarning, stacklevel=2
|
|
)
|
|
return self._root.find(path, namespaces)
|
|
|
|
def findtext(self, path, default=None, namespaces=None):
|
|
"""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.
|
|
|
|
"""
|
|
# assert self._root is not None
|
|
if path[:1] == "/":
|
|
path = "." + path
|
|
warnings.warn(
|
|
"This 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 %r" % path,
|
|
FutureWarning, stacklevel=2
|
|
)
|
|
return self._root.findtext(path, default, namespaces)
|
|
|
|
def findall(self, path, namespaces=None):
|
|
"""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.
|
|
|
|
"""
|
|
# assert self._root is not None
|
|
if path[:1] == "/":
|
|
path = "." + path
|
|
warnings.warn(
|
|
"This 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 %r" % path,
|
|
FutureWarning, stacklevel=2
|
|
)
|
|
return self._root.findall(path, namespaces)
|
|
|
|
def iterfind(self, path, namespaces=None):
|
|
"""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.
|
|
|
|
"""
|
|
# assert self._root is not None
|
|
if path[:1] == "/":
|
|
path = "." + path
|
|
warnings.warn(
|
|
"This 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 %r" % path,
|
|
FutureWarning, stacklevel=2
|
|
)
|
|
return self._root.iterfind(path, namespaces)
|
|
|
|
def write(self, file_or_filename,
|
|
encoding=None,
|
|
xml_declaration=None,
|
|
default_namespace=None,
|
|
method=None, *,
|
|
short_empty_elements=True):
|
|
"""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
|
|
|
|
"""
|
|
if not method:
|
|
method = "xml"
|
|
elif method not in _serialize:
|
|
raise ValueError("unknown method %r" % method)
|
|
if not encoding:
|
|
if method == "c14n":
|
|
encoding = "utf-8"
|
|
else:
|
|
encoding = "us-ascii"
|
|
enc_lower = encoding.lower()
|
|
with _get_writer(file_or_filename, enc_lower) as write:
|
|
if method == "xml" and (xml_declaration or
|
|
(xml_declaration is None and
|
|
enc_lower not in ("utf-8", "us-ascii", "unicode"))):
|
|
declared_encoding = encoding
|
|
if enc_lower == "unicode":
|
|
# Retrieve the default encoding for the xml declaration
|
|
import locale
|
|
declared_encoding = locale.getpreferredencoding()
|
|
write("<?xml version='1.0' encoding='%s'?>\n" % (
|
|
declared_encoding,))
|
|
if method == "text":
|
|
_serialize_text(write, self._root)
|
|
else:
|
|
qnames, namespaces = _namespaces(self._root, default_namespace)
|
|
serialize = _serialize[method]
|
|
serialize(write, self._root, qnames, namespaces,
|
|
short_empty_elements=short_empty_elements)
|
|
|
|
def write_c14n(self, file):
|
|
# lxml.etree compatibility. use output method instead
|
|
return self.write(file, method="c14n")
|
|
|
|
# --------------------------------------------------------------------
|
|
# serialization support
|
|
|
|
@contextlib.contextmanager
|
|
def _get_writer(file_or_filename, encoding):
|
|
# returns text write method and release all resources after using
|
|
try:
|
|
write = file_or_filename.write
|
|
except AttributeError:
|
|
# file_or_filename is a file name
|
|
if encoding == "unicode":
|
|
file = open(file_or_filename, "w")
|
|
else:
|
|
file = open(file_or_filename, "w", encoding=encoding,
|
|
errors="xmlcharrefreplace")
|
|
with file:
|
|
yield file.write
|
|
else:
|
|
# file_or_filename is a file-like object
|
|
# encoding determines if it is a text or binary writer
|
|
if encoding == "unicode":
|
|
# use a text writer as is
|
|
yield write
|
|
else:
|
|
# wrap a binary writer with TextIOWrapper
|
|
with contextlib.ExitStack() as stack:
|
|
if isinstance(file_or_filename, io.BufferedIOBase):
|
|
file = file_or_filename
|
|
elif isinstance(file_or_filename, io.RawIOBase):
|
|
file = io.BufferedWriter(file_or_filename)
|
|
# Keep the original file open when the BufferedWriter is
|
|
# destroyed
|
|
stack.callback(file.detach)
|
|
else:
|
|
# This is to handle passed objects that aren't in the
|
|
# IOBase hierarchy, but just have a write method
|
|
file = io.BufferedIOBase()
|
|
file.writable = lambda: True
|
|
file.write = write
|
|
try:
|
|
# TextIOWrapper uses this methods to determine
|
|
# if BOM (for UTF-16, etc) should be added
|
|
file.seekable = file_or_filename.seekable
|
|
file.tell = file_or_filename.tell
|
|
except AttributeError:
|
|
pass
|
|
file = io.TextIOWrapper(file,
|
|
encoding=encoding,
|
|
errors="xmlcharrefreplace",
|
|
newline="\n")
|
|
# Keep the original file open when the TextIOWrapper is
|
|
# destroyed
|
|
stack.callback(file.detach)
|
|
yield file.write
|
|
|
|
def _namespaces(elem, default_namespace=None):
|
|
# identify namespaces used in this tree
|
|
|
|
# maps qnames to *encoded* prefix:local names
|
|
qnames = {None: None}
|
|
|
|
# maps uri:s to prefixes
|
|
namespaces = {}
|
|
if default_namespace:
|
|
namespaces[default_namespace] = ""
|
|
|
|
def add_qname(qname):
|
|
# calculate serialized qname representation
|
|
try:
|
|
if qname[:1] == "{":
|
|
uri, tag = qname[1:].rsplit("}", 1)
|
|
prefix = namespaces.get(uri)
|
|
if prefix is None:
|
|
prefix = _namespace_map.get(uri)
|
|
if prefix is None:
|
|
prefix = "ns%d" % len(namespaces)
|
|
if prefix != "xml":
|
|
namespaces[uri] = prefix
|
|
if prefix:
|
|
qnames[qname] = "%s:%s" % (prefix, tag)
|
|
else:
|
|
qnames[qname] = tag # default element
|
|
else:
|
|
if default_namespace:
|
|
# FIXME: can this be handled in XML 1.0?
|
|
raise ValueError(
|
|
"cannot use non-qualified names with "
|
|
"default_namespace option"
|
|
)
|
|
qnames[qname] = qname
|
|
except TypeError:
|
|
_raise_serialization_error(qname)
|
|
|
|
# populate qname and namespaces table
|
|
for elem in elem.iter():
|
|
tag = elem.tag
|
|
if isinstance(tag, QName):
|
|
if tag.text not in qnames:
|
|
add_qname(tag.text)
|
|
elif isinstance(tag, str):
|
|
if tag not in qnames:
|
|
add_qname(tag)
|
|
elif tag is not None and tag is not Comment and tag is not PI:
|
|
_raise_serialization_error(tag)
|
|
for key, value in elem.items():
|
|
if isinstance(key, QName):
|
|
key = key.text
|
|
if key not in qnames:
|
|
add_qname(key)
|
|
if isinstance(value, QName) and value.text not in qnames:
|
|
add_qname(value.text)
|
|
text = elem.text
|
|
if isinstance(text, QName) and text.text not in qnames:
|
|
add_qname(text.text)
|
|
return qnames, namespaces
|
|
|
|
def _serialize_xml(write, elem, qnames, namespaces,
|
|
short_empty_elements, **kwargs):
|
|
tag = elem.tag
|
|
text = elem.text
|
|
if tag is Comment:
|
|
write("<!--%s-->" % text)
|
|
elif tag is ProcessingInstruction:
|
|
write("<?%s?>" % text)
|
|
else:
|
|
tag = qnames[tag]
|
|
if tag is None:
|
|
if text:
|
|
write(_escape_cdata(text))
|
|
for e in elem:
|
|
_serialize_xml(write, e, qnames, None,
|
|
short_empty_elements=short_empty_elements)
|
|
else:
|
|
write("<" + tag)
|
|
items = list(elem.items())
|
|
if items or namespaces:
|
|
if namespaces:
|
|
for v, k in sorted(namespaces.items(),
|
|
key=lambda x: x[1]): # sort on prefix
|
|
if k:
|
|
k = ":" + k
|
|
write(" xmlns%s=\"%s\"" % (
|
|
k,
|
|
_escape_attrib(v)
|
|
))
|
|
for k, v in items:
|
|
if isinstance(k, QName):
|
|
k = k.text
|
|
if isinstance(v, QName):
|
|
v = qnames[v.text]
|
|
else:
|
|
v = _escape_attrib(v)
|
|
write(" %s=\"%s\"" % (qnames[k], v))
|
|
if text or len(elem) or not short_empty_elements:
|
|
write(">")
|
|
if text:
|
|
write(_escape_cdata(text))
|
|
for e in elem:
|
|
_serialize_xml(write, e, qnames, None,
|
|
short_empty_elements=short_empty_elements)
|
|
write("</" + tag + ">")
|
|
else:
|
|
write(" />")
|
|
if elem.tail:
|
|
write(_escape_cdata(elem.tail))
|
|
|
|
HTML_EMPTY = ("area", "base", "basefont", "br", "col", "frame", "hr",
|
|
"img", "input", "isindex", "link", "meta", "param")
|
|
|
|
try:
|
|
HTML_EMPTY = set(HTML_EMPTY)
|
|
except NameError:
|
|
pass
|
|
|
|
def _serialize_html(write, elem, qnames, namespaces, **kwargs):
|
|
tag = elem.tag
|
|
text = elem.text
|
|
if tag is Comment:
|
|
write("<!--%s-->" % _escape_cdata(text))
|
|
elif tag is ProcessingInstruction:
|
|
write("<?%s?>" % _escape_cdata(text))
|
|
else:
|
|
tag = qnames[tag]
|
|
if tag is None:
|
|
if text:
|
|
write(_escape_cdata(text))
|
|
for e in elem:
|
|
_serialize_html(write, e, qnames, None)
|
|
else:
|
|
write("<" + tag)
|
|
items = list(elem.items())
|
|
if items or namespaces:
|
|
if namespaces:
|
|
for v, k in sorted(namespaces.items(),
|
|
key=lambda x: x[1]): # sort on prefix
|
|
if k:
|
|
k = ":" + k
|
|
write(" xmlns%s=\"%s\"" % (
|
|
k,
|
|
_escape_attrib(v)
|
|
))
|
|
for k, v in items:
|
|
if isinstance(k, QName):
|
|
k = k.text
|
|
if isinstance(v, QName):
|
|
v = qnames[v.text]
|
|
else:
|
|
v = _escape_attrib_html(v)
|
|
# FIXME: handle boolean attributes
|
|
write(" %s=\"%s\"" % (qnames[k], v))
|
|
write(">")
|
|
ltag = tag.lower()
|
|
if text:
|
|
if ltag == "script" or ltag == "style":
|
|
write(text)
|
|
else:
|
|
write(_escape_cdata(text))
|
|
for e in elem:
|
|
_serialize_html(write, e, qnames, None)
|
|
if ltag not in HTML_EMPTY:
|
|
write("</" + tag + ">")
|
|
if elem.tail:
|
|
write(_escape_cdata(elem.tail))
|
|
|
|
def _serialize_text(write, elem):
|
|
for part in elem.itertext():
|
|
write(part)
|
|
if elem.tail:
|
|
write(elem.tail)
|
|
|
|
_serialize = {
|
|
"xml": _serialize_xml,
|
|
"html": _serialize_html,
|
|
"text": _serialize_text,
|
|
# this optional method is imported at the end of the module
|
|
# "c14n": _serialize_c14n,
|
|
}
|
|
|
|
|
|
def register_namespace(prefix, uri):
|
|
"""Register a namespace prefix.
|
|
|
|
The registry is global, and any existing mapping for either the
|
|
given prefix or the namespace URI will be removed.
|
|
|
|
*prefix* is the namespace prefix, *uri* is a namespace uri. Tags and
|
|
attributes in this namespace will be serialized with prefix if possible.
|
|
|
|
ValueError is raised if prefix is reserved or is invalid.
|
|
|
|
"""
|
|
if re.match(r"ns\d+$", prefix):
|
|
raise ValueError("Prefix format reserved for internal use")
|
|
for k, v in list(_namespace_map.items()):
|
|
if k == uri or v == prefix:
|
|
del _namespace_map[k]
|
|
_namespace_map[uri] = prefix
|
|
|
|
_namespace_map = {
|
|
# "well-known" namespace prefixes
|
|
"http://www.w3.org/XML/1998/namespace": "xml",
|
|
"http://www.w3.org/1999/xhtml": "html",
|
|
"http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",
|
|
"http://schemas.xmlsoap.org/wsdl/": "wsdl",
|
|
# xml schema
|
|
"http://www.w3.org/2001/XMLSchema": "xs",
|
|
"http://www.w3.org/2001/XMLSchema-instance": "xsi",
|
|
# dublin core
|
|
"http://purl.org/dc/elements/1.1/": "dc",
|
|
}
|
|
# For tests and troubleshooting
|
|
register_namespace._namespace_map = _namespace_map
|
|
|
|
def _raise_serialization_error(text):
|
|
raise TypeError(
|
|
"cannot serialize %r (type %s)" % (text, type(text).__name__)
|
|
)
|
|
|
|
def _escape_cdata(text):
|
|
# escape character data
|
|
try:
|
|
# it's worth avoiding do-nothing calls for strings that are
|
|
# shorter than 500 characters, or so. assume that's, by far,
|
|
# the most common case in most applications.
|
|
if "&" in text:
|
|
text = text.replace("&", "&")
|
|
if "<" in text:
|
|
text = text.replace("<", "<")
|
|
if ">" in text:
|
|
text = text.replace(">", ">")
|
|
return text
|
|
except (TypeError, AttributeError):
|
|
_raise_serialization_error(text)
|
|
|
|
def _escape_attrib(text):
|
|
# escape attribute value
|
|
try:
|
|
if "&" in text:
|
|
text = text.replace("&", "&")
|
|
if "<" in text:
|
|
text = text.replace("<", "<")
|
|
if ">" in text:
|
|
text = text.replace(">", ">")
|
|
if "\"" in text:
|
|
text = text.replace("\"", """)
|
|
# Although section 2.11 of the XML specification states that CR or
|
|
# CR LN should be replaced with just LN, it applies only to EOLNs
|
|
# which take part of organizing file into lines. Within attributes,
|
|
# we are replacing these with entity numbers, so they do not count.
|
|
# http://www.w3.org/TR/REC-xml/#sec-line-ends
|
|
# The current solution, contained in following six lines, was
|
|
# discussed in issue 17582 and 39011.
|
|
if "\r" in text:
|
|
text = text.replace("\r", " ")
|
|
if "\n" in text:
|
|
text = text.replace("\n", " ")
|
|
if "\t" in text:
|
|
text = text.replace("\t", "	")
|
|
return text
|
|
except (TypeError, AttributeError):
|
|
_raise_serialization_error(text)
|
|
|
|
def _escape_attrib_html(text):
|
|
# escape attribute value
|
|
try:
|
|
if "&" in text:
|
|
text = text.replace("&", "&")
|
|
if ">" in text:
|
|
text = text.replace(">", ">")
|
|
if "\"" in text:
|
|
text = text.replace("\"", """)
|
|
return text
|
|
except (TypeError, AttributeError):
|
|
_raise_serialization_error(text)
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
def tostring(element, encoding=None, method=None, *,
|
|
xml_declaration=None, default_namespace=None,
|
|
short_empty_elements=True):
|
|
"""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", *default_namespace*
|
|
sets the default XML namespace (for "xmlns").
|
|
|
|
Returns an (optionally) encoded string containing the XML data.
|
|
|
|
"""
|
|
stream = io.StringIO() if encoding == 'unicode' else io.BytesIO()
|
|
ElementTree(element).write(stream, encoding,
|
|
xml_declaration=xml_declaration,
|
|
default_namespace=default_namespace,
|
|
method=method,
|
|
short_empty_elements=short_empty_elements)
|
|
return stream.getvalue()
|
|
|
|
class _ListDataStream(io.BufferedIOBase):
|
|
"""An auxiliary stream accumulating into a list reference."""
|
|
def __init__(self, lst):
|
|
self.lst = lst
|
|
|
|
def writable(self):
|
|
return True
|
|
|
|
def seekable(self):
|
|
return True
|
|
|
|
def write(self, b):
|
|
self.lst.append(b)
|
|
|
|
def tell(self):
|
|
return len(self.lst)
|
|
|
|
def tostringlist(element, encoding=None, method=None, *,
|
|
xml_declaration=None, default_namespace=None,
|
|
short_empty_elements=True):
|
|
lst = []
|
|
stream = _ListDataStream(lst)
|
|
ElementTree(element).write(stream, encoding,
|
|
xml_declaration=xml_declaration,
|
|
default_namespace=default_namespace,
|
|
method=method,
|
|
short_empty_elements=short_empty_elements)
|
|
return lst
|
|
|
|
|
|
def dump(elem):
|
|
"""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.
|
|
|
|
"""
|
|
# debugging
|
|
if not isinstance(elem, ElementTree):
|
|
elem = ElementTree(elem)
|
|
elem.write(sys.stdout, encoding="unicode")
|
|
tail = elem.getroot().tail
|
|
if not tail or tail[-1] != "\n":
|
|
sys.stdout.write("\n")
|
|
|
|
|
|
def indent(tree, space=" ", level=0):
|
|
"""Indent an XML document by inserting newlines and indentation space
|
|
after elements.
|
|
|
|
*tree* is the ElementTree or Element to modify. The (root) element
|
|
itself will not be changed, but the tail text of all elements in its
|
|
subtree will be adapted.
|
|
|
|
*space* is the whitespace to insert for each indentation level, two
|
|
space characters by default.
|
|
|
|
*level* is the initial indentation level. Setting this to a higher
|
|
value than 0 can be used for indenting subtrees that are more deeply
|
|
nested inside of a document.
|
|
"""
|
|
if isinstance(tree, ElementTree):
|
|
tree = tree.getroot()
|
|
if level < 0:
|
|
raise ValueError(f"Initial indentation level must be >= 0, got {level}")
|
|
if not len(tree):
|
|
return
|
|
|
|
# Reduce the memory consumption by reusing indentation strings.
|
|
indentations = ["\n" + level * space]
|
|
|
|
def _indent_children(elem, level):
|
|
# Start a new indentation level for the first child.
|
|
child_level = level + 1
|
|
try:
|
|
child_indentation = indentations[child_level]
|
|
except IndexError:
|
|
child_indentation = indentations[level] + space
|
|
indentations.append(child_indentation)
|
|
|
|
if not elem.text or not elem.text.strip():
|
|
elem.text = child_indentation
|
|
|
|
for child in elem:
|
|
if len(child):
|
|
_indent_children(child, child_level)
|
|
if not child.tail or not child.tail.strip():
|
|
child.tail = child_indentation
|
|
|
|
# Dedent after the last child by overwriting the previous indentation.
|
|
if not child.tail.strip():
|
|
child.tail = indentations[level]
|
|
|
|
_indent_children(tree, 0)
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
# parsing
|
|
|
|
|
|
def parse(source, parser=None):
|
|
"""Parse 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.
|
|
|
|
"""
|
|
tree = ElementTree()
|
|
tree.parse(source, parser)
|
|
return tree
|
|
|
|
|
|
def iterparse(source, events=None, parser=None):
|
|
"""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.
|
|
|
|
"""
|
|
# Use the internal, undocumented _parser argument for now; When the
|
|
# parser argument of iterparse is removed, this can be killed.
|
|
pullparser = XMLPullParser(events=events, _parser=parser)
|
|
def iterator():
|
|
try:
|
|
while True:
|
|
yield from pullparser.read_events()
|
|
# load event buffer
|
|
data = source.read(16 * 1024)
|
|
if not data:
|
|
break
|
|
pullparser.feed(data)
|
|
root = pullparser._close_and_return_root()
|
|
yield from pullparser.read_events()
|
|
it.root = root
|
|
finally:
|
|
if close_source:
|
|
source.close()
|
|
|
|
class IterParseIterator(collections.abc.Iterator):
|
|
__next__ = iterator().__next__
|
|
it = IterParseIterator()
|
|
it.root = None
|
|
del iterator, IterParseIterator
|
|
|
|
close_source = False
|
|
if not hasattr(source, "read"):
|
|
source = open(source, "rb")
|
|
close_source = True
|
|
|
|
return it
|
|
|
|
|
|
class XMLPullParser:
|
|
|
|
def __init__(self, events=None, *, _parser=None):
|
|
# The _parser argument is for internal use only and must not be relied
|
|
# upon in user code. It will be removed in a future release.
|
|
# See http://bugs.python.org/issue17741 for more details.
|
|
|
|
self._events_queue = collections.deque()
|
|
self._parser = _parser or XMLParser(target=TreeBuilder())
|
|
# wire up the parser for event reporting
|
|
if events is None:
|
|
events = ("end",)
|
|
self._parser._setevents(self._events_queue, events)
|
|
|
|
def feed(self, data):
|
|
"""Feed encoded data to parser."""
|
|
if self._parser is None:
|
|
raise ValueError("feed() called after end of stream")
|
|
if data:
|
|
try:
|
|
self._parser.feed(data)
|
|
except SyntaxError as exc:
|
|
self._events_queue.append(exc)
|
|
|
|
def _close_and_return_root(self):
|
|
# iterparse needs this to set its root attribute properly :(
|
|
root = self._parser.close()
|
|
self._parser = None
|
|
return root
|
|
|
|
def close(self):
|
|
"""Finish feeding data to parser.
|
|
|
|
Unlike XMLParser, does not return the root element. Use
|
|
read_events() to consume elements from XMLPullParser.
|
|
"""
|
|
self._close_and_return_root()
|
|
|
|
def read_events(self):
|
|
"""Return an iterator over currently available (event, elem) pairs.
|
|
|
|
Events are consumed from the internal event queue as they are
|
|
retrieved from the iterator.
|
|
"""
|
|
events = self._events_queue
|
|
while events:
|
|
event = events.popleft()
|
|
if isinstance(event, Exception):
|
|
raise event
|
|
else:
|
|
yield event
|
|
|
|
|
|
def XML(text, parser=None):
|
|
"""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.
|
|
|
|
"""
|
|
if not parser:
|
|
parser = XMLParser(target=TreeBuilder())
|
|
parser.feed(text)
|
|
return parser.close()
|
|
|
|
|
|
def XMLID(text, parser=None):
|
|
"""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.
|
|
|
|
"""
|
|
if not parser:
|
|
parser = XMLParser(target=TreeBuilder())
|
|
parser.feed(text)
|
|
tree = parser.close()
|
|
ids = {}
|
|
for elem in tree.iter():
|
|
id = elem.get("id")
|
|
if id:
|
|
ids[id] = elem
|
|
return tree, ids
|
|
|
|
# Parse XML document from string constant. Alias for XML().
|
|
fromstring = XML
|
|
|
|
def fromstringlist(sequence, parser=None):
|
|
"""Parse 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.
|
|
|
|
"""
|
|
if not parser:
|
|
parser = XMLParser(target=TreeBuilder())
|
|
for text in sequence:
|
|
parser.feed(text)
|
|
return parser.close()
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
|
|
class TreeBuilder:
|
|
"""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.
|
|
|
|
*comment_factory* is a factory to create comments to be used instead of
|
|
the standard factory. If *insert_comments* is false (the default),
|
|
comments will not be inserted into the tree.
|
|
|
|
*pi_factory* is a factory to create processing instructions to be used
|
|
instead of the standard factory. If *insert_pis* is false (the default),
|
|
processing instructions will not be inserted into the tree.
|
|
"""
|
|
def __init__(self, element_factory=None, *,
|
|
comment_factory=None, pi_factory=None,
|
|
insert_comments=False, insert_pis=False):
|
|
self._data = [] # data collector
|
|
self._elem = [] # element stack
|
|
self._last = None # last element
|
|
self._root = None # root element
|
|
self._tail = None # true if we're after an end tag
|
|
if comment_factory is None:
|
|
comment_factory = Comment
|
|
self._comment_factory = comment_factory
|
|
self.insert_comments = insert_comments
|
|
if pi_factory is None:
|
|
pi_factory = ProcessingInstruction
|
|
self._pi_factory = pi_factory
|
|
self.insert_pis = insert_pis
|
|
if element_factory is None:
|
|
element_factory = Element
|
|
self._factory = element_factory
|
|
|
|
def close(self):
|
|
"""Flush builder buffers and return toplevel document Element."""
|
|
assert len(self._elem) == 0, "missing end tags"
|
|
assert self._root is not None, "missing toplevel element"
|
|
return self._root
|
|
|
|
def _flush(self):
|
|
if self._data:
|
|
if self._last is not None:
|
|
text = "".join(self._data)
|
|
if self._tail:
|
|
assert self._last.tail is None, "internal error (tail)"
|
|
self._last.tail = text
|
|
else:
|
|
assert self._last.text is None, "internal error (text)"
|
|
self._last.text = text
|
|
self._data = []
|
|
|
|
def data(self, data):
|
|
"""Add text to current element."""
|
|
self._data.append(data)
|
|
|
|
def start(self, tag, attrs):
|
|
"""Open new element and return it.
|
|
|
|
*tag* is the element name, *attrs* is a dict containing element
|
|
attributes.
|
|
|
|
"""
|
|
self._flush()
|
|
self._last = elem = self._factory(tag, attrs)
|
|
if self._elem:
|
|
self._elem[-1].append(elem)
|
|
elif self._root is None:
|
|
self._root = elem
|
|
self._elem.append(elem)
|
|
self._tail = 0
|
|
return elem
|
|
|
|
def end(self, tag):
|
|
"""Close and return current Element.
|
|
|
|
*tag* is the element name.
|
|
|
|
"""
|
|
self._flush()
|
|
self._last = self._elem.pop()
|
|
assert self._last.tag == tag,\
|
|
"end tag mismatch (expected %s, got %s)" % (
|
|
self._last.tag, tag)
|
|
self._tail = 1
|
|
return self._last
|
|
|
|
def comment(self, text):
|
|
"""Create a comment using the comment_factory.
|
|
|
|
*text* is the text of the comment.
|
|
"""
|
|
return self._handle_single(
|
|
self._comment_factory, self.insert_comments, text)
|
|
|
|
def pi(self, target, text=None):
|
|
"""Create a processing instruction using the pi_factory.
|
|
|
|
*target* is the target name of the processing instruction.
|
|
*text* is the data of the processing instruction, or ''.
|
|
"""
|
|
return self._handle_single(
|
|
self._pi_factory, self.insert_pis, target, text)
|
|
|
|
def _handle_single(self, factory, insert, *args):
|
|
elem = factory(*args)
|
|
if insert:
|
|
self._flush()
|
|
self._last = elem
|
|
if self._elem:
|
|
self._elem[-1].append(elem)
|
|
self._tail = 1
|
|
return elem
|
|
|
|
|
|
# also see ElementTree and TreeBuilder
|
|
class XMLParser:
|
|
"""Element structure builder for XML source data based on the expat parser.
|
|
|
|
*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
|
|
|
|
"""
|
|
|
|
def __init__(self, *, target=None, encoding=None):
|
|
try:
|
|
from xml.parsers import expat
|
|
except ImportError:
|
|
try:
|
|
import pyexpat as expat
|
|
except ImportError:
|
|
raise ImportError(
|
|
"No module named expat; use SimpleXMLTreeBuilder instead"
|
|
)
|
|
parser = expat.ParserCreate(encoding, "}")
|
|
if target is None:
|
|
target = TreeBuilder()
|
|
# underscored names are provided for compatibility only
|
|
self.parser = self._parser = parser
|
|
self.target = self._target = target
|
|
self._error = expat.error
|
|
self._names = {} # name memo cache
|
|
# main callbacks
|
|
parser.DefaultHandlerExpand = self._default
|
|
if hasattr(target, 'start'):
|
|
parser.StartElementHandler = self._start
|
|
if hasattr(target, 'end'):
|
|
parser.EndElementHandler = self._end
|
|
if hasattr(target, 'start_ns'):
|
|
parser.StartNamespaceDeclHandler = self._start_ns
|
|
if hasattr(target, 'end_ns'):
|
|
parser.EndNamespaceDeclHandler = self._end_ns
|
|
if hasattr(target, 'data'):
|
|
parser.CharacterDataHandler = target.data
|
|
# miscellaneous callbacks
|
|
if hasattr(target, 'comment'):
|
|
parser.CommentHandler = target.comment
|
|
if hasattr(target, 'pi'):
|
|
parser.ProcessingInstructionHandler = target.pi
|
|
# Configure pyexpat: buffering, new-style attribute handling.
|
|
parser.buffer_text = 1
|
|
parser.ordered_attributes = 1
|
|
self._doctype = None
|
|
self.entity = {}
|
|
try:
|
|
self.version = "Expat %d.%d.%d" % expat.version_info
|
|
except AttributeError:
|
|
pass # unknown
|
|
|
|
def _setevents(self, events_queue, events_to_report):
|
|
# Internal API for XMLPullParser
|
|
# events_to_report: a list of events to report during parsing (same as
|
|
# the *events* of XMLPullParser's constructor.
|
|
# events_queue: a list of actual parsing events that will be populated
|
|
# by the underlying parser.
|
|
#
|
|
parser = self._parser
|
|
append = events_queue.append
|
|
for event_name in events_to_report:
|
|
if event_name == "start":
|
|
parser.ordered_attributes = 1
|
|
def handler(tag, attrib_in, event=event_name, append=append,
|
|
start=self._start):
|
|
append((event, start(tag, attrib_in)))
|
|
parser.StartElementHandler = handler
|
|
elif event_name == "end":
|
|
def handler(tag, event=event_name, append=append,
|
|
end=self._end):
|
|
append((event, end(tag)))
|
|
parser.EndElementHandler = handler
|
|
elif event_name == "start-ns":
|
|
# TreeBuilder does not implement .start_ns()
|
|
if hasattr(self.target, "start_ns"):
|
|
def handler(prefix, uri, event=event_name, append=append,
|
|
start_ns=self._start_ns):
|
|
append((event, start_ns(prefix, uri)))
|
|
else:
|
|
def handler(prefix, uri, event=event_name, append=append):
|
|
append((event, (prefix or '', uri or '')))
|
|
parser.StartNamespaceDeclHandler = handler
|
|
elif event_name == "end-ns":
|
|
# TreeBuilder does not implement .end_ns()
|
|
if hasattr(self.target, "end_ns"):
|
|
def handler(prefix, event=event_name, append=append,
|
|
end_ns=self._end_ns):
|
|
append((event, end_ns(prefix)))
|
|
else:
|
|
def handler(prefix, event=event_name, append=append):
|
|
append((event, None))
|
|
parser.EndNamespaceDeclHandler = handler
|
|
elif event_name == 'comment':
|
|
def handler(text, event=event_name, append=append, self=self):
|
|
append((event, self.target.comment(text)))
|
|
parser.CommentHandler = handler
|
|
elif event_name == 'pi':
|
|
def handler(pi_target, data, event=event_name, append=append,
|
|
self=self):
|
|
append((event, self.target.pi(pi_target, data)))
|
|
parser.ProcessingInstructionHandler = handler
|
|
else:
|
|
raise ValueError("unknown event %r" % event_name)
|
|
|
|
def _raiseerror(self, value):
|
|
err = ParseError(value)
|
|
err.code = value.code
|
|
err.position = value.lineno, value.offset
|
|
raise err
|
|
|
|
def _fixname(self, key):
|
|
# expand qname, and convert name string to ascii, if possible
|
|
try:
|
|
name = self._names[key]
|
|
except KeyError:
|
|
name = key
|
|
if "}" in name:
|
|
name = "{" + name
|
|
self._names[key] = name
|
|
return name
|
|
|
|
def _start_ns(self, prefix, uri):
|
|
return self.target.start_ns(prefix or '', uri or '')
|
|
|
|
def _end_ns(self, prefix):
|
|
return self.target.end_ns(prefix or '')
|
|
|
|
def _start(self, tag, attr_list):
|
|
# Handler for expat's StartElementHandler. Since ordered_attributes
|
|
# is set, the attributes are reported as a list of alternating
|
|
# attribute name,value.
|
|
fixname = self._fixname
|
|
tag = fixname(tag)
|
|
attrib = {}
|
|
if attr_list:
|
|
for i in range(0, len(attr_list), 2):
|
|
attrib[fixname(attr_list[i])] = attr_list[i+1]
|
|
return self.target.start(tag, attrib)
|
|
|
|
def _end(self, tag):
|
|
return self.target.end(self._fixname(tag))
|
|
|
|
def _default(self, text):
|
|
prefix = text[:1]
|
|
if prefix == "&":
|
|
# deal with undefined entities
|
|
try:
|
|
data_handler = self.target.data
|
|
except AttributeError:
|
|
return
|
|
try:
|
|
data_handler(self.entity[text[1:-1]])
|
|
except KeyError:
|
|
from xml.parsers import expat
|
|
err = expat.error(
|
|
"undefined entity %s: line %d, column %d" %
|
|
(text, self.parser.ErrorLineNumber,
|
|
self.parser.ErrorColumnNumber)
|
|
)
|
|
err.code = 11 # XML_ERROR_UNDEFINED_ENTITY
|
|
err.lineno = self.parser.ErrorLineNumber
|
|
err.offset = self.parser.ErrorColumnNumber
|
|
raise err
|
|
elif prefix == "<" and text[:9] == "<!DOCTYPE":
|
|
self._doctype = [] # inside a doctype declaration
|
|
elif self._doctype is not None:
|
|
# parse doctype contents
|
|
if prefix == ">":
|
|
self._doctype = None
|
|
return
|
|
text = text.strip()
|
|
if not text:
|
|
return
|
|
self._doctype.append(text)
|
|
n = len(self._doctype)
|
|
if n > 2:
|
|
type = self._doctype[1]
|
|
if type == "PUBLIC" and n == 4:
|
|
name, type, pubid, system = self._doctype
|
|
if pubid:
|
|
pubid = pubid[1:-1]
|
|
elif type == "SYSTEM" and n == 3:
|
|
name, type, system = self._doctype
|
|
pubid = None
|
|
else:
|
|
return
|
|
if hasattr(self.target, "doctype"):
|
|
self.target.doctype(name, pubid, system[1:-1])
|
|
elif hasattr(self, "doctype"):
|
|
warnings.warn(
|
|
"The doctype() method of XMLParser is ignored. "
|
|
"Define doctype() method on the TreeBuilder target.",
|
|
RuntimeWarning)
|
|
|
|
self._doctype = None
|
|
|
|
def feed(self, data):
|
|
"""Feed encoded data to parser."""
|
|
try:
|
|
self.parser.Parse(data, False)
|
|
except self._error as v:
|
|
self._raiseerror(v)
|
|
|
|
def close(self):
|
|
"""Finish feeding data to parser and return element structure."""
|
|
try:
|
|
self.parser.Parse(b"", True) # end of data
|
|
except self._error as v:
|
|
self._raiseerror(v)
|
|
try:
|
|
close_handler = self.target.close
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
return close_handler()
|
|
finally:
|
|
# get rid of circular references
|
|
del self.parser, self._parser
|
|
del self.target, self._target
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
# C14N 2.0
|
|
|
|
def canonicalize(xml_data=None, *, out=None, from_file=None, **options):
|
|
"""Convert XML to its C14N 2.0 serialised form.
|
|
|
|
If *out* is provided, it must be a file or file-like object that receives
|
|
the serialised canonical XML output (text, not bytes) through its ``.write()``
|
|
method. To write to a file, open it in text mode with encoding "utf-8".
|
|
If *out* is not provided, this function returns the output as text string.
|
|
|
|
Either *xml_data* (an XML string) or *from_file* (a file path or
|
|
file-like object) must be provided as input.
|
|
|
|
The configuration options are the same as for the ``C14NWriterTarget``.
|
|
"""
|
|
if xml_data is None and from_file is None:
|
|
raise ValueError("Either 'xml_data' or 'from_file' must be provided as input")
|
|
sio = None
|
|
if out is None:
|
|
sio = out = io.StringIO()
|
|
|
|
parser = XMLParser(target=C14NWriterTarget(out.write, **options))
|
|
|
|
if xml_data is not None:
|
|
parser.feed(xml_data)
|
|
parser.close()
|
|
elif from_file is not None:
|
|
parse(from_file, parser=parser)
|
|
|
|
return sio.getvalue() if sio is not None else None
|
|
|
|
|
|
_looks_like_prefix_name = re.compile(r'^\w+:\w+$', re.UNICODE).match
|
|
|
|
|
|
class C14NWriterTarget:
|
|
"""
|
|
Canonicalization writer target for the XMLParser.
|
|
|
|
Serialises parse events to XML C14N 2.0.
|
|
|
|
The *write* function is used for writing out the resulting data stream
|
|
as text (not bytes). To write to a file, open it in text mode with encoding
|
|
"utf-8" and pass its ``.write`` method.
|
|
|
|
Configuration options:
|
|
|
|
- *with_comments*: set to true to include comments
|
|
- *strip_text*: set to true to strip whitespace before and after text content
|
|
- *rewrite_prefixes*: set to true to replace namespace prefixes by "n{number}"
|
|
- *qname_aware_tags*: a set of qname aware tag names in which prefixes
|
|
should be replaced in text content
|
|
- *qname_aware_attrs*: a set of qname aware attribute names in which prefixes
|
|
should be replaced in text content
|
|
- *exclude_attrs*: a set of attribute names that should not be serialised
|
|
- *exclude_tags*: a set of tag names that should not be serialised
|
|
"""
|
|
def __init__(self, write, *,
|
|
with_comments=False, strip_text=False, rewrite_prefixes=False,
|
|
qname_aware_tags=None, qname_aware_attrs=None,
|
|
exclude_attrs=None, exclude_tags=None):
|
|
self._write = write
|
|
self._data = []
|
|
self._with_comments = with_comments
|
|
self._strip_text = strip_text
|
|
self._exclude_attrs = set(exclude_attrs) if exclude_attrs else None
|
|
self._exclude_tags = set(exclude_tags) if exclude_tags else None
|
|
|
|
self._rewrite_prefixes = rewrite_prefixes
|
|
if qname_aware_tags:
|
|
self._qname_aware_tags = set(qname_aware_tags)
|
|
else:
|
|
self._qname_aware_tags = None
|
|
if qname_aware_attrs:
|
|
self._find_qname_aware_attrs = set(qname_aware_attrs).intersection
|
|
else:
|
|
self._find_qname_aware_attrs = None
|
|
|
|
# Stack with globally and newly declared namespaces as (uri, prefix) pairs.
|
|
self._declared_ns_stack = [[
|
|
("http://www.w3.org/XML/1998/namespace", "xml"),
|
|
]]
|
|
# Stack with user declared namespace prefixes as (uri, prefix) pairs.
|
|
self._ns_stack = []
|
|
if not rewrite_prefixes:
|
|
self._ns_stack.append(list(_namespace_map.items()))
|
|
self._ns_stack.append([])
|
|
self._prefix_map = {}
|
|
self._preserve_space = [False]
|
|
self._pending_start = None
|
|
self._root_seen = False
|
|
self._root_done = False
|
|
self._ignored_depth = 0
|
|
|
|
def _iter_namespaces(self, ns_stack, _reversed=reversed):
|
|
for namespaces in _reversed(ns_stack):
|
|
if namespaces: # almost no element declares new namespaces
|
|
yield from namespaces
|
|
|
|
def _resolve_prefix_name(self, prefixed_name):
|
|
prefix, name = prefixed_name.split(':', 1)
|
|
for uri, p in self._iter_namespaces(self._ns_stack):
|
|
if p == prefix:
|
|
return f'{{{uri}}}{name}'
|
|
raise ValueError(f'Prefix {prefix} of QName "{prefixed_name}" is not declared in scope')
|
|
|
|
def _qname(self, qname, uri=None):
|
|
if uri is None:
|
|
uri, tag = qname[1:].rsplit('}', 1) if qname[:1] == '{' else ('', qname)
|
|
else:
|
|
tag = qname
|
|
|
|
prefixes_seen = set()
|
|
for u, prefix in self._iter_namespaces(self._declared_ns_stack):
|
|
if u == uri and prefix not in prefixes_seen:
|
|
return f'{prefix}:{tag}' if prefix else tag, tag, uri
|
|
prefixes_seen.add(prefix)
|
|
|
|
# Not declared yet => add new declaration.
|
|
if self._rewrite_prefixes:
|
|
if uri in self._prefix_map:
|
|
prefix = self._prefix_map[uri]
|
|
else:
|
|
prefix = self._prefix_map[uri] = f'n{len(self._prefix_map)}'
|
|
self._declared_ns_stack[-1].append((uri, prefix))
|
|
return f'{prefix}:{tag}', tag, uri
|
|
|
|
if not uri and '' not in prefixes_seen:
|
|
# No default namespace declared => no prefix needed.
|
|
return tag, tag, uri
|
|
|
|
for u, prefix in self._iter_namespaces(self._ns_stack):
|
|
if u == uri:
|
|
self._declared_ns_stack[-1].append((uri, prefix))
|
|
return f'{prefix}:{tag}' if prefix else tag, tag, uri
|
|
|
|
if not uri:
|
|
# As soon as a default namespace is defined,
|
|
# anything that has no namespace (and thus, no prefix) goes there.
|
|
return tag, tag, uri
|
|
|
|
raise ValueError(f'Namespace "{uri}" is not declared in scope')
|
|
|
|
def data(self, data):
|
|
if not self._ignored_depth:
|
|
self._data.append(data)
|
|
|
|
def _flush(self, _join_text=''.join):
|
|
data = _join_text(self._data)
|
|
del self._data[:]
|
|
if self._strip_text and not self._preserve_space[-1]:
|
|
data = data.strip()
|
|
if self._pending_start is not None:
|
|
args, self._pending_start = self._pending_start, None
|
|
qname_text = data if data and _looks_like_prefix_name(data) else None
|
|
self._start(*args, qname_text)
|
|
if qname_text is not None:
|
|
return
|
|
if data and self._root_seen:
|
|
self._write(_escape_cdata_c14n(data))
|
|
|
|
def start_ns(self, prefix, uri):
|
|
if self._ignored_depth:
|
|
return
|
|
# we may have to resolve qnames in text content
|
|
if self._data:
|
|
self._flush()
|
|
self._ns_stack[-1].append((uri, prefix))
|
|
|
|
def start(self, tag, attrs):
|
|
if self._exclude_tags is not None and (
|
|
self._ignored_depth or tag in self._exclude_tags):
|
|
self._ignored_depth += 1
|
|
return
|
|
if self._data:
|
|
self._flush()
|
|
|
|
new_namespaces = []
|
|
self._declared_ns_stack.append(new_namespaces)
|
|
|
|
if self._qname_aware_tags is not None and tag in self._qname_aware_tags:
|
|
# Need to parse text first to see if it requires a prefix declaration.
|
|
self._pending_start = (tag, attrs, new_namespaces)
|
|
return
|
|
self._start(tag, attrs, new_namespaces)
|
|
|
|
def _start(self, tag, attrs, new_namespaces, qname_text=None):
|
|
if self._exclude_attrs is not None and attrs:
|
|
attrs = {k: v for k, v in attrs.items() if k not in self._exclude_attrs}
|
|
|
|
qnames = {tag, *attrs}
|
|
resolved_names = {}
|
|
|
|
# Resolve prefixes in attribute and tag text.
|
|
if qname_text is not None:
|
|
qname = resolved_names[qname_text] = self._resolve_prefix_name(qname_text)
|
|
qnames.add(qname)
|
|
if self._find_qname_aware_attrs is not None and attrs:
|
|
qattrs = self._find_qname_aware_attrs(attrs)
|
|
if qattrs:
|
|
for attr_name in qattrs:
|
|
value = attrs[attr_name]
|
|
if _looks_like_prefix_name(value):
|
|
qname = resolved_names[value] = self._resolve_prefix_name(value)
|
|
qnames.add(qname)
|
|
else:
|
|
qattrs = None
|
|
else:
|
|
qattrs = None
|
|
|
|
# Assign prefixes in lexicographical order of used URIs.
|
|
parse_qname = self._qname
|
|
parsed_qnames = {n: parse_qname(n) for n in sorted(
|
|
qnames, key=lambda n: n.split('}', 1))}
|
|
|
|
# Write namespace declarations in prefix order ...
|
|
if new_namespaces:
|
|
attr_list = [
|
|
('xmlns:' + prefix if prefix else 'xmlns', uri)
|
|
for uri, prefix in new_namespaces
|
|
]
|
|
attr_list.sort()
|
|
else:
|
|
# almost always empty
|
|
attr_list = []
|
|
|
|
# ... followed by attributes in URI+name order
|
|
if attrs:
|
|
for k, v in sorted(attrs.items()):
|
|
if qattrs is not None and k in qattrs and v in resolved_names:
|
|
v = parsed_qnames[resolved_names[v]][0]
|
|
attr_qname, attr_name, uri = parsed_qnames[k]
|
|
# No prefix for attributes in default ('') namespace.
|
|
attr_list.append((attr_qname if uri else attr_name, v))
|
|
|
|
# Honour xml:space attributes.
|
|
space_behaviour = attrs.get('{http://www.w3.org/XML/1998/namespace}space')
|
|
self._preserve_space.append(
|
|
space_behaviour == 'preserve' if space_behaviour
|
|
else self._preserve_space[-1])
|
|
|
|
# Write the tag.
|
|
write = self._write
|
|
write('<' + parsed_qnames[tag][0])
|
|
if attr_list:
|
|
write(''.join([f' {k}="{_escape_attrib_c14n(v)}"' for k, v in attr_list]))
|
|
write('>')
|
|
|
|
# Write the resolved qname text content.
|
|
if qname_text is not None:
|
|
write(_escape_cdata_c14n(parsed_qnames[resolved_names[qname_text]][0]))
|
|
|
|
self._root_seen = True
|
|
self._ns_stack.append([])
|
|
|
|
def end(self, tag):
|
|
if self._ignored_depth:
|
|
self._ignored_depth -= 1
|
|
return
|
|
if self._data:
|
|
self._flush()
|
|
self._write(f'</{self._qname(tag)[0]}>')
|
|
self._preserve_space.pop()
|
|
self._root_done = len(self._preserve_space) == 1
|
|
self._declared_ns_stack.pop()
|
|
self._ns_stack.pop()
|
|
|
|
def comment(self, text):
|
|
if not self._with_comments:
|
|
return
|
|
if self._ignored_depth:
|
|
return
|
|
if self._root_done:
|
|
self._write('\n')
|
|
elif self._root_seen and self._data:
|
|
self._flush()
|
|
self._write(f'<!--{_escape_cdata_c14n(text)}-->')
|
|
if not self._root_seen:
|
|
self._write('\n')
|
|
|
|
def pi(self, target, data):
|
|
if self._ignored_depth:
|
|
return
|
|
if self._root_done:
|
|
self._write('\n')
|
|
elif self._root_seen and self._data:
|
|
self._flush()
|
|
self._write(
|
|
f'<?{target} {_escape_cdata_c14n(data)}?>' if data else f'<?{target}?>')
|
|
if not self._root_seen:
|
|
self._write('\n')
|
|
|
|
|
|
def _escape_cdata_c14n(text):
|
|
# escape character data
|
|
try:
|
|
# it's worth avoiding do-nothing calls for strings that are
|
|
# shorter than 500 character, or so. assume that's, by far,
|
|
# the most common case in most applications.
|
|
if '&' in text:
|
|
text = text.replace('&', '&')
|
|
if '<' in text:
|
|
text = text.replace('<', '<')
|
|
if '>' in text:
|
|
text = text.replace('>', '>')
|
|
if '\r' in text:
|
|
text = text.replace('\r', '
')
|
|
return text
|
|
except (TypeError, AttributeError):
|
|
_raise_serialization_error(text)
|
|
|
|
|
|
def _escape_attrib_c14n(text):
|
|
# escape attribute value
|
|
try:
|
|
if '&' in text:
|
|
text = text.replace('&', '&')
|
|
if '<' in text:
|
|
text = text.replace('<', '<')
|
|
if '"' in text:
|
|
text = text.replace('"', '"')
|
|
if '\t' in text:
|
|
text = text.replace('\t', '	')
|
|
if '\n' in text:
|
|
text = text.replace('\n', '
')
|
|
if '\r' in text:
|
|
text = text.replace('\r', '
')
|
|
return text
|
|
except (TypeError, AttributeError):
|
|
_raise_serialization_error(text)
|
|
|
|
|
|
# --------------------------------------------------------------------
|
|
|
|
# Import the C accelerators
|
|
try:
|
|
# Element is going to be shadowed by the C implementation. We need to keep
|
|
# the Python version of it accessible for some "creative" by external code
|
|
# (see tests)
|
|
_Element_Py = Element
|
|
|
|
# Element, SubElement, ParseError, TreeBuilder, XMLParser, _set_factories
|
|
from _elementtree import *
|
|
from _elementtree import _set_factories
|
|
except ImportError:
|
|
pass
|
|
else:
|
|
_set_factories(Comment, ProcessingInstruction)
|