#

# ElementTree

# $Id: ElementTree.py 3440 2008-07-18 14:45:01Z fredrik $

#

# light-weight XML support for Python 2.3 and later.

#

# history (since 1.2.6):

# 2005-11-12 fl added tostringlist/fromstringlist helpers

# 2006-07-05 fl merged in selected changes from the 1.3 sandbox

# 2006-07-05 fl removed support for 2.1 and earlier

# 2007-06-21 fl added deprecation/future warnings

# 2007-08-25 fl added doctype hook, added parser version attribute etc

# 2007-08-26 fl added new serializer code (better namespace handling, etc)

# 2007-08-27 fl warn for broken /tag searches on tree level

# 2007-09-02 fl added html/text methods to serializer (experimental)

# 2007-09-05 fl added method argument to tostring/tostringlist

# 2007-09-06 fl improved error handling

# 2007-09-13 fl added itertext, iterfind; assorted cleanups

# 2007-12-15 fl added C14N hooks, copy method (experimental)

#

# Copyright (c) 1999-2008 by Fredrik Lundh. All rights reserved.

#

# [email protected]

# 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.

# --------------------------------------------------------------------

# Licensed to PSF under a Contributor Agreement.

# See http://www.python.org/psf/license for licensing details.

__all__ = [

# public symbols

"Comment",

"dump",

"Element", "ElementTree",

"fromstring", "fromstringlist",

"iselement", "iterparse",

"parse", "ParseError",

"PI", "ProcessingInstruction",

"QName",

"SubElement",

"tostring", "tostringlist",

"TreeBuilder",

"VERSION",

"XML", "XMLID",

"XMLParser", "XMLTreeBuilder",

"register_namespace",

]

VERSION = "1.3.0"

##

# The <b>Element</b> type is a flexible container object, designed to

# store hierarchical data structures in memory. The type can be

# described as a cross between a list and a dictionary.

# <p>

# Each element has a number of properties associated with it:

# <ul>

# <li>a <i>tag</i>. This is a string identifying what kind of data

# this element represents (the element type, in other words).</li>

# <li>a number of <i>attributes</i>, stored in a Python dictionary.</li>

# <li>a <i>text</i> string.</li>

# <li>an optional <i>tail</i> string.</li>

# <li>a number of <i>child elements</i>, stored in a Python sequence</li>

# </ul>

#

# To create an element instance, use the {@link #Element} constructor

# or the {@link #SubElement} factory function.

# <p>

# The {@link #ElementTree} class can be used to wrap an element

# structure, and convert it from and to XML.

##

import sys

import re

import warnings

import io

import contextlib

from . import ElementPath

##

# Parser error. This is a subclass of <b>SyntaxError</b>.

# <p>

# In addition to the exception value, an exception instance contains a

# specific exception code in the <b>code</b> attribute, and the line and

# column of the error in the <b>position</b> attribute.

class ParseError(SyntaxError):

pass

# --------------------------------------------------------------------

##

# Checks if an object appears to be a valid element object.

#

# @param An element instance.

# @return A true value if this is an element object.

# @defreturn flag

def iselement(element):

# FIXME: not sure about this;

# isinstance(element, Element) or look for tag/attrib/text attributes

return hasattr(element, 'tag')

##

# Element class. This class defines the Element interface, and

# provides a reference implementation of this interface.

# <p>

# The element name, attribute names, and attribute values can be

# either ASCII strings (ordinary Python strings containing only 7-bit

# ASCII characters) or Unicode strings.

#

# @param tag The element name.

# @param attrib An optional dictionary, containing element attributes.

# @param **extra Additional attributes, given as keyword arguments.

# @see Element

# @see SubElement

# @see Comment

# @see ProcessingInstruction

class Element:

# <tag attrib>text<child/>...</tag>tail

##

# (Attribute) Element tag.

tag = None

##

# (Attribute) Element attribute dictionary. Where possible, use

# {@link #Element.get},

# {@link #Element.set},

# {@link #Element.keys}, and

# {@link #Element.items} to access

# element attributes.

attrib = None

##

# (Attribute) Text before first subelement. 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.

text = None

##

# (Attribute) 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.

tail = None # text after end tag, if any

# constructor

def __init__(self, tag, attrib={}, **extra):

if not isinstance(attrib, dict):

raise TypeError("attrib must be dict, not %s" % (

attrib.__class__.__name__,))

attrib = attrib.copy()

attrib.update(extra)

self.tag = tag

self.attrib = attrib

self._children = []

def __repr__(self):

return "<Element %s at 0x%x>" % (repr(self.tag), id(self))

