python模块：xml.dom.minidom

 """Simple implementation of the Level 1 DOM.

 Namespaces and other minor Level 2 features are also supported.

 parse("foo.xml")

 parseString("<foo><bar/></foo>")

 Todo:
 =====
  * convenience methods for getting elements and text.
  * more testing
  * bring some of the writer and linearizer code into conformance with this
         interface
  * SAX 2 namespaces
 """

 import io
 import xml.dom

 from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE, domreg
 from xml.dom.minicompat import *
 from xml.dom.xmlbuilder import DOMImplementationLS, DocumentLS

 # This is used by the ID-cache invalidation checks; the list isn't
 # actually complete, since the nodes being checked will never be the
 # DOCUMENT_NODE or DOCUMENT_FRAGMENT_NODE.  (The node being checked is
 # the node being added or removed, not the node being modified.)
 #
 _nodeTypes_with_children = (xml.dom.Node.ELEMENT_NODE,
                             xml.dom.Node.ENTITY_REFERENCE_NODE)

 class Node(xml.dom.Node):
     namespaceURI = None # this is non-null only for elements and attributes
     parentNode = None
     ownerDocument = None
     nextSibling = None
     previousSibling = None

     prefix = EMPTY_PREFIX # non-null only for NS elements and attributes

     def __bool__(self):
         return True

     def toxml(self, encoding=None):
         return self.toprettyxml("", "", encoding)

     def toprettyxml(self, indent="\t", newl="\n", encoding=None):
         if encoding is None:
             writer = io.StringIO()
         else:
             writer = io.TextIOWrapper(io.BytesIO(),
                                       encoding=encoding,
                                       errors="xmlcharrefreplace",
                                       newline='\n')
         if self.nodeType == Node.DOCUMENT_NODE:
             # Can pass encoding only to document, to put it into XML header
             self.writexml(writer, "", indent, newl, encoding)
         else:
             self.writexml(writer, "", indent, newl)
         if encoding is None:
             return writer.getvalue()
         else:
             return writer.detach().getvalue()

     def hasChildNodes(self):
         return bool(self.childNodes)

     def _get_childNodes(self):
         return self.childNodes

     def _get_firstChild(self):
         if self.childNodes:
             return self.childNodes[0]

     def _get_lastChild(self):
         if self.childNodes:
             return self.childNodes[-1]

     def insertBefore(self, newChild, refChild):
         if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
             for c in tuple(newChild.childNodes):
                 self.insertBefore(c, refChild)
             ### The DOM does not clearly specify what to return in this case
             return newChild
         if newChild.nodeType not in self._child_node_types:
             raise xml.dom.HierarchyRequestErr(
                 "%s cannot be child of %s" % (repr(newChild), repr(self)))
         if newChild.parentNode is not None:
             newChild.parentNode.removeChild(newChild)
         if refChild is None:
             self.appendChild(newChild)
         else:
             try:
                 index = self.childNodes.index(refChild)
             except ValueError:
                 raise xml.dom.NotFoundErr()
             if newChild.nodeType in _nodeTypes_with_children:
                 _clear_id_cache(self)
             self.childNodes.insert(index, newChild)
             newChild.nextSibling = refChild
             refChild.previousSibling = newChild
             if index:
                 node = self.childNodes[index-1]
                 node.nextSibling = newChild
                 newChild.previousSibling = node
             else:
                 newChild.previousSibling = None
             newChild.parentNode = self
         return newChild

     def appendChild(self, node):
         if node.nodeType == self.DOCUMENT_FRAGMENT_NODE:
             for c in tuple(node.childNodes):
                 self.appendChild(c)
             ### The DOM does not clearly specify what to return in this case
             return node
         if node.nodeType not in self._child_node_types:
             raise xml.dom.HierarchyRequestErr(
                 "%s cannot be child of %s" % (repr(node), repr(self)))
         elif node.nodeType in _nodeTypes_with_children:
             _clear_id_cache(self)
         if node.parentNode is not None:
             node.parentNode.removeChild(node)
         _append_child(self, node)
         node.nextSibling = None
         return node

     def replaceChild(self, newChild, oldChild):
         if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
             refChild = oldChild.nextSibling
             self.removeChild(oldChild)
             return self.insertBefore(newChild, refChild)
         if newChild.nodeType not in self._child_node_types:
             raise xml.dom.HierarchyRequestErr(
                 "%s cannot be child of %s" % (repr(newChild), repr(self)))
         if newChild is oldChild:
             return
         if newChild.parentNode is not None:
             newChild.parentNode.removeChild(newChild)
         try:
             index = self.childNodes.index(oldChild)
         except ValueError:
             raise xml.dom.NotFoundErr()
         self.childNodes[index] = newChild
         newChild.parentNode = self
         oldChild.parentNode = None
         if (newChild.nodeType in _nodeTypes_with_children
             or oldChild.nodeType in _nodeTypes_with_children):
             _clear_id_cache(self)
         newChild.nextSibling = oldChild.nextSibling
         newChild.previousSibling = oldChild.previousSibling
         oldChild.nextSibling = None
         oldChild.previousSibling = None
         if newChild.previousSibling:
             newChild.previousSibling.nextSibling = newChild
         if newChild.nextSibling:
             newChild.nextSibling.previousSibling = newChild
         return oldChild

     def removeChild(self, oldChild):
         try:
             self.childNodes.remove(oldChild)
         except ValueError:
             raise xml.dom.NotFoundErr()
         if oldChild.nextSibling is not None:
             oldChild.nextSibling.previousSibling = oldChild.previousSibling
         if oldChild.previousSibling is not None:
             oldChild.previousSibling.nextSibling = oldChild.nextSibling
         oldChild.nextSibling = oldChild.previousSibling = None
         if oldChild.nodeType in _nodeTypes_with_children:
             _clear_id_cache(self)

         oldChild.parentNode = None
         return oldChild

     def normalize(self):
         L = []
         for child in self.childNodes:
             if child.nodeType == Node.TEXT_NODE:
                 if not child.data:
                     # empty text node; discard
                     if L:
                         L[-1].nextSibling = child.nextSibling
                     if child.nextSibling:
                         child.nextSibling.previousSibling = child.previousSibling
                     child.unlink()
                 elif L and L[-1].nodeType == child.nodeType:
                     # collapse text node
                     node = L[-1]
                     node.data = node.data + child.data
                     node.nextSibling = child.nextSibling
                     if child.nextSibling:
                         child.nextSibling.previousSibling = node
                     child.unlink()
                 else:
                     L.append(child)
             else:
                 L.append(child)
                 if child.nodeType == Node.ELEMENT_NODE:
                     child.normalize()
         self.childNodes[:] = L

     def cloneNode(self, deep):
         return _clone_node(self, deep, self.ownerDocument or self)

     def isSupported(self, feature, version):
         return self.ownerDocument.implementation.hasFeature(feature, version)

     def _get_localName(self):
         # Overridden in Element and Attr where localName can be Non-Null
         return None

     # Node interfaces from Level 3 (WD 9 April 2002)

     def isSameNode(self, other):
         return self is other

     def getInterface(self, feature):
         if self.isSupported(feature, None):
             return self
         else:
             return None

     # The "user data" functions use a dictionary that is only present
     # if some user data has been set, so be careful not to assume it
     # exists.

     def getUserData(self, key):
         try:
             return self._user_data[key][0]
         except (AttributeError, KeyError):
             return None

     def setUserData(self, key, data, handler):
         old = None
         try:
             d = self._user_data
         except AttributeError:
             d = {}
             self._user_data = d
         if key in d:
             old = d[key][0]
         if data is None:
             # ignore handlers passed for None
             handler = None
             if old is not None:
                 del d[key]
         else:
             d[key] = (data, handler)
         return old

     def _call_user_data_handler(self, operation, src, dst):
         if hasattr(self, "_user_data"):
             for key, (data, handler) in list(self._user_data.items()):
                 if handler is not None:
                     handler.handle(operation, key, data, src, dst)

     # minidom-specific API:

     def unlink(self):
         self.parentNode = self.ownerDocument = None
         if self.childNodes:
             for child in self.childNodes:
                 child.unlink()
             self.childNodes = NodeList()
         self.previousSibling = None
         self.nextSibling = None

     # A Node is its own context manager, to ensure that an unlink() call occurs.
     # This is similar to how a file object works.
     def __enter__(self):
         return self

     def __exit__(self, et, ev, tb):
         self.unlink()

 defproperty(Node, "firstChild", doc="First child node, or None.")
 defproperty(Node, "lastChild",  doc="Last child node, or None.")
 defproperty(Node, "localName",  doc="Namespace-local name of this node.")

 def _append_child(self, node):
     # fast path with less checks; usable by DOM builders if careful
     childNodes = self.childNodes
     if childNodes:
         last = childNodes[-1]
         node.previousSibling = last
         last.nextSibling = node
     childNodes.append(node)
     node.parentNode = self

 def _in_document(node):
     # return True iff node is part of a document tree
     while node is not None:
         if node.nodeType == Node.DOCUMENT_NODE:
             return True
         node = node.parentNode
     return False

 def _write_data(writer, data):
     "Writes datachars to writer."
     if data:
         data = data.replace("&", "&amp;").replace("<", "&lt;"). \
                     replace("\"", "&quot;").replace(">", "&gt;")
         writer.write(data)

 def _get_elements_by_tagName_helper(parent, name, rc):
     for node in parent.childNodes:
         if node.nodeType == Node.ELEMENT_NODE and \
             (name == "*" or node.tagName == name):
             rc.append(node)
         _get_elements_by_tagName_helper(node, name, rc)
     return rc

 def _get_elements_by_tagName_ns_helper(parent, nsURI, localName, rc):
     for node in parent.childNodes:
         if node.nodeType == Node.ELEMENT_NODE:
             if ((localName == "*" or node.localName == localName) and
                 (nsURI == "*" or node.namespaceURI == nsURI)):
                 rc.append(node)
             _get_elements_by_tagName_ns_helper(node, nsURI, localName, rc)
     return rc

 class DocumentFragment(Node):
     nodeType = Node.DOCUMENT_FRAGMENT_NODE
     nodeName = "#document-fragment"
     nodeValue = None
     attributes = None
     parentNode = None
     _child_node_types = (Node.ELEMENT_NODE,
                          Node.TEXT_NODE,
                          Node.CDATA_SECTION_NODE,
                          Node.ENTITY_REFERENCE_NODE,
                          Node.PROCESSING_INSTRUCTION_NODE,
                          Node.COMMENT_NODE,
                          Node.NOTATION_NODE)

     def __init__(self):
         self.childNodes = NodeList()

 class Attr(Node):
     __slots__=('_name', '_value', 'namespaceURI',
                '_prefix', 'childNodes', '_localName', 'ownerDocument', 'ownerElement')
     nodeType = Node.ATTRIBUTE_NODE
     attributes = None
     specified = False
     _is_id = False

     _child_node_types = (Node.TEXT_NODE, Node.ENTITY_REFERENCE_NODE)

     def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None,
                  prefix=None):
         self.ownerElement = None
         self._name = qName
         self.namespaceURI = namespaceURI
         self._prefix = prefix
         self.childNodes = NodeList()

         # Add the single child node that represents the value of the attr
         self.childNodes.append(Text())

         # nodeValue and value are set elsewhere

     def _get_localName(self):
         try:
             return self._localName
         except AttributeError:
             return self.nodeName.split(":", 1)[-1]

     def _get_specified(self):
         return self.specified

     def _get_name(self):
         return self._name

     def _set_name(self, value):
         self._name = value
         if self.ownerElement is not None:
             _clear_id_cache(self.ownerElement)

     nodeName = name = property(_get_name, _set_name)

     def _get_value(self):
         return self._value

     def _set_value(self, value):
         self._value = value
         self.childNodes[0].data = value
         if self.ownerElement is not None:
             _clear_id_cache(self.ownerElement)
         self.childNodes[0].data = value

     nodeValue = value = property(_get_value, _set_value)

     def _get_prefix(self):
         return self._prefix

     def _set_prefix(self, prefix):
         nsuri = self.namespaceURI
         if prefix == "xmlns":
             if nsuri and nsuri != XMLNS_NAMESPACE:
                 raise xml.dom.NamespaceErr(
                     "illegal use of 'xmlns' prefix for the wrong namespace")
         self._prefix = prefix
         if prefix is None:
             newName = self.localName
         else:
             newName = "%s:%s" % (prefix, self.localName)
         if self.ownerElement:
             _clear_id_cache(self.ownerElement)
         self.name = newName

     prefix = property(_get_prefix, _set_prefix)

     def unlink(self):
         # This implementation does not call the base implementation
         # since most of that is not needed, and the expense of the
         # method call is not warranted.  We duplicate the removal of
         # children, but that's all we needed from the base class.
         elem = self.ownerElement
         if elem is not None:
             del elem._attrs[self.nodeName]
             del elem._attrsNS[(self.namespaceURI, self.localName)]
             if self._is_id:
                 self._is_id = False
                 elem._magic_id_nodes -= 1
                 self.ownerDocument._magic_id_count -= 1
         for child in self.childNodes:
             child.unlink()
         del self.childNodes[:]

     def _get_isId(self):
         if self._is_id:
             return True
         doc = self.ownerDocument
         elem = self.ownerElement
         if doc is None or elem is None:
             return False

         info = doc._get_elem_info(elem)
         if info is None:
             return False
         if self.namespaceURI:
             return info.isIdNS(self.namespaceURI, self.localName)
         else:
             return info.isId(self.nodeName)

     def _get_schemaType(self):
         doc = self.ownerDocument
         elem = self.ownerElement
         if doc is None or elem is None:
             return _no_type

         info = doc._get_elem_info(elem)
         if info is None:
             return _no_type
         if self.namespaceURI:
             return info.getAttributeTypeNS(self.namespaceURI, self.localName)
         else:
             return info.getAttributeType(self.nodeName)

 defproperty(Attr, "isId",       doc="True if this attribute is an ID.")
 defproperty(Attr, "localName",  doc="Namespace-local name of this attribute.")
 defproperty(Attr, "schemaType", doc="Schema type for this attribute.")

 class NamedNodeMap(object):
     """The attribute list is a transient interface to the underlying
     dictionaries.  Mutations here will change the underlying element's
     dictionary.

     Ordering is imposed artificially and does not reflect the order of
     attributes as found in an input document.
     """

     __slots__ = ('_attrs', '_attrsNS', '_ownerElement')

     def __init__(self, attrs, attrsNS, ownerElement):
         self._attrs = attrs
         self._attrsNS = attrsNS
         self._ownerElement = ownerElement

     def _get_length(self):
         return len(self._attrs)

     def item(self, index):
         try:
             return self[list(self._attrs.keys())[index]]
         except IndexError:
             return None

     def items(self):
         L = []
         for node in self._attrs.values():
             L.append((node.nodeName, node.value))
         return L

     def itemsNS(self):
         L = []
         for node in self._attrs.values():
             L.append(((node.namespaceURI, node.localName), node.value))
         return L

     def __contains__(self, key):
         if isinstance(key, str):
             return key in self._attrs
         else:
             return key in self._attrsNS

     def keys(self):
         return self._attrs.keys()

     def keysNS(self):
         return self._attrsNS.keys()

     def values(self):
         return self._attrs.values()

     def get(self, name, value=None):
         return self._attrs.get(name, value)

     __len__ = _get_length

     def _cmp(self, other):
         if self._attrs is getattr(other, "_attrs", None):
             return 0
         else:
             return (id(self) > id(other)) - (id(self) < id(other))

     def __eq__(self, other):
         return self._cmp(other) == 0

     def __ge__(self, other):
         return self._cmp(other) >= 0

     def __gt__(self, other):
         return self._cmp(other) > 0

     def __le__(self, other):
         return self._cmp(other) <= 0

     def __lt__(self, other):
         return self._cmp(other) < 0

     def __getitem__(self, attname_or_tuple):
         if isinstance(attname_or_tuple, tuple):
             return self._attrsNS[attname_or_tuple]
         else:
             return self._attrs[attname_or_tuple]

     # same as set
     def __setitem__(self, attname, value):
         if isinstance(value, str):
             try:
                 node = self._attrs[attname]
             except KeyError:
                 node = Attr(attname)
                 node.ownerDocument = self._ownerElement.ownerDocument
                 self.setNamedItem(node)
             node.value = value
         else:
             if not isinstance(value, Attr):
                 raise TypeError("value must be a string or Attr object")
             node = value
             self.setNamedItem(node)

     def getNamedItem(self, name):
         try:
             return self._attrs[name]
         except KeyError:
             return None

     def getNamedItemNS(self, namespaceURI, localName):
         try:
             return self._attrsNS[(namespaceURI, localName)]
         except KeyError:
             return None

     def removeNamedItem(self, name):
         n = self.getNamedItem(name)
         if n is not None:
             _clear_id_cache(self._ownerElement)
             del self._attrs[n.nodeName]
             del self._attrsNS[(n.namespaceURI, n.localName)]
             if hasattr(n, 'ownerElement'):
                 n.ownerElement = None
             return n
         else:
             raise xml.dom.NotFoundErr()

     def removeNamedItemNS(self, namespaceURI, localName):
         n = self.getNamedItemNS(namespaceURI, localName)
         if n is not None:
             _clear_id_cache(self._ownerElement)
             del self._attrsNS[(n.namespaceURI, n.localName)]
             del self._attrs[n.nodeName]
             if hasattr(n, 'ownerElement'):
                 n.ownerElement = None
             return n
         else:
             raise xml.dom.NotFoundErr()

     def setNamedItem(self, node):
         if not isinstance(node, Attr):
             raise xml.dom.HierarchyRequestErr(
                 "%s cannot be child of %s" % (repr(node), repr(self)))
         old = self._attrs.get(node.name)
         if old:
             old.unlink()
         self._attrs[node.name] = node
         self._attrsNS[(node.namespaceURI, node.localName)] = node
         node.ownerElement = self._ownerElement
         _clear_id_cache(node.ownerElement)
         return old

     def setNamedItemNS(self, node):
         return self.setNamedItem(node)

     def __delitem__(self, attname_or_tuple):
         node = self[attname_or_tuple]
         _clear_id_cache(node.ownerElement)
         node.unlink()

     def __getstate__(self):
         return self._attrs, self._attrsNS, self._ownerElement

     def __setstate__(self, state):
         self._attrs, self._attrsNS, self._ownerElement = state

 defproperty(NamedNodeMap, "length",
             doc="Number of nodes in the NamedNodeMap.")

 AttributeList = NamedNodeMap

 class TypeInfo(object):
     __slots__ = 'namespace', 'name'

     def __init__(self, namespace, name):
         self.namespace = namespace
         self.name = name

     def __repr__(self):
         if self.namespace:
             return "<%s %r (from %r)>" % (self.__class__.__name__, self.name,
                                           self.namespace)
         else:
             return "<%s %r>" % (self.__class__.__name__, self.name)

     def _get_name(self):
         return self.name

     def _get_namespace(self):
         return self.namespace

 _no_type = TypeInfo(None, None)

 class Element(Node):
     __slots__=('ownerDocument', 'parentNode', 'tagName', 'nodeName', 'prefix',
                'namespaceURI', '_localName', 'childNodes', '_attrs', '_attrsNS',
                'nextSibling', 'previousSibling')
     nodeType = Node.ELEMENT_NODE
     nodeValue = None
     schemaType = _no_type

     _magic_id_nodes = 0

     _child_node_types = (Node.ELEMENT_NODE,
                          Node.PROCESSING_INSTRUCTION_NODE,
                          Node.COMMENT_NODE,
                          Node.TEXT_NODE,
                          Node.CDATA_SECTION_NODE,
                          Node.ENTITY_REFERENCE_NODE)

     def __init__(self, tagName, namespaceURI=EMPTY_NAMESPACE, prefix=None,
                  localName=None):
         self.parentNode = None
         self.tagName = self.nodeName = tagName
         self.prefix = prefix
         self.namespaceURI = namespaceURI
         self.childNodes = NodeList()
         self.nextSibling = self.previousSibling = None

         # Attribute dictionaries are lazily created
         # attributes are double-indexed:
         #    tagName -> Attribute
         #    URI,localName -> Attribute
         # in the future: consider lazy generation
         # of attribute objects this is too tricky
         # for now because of headaches with
         # namespaces.
         self._attrs = None
         self._attrsNS = None

     def _ensure_attributes(self):
         if self._attrs is None:
             self._attrs = {}
             self._attrsNS = {}

     def _get_localName(self):
         try:
             return self._localName
         except AttributeError:
             return self.tagName.split(":", 1)[-1]

     def _get_tagName(self):
         return self.tagName

     def unlink(self):
         if self._attrs is not None:
             for attr in list(self._attrs.values()):
                 attr.unlink()
         self._attrs = None
         self._attrsNS = None
         Node.unlink(self)

     def getAttribute(self, attname):
         if self._attrs is None:
             return ""
         try:
             return self._attrs[attname].value
         except KeyError:
             return ""

     def getAttributeNS(self, namespaceURI, localName):
         if self._attrsNS is None:
             return ""
         try:
             return self._attrsNS[(namespaceURI, localName)].value
         except KeyError:
             return ""

     def setAttribute(self, attname, value):
         attr = self.getAttributeNode(attname)
         if attr is None:
             attr = Attr(attname)
             attr.value = value # also sets nodeValue
             attr.ownerDocument = self.ownerDocument
             self.setAttributeNode(attr)
         elif value != attr.value:
             attr.value = value
             if attr.isId:
                 _clear_id_cache(self)

     def setAttributeNS(self, namespaceURI, qualifiedName, value):
         prefix, localname = _nssplit(qualifiedName)
         attr = self.getAttributeNodeNS(namespaceURI, localname)
         if attr is None:
             attr = Attr(qualifiedName, namespaceURI, localname, prefix)
             attr.value = value
             attr.ownerDocument = self.ownerDocument
             self.setAttributeNode(attr)
         else:
             if value != attr.value:
                 attr.value = value
                 if attr.isId:
                     _clear_id_cache(self)
             if attr.prefix != prefix:
                 attr.prefix = prefix
                 attr.nodeName = qualifiedName

     def getAttributeNode(self, attrname):
         if self._attrs is None:
             return None
         return self._attrs.get(attrname)

     def getAttributeNodeNS(self, namespaceURI, localName):
         if self._attrsNS is None:
             return None
         return self._attrsNS.get((namespaceURI, localName))

     def setAttributeNode(self, attr):
         if attr.ownerElement not in (None, self):
             raise xml.dom.InuseAttributeErr("attribute node already owned")
         self._ensure_attributes()
         old1 = self._attrs.get(attr.name, None)
         if old1 is not None:
             self.removeAttributeNode(old1)
         old2 = self._attrsNS.get((attr.namespaceURI, attr.localName), None)
         if old2 is not None and old2 is not old1:
             self.removeAttributeNode(old2)
         _set_attribute_node(self, attr)

         if old1 is not attr:
             # It might have already been part of this node, in which case
             # it doesn't represent a change, and should not be returned.
             return old1
         if old2 is not attr:
             return old2

     setAttributeNodeNS = setAttributeNode

     def removeAttribute(self, name):
         if self._attrsNS is None:
             raise xml.dom.NotFoundErr()
         try:
             attr = self._attrs[name]
         except KeyError:
             raise xml.dom.NotFoundErr()
         self.removeAttributeNode(attr)

     def removeAttributeNS(self, namespaceURI, localName):
         if self._attrsNS is None:
             raise xml.dom.NotFoundErr()
         try:
             attr = self._attrsNS[(namespaceURI, localName)]
         except KeyError:
             raise xml.dom.NotFoundErr()
         self.removeAttributeNode(attr)

     def removeAttributeNode(self, node):
         if node is None:
             raise xml.dom.NotFoundErr()
         try:
             self._attrs[node.name]
         except KeyError:
             raise xml.dom.NotFoundErr()
         _clear_id_cache(self)
         node.unlink()
         # Restore this since the node is still useful and otherwise
         # unlinked
         node.ownerDocument = self.ownerDocument

     removeAttributeNodeNS = removeAttributeNode

     def hasAttribute(self, name):
         if self._attrs is None:
             return False
         return name in self._attrs

     def hasAttributeNS(self, namespaceURI, localName):
         if self._attrsNS is None:
             return False
         return (namespaceURI, localName) in self._attrsNS

     def getElementsByTagName(self, name):
         return _get_elements_by_tagName_helper(self, name, NodeList())

     def getElementsByTagNameNS(self, namespaceURI, localName):
         return _get_elements_by_tagName_ns_helper(
             self, namespaceURI, localName, NodeList())

     def __repr__(self):
         return "<DOM Element: %s at %#x>" % (self.tagName, id(self))

     def writexml(self, writer, indent="", addindent="", newl=""):
         # indent = current indentation
         # addindent = indentation to add to higher levels
         # newl = newline string
         writer.write(indent+"<" + self.tagName)

         attrs = self._get_attributes()
         a_names = sorted(attrs.keys())

         for a_name in a_names:
             writer.write(" %s=\"" % a_name)
             _write_data(writer, attrs[a_name].value)
             writer.write("\"")
         if self.childNodes:
             writer.write(">")
             if (len(self.childNodes) == 1 and
                 self.childNodes[0].nodeType == Node.TEXT_NODE):
                 self.childNodes[0].writexml(writer, '', '', '')
             else:
                 writer.write(newl)
                 for node in self.childNodes:
                     node.writexml(writer, indent+addindent, addindent, newl)
                 writer.write(indent)
             writer.write("</%s>%s" % (self.tagName, newl))
         else:
             writer.write("/>%s"%(newl))

     def _get_attributes(self):
         self._ensure_attributes()
         return NamedNodeMap(self._attrs, self._attrsNS, self)

     def hasAttributes(self):
         if self._attrs:
             return True
         else:
             return False

     # DOM Level 3 attributes, based on the 22 Oct 2002 draft

     def setIdAttribute(self, name):
         idAttr = self.getAttributeNode(name)
         self.setIdAttributeNode(idAttr)

     def setIdAttributeNS(self, namespaceURI, localName):
         idAttr = self.getAttributeNodeNS(namespaceURI, localName)
         self.setIdAttributeNode(idAttr)

     def setIdAttributeNode(self, idAttr):
         if idAttr is None or not self.isSameNode(idAttr.ownerElement):
             raise xml.dom.NotFoundErr()
         if _get_containing_entref(self) is not None:
             raise xml.dom.NoModificationAllowedErr()
         if not idAttr._is_id:
             idAttr._is_id = True
             self._magic_id_nodes += 1
             self.ownerDocument._magic_id_count += 1
             _clear_id_cache(self)

 defproperty(Element, "attributes",
             doc="NamedNodeMap of attributes on the element.")
 defproperty(Element, "localName",
             doc="Namespace-local name of this element.")

 def _set_attribute_node(element, attr):
     _clear_id_cache(element)
     element._ensure_attributes()
     element._attrs[attr.name] = attr
     element._attrsNS[(attr.namespaceURI, attr.localName)] = attr

     # This creates a circular reference, but Element.unlink()
     # breaks the cycle since the references to the attribute
     # dictionaries are tossed.
     attr.ownerElement = element

 class Childless:
     """Mixin that makes childless-ness easy to implement and avoids
     the complexity of the Node methods that deal with children.
     """
     __slots__ = ()

     attributes = None
     childNodes = EmptyNodeList()
     firstChild = None
     lastChild = None

     def _get_firstChild(self):
         return None

     def _get_lastChild(self):
         return None

     def appendChild(self, node):
         raise xml.dom.HierarchyRequestErr(
             self.nodeName + " nodes cannot have children")

     def hasChildNodes(self):
         return False

     def insertBefore(self, newChild, refChild):
         raise xml.dom.HierarchyRequestErr(
             self.nodeName + " nodes do not have children")

     def removeChild(self, oldChild):
         raise xml.dom.NotFoundErr(
             self.nodeName + " nodes do not have children")

     def normalize(self):
         # For childless nodes, normalize() has nothing to do.
         pass

     def replaceChild(self, newChild, oldChild):
         raise xml.dom.HierarchyRequestErr(
             self.nodeName + " nodes do not have children")

 class ProcessingInstruction(Childless, Node):
     nodeType = Node.PROCESSING_INSTRUCTION_NODE
     __slots__ = ('target', 'data')

     def __init__(self, target, data):
         self.target = target
         self.data = data

     # nodeValue is an alias for data
     def _get_nodeValue(self):
         return self.data
     def _set_nodeValue(self, value):
         self.data = value
     nodeValue = property(_get_nodeValue, _set_nodeValue)

     # nodeName is an alias for target
     def _get_nodeName(self):
         return self.target
     def _set_nodeName(self, value):
         self.target = value
     nodeName = property(_get_nodeName, _set_nodeName)

     def writexml(self, writer, indent="", addindent="", newl=""):
         writer.write("%s<?%s %s?>%s" % (indent,self.target, self.data, newl))

 class CharacterData(Childless, Node):
     __slots__=('_data', 'ownerDocument','parentNode', 'previousSibling', 'nextSibling')

     def __init__(self):
         self.ownerDocument = self.parentNode = None
         self.previousSibling = self.nextSibling = None
         self._data = ''
         Node.__init__(self)

     def _get_length(self):
         return len(self.data)
     __len__ = _get_length

     def _get_data(self):
         return self._data
     def _set_data(self, data):
         self._data = data

     data = nodeValue = property(_get_data, _set_data)

     def __repr__(self):
         data = self.data
         if len(data) > 10:
             dotdotdot = "..."
         else:
             dotdotdot = ""
         return '<DOM %s node "%r%s">' % (
             self.__class__.__name__, data[0:10], dotdotdot)

     def substringData(self, offset, count):
         if offset < 0:
             raise xml.dom.IndexSizeErr("offset cannot be negative")
         if offset >= len(self.data):
             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
         if count < 0:
             raise xml.dom.IndexSizeErr("count cannot be negative")
         return self.data[offset:offset+count]

     def appendData(self, arg):
         self.data = self.data + arg

     def insertData(self, offset, arg):
         if offset < 0:
             raise xml.dom.IndexSizeErr("offset cannot be negative")
         if offset >= len(self.data):
             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
         if arg:
             self.data = "%s%s%s" % (
                 self.data[:offset], arg, self.data[offset:])

     def deleteData(self, offset, count):
         if offset < 0:
             raise xml.dom.IndexSizeErr("offset cannot be negative")
         if offset >= len(self.data):
             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
         if count < 0:
             raise xml.dom.IndexSizeErr("count cannot be negative")
         if count:
             self.data = self.data[:offset] + self.data[offset+count:]

     def replaceData(self, offset, count, arg):
         if offset < 0:
             raise xml.dom.IndexSizeErr("offset cannot be negative")
         if offset >= len(self.data):
             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
         if count < 0:
             raise xml.dom.IndexSizeErr("count cannot be negative")
         if count:
             self.data = "%s%s%s" % (
                 self.data[:offset], arg, self.data[offset+count:])

 defproperty(CharacterData, "length", doc="Length of the string data.")

 class Text(CharacterData):
     __slots__ = ()

     nodeType = Node.TEXT_NODE
     nodeName = "#text"
     attributes = None

     def splitText(self, offset):
         if offset < 0 or offset > len(self.data):
             raise xml.dom.IndexSizeErr("illegal offset value")
         newText = self.__class__()
         newText.data = self.data[offset:]
         newText.ownerDocument = self.ownerDocument
         next = self.nextSibling
         if self.parentNode and self in self.parentNode.childNodes:
             if next is None:
                 self.parentNode.appendChild(newText)
             else:
                 self.parentNode.insertBefore(newText, next)
         self.data = self.data[:offset]
         return newText

     def writexml(self, writer, indent="", addindent="", newl=""):
         _write_data(writer, "%s%s%s" % (indent, self.data, newl))

     # DOM Level 3 (WD 9 April 2002)

     def _get_wholeText(self):
         L = [self.data]
         n = self.previousSibling
         while n is not None:
             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                 L.insert(0, n.data)
                 n = n.previousSibling
             else:
                 break
         n = self.nextSibling
         while n is not None:
             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                 L.append(n.data)
                 n = n.nextSibling
             else:
                 break
         return ''.join(L)

     def replaceWholeText(self, content):
         # XXX This needs to be seriously changed if minidom ever
         # supports EntityReference nodes.
         parent = self.parentNode
         n = self.previousSibling
         while n is not None:
             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                 next = n.previousSibling
                 parent.removeChild(n)
                 n = next
             else:
                 break
         n = self.nextSibling
         if not content:
             parent.removeChild(self)
         while n is not None:
             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                 next = n.nextSibling
                 parent.removeChild(n)
                 n = next
             else:
                 break
         if content:
             self.data = content
             return self
         else:
             return None

     def _get_isWhitespaceInElementContent(self):
         if self.data.strip():
             return False
         elem = _get_containing_element(self)
         if elem is None:
             return False
         info = self.ownerDocument._get_elem_info(elem)
         if info is None:
             return False
         else:
             return info.isElementContent()

 defproperty(Text, "isWhitespaceInElementContent",
             doc="True iff this text node contains only whitespace"
                 " and is in element content.")
 defproperty(Text, "wholeText",
             doc="The text of all logically-adjacent text nodes.")

 def _get_containing_element(node):
     c = node.parentNode
     while c is not None:
         if c.nodeType == Node.ELEMENT_NODE:
             return c
         c = c.parentNode
     return None

 def _get_containing_entref(node):
     c = node.parentNode
     while c is not None:
         if c.nodeType == Node.ENTITY_REFERENCE_NODE:
             return c
         c = c.parentNode
     return None

 class Comment(CharacterData):
     nodeType = Node.COMMENT_NODE
     nodeName = "#comment"

     def __init__(self, data):
         CharacterData.__init__(self)
         self._data = data

     def writexml(self, writer, indent="", addindent="", newl=""):
         if "--" in self.data:
             raise ValueError("'--' is not allowed in a comment node")
         writer.write("%s<!--%s-->%s" % (indent, self.data, newl))

 class CDATASection(Text):
     __slots__ = ()

     nodeType = Node.CDATA_SECTION_NODE
     nodeName = "#cdata-section"

     def writexml(self, writer, indent="", addindent="", newl=""):
         if self.data.find("]]>") >= 0:
             raise ValueError("']]>' not allowed in a CDATA section")
         writer.write("<![CDATA[%s]]>" % self.data)

 class ReadOnlySequentialNamedNodeMap(object):
     __slots__ = '_seq',

     def __init__(self, seq=()):
         # seq should be a list or tuple
         self._seq = seq

     def __len__(self):
         return len(self._seq)

     def _get_length(self):
         return len(self._seq)

     def getNamedItem(self, name):
         for n in self._seq:
             if n.nodeName == name:
                 return n

     def getNamedItemNS(self, namespaceURI, localName):
         for n in self._seq:
             if n.namespaceURI == namespaceURI and n.localName == localName:
                 return n

     def __getitem__(self, name_or_tuple):
         if isinstance(name_or_tuple, tuple):
             node = self.getNamedItemNS(*name_or_tuple)
         else:
             node = self.getNamedItem(name_or_tuple)
         if node is None:
             raise KeyError(name_or_tuple)
         return node

     def item(self, index):
         if index < 0:
             return None
         try:
             return self._seq[index]
         except IndexError:
             return None

     def removeNamedItem(self, name):
         raise xml.dom.NoModificationAllowedErr(
             "NamedNodeMap instance is read-only")

     def removeNamedItemNS(self, namespaceURI, localName):
         raise xml.dom.NoModificationAllowedErr(
             "NamedNodeMap instance is read-only")

     def setNamedItem(self, node):
         raise xml.dom.NoModificationAllowedErr(
             "NamedNodeMap instance is read-only")

     def setNamedItemNS(self, node):
         raise xml.dom.NoModificationAllowedErr(
             "NamedNodeMap instance is read-only")

     def __getstate__(self):
         return [self._seq]

     def __setstate__(self, state):
         self._seq = state[0]

 defproperty(ReadOnlySequentialNamedNodeMap, "length",
             doc="Number of entries in the NamedNodeMap.")

 class Identified:
     """Mix-in class that supports the publicId and systemId attributes."""

     __slots__ = 'publicId', 'systemId'

     def _identified_mixin_init(self, publicId, systemId):
         self.publicId = publicId
         self.systemId = systemId

     def _get_publicId(self):
         return self.publicId

     def _get_systemId(self):
         return self.systemId

 class DocumentType(Identified, Childless, Node):
     nodeType = Node.DOCUMENT_TYPE_NODE
     nodeValue = None
     name = None
     publicId = None
     systemId = None
     internalSubset = None

     def __init__(self, qualifiedName):
         self.entities = ReadOnlySequentialNamedNodeMap()
         self.notations = ReadOnlySequentialNamedNodeMap()
         if qualifiedName:
             prefix, localname = _nssplit(qualifiedName)
             self.name = localname
         self.nodeName = self.name

     def _get_internalSubset(self):
         return self.internalSubset

     def cloneNode(self, deep):
         if self.ownerDocument is None:
             # it's ok
             clone = DocumentType(None)
             clone.name = self.name
             clone.nodeName = self.name
             operation = xml.dom.UserDataHandler.NODE_CLONED
             if deep:
                 clone.entities._seq = []
                 clone.notations._seq = []
                 for n in self.notations._seq:
                     notation = Notation(n.nodeName, n.publicId, n.systemId)
                     clone.notations._seq.append(notation)
                     n._call_user_data_handler(operation, n, notation)
                 for e in self.entities._seq:
                     entity = Entity(e.nodeName, e.publicId, e.systemId,
                                     e.notationName)
                     entity.actualEncoding = e.actualEncoding
                     entity.encoding = e.encoding
                     entity.version = e.version
                     clone.entities._seq.append(entity)
                     e._call_user_data_handler(operation, n, entity)
             self._call_user_data_handler(operation, self, clone)
             return clone
         else:
             return None

     def writexml(self, writer, indent="", addindent="", newl=""):
         writer.write("<!DOCTYPE ")
         writer.write(self.name)
         if self.publicId:
             writer.write("%s  PUBLIC '%s'%s  '%s'"
                          % (newl, self.publicId, newl, self.systemId))
         elif self.systemId:
             writer.write("%s  SYSTEM '%s'" % (newl, self.systemId))
         if self.internalSubset is not None:
             writer.write(" [")
             writer.write(self.internalSubset)
             writer.write("]")
         writer.write(">"+newl)

 class Entity(Identified, Node):
     attributes = None
     nodeType = Node.ENTITY_NODE
     nodeValue = None

     actualEncoding = None
     encoding = None
     version = None

     def __init__(self, name, publicId, systemId, notation):
         self.nodeName = name
         self.notationName = notation
         self.childNodes = NodeList()
         self._identified_mixin_init(publicId, systemId)

     def _get_actualEncoding(self):
         return self.actualEncoding

     def _get_encoding(self):
         return self.encoding

     def _get_version(self):
         return self.version

     def appendChild(self, newChild):
         raise xml.dom.HierarchyRequestErr(
             "cannot append children to an entity node")

     def insertBefore(self, newChild, refChild):
         raise xml.dom.HierarchyRequestErr(
             "cannot insert children below an entity node")

     def removeChild(self, oldChild):
         raise xml.dom.HierarchyRequestErr(
             "cannot remove children from an entity node")

     def replaceChild(self, newChild, oldChild):
         raise xml.dom.HierarchyRequestErr(
             "cannot replace children of an entity node")

 class Notation(Identified, Childless, Node):
     nodeType = Node.NOTATION_NODE
     nodeValue = None

     def __init__(self, name, publicId, systemId):
         self.nodeName = name
         self._identified_mixin_init(publicId, systemId)

 class DOMImplementation(DOMImplementationLS):
     _features = [("core", "1.0"),
                  ("core", "2.0"),
                  ("core", None),
                  ("xml", "1.0"),
                  ("xml", "2.0"),
                  ("xml", None),
                  ("ls-load", "3.0"),
                  ("ls-load", None),
                  ]

     def hasFeature(self, feature, version):
         if version == "":
             version = None
         return (feature.lower(), version) in self._features

     def createDocument(self, namespaceURI, qualifiedName, doctype):
         if doctype and doctype.parentNode is not None:
             raise xml.dom.WrongDocumentErr(
                 "doctype object owned by another DOM tree")
         doc = self._create_document()

         add_root_element = not (namespaceURI is None
                                 and qualifiedName is None
                                 and doctype is None)

         if not qualifiedName and add_root_element:
             # The spec is unclear what to raise here; SyntaxErr
             # would be the other obvious candidate. Since Xerces raises
             # InvalidCharacterErr, and since SyntaxErr is not listed
             # for createDocument, that seems to be the better choice.
             # XXX: need to check for illegal characters here and in
             # createElement.

             # DOM Level III clears this up when talking about the return value
             # of this function.  If namespaceURI, qName and DocType are
             # Null the document is returned without a document element
             # Otherwise if doctype or namespaceURI are not None
             # Then we go back to the above problem
             raise xml.dom.InvalidCharacterErr("Element with no name")

         if add_root_element:
             prefix, localname = _nssplit(qualifiedName)
             if prefix == "xml" \
                and namespaceURI != "http://www.w3.org/XML/1998/namespace":
                 raise xml.dom.NamespaceErr("illegal use of 'xml' prefix")
             if prefix and not namespaceURI:
                 raise xml.dom.NamespaceErr(
                     "illegal use of prefix without namespaces")
             element = doc.createElementNS(namespaceURI, qualifiedName)
             if doctype:
                 doc.appendChild(doctype)
             doc.appendChild(element)

         if doctype:
             doctype.parentNode = doctype.ownerDocument = doc

         doc.doctype = doctype
         doc.implementation = self
         return doc

     def createDocumentType(self, qualifiedName, publicId, systemId):
         doctype = DocumentType(qualifiedName)
         doctype.publicId = publicId
         doctype.systemId = systemId
         return doctype

     # DOM Level 3 (WD 9 April 2002)

     def getInterface(self, feature):
         if self.hasFeature(feature, None):
             return self
         else:
             return None

     # internal
     def _create_document(self):
         return Document()

 class ElementInfo(object):
     """Object that represents content-model information for an element.

     This implementation is not expected to be used in practice; DOM
     builders should provide implementations which do the right thing
     using information available to it.

     """

     __slots__ = 'tagName',

     def __init__(self, name):
         self.tagName = name

     def getAttributeType(self, aname):
         return _no_type

     def getAttributeTypeNS(self, namespaceURI, localName):
         return _no_type

     def isElementContent(self):
         return False

     def isEmpty(self):
         """Returns true iff this element is declared to have an EMPTY
         content model."""
         return False

     def isId(self, aname):
         """Returns true iff the named attribute is a DTD-style ID."""
         return False

     def isIdNS(self, namespaceURI, localName):
         """Returns true iff the identified attribute is a DTD-style ID."""
         return False

     def __getstate__(self):
         return self.tagName

     def __setstate__(self, state):
         self.tagName = state

 def _clear_id_cache(node):
     if node.nodeType == Node.DOCUMENT_NODE:
         node._id_cache.clear()
         node._id_search_stack = None
     elif _in_document(node):
         node.ownerDocument._id_cache.clear()
         node.ownerDocument._id_search_stack= None

 class Document(Node, DocumentLS):
     __slots__ = ('_elem_info', 'doctype',
                  '_id_search_stack', 'childNodes', '_id_cache')
     _child_node_types = (Node.ELEMENT_NODE, Node.PROCESSING_INSTRUCTION_NODE,
                          Node.COMMENT_NODE, Node.DOCUMENT_TYPE_NODE)

     implementation = DOMImplementation()
     nodeType = Node.DOCUMENT_NODE
     nodeName = "#document"
     nodeValue = None
     attributes = None
     parentNode = None
     previousSibling = nextSibling = None

     # Document attributes from Level 3 (WD 9 April 2002)

     actualEncoding = None
     encoding = None
     standalone = None
     version = None
     strictErrorChecking = False
     errorHandler = None
     documentURI = None

     _magic_id_count = 0

     def __init__(self):
         self.doctype = None
         self.childNodes = NodeList()
         # mapping of (namespaceURI, localName) -> ElementInfo
         #        and tagName -> ElementInfo
         self._elem_info = {}
         self._id_cache = {}
         self._id_search_stack = None

     def _get_elem_info(self, element):
         if element.namespaceURI:
             key = element.namespaceURI, element.localName
         else:
             key = element.tagName
         return self._elem_info.get(key)

     def _get_actualEncoding(self):
         return self.actualEncoding

     def _get_doctype(self):
         return self.doctype

     def _get_documentURI(self):
         return self.documentURI

     def _get_encoding(self):
         return self.encoding

     def _get_errorHandler(self):
         return self.errorHandler

     def _get_standalone(self):
         return self.standalone

     def _get_strictErrorChecking(self):
         return self.strictErrorChecking

     def _get_version(self):
         return self.version

     def appendChild(self, node):
         if node.nodeType not in self._child_node_types:
             raise xml.dom.HierarchyRequestErr(
                 "%s cannot be child of %s" % (repr(node), repr(self)))
         if node.parentNode is not None:
             # This needs to be done before the next test since this
             # may *be* the document element, in which case it should
             # end up re-ordered to the end.
             node.parentNode.removeChild(node)

         if node.nodeType == Node.ELEMENT_NODE \
            and self._get_documentElement():
             raise xml.dom.HierarchyRequestErr(
                 "two document elements disallowed")
         return Node.appendChild(self, node)

     def removeChild(self, oldChild):
         try:
             self.childNodes.remove(oldChild)
         except ValueError:
             raise xml.dom.NotFoundErr()
         oldChild.nextSibling = oldChild.previousSibling = None
         oldChild.parentNode = None
         if self.documentElement is oldChild:
             self.documentElement = None

         return oldChild

     def _get_documentElement(self):
         for node in self.childNodes:
             if node.nodeType == Node.ELEMENT_NODE:
                 return node

     def unlink(self):
         if self.doctype is not None:
             self.doctype.unlink()
             self.doctype = None
         Node.unlink(self)

     def cloneNode(self, deep):
         if not deep:
             return None
         clone = self.implementation.createDocument(None, None, None)
         clone.encoding = self.encoding
         clone.standalone = self.standalone
         clone.version = self.version
         for n in self.childNodes:
             childclone = _clone_node(n, deep, clone)
             assert childclone.ownerDocument.isSameNode(clone)
             clone.childNodes.append(childclone)
             if childclone.nodeType == Node.DOCUMENT_NODE:
                 assert clone.documentElement is None
             elif childclone.nodeType == Node.DOCUMENT_TYPE_NODE:
                 assert clone.doctype is None
                 clone.doctype = childclone
             childclone.parentNode = clone
         self._call_user_data_handler(xml.dom.UserDataHandler.NODE_CLONED,
                                      self, clone)
         return clone

     def createDocumentFragment(self):
         d = DocumentFragment()
         d.ownerDocument = self
         return d

     def createElement(self, tagName):
         e = Element(tagName)
         e.ownerDocument = self
         return e

     def createTextNode(self, data):
         if not isinstance(data, str):
             raise TypeError("node contents must be a string")
         t = Text()
         t.data = data
         t.ownerDocument = self
         return t

     def createCDATASection(self, data):
         if not isinstance(data, str):
             raise TypeError("node contents must be a string")
         c = CDATASection()
         c.data = data
         c.ownerDocument = self
         return c

     def createComment(self, data):
         c = Comment(data)
         c.ownerDocument = self
         return c

     def createProcessingInstruction(self, target, data):
         p = ProcessingInstruction(target, data)
         p.ownerDocument = self
         return p

     def createAttribute(self, qName):
         a = Attr(qName)
         a.ownerDocument = self
         a.value = ""
         return a

     def createElementNS(self, namespaceURI, qualifiedName):
         prefix, localName = _nssplit(qualifiedName)
         e = Element(qualifiedName, namespaceURI, prefix)
         e.ownerDocument = self
         return e

     def createAttributeNS(self, namespaceURI, qualifiedName):
         prefix, localName = _nssplit(qualifiedName)
         a = Attr(qualifiedName, namespaceURI, localName, prefix)
         a.ownerDocument = self
         a.value = ""
         return a

     # A couple of implementation-specific helpers to create node types
     # not supported by the W3C DOM specs:

     def _create_entity(self, name, publicId, systemId, notationName):
         e = Entity(name, publicId, systemId, notationName)
         e.ownerDocument = self
         return e

     def _create_notation(self, name, publicId, systemId):
         n = Notation(name, publicId, systemId)
         n.ownerDocument = self
         return n

     def getElementById(self, id):
         if id in self._id_cache:
             return self._id_cache[id]
         if not (self._elem_info or self._magic_id_count):
             return None

         stack = self._id_search_stack
         if stack is None:
             # we never searched before, or the cache has been cleared
             stack = [self.documentElement]
             self._id_search_stack = stack
         elif not stack:
             # Previous search was completed and cache is still valid;
             # no matching node.
             return None

         result = None
         while stack:
             node = stack.pop()
             # add child elements to stack for continued searching
             stack.extend([child for child in node.childNodes
                           if child.nodeType in _nodeTypes_with_children])
             # check this node
             info = self._get_elem_info(node)
             if info:
                 # We have to process all ID attributes before
                 # returning in order to get all the attributes set to
                 # be IDs using Element.setIdAttribute*().
                 for attr in node.attributes.values():
                     if attr.namespaceURI:
                         if info.isIdNS(attr.namespaceURI, attr.localName):
                             self._id_cache[attr.value] = node
                             if attr.value == id:
                                 result = node
                             elif not node._magic_id_nodes:
                                 break
                     elif info.isId(attr.name):
                         self._id_cache[attr.value] = node
                         if attr.value == id:
                             result = node
                         elif not node._magic_id_nodes:
                             break
                     elif attr._is_id:
                         self._id_cache[attr.value] = node
                         if attr.value == id:
                             result = node
                         elif node._magic_id_nodes == 1:
                             break
             elif node._magic_id_nodes:
                 for attr in node.attributes.values():
                     if attr._is_id:
                         self._id_cache[attr.value] = node
                         if attr.value == id:
                             result = node
             if result is not None:
                 break
         return result

     def getElementsByTagName(self, name):
         return _get_elements_by_tagName_helper(self, name, NodeList())

     def getElementsByTagNameNS(self, namespaceURI, localName):
         return _get_elements_by_tagName_ns_helper(
             self, namespaceURI, localName, NodeList())

     def isSupported(self, feature, version):
         return self.implementation.hasFeature(feature, version)

     def importNode(self, node, deep):
         if node.nodeType == Node.DOCUMENT_NODE:
             raise xml.dom.NotSupportedErr("cannot import document nodes")
         elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
             raise xml.dom.NotSupportedErr("cannot import document type nodes")
         return _clone_node(node, deep, self)

     def writexml(self, writer, indent="", addindent="", newl="", encoding=None):
         if encoding is None:
             writer.write('<?xml version="1.0" ?>'+newl)
         else:
             writer.write('<?xml version="1.0" encoding="%s"?>%s' % (
                 encoding, newl))
         for node in self.childNodes:
             node.writexml(writer, indent, addindent, newl)

     # DOM Level 3 (WD 9 April 2002)

     def renameNode(self, n, namespaceURI, name):
         if n.ownerDocument is not self:
             raise xml.dom.WrongDocumentErr(
                 "cannot rename nodes from other documents;\n"
                 "expected %s,\nfound %s" % (self, n.ownerDocument))
         if n.nodeType not in (Node.ELEMENT_NODE, Node.ATTRIBUTE_NODE):
             raise xml.dom.NotSupportedErr(
                 "renameNode() only applies to element and attribute nodes")
         if namespaceURI != EMPTY_NAMESPACE:
             if ':' in name:
                 prefix, localName = name.split(':', 1)
                 if (  prefix == "xmlns"
                       and namespaceURI != xml.dom.XMLNS_NAMESPACE):
                     raise xml.dom.NamespaceErr(
                         "illegal use of 'xmlns' prefix")
             else:
                 if (  name == "xmlns"
                       and namespaceURI != xml.dom.XMLNS_NAMESPACE
                       and n.nodeType == Node.ATTRIBUTE_NODE):
                     raise xml.dom.NamespaceErr(
                         "illegal use of the 'xmlns' attribute")
                 prefix = None
                 localName = name
         else:
             prefix = None
             localName = None
         if n.nodeType == Node.ATTRIBUTE_NODE:
             element = n.ownerElement
             if element is not None:
                 is_id = n._is_id
                 element.removeAttributeNode(n)
         else:
             element = None
         n.prefix = prefix
         n._localName = localName
         n.namespaceURI = namespaceURI
         n.nodeName = name
         if n.nodeType == Node.ELEMENT_NODE:
             n.tagName = name
         else:
             # attribute node
             n.name = name
             if element is not None:
                 element.setAttributeNode(n)
                 if is_id:
                     element.setIdAttributeNode(n)
         # It's not clear from a semantic perspective whether we should
         # call the user data handlers for the NODE_RENAMED event since
         # we're re-using the existing node.  The draft spec has been
         # interpreted as meaning "no, don't call the handler unless a
         # new node is created."
         return n

 defproperty(Document, "documentElement",
             doc="Top-level element of this document.")

 def _clone_node(node, deep, newOwnerDocument):
     """
     Clone a node and give it the new owner document.
     Called by Node.cloneNode and Document.importNode
     """
     if node.ownerDocument.isSameNode(newOwnerDocument):
         operation = xml.dom.UserDataHandler.NODE_CLONED
     else:
         operation = xml.dom.UserDataHandler.NODE_IMPORTED
     if node.nodeType == Node.ELEMENT_NODE:
         clone = newOwnerDocument.createElementNS(node.namespaceURI,
                                                  node.nodeName)
         for attr in node.attributes.values():
             clone.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value)
             a = clone.getAttributeNodeNS(attr.namespaceURI, attr.localName)
             a.specified = attr.specified

         if deep:
             for child in node.childNodes:
                 c = _clone_node(child, deep, newOwnerDocument)
                 clone.appendChild(c)

     elif node.nodeType == Node.DOCUMENT_FRAGMENT_NODE:
         clone = newOwnerDocument.createDocumentFragment()
         if deep:
             for child in node.childNodes:
                 c = _clone_node(child, deep, newOwnerDocument)
                 clone.appendChild(c)

     elif node.nodeType == Node.TEXT_NODE:
         clone = newOwnerDocument.createTextNode(node.data)
     elif node.nodeType == Node.CDATA_SECTION_NODE:
         clone = newOwnerDocument.createCDATASection(node.data)
     elif node.nodeType == Node.PROCESSING_INSTRUCTION_NODE:
         clone = newOwnerDocument.createProcessingInstruction(node.target,
                                                              node.data)
     elif node.nodeType == Node.COMMENT_NODE:
         clone = newOwnerDocument.createComment(node.data)
     elif node.nodeType == Node.ATTRIBUTE_NODE:
         clone = newOwnerDocument.createAttributeNS(node.namespaceURI,
                                                    node.nodeName)
         clone.specified = True
         clone.value = node.value
     elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
         assert node.ownerDocument is not newOwnerDocument
         operation = xml.dom.UserDataHandler.NODE_IMPORTED
         clone = newOwnerDocument.implementation.createDocumentType(
             node.name, node.publicId, node.systemId)
         clone.ownerDocument = newOwnerDocument
         if deep:
             clone.entities._seq = []
             clone.notations._seq = []
             for n in node.notations._seq:
                 notation = Notation(n.nodeName, n.publicId, n.systemId)
                 notation.ownerDocument = newOwnerDocument
                 clone.notations._seq.append(notation)
                 if hasattr(n, '_call_user_data_handler'):
                     n._call_user_data_handler(operation, n, notation)
             for e in node.entities._seq:
                 entity = Entity(e.nodeName, e.publicId, e.systemId,
                                 e.notationName)
                 entity.actualEncoding = e.actualEncoding
                 entity.encoding = e.encoding
                 entity.version = e.version
                 entity.ownerDocument = newOwnerDocument
                 clone.entities._seq.append(entity)
                 if hasattr(e, '_call_user_data_handler'):
                     e._call_user_data_handler(operation, n, entity)
     else:
         # Note the cloning of Document and DocumentType nodes is
         # implementation specific.  minidom handles those cases
         # directly in the cloneNode() methods.
         raise xml.dom.NotSupportedErr("Cannot clone node %s" % repr(node))

     # Check for _call_user_data_handler() since this could conceivably
     # used with other DOM implementations (one of the FourThought
     # DOMs, perhaps?).
     if hasattr(node, '_call_user_data_handler'):
         node._call_user_data_handler(operation, node, clone)
     return clone

 def _nssplit(qualifiedName):
     fields = qualifiedName.split(':', 1)
     if len(fields) == 2:
         return fields
     else:
         return (None, fields[0])

 def _do_pulldom_parse(func, args, kwargs):
     events = func(*args, **kwargs)
     toktype, rootNode = events.getEvent()
     events.expandNode(rootNode)
     events.clear()
     return rootNode

 def parse(file, parser=None, bufsize=None):
     """Parse a file into a DOM by filename or file object."""
     if parser is None and not bufsize:
         from xml.dom import expatbuilder
         return expatbuilder.parse(file)
     else:
         from xml.dom import pulldom
         return _do_pulldom_parse(pulldom.parse, (file,),
             {'parser': parser, 'bufsize': bufsize})

 def parseString(string, parser=None):
     """Parse a file into a DOM from a string."""
     if parser is None:
         from xml.dom import expatbuilder
         return expatbuilder.parseString(string)
     else:
         from xml.dom import pulldom
         return _do_pulldom_parse(pulldom.parseString, (string,),
                                  {'parser': parser})

 def getDOMImplementation(features=None):
     if features:
         if isinstance(features, str):
             features = domreg._parse_feature_string(features)
         for f, v in features:
             if not Document.implementation.hasFeature(f, v):
                 return None
     return Document.implementation

xml.dom.minidom