File Explorer

1"""Simple implementation of the Level 1 DOM.2 3Namespaces and other minor Level 2 features are also supported.4 5parse("foo.xml")6 7parseString("<foo><bar/></foo>")8 9Todo:10=====11 * convenience methods for getting elements and text.12 * more testing13 * bring some of the writer and linearizer code into conformance with this14        interface15 * SAX 2 namespaces16"""17 18import io19import xml.dom20 21from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE, domreg22from xml.dom.minicompat import *23from xml.dom.xmlbuilder import DOMImplementationLS, DocumentLS24 25# This is used by the ID-cache invalidation checks; the list isn't26# actually complete, since the nodes being checked will never be the27# DOCUMENT_NODE or DOCUMENT_FRAGMENT_NODE.  (The node being checked is28# the node being added or removed, not the node being modified.)29#30_nodeTypes_with_children = (xml.dom.Node.ELEMENT_NODE,31                            xml.dom.Node.ENTITY_REFERENCE_NODE)32 33 34class Node(xml.dom.Node):35    namespaceURI = None # this is non-null only for elements and attributes36    parentNode = None37    ownerDocument = None38    nextSibling = None39    previousSibling = None40 41    prefix = EMPTY_PREFIX # non-null only for NS elements and attributes42 43    def __bool__(self):44        return True45 46    def toxml(self, encoding=None, standalone=None):47        return self.toprettyxml("", "", encoding, standalone)48 49    def toprettyxml(self, indent="\t", newl="\n", encoding=None,50                    standalone=None):51        if encoding is None:52            writer = io.StringIO()53        else:54            writer = io.TextIOWrapper(io.BytesIO(),55                                      encoding=encoding,56                                      errors="xmlcharrefreplace",57                                      newline='\n')58        if self.nodeType == Node.DOCUMENT_NODE:59            # Can pass encoding only to document, to put it into XML header60            self.writexml(writer, "", indent, newl, encoding, standalone)61        else:62            self.writexml(writer, "", indent, newl)63        if encoding is None:64            return writer.getvalue()65        else:66            return writer.detach().getvalue()67 68    def hasChildNodes(self):69        return bool(self.childNodes)70 71    def _get_childNodes(self):72        return self.childNodes73 74    def _get_firstChild(self):75        if self.childNodes:76            return self.childNodes[0]77 78    def _get_lastChild(self):79        if self.childNodes:80            return self.childNodes[-1]81 82    def insertBefore(self, newChild, refChild):83        if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:84            for c in tuple(newChild.childNodes):85                self.insertBefore(c, refChild)86            ### The DOM does not clearly specify what to return in this case87            return newChild88        if newChild.nodeType not in self._child_node_types:89            raise xml.dom.HierarchyRequestErr(90                "%s cannot be child of %s" % (repr(newChild), repr(self)))91        if newChild.parentNode is not None:92            newChild.parentNode.removeChild(newChild)93        if refChild is None:94            self.appendChild(newChild)95        else:96            try:97                index = self.childNodes.index(refChild)98            except ValueError:99                raise xml.dom.NotFoundErr()100            if newChild.nodeType in _nodeTypes_with_children:101                _clear_id_cache(self)102            self.childNodes.insert(index, newChild)103            newChild.nextSibling = refChild104            refChild.previousSibling = newChild105            if index:106                node = self.childNodes[index-1]107                node.nextSibling = newChild108                newChild.previousSibling = node109            else:110                newChild.previousSibling = None111            newChild.parentNode = self112        return newChild113 114    def appendChild(self, node):115        if node.nodeType == self.DOCUMENT_FRAGMENT_NODE:116            for c in tuple(node.childNodes):117                self.appendChild(c)118            ### The DOM does not clearly specify what to return in this case119            return node120        if node.nodeType not in self._child_node_types:121            raise xml.dom.HierarchyRequestErr(122                "%s cannot be child of %s" % (repr(node), repr(self)))123        elif node.nodeType in _nodeTypes_with_children:124            _clear_id_cache(self)125        if node.parentNode is not None:126            node.parentNode.removeChild(node)127        _append_child(self, node)128        node.nextSibling = None129        return node130 131    def replaceChild(self, newChild, oldChild):132        if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:133            refChild = oldChild.nextSibling134            self.removeChild(oldChild)135            return self.insertBefore(newChild, refChild)136        if newChild.nodeType not in self._child_node_types:137            raise xml.dom.HierarchyRequestErr(138                "%s cannot be child of %s" % (repr(newChild), repr(self)))139        if newChild is oldChild:140            return141        if newChild.parentNode is not None:142            newChild.parentNode.removeChild(newChild)143        try:144            index = self.childNodes.index(oldChild)145        except ValueError:146            raise xml.dom.NotFoundErr()147        self.childNodes[index] = newChild148        newChild.parentNode = self149        oldChild.parentNode = None150        if (newChild.nodeType in _nodeTypes_with_children151            or oldChild.nodeType in _nodeTypes_with_children):152            _clear_id_cache(self)153        newChild.nextSibling = oldChild.nextSibling154        newChild.previousSibling = oldChild.previousSibling155        oldChild.nextSibling = None156        oldChild.previousSibling = None157        if newChild.previousSibling:158            newChild.previousSibling.nextSibling = newChild159        if newChild.nextSibling:160            newChild.nextSibling.previousSibling = newChild161        return oldChild162 163    def removeChild(self, oldChild):164        try:165            self.childNodes.remove(oldChild)166        except ValueError:167            raise xml.dom.NotFoundErr()168        if oldChild.nextSibling is not None:169            oldChild.nextSibling.previousSibling = oldChild.previousSibling170        if oldChild.previousSibling is not None:171            oldChild.previousSibling.nextSibling = oldChild.nextSibling172        oldChild.nextSibling = oldChild.previousSibling = None173        if oldChild.nodeType in _nodeTypes_with_children:174            _clear_id_cache(self)175 176        oldChild.parentNode = None177        return oldChild178 179    def normalize(self):180        L = []181        for child in self.childNodes:182            if child.nodeType == Node.TEXT_NODE:183                if not child.data:184                    # empty text node; discard185                    if L:186                        L[-1].nextSibling = child.nextSibling187                    if child.nextSibling:188                        child.nextSibling.previousSibling = child.previousSibling189                    child.unlink()190                elif L and L[-1].nodeType == child.nodeType:191                    # collapse text node192                    node = L[-1]193                    node.data = node.data + child.data194                    node.nextSibling = child.nextSibling195                    if child.nextSibling:196                        child.nextSibling.previousSibling = node197                    child.unlink()198                else:199                    L.append(child)200            else:201                L.append(child)202                if child.nodeType == Node.ELEMENT_NODE:203                    child.normalize()204        self.childNodes[:] = L205 206    def cloneNode(self, deep):207        return _clone_node(self, deep, self.ownerDocument or self)208 209    def isSupported(self, feature, version):210        return self.ownerDocument.implementation.hasFeature(feature, version)211 212    def _get_localName(self):213        # Overridden in Element and Attr where localName can be Non-Null214        return None215 216    # Node interfaces from Level 3 (WD 9 April 2002)217 218    def isSameNode(self, other):219        return self is other220 221    def getInterface(self, feature):222        if self.isSupported(feature, None):223            return self224        else:225            return None226 227    # The "user data" functions use a dictionary that is only present228    # if some user data has been set, so be careful not to assume it229    # exists.230 231    def getUserData(self, key):232        try:233            return self._user_data[key][0]234        except (AttributeError, KeyError):235            return None236 237    def setUserData(self, key, data, handler):238        old = None239        try:240            d = self._user_data241        except AttributeError:242            d = {}243            self._user_data = d244        if key in d:245            old = d[key][0]246        if data is None:247            # ignore handlers passed for None248            handler = None249            if old is not None:250                del d[key]251        else:252            d[key] = (data, handler)253        return old254 255    def _call_user_data_handler(self, operation, src, dst):256        if hasattr(self, "_user_data"):257            for key, (data, handler) in list(self._user_data.items()):258                if handler is not None:259                    handler.handle(operation, key, data, src, dst)260 261    # minidom-specific API:262 263    def unlink(self):264        self.parentNode = self.ownerDocument = None265        if self.childNodes:266            for child in self.childNodes:267                child.unlink()268            self.childNodes = NodeList()269        self.previousSibling = None270        self.nextSibling = None271 272    # A Node is its own context manager, to ensure that an unlink() call occurs.273    # This is similar to how a file object works.274    def __enter__(self):275        return self276 277    def __exit__(self, et, ev, tb):278        self.unlink()279 280defproperty(Node, "firstChild", doc="First child node, or None.")281defproperty(Node, "lastChild",  doc="Last child node, or None.")282defproperty(Node, "localName",  doc="Namespace-local name of this node.")283 284 285def _append_child(self, node):286    # fast path with less checks; usable by DOM builders if careful287    childNodes = self.childNodes288    if childNodes:289        last = childNodes[-1]290        node.previousSibling = last291        last.nextSibling = node292    childNodes.append(node)293    node.parentNode = self294 295 296def _write_data(writer, data):297    "Writes datachars to writer."298    if data:299        data = data.replace("&", "&amp;").replace("<", "&lt;"). \300                    replace("\"", "&quot;").replace(">", "&gt;")301        writer.write(data)302 303def _get_elements_by_tagName_helper(parent, name, rc):304    for node in parent.childNodes:305        if node.nodeType == Node.ELEMENT_NODE and \306            (name == "*" or node.tagName == name):307            rc.append(node)308        _get_elements_by_tagName_helper(node, name, rc)309    return rc310 311def _get_elements_by_tagName_ns_helper(parent, nsURI, localName, rc):312    for node in parent.childNodes:313        if node.nodeType == Node.ELEMENT_NODE:314            if ((localName == "*" or node.localName == localName) and315                (nsURI == "*" or node.namespaceURI == nsURI)):316                rc.append(node)317            _get_elements_by_tagName_ns_helper(node, nsURI, localName, rc)318    return rc319 320class DocumentFragment(Node):321    nodeType = Node.DOCUMENT_FRAGMENT_NODE322    nodeName = "#document-fragment"323    nodeValue = None324    attributes = None325    parentNode = None326    _child_node_types = (Node.ELEMENT_NODE,327                         Node.TEXT_NODE,328                         Node.CDATA_SECTION_NODE,329                         Node.ENTITY_REFERENCE_NODE,330                         Node.PROCESSING_INSTRUCTION_NODE,331                         Node.COMMENT_NODE,332                         Node.NOTATION_NODE)333 334    def __init__(self):335        self.childNodes = NodeList()336 337 338class Attr(Node):339    __slots__=('_name', '_value', 'namespaceURI',340               '_prefix', 'childNodes', '_localName', 'ownerDocument', 'ownerElement')341    nodeType = Node.ATTRIBUTE_NODE342    attributes = None343    specified = False344    _is_id = False345 346    _child_node_types = (Node.TEXT_NODE, Node.ENTITY_REFERENCE_NODE)347 348    def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None,349                 prefix=None):350        self.ownerElement = None351        self._name = qName352        self.namespaceURI = namespaceURI353        self._prefix = prefix354        self.childNodes = NodeList()355 356        # Add the single child node that represents the value of the attr357        self.childNodes.append(Text())358 359        # nodeValue and value are set elsewhere360 361    def _get_localName(self):362        try:363            return self._localName364        except AttributeError:365            return self.nodeName.split(":", 1)[-1]366 367    def _get_specified(self):368        return self.specified369 370    def _get_name(self):371        return self._name372 373    def _set_name(self, value):374        self._name = value375        if self.ownerElement is not None:376            _clear_id_cache(self.ownerElement)377 378    nodeName = name = property(_get_name, _set_name)379 380    def _get_value(self):381        return self._value382 383    def _set_value(self, value):384        self._value = value385        self.childNodes[0].data = value386        if self.ownerElement is not None:387            _clear_id_cache(self.ownerElement)388        self.childNodes[0].data = value389 390    nodeValue = value = property(_get_value, _set_value)391 392    def _get_prefix(self):393        return self._prefix394 395    def _set_prefix(self, prefix):396        nsuri = self.namespaceURI397        if prefix == "xmlns":398            if nsuri and nsuri != XMLNS_NAMESPACE:399                raise xml.dom.NamespaceErr(400                    "illegal use of 'xmlns' prefix for the wrong namespace")401        self._prefix = prefix402        if prefix is None:403            newName = self.localName404        else:405            newName = "%s:%s" % (prefix, self.localName)406        if self.ownerElement:407            _clear_id_cache(self.ownerElement)408        self.name = newName409 410    prefix = property(_get_prefix, _set_prefix)411 412    def unlink(self):413        # This implementation does not call the base implementation414        # since most of that is not needed, and the expense of the415        # method call is not warranted.  We duplicate the removal of416        # children, but that's all we needed from the base class.417        elem = self.ownerElement418        if elem is not None:419            del elem._attrs[self.nodeName]420            del elem._attrsNS[(self.namespaceURI, self.localName)]421            if self._is_id:422                self._is_id = False423                elem._magic_id_nodes -= 1424                self.ownerDocument._magic_id_count -= 1425        for child in self.childNodes:426            child.unlink()427        del self.childNodes[:]428 429    def _get_isId(self):430        if self._is_id:431            return True432        doc = self.ownerDocument433        elem = self.ownerElement434        if doc is None or elem is None:435            return False436 437        info = doc._get_elem_info(elem)438        if info is None:439            return False440        if self.namespaceURI:441            return info.isIdNS(self.namespaceURI, self.localName)442        else:443            return info.isId(self.nodeName)444 445    def _get_schemaType(self):446        doc = self.ownerDocument447        elem = self.ownerElement448        if doc is None or elem is None:449            return _no_type450 451        info = doc._get_elem_info(elem)452        if info is None:453            return _no_type454        if self.namespaceURI:455            return info.getAttributeTypeNS(self.namespaceURI, self.localName)456        else:457            return info.getAttributeType(self.nodeName)458 459defproperty(Attr, "isId",       doc="True if this attribute is an ID.")460defproperty(Attr, "localName",  doc="Namespace-local name of this attribute.")461defproperty(Attr, "schemaType", doc="Schema type for this attribute.")462 463 464class NamedNodeMap(object):465    """The attribute list is a transient interface to the underlying466    dictionaries.  Mutations here will change the underlying element's467    dictionary.468 469    Ordering is imposed artificially and does not reflect the order of470    attributes as found in an input document.471    """472 473    __slots__ = ('_attrs', '_attrsNS', '_ownerElement')474 475    def __init__(self, attrs, attrsNS, ownerElement):476        self._attrs = attrs477        self._attrsNS = attrsNS478        self._ownerElement = ownerElement479 480    def _get_length(self):481        return len(self._attrs)482 483    def item(self, index):484        try:485            return self[list(self._attrs.keys())[index]]486        except IndexError:487            return None488 489    def items(self):490        L = []491        for node in self._attrs.values():492            L.append((node.nodeName, node.value))493        return L494 495    def itemsNS(self):496        L = []497        for node in self._attrs.values():498            L.append(((node.namespaceURI, node.localName), node.value))499        return L500 501    def __contains__(self, key):502        if isinstance(key, str):503            return key in self._attrs504        else:505            return key in self._attrsNS506 507    def keys(self):508        return self._attrs.keys()509 510    def keysNS(self):511        return self._attrsNS.keys()512 513    def values(self):514        return self._attrs.values()515 516    def get(self, name, value=None):517        return self._attrs.get(name, value)518 519    __len__ = _get_length520 521    def _cmp(self, other):522        if self._attrs is getattr(other, "_attrs", None):523            return 0524        else:525            return (id(self) > id(other)) - (id(self) < id(other))526 527    def __eq__(self, other):528        return self._cmp(other) == 0529 530    def __ge__(self, other):531        return self._cmp(other) >= 0532 533    def __gt__(self, other):534        return self._cmp(other) > 0535 536    def __le__(self, other):537        return self._cmp(other) <= 0538 539    def __lt__(self, other):540        return self._cmp(other) < 0541 542    def __getitem__(self, attname_or_tuple):543        if isinstance(attname_or_tuple, tuple):544            return self._attrsNS[attname_or_tuple]545        else:546            return self._attrs[attname_or_tuple]547 548    # same as set549    def __setitem__(self, attname, value):550        if isinstance(value, str):551            try:552                node = self._attrs[attname]553            except KeyError:554                node = Attr(attname)555                node.ownerDocument = self._ownerElement.ownerDocument556                self.setNamedItem(node)557            node.value = value558        else:559            if not isinstance(value, Attr):560                raise TypeError("value must be a string or Attr object")561            node = value562            self.setNamedItem(node)563 564    def getNamedItem(self, name):565        try:566            return self._attrs[name]567        except KeyError:568            return None569 570    def getNamedItemNS(self, namespaceURI, localName):571        try:572            return self._attrsNS[(namespaceURI, localName)]573        except KeyError:574            return None575 576    def removeNamedItem(self, name):577        n = self.getNamedItem(name)578        if n is not None:579            _clear_id_cache(self._ownerElement)580            del self._attrs[n.nodeName]581            del self._attrsNS[(n.namespaceURI, n.localName)]582            if hasattr(n, 'ownerElement'):583                n.ownerElement = None584            return n585        else:586            raise xml.dom.NotFoundErr()587 588    def removeNamedItemNS(self, namespaceURI, localName):589        n = self.getNamedItemNS(namespaceURI, localName)590        if n is not None:591            _clear_id_cache(self._ownerElement)592            del self._attrsNS[(n.namespaceURI, n.localName)]593            del self._attrs[n.nodeName]594            if hasattr(n, 'ownerElement'):595                n.ownerElement = None596            return n597        else:598            raise xml.dom.NotFoundErr()599 600    def setNamedItem(self, node):601        if not isinstance(node, Attr):602            raise xml.dom.HierarchyRequestErr(603                "%s cannot be child of %s" % (repr(node), repr(self)))604        old = self._attrs.get(node.name)605        if old:606            old.unlink()607        self._attrs[node.name] = node608        self._attrsNS[(node.namespaceURI, node.localName)] = node609        node.ownerElement = self._ownerElement610        _clear_id_cache(node.ownerElement)611        return old612 613    def setNamedItemNS(self, node):614        return self.setNamedItem(node)615 616    def __delitem__(self, attname_or_tuple):617        node = self[attname_or_tuple]618        _clear_id_cache(node.ownerElement)619        node.unlink()620 621    def __getstate__(self):622        return self._attrs, self._attrsNS, self._ownerElement623 624    def __setstate__(self, state):625        self._attrs, self._attrsNS, self._ownerElement = state626 627defproperty(NamedNodeMap, "length",628            doc="Number of nodes in the NamedNodeMap.")629 630AttributeList = NamedNodeMap631 632 633class TypeInfo(object):634    __slots__ = 'namespace', 'name'635 636    def __init__(self, namespace, name):637        self.namespace = namespace638        self.name = name639 640    def __repr__(self):641        if self.namespace:642            return "<%s %r (from %r)>" % (self.__class__.__name__, self.name,643                                          self.namespace)644        else:645            return "<%s %r>" % (self.__class__.__name__, self.name)646 647    def _get_name(self):648        return self.name649 650    def _get_namespace(self):651        return self.namespace652 653_no_type = TypeInfo(None, None)654 655class Element(Node):656    __slots__=('ownerDocument', 'parentNode', 'tagName', 'nodeName', 'prefix',657               'namespaceURI', '_localName', 'childNodes', '_attrs', '_attrsNS',658               'nextSibling', 'previousSibling')659    nodeType = Node.ELEMENT_NODE660    nodeValue = None661    schemaType = _no_type662 663    _magic_id_nodes = 0664 665    _child_node_types = (Node.ELEMENT_NODE,666                         Node.PROCESSING_INSTRUCTION_NODE,667                         Node.COMMENT_NODE,668                         Node.TEXT_NODE,669                         Node.CDATA_SECTION_NODE,670                         Node.ENTITY_REFERENCE_NODE)671 672    def __init__(self, tagName, namespaceURI=EMPTY_NAMESPACE, prefix=None,673                 localName=None):674        self.parentNode = None675        self.tagName = self.nodeName = tagName676        self.prefix = prefix677        self.namespaceURI = namespaceURI678        self.childNodes = NodeList()679        self.nextSibling = self.previousSibling = None680 681        # Attribute dictionaries are lazily created682        # attributes are double-indexed:683        #    tagName -> Attribute684        #    URI,localName -> Attribute685        # in the future: consider lazy generation686        # of attribute objects this is too tricky687        # for now because of headaches with688        # namespaces.689        self._attrs = None690        self._attrsNS = None691 692    def _ensure_attributes(self):693        if self._attrs is None:694            self._attrs = {}695            self._attrsNS = {}696 697    def _get_localName(self):698        try:699            return self._localName700        except AttributeError:701            return self.tagName.split(":", 1)[-1]702 703    def _get_tagName(self):704        return self.tagName705 706    def unlink(self):707        if self._attrs is not None:708            for attr in list(self._attrs.values()):709                attr.unlink()710        self._attrs = None711        self._attrsNS = None712        Node.unlink(self)713 714    def getAttribute(self, attname):715        """Returns the value of the specified attribute.716 717        Returns the value of the element's attribute named attname as718        a string. An empty string is returned if the element does not719        have such an attribute. Note that an empty string may also be720        returned as an explicitly given attribute value, use the721        hasAttribute method to distinguish these two cases.722        """723        if self._attrs is None:724            return ""725        try:726            return self._attrs[attname].value727        except KeyError:728            return ""729 730    def getAttributeNS(self, namespaceURI, localName):731        if self._attrsNS is None:732            return ""733        try:734            return self._attrsNS[(namespaceURI, localName)].value735        except KeyError:736            return ""737 738    def setAttribute(self, attname, value):739        attr = self.getAttributeNode(attname)740        if attr is None:741            attr = Attr(attname)742            attr.value = value # also sets nodeValue743            attr.ownerDocument = self.ownerDocument744            self.setAttributeNode(attr)745        elif value != attr.value:746            attr.value = value747            if attr.isId:748                _clear_id_cache(self)749 750    def setAttributeNS(self, namespaceURI, qualifiedName, value):751        prefix, localname = _nssplit(qualifiedName)752        attr = self.getAttributeNodeNS(namespaceURI, localname)753        if attr is None:754            attr = Attr(qualifiedName, namespaceURI, localname, prefix)755            attr.value = value756            attr.ownerDocument = self.ownerDocument757            self.setAttributeNode(attr)758        else:759            if value != attr.value:760                attr.value = value761                if attr.isId:762                    _clear_id_cache(self)763            if attr.prefix != prefix:764                attr.prefix = prefix765                attr.nodeName = qualifiedName766 767    def getAttributeNode(self, attrname):768        if self._attrs is None:769            return None770        return self._attrs.get(attrname)771 772    def getAttributeNodeNS(self, namespaceURI, localName):773        if self._attrsNS is None:774            return None775        return self._attrsNS.get((namespaceURI, localName))776 777    def setAttributeNode(self, attr):778        if attr.ownerElement not in (None, self):779            raise xml.dom.InuseAttributeErr("attribute node already owned")780        self._ensure_attributes()781        old1 = self._attrs.get(attr.name, None)782        if old1 is not None:783            self.removeAttributeNode(old1)784        old2 = self._attrsNS.get((attr.namespaceURI, attr.localName), None)785        if old2 is not None and old2 is not old1:786            self.removeAttributeNode(old2)787        _set_attribute_node(self, attr)788 789        if old1 is not attr:790            # It might have already been part of this node, in which case791            # it doesn't represent a change, and should not be returned.792            return old1793        if old2 is not attr:794            return old2795 796    setAttributeNodeNS = setAttributeNode797 798    def removeAttribute(self, name):799        if self._attrsNS is None:800            raise xml.dom.NotFoundErr()801        try:802            attr = self._attrs[name]803        except KeyError:804            raise xml.dom.NotFoundErr()805        self.removeAttributeNode(attr)806 807    def removeAttributeNS(self, namespaceURI, localName):808        if self._attrsNS is None:809            raise xml.dom.NotFoundErr()810        try:811            attr = self._attrsNS[(namespaceURI, localName)]812        except KeyError:813            raise xml.dom.NotFoundErr()814        self.removeAttributeNode(attr)815 816    def removeAttributeNode(self, node):817        if node is None:818            raise xml.dom.NotFoundErr()819        try:820            self._attrs[node.name]821        except KeyError:822            raise xml.dom.NotFoundErr()823        _clear_id_cache(self)824        node.unlink()825        # Restore this since the node is still useful and otherwise826        # unlinked827        node.ownerDocument = self.ownerDocument828        return node829 830    removeAttributeNodeNS = removeAttributeNode831 832    def hasAttribute(self, name):833        """Checks whether the element has an attribute with the specified name.834 835        Returns True if the element has an attribute with the specified name.836        Otherwise, returns False.837        """838        if self._attrs is None:839            return False840        return name in self._attrs841 842    def hasAttributeNS(self, namespaceURI, localName):843        if self._attrsNS is None:844            return False845        return (namespaceURI, localName) in self._attrsNS846 847    def getElementsByTagName(self, name):848        """Returns all descendant elements with the given tag name.849 850        Returns the list of all descendant elements (not direct children851        only) with the specified tag name.852        """853        return _get_elements_by_tagName_helper(self, name, NodeList())854 855    def getElementsByTagNameNS(self, namespaceURI, localName):856        return _get_elements_by_tagName_ns_helper(857            self, namespaceURI, localName, NodeList())858 859    def __repr__(self):860        return "<DOM Element: %s at %#x>" % (self.tagName, id(self))861 862    def writexml(self, writer, indent="", addindent="", newl=""):863        """Write an XML element to a file-like object864 865        Write the element to the writer object that must provide866        a write method (e.g. a file or StringIO object).867        """868        # indent = current indentation869        # addindent = indentation to add to higher levels870        # newl = newline string871        writer.write(indent+"<" + self.tagName)872 873        attrs = self._get_attributes()874 875        for a_name in attrs.keys():876            writer.write(" %s=\"" % a_name)877            _write_data(writer, attrs[a_name].value)878            writer.write("\"")879        if self.childNodes:880            writer.write(">")881            if (len(self.childNodes) == 1 and882                self.childNodes[0].nodeType in (883                        Node.TEXT_NODE, Node.CDATA_SECTION_NODE)):884                self.childNodes[0].writexml(writer, '', '', '')885            else:886                writer.write(newl)887                for node in self.childNodes:888                    node.writexml(writer, indent+addindent, addindent, newl)889                writer.write(indent)890            writer.write("</%s>%s" % (self.tagName, newl))891        else:892            writer.write("/>%s"%(newl))893 894    def _get_attributes(self):895        self._ensure_attributes()896        return NamedNodeMap(self._attrs, self._attrsNS, self)897 898    def hasAttributes(self):899        if self._attrs:900            return True901        else:902            return False903 904    # DOM Level 3 attributes, based on the 22 Oct 2002 draft905 906    def setIdAttribute(self, name):907        idAttr = self.getAttributeNode(name)908        self.setIdAttributeNode(idAttr)909 910    def setIdAttributeNS(self, namespaceURI, localName):911        idAttr = self.getAttributeNodeNS(namespaceURI, localName)912        self.setIdAttributeNode(idAttr)913 914    def setIdAttributeNode(self, idAttr):915        if idAttr is None or not self.isSameNode(idAttr.ownerElement):916            raise xml.dom.NotFoundErr()917        if _get_containing_entref(self) is not None:918            raise xml.dom.NoModificationAllowedErr()919        if not idAttr._is_id:920            idAttr._is_id = True921            self._magic_id_nodes += 1922            self.ownerDocument._magic_id_count += 1923            _clear_id_cache(self)924 925defproperty(Element, "attributes",926            doc="NamedNodeMap of attributes on the element.")927defproperty(Element, "localName",928            doc="Namespace-local name of this element.")929 930 931def _set_attribute_node(element, attr):932    _clear_id_cache(element)933    element._ensure_attributes()934    element._attrs[attr.name] = attr935    element._attrsNS[(attr.namespaceURI, attr.localName)] = attr936 937    # This creates a circular reference, but Element.unlink()938    # breaks the cycle since the references to the attribute939    # dictionaries are tossed.940    attr.ownerElement = element941 942class Childless:943    """Mixin that makes childless-ness easy to implement and avoids944    the complexity of the Node methods that deal with children.945    """946    __slots__ = ()947 948    attributes = None949    childNodes = EmptyNodeList()950    firstChild = None951    lastChild = None952 953    def _get_firstChild(self):954        return None955 956    def _get_lastChild(self):957        return None958 959    def appendChild(self, node):960        raise xml.dom.HierarchyRequestErr(961            self.nodeName + " nodes cannot have children")962 963    def hasChildNodes(self):964        return False965 966    def insertBefore(self, newChild, refChild):967        raise xml.dom.HierarchyRequestErr(968            self.nodeName + " nodes do not have children")969 970    def removeChild(self, oldChild):971        raise xml.dom.NotFoundErr(972            self.nodeName + " nodes do not have children")973 974    def normalize(self):975        # For childless nodes, normalize() has nothing to do.976        pass977 978    def replaceChild(self, newChild, oldChild):979        raise xml.dom.HierarchyRequestErr(980            self.nodeName + " nodes do not have children")981 982 983class ProcessingInstruction(Childless, Node):984    nodeType = Node.PROCESSING_INSTRUCTION_NODE985    __slots__ = ('target', 'data')986 987    def __init__(self, target, data):988        self.target = target989        self.data = data990 991    # nodeValue is an alias for data992    def _get_nodeValue(self):993        return self.data994    def _set_nodeValue(self, value):995        self.data = value996    nodeValue = property(_get_nodeValue, _set_nodeValue)997 998    # nodeName is an alias for target999    def _get_nodeName(self):1000        return self.target1001    def _set_nodeName(self, value):1002        self.target = value1003    nodeName = property(_get_nodeName, _set_nodeName)1004 1005    def writexml(self, writer, indent="", addindent="", newl=""):1006        writer.write("%s<?%s %s?>%s" % (indent,self.target, self.data, newl))1007 1008 1009class CharacterData(Childless, Node):1010    __slots__=('_data', 'ownerDocument','parentNode', 'previousSibling', 'nextSibling')1011 1012    def __init__(self):1013        self.ownerDocument = self.parentNode = None1014        self.previousSibling = self.nextSibling = None1015        self._data = ''1016        Node.__init__(self)1017 1018    def _get_length(self):1019        return len(self.data)1020    __len__ = _get_length1021 1022    def _get_data(self):1023        return self._data1024    def _set_data(self, data):1025        self._data = data1026 1027    data = nodeValue = property(_get_data, _set_data)1028 1029    def __repr__(self):1030        data = self.data1031        if len(data) > 10:1032            dotdotdot = "..."1033        else:1034            dotdotdot = ""1035        return '<DOM %s node "%r%s">' % (1036            self.__class__.__name__, data[0:10], dotdotdot)1037 1038    def substringData(self, offset, count):1039        if offset < 0:1040            raise xml.dom.IndexSizeErr("offset cannot be negative")1041        if offset >= len(self.data):1042            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")1043        if count < 0:1044            raise xml.dom.IndexSizeErr("count cannot be negative")1045        return self.data[offset:offset+count]1046 1047    def appendData(self, arg):1048        self.data = self.data + arg1049 1050    def insertData(self, offset, arg):1051        if offset < 0:1052            raise xml.dom.IndexSizeErr("offset cannot be negative")1053        if offset >= len(self.data):1054            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")1055        if arg:1056            self.data = "%s%s%s" % (1057                self.data[:offset], arg, self.data[offset:])1058 1059    def deleteData(self, offset, count):1060        if offset < 0:1061            raise xml.dom.IndexSizeErr("offset cannot be negative")1062        if offset >= len(self.data):1063            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")1064        if count < 0:1065            raise xml.dom.IndexSizeErr("count cannot be negative")1066        if count:1067            self.data = self.data[:offset] + self.data[offset+count:]1068 1069    def replaceData(self, offset, count, arg):1070        if offset < 0:1071            raise xml.dom.IndexSizeErr("offset cannot be negative")1072        if offset >= len(self.data):1073            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")1074        if count < 0:1075            raise xml.dom.IndexSizeErr("count cannot be negative")1076        if count:1077            self.data = "%s%s%s" % (1078                self.data[:offset], arg, self.data[offset+count:])1079 1080defproperty(CharacterData, "length", doc="Length of the string data.")1081 1082 1083class Text(CharacterData):1084    __slots__ = ()1085 1086    nodeType = Node.TEXT_NODE1087    nodeName = "#text"1088    attributes = None1089 1090    def splitText(self, offset):1091        if offset < 0 or offset > len(self.data):1092            raise xml.dom.IndexSizeErr("illegal offset value")1093        newText = self.__class__()1094        newText.data = self.data[offset:]1095        newText.ownerDocument = self.ownerDocument1096        next = self.nextSibling1097        if self.parentNode and self in self.parentNode.childNodes:1098            if next is None:1099                self.parentNode.appendChild(newText)1100            else:1101                self.parentNode.insertBefore(newText, next)1102        self.data = self.data[:offset]1103        return newText1104 1105    def writexml(self, writer, indent="", addindent="", newl=""):1106        _write_data(writer, "%s%s%s" % (indent, self.data, newl))1107 1108    # DOM Level 3 (WD 9 April 2002)1109 1110    def _get_wholeText(self):1111        L = [self.data]1112        n = self.previousSibling1113        while n is not None:1114            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):1115                L.insert(0, n.data)1116                n = n.previousSibling1117            else:1118                break1119        n = self.nextSibling1120        while n is not None:1121            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):1122                L.append(n.data)1123                n = n.nextSibling1124            else:1125                break1126        return ''.join(L)1127 1128    def replaceWholeText(self, content):1129        # XXX This needs to be seriously changed if minidom ever1130        # supports EntityReference nodes.1131        parent = self.parentNode1132        n = self.previousSibling1133        while n is not None:1134            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):1135                next = n.previousSibling1136                parent.removeChild(n)1137                n = next1138            else:1139                break1140        n = self.nextSibling1141        if not content:1142            parent.removeChild(self)1143        while n is not None:1144            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):1145                next = n.nextSibling1146                parent.removeChild(n)1147                n = next1148            else:1149                break1150        if content:1151            self.data = content1152            return self1153        else:1154            return None1155 1156    def _get_isWhitespaceInElementContent(self):1157        if self.data.strip():1158            return False1159        elem = _get_containing_element(self)1160        if elem is None:1161            return False1162        info = self.ownerDocument._get_elem_info(elem)1163        if info is None:1164            return False1165        else:1166            return info.isElementContent()1167 1168defproperty(Text, "isWhitespaceInElementContent",1169            doc="True iff this text node contains only whitespace"1170                " and is in element content.")1171defproperty(Text, "wholeText",1172            doc="The text of all logically-adjacent text nodes.")1173 1174 1175def _get_containing_element(node):1176    c = node.parentNode1177    while c is not None:1178        if c.nodeType == Node.ELEMENT_NODE:1179            return c1180        c = c.parentNode1181    return None1182 1183def _get_containing_entref(node):1184    c = node.parentNode1185    while c is not None:1186        if c.nodeType == Node.ENTITY_REFERENCE_NODE:1187            return c1188        c = c.parentNode1189    return None1190 1191 1192class Comment(CharacterData):1193    nodeType = Node.COMMENT_NODE1194    nodeName = "#comment"1195 1196    def __init__(self, data):1197        CharacterData.__init__(self)1198        self._data = data1199 1200    def writexml(self, writer, indent="", addindent="", newl=""):1201        if "--" in self.data:1202            raise ValueError("'--' is not allowed in a comment node")1203        writer.write("%s<!--%s-->%s" % (indent, self.data, newl))1204 1205 1206class CDATASection(Text):1207    __slots__ = ()1208 1209    nodeType = Node.CDATA_SECTION_NODE1210    nodeName = "#cdata-section"1211 1212    def writexml(self, writer, indent="", addindent="", newl=""):1213        if self.data.find("]]>") >= 0:1214            raise ValueError("']]>' not allowed in a CDATA section")1215        writer.write("<![CDATA[%s]]>" % self.data)1216 1217 1218class ReadOnlySequentialNamedNodeMap(object):1219    __slots__ = '_seq',1220 1221    def __init__(self, seq=()):1222        # seq should be a list or tuple1223        self._seq = seq1224 1225    def __len__(self):1226        return len(self._seq)1227 1228    def _get_length(self):1229        return len(self._seq)1230 1231    def getNamedItem(self, name):1232        for n in self._seq:1233            if n.nodeName == name:1234                return n1235 1236    def getNamedItemNS(self, namespaceURI, localName):1237        for n in self._seq:1238            if n.namespaceURI == namespaceURI and n.localName == localName:1239                return n1240 1241    def __getitem__(self, name_or_tuple):1242        if isinstance(name_or_tuple, tuple):1243            node = self.getNamedItemNS(*name_or_tuple)1244        else:1245            node = self.getNamedItem(name_or_tuple)1246        if node is None:1247            raise KeyError(name_or_tuple)1248        return node1249 1250    def item(self, index):1251        if index < 0:1252            return None1253        try:1254            return self._seq[index]1255        except IndexError:1256            return None1257 1258    def removeNamedItem(self, name):1259        raise xml.dom.NoModificationAllowedErr(1260            "NamedNodeMap instance is read-only")1261 1262    def removeNamedItemNS(self, namespaceURI, localName):1263        raise xml.dom.NoModificationAllowedErr(1264            "NamedNodeMap instance is read-only")1265 1266    def setNamedItem(self, node):1267        raise xml.dom.NoModificationAllowedErr(1268            "NamedNodeMap instance is read-only")1269 1270    def setNamedItemNS(self, node):1271        raise xml.dom.NoModificationAllowedErr(1272            "NamedNodeMap instance is read-only")1273 1274    def __getstate__(self):1275        return [self._seq]1276 1277    def __setstate__(self, state):1278        self._seq = state[0]1279 1280defproperty(ReadOnlySequentialNamedNodeMap, "length",1281            doc="Number of entries in the NamedNodeMap.")1282 1283 1284class Identified:1285    """Mix-in class that supports the publicId and systemId attributes."""1286 1287    __slots__ = 'publicId', 'systemId'1288 1289    def _identified_mixin_init(self, publicId, systemId):1290        self.publicId = publicId1291        self.systemId = systemId1292 1293    def _get_publicId(self):1294        return self.publicId1295 1296    def _get_systemId(self):1297        return self.systemId1298 1299class DocumentType(Identified, Childless, Node):1300    nodeType = Node.DOCUMENT_TYPE_NODE1301    nodeValue = None1302    name = None1303    publicId = None1304    systemId = None1305    internalSubset = None1306 1307    def __init__(self, qualifiedName):1308        self.entities = ReadOnlySequentialNamedNodeMap()1309        self.notations = ReadOnlySequentialNamedNodeMap()1310        if qualifiedName:1311            prefix, localname = _nssplit(qualifiedName)1312            self.name = localname1313        self.nodeName = self.name1314 1315    def _get_internalSubset(self):1316        return self.internalSubset1317 1318    def cloneNode(self, deep):1319        if self.ownerDocument is None:1320            # it's ok1321            clone = DocumentType(None)1322            clone.name = self.name1323            clone.nodeName = self.name1324            operation = xml.dom.UserDataHandler.NODE_CLONED1325            if deep:1326                clone.entities._seq = []1327                clone.notations._seq = []1328                for n in self.notations._seq:1329                    notation = Notation(n.nodeName, n.publicId, n.systemId)1330                    clone.notations._seq.append(notation)1331                    n._call_user_data_handler(operation, n, notation)1332                for e in self.entities._seq:1333                    entity = Entity(e.nodeName, e.publicId, e.systemId,1334                                    e.notationName)1335                    entity.actualEncoding = e.actualEncoding1336                    entity.encoding = e.encoding1337                    entity.version = e.version1338                    clone.entities._seq.append(entity)1339                    e._call_user_data_handler(operation, e, entity)1340            self._call_user_data_handler(operation, self, clone)1341            return clone1342        else:1343            return None1344 1345    def writexml(self, writer, indent="", addindent="", newl=""):1346        writer.write("<!DOCTYPE ")1347        writer.write(self.name)1348        if self.publicId:1349            writer.write("%s  PUBLIC '%s'%s  '%s'"1350                         % (newl, self.publicId, newl, self.systemId))1351        elif self.systemId:1352            writer.write("%s  SYSTEM '%s'" % (newl, self.systemId))1353        if self.internalSubset is not None:1354            writer.write(" [")1355            writer.write(self.internalSubset)1356            writer.write("]")1357        writer.write(">"+newl)1358 1359class Entity(Identified, Node):1360    attributes = None1361    nodeType = Node.ENTITY_NODE1362    nodeValue = None1363 1364    actualEncoding = None1365    encoding = None1366    version = None1367 1368    def __init__(self, name, publicId, systemId, notation):1369        self.nodeName = name1370        self.notationName = notation1371        self.childNodes = NodeList()1372        self._identified_mixin_init(publicId, systemId)1373 1374    def _get_actualEncoding(self):1375        return self.actualEncoding1376 1377    def _get_encoding(self):1378        return self.encoding1379 1380    def _get_version(self):1381        return self.version1382 1383    def appendChild(self, newChild):1384        raise xml.dom.HierarchyRequestErr(1385            "cannot append children to an entity node")1386 1387    def insertBefore(self, newChild, refChild):1388        raise xml.dom.HierarchyRequestErr(1389            "cannot insert children below an entity node")1390 1391    def removeChild(self, oldChild):1392        raise xml.dom.HierarchyRequestErr(1393            "cannot remove children from an entity node")1394 1395    def replaceChild(self, newChild, oldChild):1396        raise xml.dom.HierarchyRequestErr(1397            "cannot replace children of an entity node")1398 1399class Notation(Identified, Childless, Node):1400    nodeType = Node.NOTATION_NODE1401    nodeValue = None1402 1403    def __init__(self, name, publicId, systemId):1404        self.nodeName = name1405        self._identified_mixin_init(publicId, systemId)1406 1407 1408class DOMImplementation(DOMImplementationLS):1409    _features = [("core", "1.0"),1410                 ("core", "2.0"),1411                 ("core", None),1412                 ("xml", "1.0"),1413                 ("xml", "2.0"),1414                 ("xml", None),1415                 ("ls-load", "3.0"),1416                 ("ls-load", None),1417                 ]1418 1419    def hasFeature(self, feature, version):1420        if version == "":1421            version = None1422        return (feature.lower(), version) in self._features1423 1424    def createDocument(self, namespaceURI, qualifiedName, doctype):1425        if doctype and doctype.parentNode is not None:1426            raise xml.dom.WrongDocumentErr(1427                "doctype object owned by another DOM tree")1428        doc = self._create_document()1429 1430        add_root_element = not (namespaceURI is None1431                                and qualifiedName is None1432                                and doctype is None)1433 1434        if not qualifiedName and add_root_element:1435            # The spec is unclear what to raise here; SyntaxErr1436            # would be the other obvious candidate. Since Xerces raises1437            # InvalidCharacterErr, and since SyntaxErr is not listed1438            # for createDocument, that seems to be the better choice.1439            # XXX: need to check for illegal characters here and in1440            # createElement.1441 1442            # DOM Level III clears this up when talking about the return value1443            # of this function.  If namespaceURI, qName and DocType are1444            # Null the document is returned without a document element1445            # Otherwise if doctype or namespaceURI are not None1446            # Then we go back to the above problem1447            raise xml.dom.InvalidCharacterErr("Element with no name")1448 1449        if add_root_element:1450            prefix, localname = _nssplit(qualifiedName)1451            if prefix == "xml" \1452               and namespaceURI != "http://www.w3.org/XML/1998/namespace":1453                raise xml.dom.NamespaceErr("illegal use of 'xml' prefix")1454            if prefix and not namespaceURI:1455                raise xml.dom.NamespaceErr(1456                    "illegal use of prefix without namespaces")1457            element = doc.createElementNS(namespaceURI, qualifiedName)1458            if doctype:1459                doc.appendChild(doctype)1460            doc.appendChild(element)1461 1462        if doctype:1463            doctype.parentNode = doctype.ownerDocument = doc1464 1465        doc.doctype = doctype1466        doc.implementation = self1467        return doc1468 1469    def createDocumentType(self, qualifiedName, publicId, systemId):1470        doctype = DocumentType(qualifiedName)1471        doctype.publicId = publicId1472        doctype.systemId = systemId1473        return doctype1474 1475    # DOM Level 3 (WD 9 April 2002)1476 1477    def getInterface(self, feature):1478        if self.hasFeature(feature, None):1479            return self1480        else:1481            return None1482 1483    # internal1484    def _create_document(self):1485        return Document()1486 1487class ElementInfo(object):1488    """Object that represents content-model information for an element.1489 1490    This implementation is not expected to be used in practice; DOM1491    builders should provide implementations which do the right thing1492    using information available to it.1493 1494    """1495 1496    __slots__ = 'tagName',1497 1498    def __init__(self, name):1499        self.tagName = name1500 1501    def getAttributeType(self, aname):1502        return _no_type1503 1504    def getAttributeTypeNS(self, namespaceURI, localName):1505        return _no_type1506 1507    def isElementContent(self):1508        return False1509 1510    def isEmpty(self):1511        """Returns true iff this element is declared to have an EMPTY1512        content model."""1513        return False1514 1515    def isId(self, aname):1516        """Returns true iff the named attribute is a DTD-style ID."""1517        return False1518 1519    def isIdNS(self, namespaceURI, localName):1520        """Returns true iff the identified attribute is a DTD-style ID."""1521        return False1522 1523    def __getstate__(self):1524        return self.tagName1525 1526    def __setstate__(self, state):1527        self.tagName = state1528 1529def _clear_id_cache(node):1530    if node.nodeType == Node.DOCUMENT_NODE:1531        node._id_cache.clear()1532        node._id_search_stack = None1533    elif node.ownerDocument:1534        node.ownerDocument._id_cache.clear()1535        node.ownerDocument._id_search_stack= None1536 1537class Document(Node, DocumentLS):1538    __slots__ = ('_elem_info', 'doctype',1539                 '_id_search_stack', 'childNodes', '_id_cache')1540    _child_node_types = (Node.ELEMENT_NODE, Node.PROCESSING_INSTRUCTION_NODE,1541                         Node.COMMENT_NODE, Node.DOCUMENT_TYPE_NODE)1542 1543    implementation = DOMImplementation()1544    nodeType = Node.DOCUMENT_NODE1545    nodeName = "#document"1546    nodeValue = None1547    attributes = None1548    parentNode = None1549    previousSibling = nextSibling = None1550 1551 1552    # Document attributes from Level 3 (WD 9 April 2002)1553 1554    actualEncoding = None1555    encoding = None1556    standalone = None1557    version = None1558    strictErrorChecking = False1559    errorHandler = None1560    documentURI = None1561 1562    _magic_id_count = 01563 1564    def __init__(self):1565        self.doctype = None1566        self.childNodes = NodeList()1567        # mapping of (namespaceURI, localName) -> ElementInfo1568        #        and tagName -> ElementInfo1569        self._elem_info = {}1570        self._id_cache = {}1571        self._id_search_stack = None1572 1573    def _get_elem_info(self, element):1574        if element.namespaceURI:1575            key = element.namespaceURI, element.localName1576        else:1577            key = element.tagName1578        return self._elem_info.get(key)1579 1580    def _get_actualEncoding(self):1581        return self.actualEncoding1582 1583    def _get_doctype(self):1584        return self.doctype1585 1586    def _get_documentURI(self):1587        return self.documentURI1588 1589    def _get_encoding(self):1590        return self.encoding1591 1592    def _get_errorHandler(self):1593        return self.errorHandler1594 1595    def _get_standalone(self):1596        return self.standalone1597 1598    def _get_strictErrorChecking(self):1599        return self.strictErrorChecking1600 1601    def _get_version(self):1602        return self.version1603 1604    def appendChild(self, node):1605        if node.nodeType not in self._child_node_types:1606            raise xml.dom.HierarchyRequestErr(1607                "%s cannot be child of %s" % (repr(node), repr(self)))1608        if node.parentNode is not None:1609            # This needs to be done before the next test since this1610            # may *be* the document element, in which case it should1611            # end up re-ordered to the end.1612            node.parentNode.removeChild(node)1613 1614        if node.nodeType == Node.ELEMENT_NODE \1615           and self._get_documentElement():1616            raise xml.dom.HierarchyRequestErr(1617                "two document elements disallowed")1618        return Node.appendChild(self, node)1619 1620    def removeChild(self, oldChild):1621        try:1622            self.childNodes.remove(oldChild)1623        except ValueError:1624            raise xml.dom.NotFoundErr()1625        oldChild.nextSibling = oldChild.previousSibling = None1626        oldChild.parentNode = None1627        if self.documentElement is oldChild:1628            self.documentElement = None1629 1630        return oldChild1631 1632    def _get_documentElement(self):1633        for node in self.childNodes:1634            if node.nodeType == Node.ELEMENT_NODE:1635                return node1636 1637    def unlink(self):1638        if self.doctype is not None:1639            self.doctype.unlink()1640            self.doctype = None1641        Node.unlink(self)1642 1643    def cloneNode(self, deep):1644        if not deep:1645            return None1646        clone = self.implementation.createDocument(None, None, None)1647        clone.encoding = self.encoding1648        clone.standalone = self.standalone1649        clone.version = self.version1650        for n in self.childNodes:1651            childclone = _clone_node(n, deep, clone)1652            assert childclone.ownerDocument.isSameNode(clone)1653            clone.childNodes.append(childclone)1654            if childclone.nodeType == Node.DOCUMENT_NODE:1655                assert clone.documentElement is None1656            elif childclone.nodeType == Node.DOCUMENT_TYPE_NODE:1657                assert clone.doctype is None1658                clone.doctype = childclone1659            childclone.parentNode = clone1660        self._call_user_data_handler(xml.dom.UserDataHandler.NODE_CLONED,1661                                     self, clone)1662        return clone1663 1664    def createDocumentFragment(self):1665        d = DocumentFragment()1666        d.ownerDocument = self1667        return d1668 1669    def createElement(self, tagName):1670        e = Element(tagName)1671        e.ownerDocument = self1672        return e1673 1674    def createTextNode(self, data):1675        if not isinstance(data, str):1676            raise TypeError("node contents must be a string")1677        t = Text()1678        t.data = data1679        t.ownerDocument = self1680        return t1681 1682    def createCDATASection(self, data):1683        if not isinstance(data, str):1684            raise TypeError("node contents must be a string")1685        c = CDATASection()1686        c.data = data1687        c.ownerDocument = self1688        return c1689 1690    def createComment(self, data):1691        c = Comment(data)1692        c.ownerDocument = self1693        return c1694 1695    def createProcessingInstruction(self, target, data):1696        p = ProcessingInstruction(target, data)1697        p.ownerDocument = self1698        return p1699 1700    def createAttribute(self, qName):1701        a = Attr(qName)1702        a.ownerDocument = self1703        a.value = ""1704        return a1705 1706    def createElementNS(self, namespaceURI, qualifiedName):1707        prefix, localName = _nssplit(qualifiedName)1708        e = Element(qualifiedName, namespaceURI, prefix)1709        e.ownerDocument = self1710        return e1711 1712    def createAttributeNS(self, namespaceURI, qualifiedName):1713        prefix, localName = _nssplit(qualifiedName)1714        a = Attr(qualifiedName, namespaceURI, localName, prefix)1715        a.ownerDocument = self1716        a.value = ""1717        return a1718 1719    # A couple of implementation-specific helpers to create node types1720    # not supported by the W3C DOM specs:1721 1722    def _create_entity(self, name, publicId, systemId, notationName):1723        e = Entity(name, publicId, systemId, notationName)1724        e.ownerDocument = self1725        return e1726 1727    def _create_notation(self, name, publicId, systemId):1728        n = Notation(name, publicId, systemId)1729        n.ownerDocument = self1730        return n1731 1732    def getElementById(self, id):1733        if id in self._id_cache:1734            return self._id_cache[id]1735        if not (self._elem_info or self._magic_id_count):1736            return None1737 1738        stack = self._id_search_stack1739        if stack is None:1740            # we never searched before, or the cache has been cleared1741            stack = [self.documentElement]1742            self._id_search_stack = stack1743        elif not stack:1744            # Previous search was completed and cache is still valid;1745            # no matching node.1746            return None1747 1748        result = None1749        while stack:1750            node = stack.pop()1751            # add child elements to stack for continued searching1752            stack.extend([child for child in node.childNodes1753                          if child.nodeType in _nodeTypes_with_children])1754            # check this node1755            info = self._get_elem_info(node)1756            if info:1757                # We have to process all ID attributes before1758                # returning in order to get all the attributes set to1759                # be IDs using Element.setIdAttribute*().1760                for attr in node.attributes.values():1761                    if attr.namespaceURI:1762                        if info.isIdNS(attr.namespaceURI, attr.localName):1763                            self._id_cache[attr.value] = node1764                            if attr.value == id:1765                                result = node1766                            elif not node._magic_id_nodes:1767                                break1768                    elif info.isId(attr.name):1769                        self._id_cache[attr.value] = node1770                        if attr.value == id:1771                            result = node1772                        elif not node._magic_id_nodes:1773                            break1774                    elif attr._is_id:1775                        self._id_cache[attr.value] = node1776                        if attr.value == id:1777                            result = node1778                        elif node._magic_id_nodes == 1:1779                            break1780            elif node._magic_id_nodes:1781                for attr in node.attributes.values():1782                    if attr._is_id:1783                        self._id_cache[attr.value] = node1784                        if attr.value == id:1785                            result = node1786            if result is not None:1787                break1788        return result1789 1790    def getElementsByTagName(self, name):1791        return _get_elements_by_tagName_helper(self, name, NodeList())1792 1793    def getElementsByTagNameNS(self, namespaceURI, localName):1794        return _get_elements_by_tagName_ns_helper(1795            self, namespaceURI, localName, NodeList())1796 1797    def isSupported(self, feature, version):1798        return self.implementation.hasFeature(feature, version)1799 1800    def importNode(self, node, deep):1801        if node.nodeType == Node.DOCUMENT_NODE:1802            raise xml.dom.NotSupportedErr("cannot import document nodes")1803        elif node.nodeType == Node.DOCUMENT_TYPE_NODE:1804            raise xml.dom.NotSupportedErr("cannot import document type nodes")1805        return _clone_node(node, deep, self)1806 1807    def writexml(self, writer, indent="", addindent="", newl="", encoding=None,1808                 standalone=None):1809        declarations = []1810 1811        if encoding:1812            declarations.append(f'encoding="{encoding}"')1813        if standalone is not None:1814            declarations.append(f'standalone="{"yes" if standalone else "no"}"')1815 1816        writer.write(f'<?xml version="1.0" {" ".join(declarations)}?>{newl}')1817 1818        for node in self.childNodes:1819            node.writexml(writer, indent, addindent, newl)1820 1821    # DOM Level 3 (WD 9 April 2002)1822 1823    def renameNode(self, n, namespaceURI, name):1824        if n.ownerDocument is not self:1825            raise xml.dom.WrongDocumentErr(1826                "cannot rename nodes from other documents;\n"1827                "expected %s,\nfound %s" % (self, n.ownerDocument))1828        if n.nodeType not in (Node.ELEMENT_NODE, Node.ATTRIBUTE_NODE):1829            raise xml.dom.NotSupportedErr(1830                "renameNode() only applies to element and attribute nodes")1831        if namespaceURI != EMPTY_NAMESPACE:1832            if ':' in name:1833                prefix, localName = name.split(':', 1)1834                if (  prefix == "xmlns"1835                      and namespaceURI != xml.dom.XMLNS_NAMESPACE):1836                    raise xml.dom.NamespaceErr(1837                        "illegal use of 'xmlns' prefix")1838            else:1839                if (  name == "xmlns"1840                      and namespaceURI != xml.dom.XMLNS_NAMESPACE1841                      and n.nodeType == Node.ATTRIBUTE_NODE):1842                    raise xml.dom.NamespaceErr(1843                        "illegal use of the 'xmlns' attribute")1844                prefix = None1845                localName = name1846        else:1847            prefix = None1848            localName = None1849        if n.nodeType == Node.ATTRIBUTE_NODE:1850            element = n.ownerElement1851            if element is not None:1852                is_id = n._is_id1853                element.removeAttributeNode(n)1854        else:1855            element = None1856        n.prefix = prefix1857        n._localName = localName1858        n.namespaceURI = namespaceURI1859        n.nodeName = name1860        if n.nodeType == Node.ELEMENT_NODE:1861            n.tagName = name1862        else:1863            # attribute node1864            n.name = name1865            if element is not None:1866                element.setAttributeNode(n)1867                if is_id:1868                    element.setIdAttributeNode(n)1869        # It's not clear from a semantic perspective whether we should1870        # call the user data handlers for the NODE_RENAMED event since1871        # we're re-using the existing node.  The draft spec has been1872        # interpreted as meaning "no, don't call the handler unless a1873        # new node is created."1874        return n1875 1876defproperty(Document, "documentElement",1877            doc="Top-level element of this document.")1878 1879 1880def _clone_node(node, deep, newOwnerDocument):1881    """1882    Clone a node and give it the new owner document.1883    Called by Node.cloneNode and Document.importNode1884    """1885    if node.ownerDocument.isSameNode(newOwnerDocument):1886        operation = xml.dom.UserDataHandler.NODE_CLONED1887    else:1888        operation = xml.dom.UserDataHandler.NODE_IMPORTED1889    if node.nodeType == Node.ELEMENT_NODE:1890        clone = newOwnerDocument.createElementNS(node.namespaceURI,1891                                                 node.nodeName)1892        for attr in node.attributes.values():1893            clone.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value)1894            a = clone.getAttributeNodeNS(attr.namespaceURI, attr.localName)1895            a.specified = attr.specified1896 1897        if deep:1898            for child in node.childNodes:1899                c = _clone_node(child, deep, newOwnerDocument)1900                clone.appendChild(c)1901 1902    elif node.nodeType == Node.DOCUMENT_FRAGMENT_NODE:1903        clone = newOwnerDocument.createDocumentFragment()1904        if deep:1905            for child in node.childNodes:1906                c = _clone_node(child, deep, newOwnerDocument)1907                clone.appendChild(c)1908 1909    elif node.nodeType == Node.TEXT_NODE:1910        clone = newOwnerDocument.createTextNode(node.data)1911    elif node.nodeType == Node.CDATA_SECTION_NODE:1912        clone = newOwnerDocument.createCDATASection(node.data)1913    elif node.nodeType == Node.PROCESSING_INSTRUCTION_NODE:1914        clone = newOwnerDocument.createProcessingInstruction(node.target,1915                                                             node.data)1916    elif node.nodeType == Node.COMMENT_NODE:1917        clone = newOwnerDocument.createComment(node.data)1918    elif node.nodeType == Node.ATTRIBUTE_NODE:1919        clone = newOwnerDocument.createAttributeNS(node.namespaceURI,1920                                                   node.nodeName)1921        clone.specified = True1922        clone.value = node.value1923    elif node.nodeType == Node.DOCUMENT_TYPE_NODE:1924        assert node.ownerDocument is not newOwnerDocument1925        operation = xml.dom.UserDataHandler.NODE_IMPORTED1926        clone = newOwnerDocument.implementation.createDocumentType(1927            node.name, node.publicId, node.systemId)1928        clone.ownerDocument = newOwnerDocument1929        if deep:1930            clone.entities._seq = []1931            clone.notations._seq = []1932            for n in node.notations._seq:1933                notation = Notation(n.nodeName, n.publicId, n.systemId)1934                notation.ownerDocument = newOwnerDocument1935                clone.notations._seq.append(notation)1936                if hasattr(n, '_call_user_data_handler'):1937                    n._call_user_data_handler(operation, n, notation)1938            for e in node.entities._seq:1939                entity = Entity(e.nodeName, e.publicId, e.systemId,1940                                e.notationName)1941                entity.actualEncoding = e.actualEncoding1942                entity.encoding = e.encoding1943                entity.version = e.version1944                entity.ownerDocument = newOwnerDocument1945                clone.entities._seq.append(entity)1946                if hasattr(e, '_call_user_data_handler'):1947                    e._call_user_data_handler(operation, e, entity)1948    else:1949        # Note the cloning of Document and DocumentType nodes is1950        # implementation specific.  minidom handles those cases1951        # directly in the cloneNode() methods.1952        raise xml.dom.NotSupportedErr("Cannot clone node %s" % repr(node))1953 1954    # Check for _call_user_data_handler() since this could conceivably1955    # used with other DOM implementations (one of the FourThought1956    # DOMs, perhaps?).1957    if hasattr(node, '_call_user_data_handler'):1958        node._call_user_data_handler(operation, node, clone)1959    return clone1960 1961 1962def _nssplit(qualifiedName):1963    fields = qualifiedName.split(':', 1)1964    if len(fields) == 2:1965        return fields1966    else:1967        return (None, fields[0])1968 1969 1970def _do_pulldom_parse(func, args, kwargs):1971    events = func(*args, **kwargs)1972    toktype, rootNode = events.getEvent()1973    events.expandNode(rootNode)1974    events.clear()1975    return rootNode1976 1977def parse(file, parser=None, bufsize=None):1978    """Parse a file into a DOM by filename or file object."""1979    if parser is None and not bufsize:1980        from xml.dom import expatbuilder1981        return expatbuilder.parse(file)1982    else:1983        from xml.dom import pulldom1984        return _do_pulldom_parse(pulldom.parse, (file,),1985            {'parser': parser, 'bufsize': bufsize})1986 1987def parseString(string, parser=None):1988    """Parse a file into a DOM from a string."""1989    if parser is None:1990        from xml.dom import expatbuilder1991        return expatbuilder.parseString(string)1992    else:1993        from xml.dom import pulldom1994        return _do_pulldom_parse(pulldom.parseString, (string,),1995                                 {'parser': parser})1996 1997def getDOMImplementation(features=None):1998    if features:1999        if isinstance(features, str):2000            features = domreg._parse_feature_string(features)2001        for f, v in features:2002            if not Document.implementation.hasFeature(f, v):2003                return None2004    return Document.implementation2005