##

# Creates a new element object of the same type as this element.

#

# @param tag Element tag.

# @param attrib Element attributes, given as a dictionary.

# @return A new element instance.

def makeelement(self, tag, attrib):

return self.__class__(tag, attrib)

##

# (Experimental) Copies the current element. This creates a

# shallow copy; subelements will be shared with the original tree.

#

# @return A new element instance.

def copy(self):

elem = self.makeelement(self.tag, self.attrib)

elem.text = self.text

elem.tail = self.tail

elem[:] = self

return elem

##

# Returns the number of subelements. Note that this only counts

# full elements; to check if there's any content in an element, you

# have to check both the length and the <b>text</b> attribute.

#

# @return The number of subelements.

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

##

# Returns the given subelement, by index.

#

# @param index What subelement to return.

# @return The given subelement.

# @exception IndexError If the given element does not exist.

def __getitem__(self, index):

return self._children[index]

##

# Replaces the given subelement, by index.

#

# @param index What subelement to replace.

# @param element The new element value.

# @exception IndexError If the given element does not exist.

def __setitem__(self, index, element):

# if isinstance(index, slice):

# for elt in element:

# assert iselement(elt)

# else:

# assert iselement(element)

self._children[index] = element

##

# Deletes the given subelement, by index.

#

# @param index What subelement to delete.

# @exception IndexError If the given element does not exist.

def __delitem__(self, index):

del self._children[index]

##

# Adds a subelement to the end of this element. In document order,

# the new element will appear after the last existing subelement (or

# directly after the text, if it's the first subelement), but before

# the end tag for this element.

#

# @param element The element to add.

def append(self, element):

self._assert_is_element(element)

self._children.append(element)

##

# Appends subelements from a sequence.

#

# @param elements A sequence object with zero or more elements.

# @since 1.3

def extend(self, elements):

for element in elements:

self._assert_is_element(element)

self._children.extend(elements)

##

# Inserts a subelement at the given position in this element.

#

# @param index Where to insert the new subelement.

def insert(self, index, element):

self._assert_is_element(element)

self._children.insert(index, element)

def _assert_is_element(self, e):

# Need to refer to the actual Python implementation, not the

# shadowing C implementation.

if not isinstance(e, _Element):

raise TypeError('expected an Element, not %s' % type(e).__name__)

##

# Removes a matching subelement. Unlike the <b>find</b> methods,

# this method compares elements based on identity, not on tag

# value or contents. To remove subelements by other means, the

# easiest way is often to use a list comprehension to select what

# elements to keep, and use slice assignment to update the parent

# element.

#

# @param element What element to remove.

# @exception ValueError If a matching element could not be found.

def remove(self, element):

# assert iselement(element)

self._children.remove(element)

##

# (Deprecated) Returns all subelements. The elements are returned

# in document order.

#

# @return A list of subelements.

# @defreturn list of Element instances

def getchildren(self):

warnings.warn(

"This method will be removed in future versions. "

"Use 'list(elem)' or iteration over elem instead.",

DeprecationWarning, stacklevel=2

)

return self._children

##

# Finds the first matching subelement, by tag name or path.

#

# @param path What element to look for.

# @keyparam namespaces Optional namespace prefix map.

# @return The first matching element, or None if no element was found.

# @defreturn Element or None

def find(self, path, namespaces=None):

return ElementPath.find(self, path, namespaces)

##

# Finds text for the first matching subelement, by tag name or path.

#

# @param path What element to look for.

# @param default What to return if the element was not found.

# @keyparam namespaces Optional namespace prefix map.

# @return The text content of the first matching element, or the

# default value no element was found. Note that if the element

# is found, but has no text content, this method returns an

# empty string.

# @defreturn string

def findtext(self, path, default=None, namespaces=None):

return ElementPath.findtext(self, path, default, namespaces)

##

# Finds all matching subelements, by tag name or path.

#

# @param path What element to look for.

# @keyparam namespaces Optional namespace prefix map.

# @return A list or other sequence containing all matching elements,

# in document order.

# @defreturn list of Element instances

def findall(self, path, namespaces=None):

return ElementPath.findall(self, path, namespaces)

##

# Finds all matching subelements, by tag name or path.

#

# @param path What element to look for.

# @keyparam namespaces Optional namespace prefix map.

# @return An iterator or sequence containing all matching elements,

# in document order.

# @defreturn a generated sequence of Element instances

def iterfind(self, path, namespaces=None):

return ElementPath.iterfind(self, path, namespaces)

##

# Resets an element. This function removes all subelements, clears

# all attributes, and sets the <b>text</b> and <b>tail</b> attributes

# to None.

def clear(self):

self.attrib.clear()

self._children = []

self.text = self.tail = None

##

# Gets an element attribute. Equivalent to <b>attrib.get</b>, but

# some implementations may handle this a bit more efficiently.

#

# @param key What attribute to look for.

# @param default What to return if the attribute was not found.

# @return The attribute value, or the default value, if the

# attribute was not found.

# @defreturn string or None

def get(self, key, default=None):

return self.attrib.get(key, default)

##

# Sets an element attribute. Equivalent to <b>attrib[key] = value</b>,

# but some implementations may handle this a bit more efficiently.

#

# @param key What attribute to set.

# @param value The attribute value.

def set(self, key, value):

self.attrib[key] = value

##

# Gets a list of attribute names. The names are returned in an

# arbitrary order (just like for an ordinary Python dictionary).

# Equivalent to <b>attrib.keys()</b>.

#

# @return A list of element attribute names.

# @defreturn list of strings

def keys(self):

return self.attrib.keys()

##

# Gets element attributes, as a sequence. The attributes are

# returned in an arbitrary order. Equivalent to <b>attrib.items()</b>.

#

# @return A list of (name, value) tuples for all attributes.

# @defreturn list of (string, string) tuples

def items(self):

return self.attrib.items()

##

# Creates a tree iterator. The iterator loops over this element

# and all subelements, in document order, and returns all elements

# with a matching tag.

# <p>

# 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.

#

# @param tag What tags to look for (default is to return all elements).

# @return An iterator containing all the matching elements.

# @defreturn iterator

def iter(self, tag=None):

if tag == "*":

tag = None

if tag is None or self.tag == tag:

yield self

for e in self._children:

for e in e.iter(tag):

yield e

# compatibility

def getiterator(self, tag=None):

# Change for a DeprecationWarning in 1.4

warnings.warn(

"This method will be removed in future versions. "

"Use 'elem.iter()' or 'list(elem.iter())' instead.",

PendingDeprecationWarning, stacklevel=2

)

return list(self.iter(tag))

##

# Creates a text iterator. The iterator loops over this element

# and all subelements, in document order, and returns all inner

# text.

#

# @return An iterator containing all inner text.

# @defreturn iterator

def itertext(self):

tag = self.tag

if not isinstance(tag, str) and tag is not None:

return

if self.text:

yield self.text

for e in self:

for s in e.itertext():

yield s

if e.tail:

yield e.tail

# compatibility

_Element = _ElementInterface = Element

##

# Subelement factory. This function creates an element instance, and

# appends it to an existing element.

# <p>

# The element name, attribute names, and attribute values can be

# either 8-bit ASCII strings or Unicode strings.

#

# @param parent The parent element.

# @param tag The subelement name.

# @param attrib An optional dictionary, containing element attributes.

# @param **extra Additional attributes, given as keyword arguments.

# @return An element instance.

# @defreturn Element

def SubElement(parent, tag, attrib={}, **extra):

attrib = attrib.copy()

attrib.update(extra)

element = parent.makeelement(tag, attrib)

parent.append(element)

return element

##

# Comment element factory. This factory function creates a special

# element that will be serialized as an XML comment by the standard

# serializer.

# <p>

# The comment string can be either an 8-bit ASCII string or a Unicode

# string.

#

# @param text A string containing the comment string.

# @return An element instance, representing a comment.

# @defreturn Element

def Comment(text=None):

element = Element(Comment)

element.text = text

return element

##

# PI element factory. This factory function creates a special element

# that will be serialized as an XML processing instruction by the standard

# serializer.

#

# @param target A string containing the PI target.

# @param text A string containing the PI contents, if any.

# @return An element instance, representing a PI.

# @defreturn Element

def ProcessingInstruction(target, text=None):

element = Element(ProcessingInstruction)

element.text = target

if text:

element.text = element.text + " " + text

return element

PI = ProcessingInstruction

##

# QName wrapper. This can be used to wrap a QName attribute value, in

# order to get proper namespace handling on output.

#

# @param text A string containing the QName value, in the form {uri}local,

# or, if the tag argument is given, the URI part of a QName.

# @param tag Optional tag. If given, the first argument is interpreted as

# an URI, and this argument is interpreted as a local name.

# @return An opaque object, representing the QName.

class QName:

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 '<QName %r>' % (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

def __ne__(self, other):

if isinstance(other, QName):

return self.text != other.text

return self.text != other

# --------------------------------------------------------------------

##

# ElementTree wrapper class. This class represents an entire element

# hierarchy, and adds some extra support for serialization to and from

# standard XML.

#

# @param element Optional root element.

# @keyparam file Optional file handle or file name. If given, the

# tree is initialized with the contents of this XML file.

class ElementTree:

def __init__(self, element=None, file=None):

# assert element is None or iselement(element)

self._root = element # first node

if file:

self.parse(file)

##

# Gets the root element for this tree.

#

# @return An element instance.

# @defreturn Element

def getroot(self):

return self._root

##

# Replaces the root element for this tree. This discards the

# current contents of the tree, and replaces it with the given

# element. Use with care.

#

# @param element An element instance.

def _setroot(self, element):

# assert iselement(element)

self._root = element

##

# Loads an external XML document into this element tree.

#

# @param source A file name or file object. If a file object is

# given, it only has to implement a <b>read(n)</b> method.

# @keyparam parser An optional parser instance. If not given, the

# standard {@link XMLParser} parser is used.

# @return The document root element.

# @defreturn Element

# @exception ParseError If the parser fails to parse the document.

def parse(self, source, parser=None):

close_source = False

if not hasattr(source, "read"):

source = open(source, "rb")

close_source = True

try:

if not parser:

parser = XMLParser(target=TreeBuilder())

while 1:

data = source.read(65536)

if not data:

break

parser.feed(data)

self._root = parser.close()

return self._root

finally:

if close_source:

source.close()

##

# Creates a tree iterator for the root element. The iterator loops

# over all elements in this tree, in document order.

#

# @param tag What tags to look for (default is to return all elements)

# @return An iterator.

# @defreturn iterator

def iter(self, tag=None):

# assert self._root is not None

return self._root.iter(tag)

# compatibility

def getiterator(self, tag=None):

# Change for a DeprecationWarning in 1.4

warnings.warn(

"This method will be removed in future versions. "

"Use 'tree.iter()' or 'list(tree.iter())' instead.",

PendingDeprecationWarning, stacklevel=2

)

return list(self.iter(tag))

##

# Same as getroot().find(path), starting at the root of the tree.

#

# @param path What element to look for.

# @keyparam namespaces Optional namespace prefix map.

# @return The first matching element, or None if no element was found.

# @defreturn Element or None

def find(self, path, namespaces=None):

# 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)

##

# Same as getroot().findtext(path), starting at the root of the tree.

#

# @param path What element to look for.

# @param default What to return if the element was not found.

# @keyparam namespaces Optional namespace prefix map.

# @return The text content of the first matching element, or the

# default value no element was found. Note that if the element

# is found, but has no text content, this method returns an

# empty string.

# @defreturn string

def findtext(self, path, default=None, namespaces=None):

# 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)

##

# Same as getroot().findall(path), starting at the root of the tree.

#

# @param path What element to look for.

# @keyparam namespaces Optional namespace prefix map.

# @return A list or iterator containing all matching elements,

# in document order.

# @defreturn list of Element instances

def findall(self, path, namespaces=None):

# 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)

##

# Finds all matching subelements, by tag name or path.

# Same as getroot().iterfind(path).

#

# @param path What element to look for.

# @keyparam namespaces Optional namespace prefix map.

# @return An iterator or sequence containing all matching elements,

# in document order.

# @defreturn a generated sequence of Element instances

def iterfind(self, path, namespaces=None):

# 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)

##

# Writes the element tree to a file, as XML.

#

# @def write(file, **options)

# @param file A file name, or a file object opened for writing.

# @param **options Options, given as keyword arguments.

# @keyparam encoding Optional output encoding (default is US-ASCII).

# Use "unicode" to return a Unicode string.

# @keyparam xml_declaration Controls if an XML declaration should

# be added to the file. Use False for never, True for always,

# None for only if not US-ASCII or UTF-8 or Unicode. None is default.

# @keyparam default_namespace Sets the default XML namespace (for "xmlns").

# @keyparam method Optional output method ("xml", "html", "text" or

# "c14n"; default is "xml").

def write(self, file_or_filename,

encoding=None,

xml_declaration=None,

default_namespace=None,

method=None):

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"

else:

encoding = encoding.lower()

with _get_writer(file_or_filename, encoding) as write:

if method == "xml" and (xml_declaration or

(xml_declaration is None and

encoding not in ("utf-8", "us-ascii", "unicode"))):

declared_encoding = encoding

if encoding == "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)

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):

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)

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 sorted(items): # lexical order

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):

write(">")

if text:

write(_escape_cdata(text))

for e in elem:

_serialize_xml(write, e, qnames, None)

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: