lmgsanm

每天学习一点，每天进步一点点…… Tomorrow is another beatifull day

导航

python模块：xml.dom.minidom 

   1 """Simple implementation of the Level 1 DOM.
   2 
   3 Namespaces and other minor Level 2 features are also supported.
   4 
   5 parse("foo.xml")
   6 
   7 parseString("<foo><bar/></foo>")
   8 
   9 Todo:
  10 =====
  11  * convenience methods for getting elements and text.
  12  * more testing
  13  * bring some of the writer and linearizer code into conformance with this
  14         interface
  15  * SAX 2 namespaces
  16 """
  17 
  18 import io
  19 import xml.dom
  20 
  21 from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE, domreg
  22 from xml.dom.minicompat import *
  23 from xml.dom.xmlbuilder import DOMImplementationLS, DocumentLS
  24 
  25 # This is used by the ID-cache invalidation checks; the list isn't
  26 # actually complete, since the nodes being checked will never be the
  27 # DOCUMENT_NODE or DOCUMENT_FRAGMENT_NODE.  (The node being checked is
  28 # 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 
  34 class Node(xml.dom.Node):
  35     namespaceURI = None # this is non-null only for elements and attributes
  36     parentNode = None
  37     ownerDocument = None
  38     nextSibling = None
  39     previousSibling = None
  40 
  41     prefix = EMPTY_PREFIX # non-null only for NS elements and attributes
  42 
  43     def __bool__(self):
  44         return True
  45 
  46     def toxml(self, encoding=None):
  47         return self.toprettyxml("", "", encoding)
  48 
  49     def toprettyxml(self, indent="\t", newl="\n", encoding=None):
  50         if encoding is None:
  51             writer = io.StringIO()
  52         else:
  53             writer = io.TextIOWrapper(io.BytesIO(),
  54                                       encoding=encoding,
  55                                       errors="xmlcharrefreplace",
  56                                       newline='\n')
  57         if self.nodeType == Node.DOCUMENT_NODE:
  58             # Can pass encoding only to document, to put it into XML header
  59             self.writexml(writer, "", indent, newl, encoding)
  60         else:
  61             self.writexml(writer, "", indent, newl)
  62         if encoding is None:
  63             return writer.getvalue()
  64         else:
  65             return writer.detach().getvalue()
  66 
  67     def hasChildNodes(self):
  68         return bool(self.childNodes)
  69 
  70     def _get_childNodes(self):
  71         return self.childNodes
  72 
  73     def _get_firstChild(self):
  74         if self.childNodes:
  75             return self.childNodes[0]
  76 
  77     def _get_lastChild(self):
  78         if self.childNodes:
  79             return self.childNodes[-1]
  80 
  81     def insertBefore(self, newChild, refChild):
  82         if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
  83             for c in tuple(newChild.childNodes):
  84                 self.insertBefore(c, refChild)
  85             ### The DOM does not clearly specify what to return in this case
  86             return newChild
  87         if newChild.nodeType not in self._child_node_types:
  88             raise xml.dom.HierarchyRequestErr(
  89                 "%s cannot be child of %s" % (repr(newChild), repr(self)))
  90         if newChild.parentNode is not None:
  91             newChild.parentNode.removeChild(newChild)
  92         if refChild is None:
  93             self.appendChild(newChild)
  94         else:
  95             try:
  96                 index = self.childNodes.index(refChild)
  97             except ValueError:
  98                 raise xml.dom.NotFoundErr()
  99             if newChild.nodeType in _nodeTypes_with_children:
 100                 _clear_id_cache(self)
 101             self.childNodes.insert(index, newChild)
 102             newChild.nextSibling = refChild
 103             refChild.previousSibling = newChild
 104             if index:
 105                 node = self.childNodes[index-1]
 106                 node.nextSibling = newChild
 107                 newChild.previousSibling = node
 108             else:
 109                 newChild.previousSibling = None
 110             newChild.parentNode = self
 111         return newChild
 112 
 113     def appendChild(self, node):
 114         if node.nodeType == self.DOCUMENT_FRAGMENT_NODE:
 115             for c in tuple(node.childNodes):
 116                 self.appendChild(c)
 117             ### The DOM does not clearly specify what to return in this case
 118             return node
 119         if node.nodeType not in self._child_node_types:
 120             raise xml.dom.HierarchyRequestErr(
 121                 "%s cannot be child of %s" % (repr(node), repr(self)))
 122         elif node.nodeType in _nodeTypes_with_children:
 123             _clear_id_cache(self)
 124         if node.parentNode is not None:
 125             node.parentNode.removeChild(node)
 126         _append_child(self, node)
 127         node.nextSibling = None
 128         return node
 129 
 130     def replaceChild(self, newChild, oldChild):
 131         if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:
 132             refChild = oldChild.nextSibling
 133             self.removeChild(oldChild)
 134             return self.insertBefore(newChild, refChild)
 135         if newChild.nodeType not in self._child_node_types:
 136             raise xml.dom.HierarchyRequestErr(
 137                 "%s cannot be child of %s" % (repr(newChild), repr(self)))
 138         if newChild is oldChild:
 139             return
 140         if newChild.parentNode is not None:
 141             newChild.parentNode.removeChild(newChild)
 142         try:
 143             index = self.childNodes.index(oldChild)
 144         except ValueError:
 145             raise xml.dom.NotFoundErr()
 146         self.childNodes[index] = newChild
 147         newChild.parentNode = self
 148         oldChild.parentNode = None
 149         if (newChild.nodeType in _nodeTypes_with_children
 150             or oldChild.nodeType in _nodeTypes_with_children):
 151             _clear_id_cache(self)
 152         newChild.nextSibling = oldChild.nextSibling
 153         newChild.previousSibling = oldChild.previousSibling
 154         oldChild.nextSibling = None
 155         oldChild.previousSibling = None
 156         if newChild.previousSibling:
 157             newChild.previousSibling.nextSibling = newChild
 158         if newChild.nextSibling:
 159             newChild.nextSibling.previousSibling = newChild
 160         return oldChild
 161 
 162     def removeChild(self, oldChild):
 163         try:
 164             self.childNodes.remove(oldChild)
 165         except ValueError:
 166             raise xml.dom.NotFoundErr()
 167         if oldChild.nextSibling is not None:
 168             oldChild.nextSibling.previousSibling = oldChild.previousSibling
 169         if oldChild.previousSibling is not None:
 170             oldChild.previousSibling.nextSibling = oldChild.nextSibling
 171         oldChild.nextSibling = oldChild.previousSibling = None
 172         if oldChild.nodeType in _nodeTypes_with_children:
 173             _clear_id_cache(self)
 174 
 175         oldChild.parentNode = None
 176         return oldChild
 177 
 178     def normalize(self):
 179         L = []
 180         for child in self.childNodes:
 181             if child.nodeType == Node.TEXT_NODE:
 182                 if not child.data:
 183                     # empty text node; discard
 184                     if L:
 185                         L[-1].nextSibling = child.nextSibling
 186                     if child.nextSibling:
 187                         child.nextSibling.previousSibling = child.previousSibling
 188                     child.unlink()
 189                 elif L and L[-1].nodeType == child.nodeType:
 190                     # collapse text node
 191                     node = L[-1]
 192                     node.data = node.data + child.data
 193                     node.nextSibling = child.nextSibling
 194                     if child.nextSibling:
 195                         child.nextSibling.previousSibling = node
 196                     child.unlink()
 197                 else:
 198                     L.append(child)
 199             else:
 200                 L.append(child)
 201                 if child.nodeType == Node.ELEMENT_NODE:
 202                     child.normalize()
 203         self.childNodes[:] = L
 204 
 205     def cloneNode(self, deep):
 206         return _clone_node(self, deep, self.ownerDocument or self)
 207 
 208     def isSupported(self, feature, version):
 209         return self.ownerDocument.implementation.hasFeature(feature, version)
 210 
 211     def _get_localName(self):
 212         # Overridden in Element and Attr where localName can be Non-Null
 213         return None
 214 
 215     # Node interfaces from Level 3 (WD 9 April 2002)
 216 
 217     def isSameNode(self, other):
 218         return self is other
 219 
 220     def getInterface(self, feature):
 221         if self.isSupported(feature, None):
 222             return self
 223         else:
 224             return None
 225 
 226     # The "user data" functions use a dictionary that is only present
 227     # if some user data has been set, so be careful not to assume it
 228     # exists.
 229 
 230     def getUserData(self, key):
 231         try:
 232             return self._user_data[key][0]
 233         except (AttributeError, KeyError):
 234             return None
 235 
 236     def setUserData(self, key, data, handler):
 237         old = None
 238         try:
 239             d = self._user_data
 240         except AttributeError:
 241             d = {}
 242             self._user_data = d
 243         if key in d:
 244             old = d[key][0]
 245         if data is None:
 246             # ignore handlers passed for None
 247             handler = None
 248             if old is not None:
 249                 del d[key]
 250         else:
 251             d[key] = (data, handler)
 252         return old
 253 
 254     def _call_user_data_handler(self, operation, src, dst):
 255         if hasattr(self, "_user_data"):
 256             for key, (data, handler) in list(self._user_data.items()):
 257                 if handler is not None:
 258                     handler.handle(operation, key, data, src, dst)
 259 
 260     # minidom-specific API:
 261 
 262     def unlink(self):
 263         self.parentNode = self.ownerDocument = None
 264         if self.childNodes:
 265             for child in self.childNodes:
 266                 child.unlink()
 267             self.childNodes = NodeList()
 268         self.previousSibling = None
 269         self.nextSibling = None
 270 
 271     # A Node is its own context manager, to ensure that an unlink() call occurs.
 272     # This is similar to how a file object works.
 273     def __enter__(self):
 274         return self
 275 
 276     def __exit__(self, et, ev, tb):
 277         self.unlink()
 278 
 279 defproperty(Node, "firstChild", doc="First child node, or None.")
 280 defproperty(Node, "lastChild",  doc="Last child node, or None.")
 281 defproperty(Node, "localName",  doc="Namespace-local name of this node.")
 282 
 283 
 284 def _append_child(self, node):
 285     # fast path with less checks; usable by DOM builders if careful
 286     childNodes = self.childNodes
 287     if childNodes:
 288         last = childNodes[-1]
 289         node.previousSibling = last
 290         last.nextSibling = node
 291     childNodes.append(node)
 292     node.parentNode = self
 293 
 294 def _in_document(node):
 295     # return True iff node is part of a document tree
 296     while node is not None:
 297         if node.nodeType == Node.DOCUMENT_NODE:
 298             return True
 299         node = node.parentNode
 300     return False
 301 
 302 def _write_data(writer, data):
 303     "Writes datachars to writer."
 304     if data:
 305         data = data.replace("&", "&amp;").replace("<", "&lt;"). \
 306                     replace("\"", "&quot;").replace(">", "&gt;")
 307         writer.write(data)
 308 
 309 def _get_elements_by_tagName_helper(parent, name, rc):
 310     for node in parent.childNodes:
 311         if node.nodeType == Node.ELEMENT_NODE and \
 312             (name == "*" or node.tagName == name):
 313             rc.append(node)
 314         _get_elements_by_tagName_helper(node, name, rc)
 315     return rc
 316 
 317 def _get_elements_by_tagName_ns_helper(parent, nsURI, localName, rc):
 318     for node in parent.childNodes:
 319         if node.nodeType == Node.ELEMENT_NODE:
 320             if ((localName == "*" or node.localName == localName) and
 321                 (nsURI == "*" or node.namespaceURI == nsURI)):
 322                 rc.append(node)
 323             _get_elements_by_tagName_ns_helper(node, nsURI, localName, rc)
 324     return rc
 325 
 326 class DocumentFragment(Node):
 327     nodeType = Node.DOCUMENT_FRAGMENT_NODE
 328     nodeName = "#document-fragment"
 329     nodeValue = None
 330     attributes = None
 331     parentNode = None
 332     _child_node_types = (Node.ELEMENT_NODE,
 333                          Node.TEXT_NODE,
 334                          Node.CDATA_SECTION_NODE,
 335                          Node.ENTITY_REFERENCE_NODE,
 336                          Node.PROCESSING_INSTRUCTION_NODE,
 337                          Node.COMMENT_NODE,
 338                          Node.NOTATION_NODE)
 339 
 340     def __init__(self):
 341         self.childNodes = NodeList()
 342 
 343 
 344 class Attr(Node):
 345     __slots__=('_name', '_value', 'namespaceURI',
 346                '_prefix', 'childNodes', '_localName', 'ownerDocument', 'ownerElement')
 347     nodeType = Node.ATTRIBUTE_NODE
 348     attributes = None
 349     specified = False
 350     _is_id = False
 351 
 352     _child_node_types = (Node.TEXT_NODE, Node.ENTITY_REFERENCE_NODE)
 353 
 354     def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None,
 355                  prefix=None):
 356         self.ownerElement = None
 357         self._name = qName
 358         self.namespaceURI = namespaceURI
 359         self._prefix = prefix
 360         self.childNodes = NodeList()
 361 
 362         # Add the single child node that represents the value of the attr
 363         self.childNodes.append(Text())
 364 
 365         # nodeValue and value are set elsewhere
 366 
 367     def _get_localName(self):
 368         try:
 369             return self._localName
 370         except AttributeError:
 371             return self.nodeName.split(":", 1)[-1]
 372 
 373     def _get_specified(self):
 374         return self.specified
 375 
 376     def _get_name(self):
 377         return self._name
 378 
 379     def _set_name(self, value):
 380         self._name = value
 381         if self.ownerElement is not None:
 382             _clear_id_cache(self.ownerElement)
 383 
 384     nodeName = name = property(_get_name, _set_name)
 385 
 386     def _get_value(self):
 387         return self._value
 388 
 389     def _set_value(self, value):
 390         self._value = value
 391         self.childNodes[0].data = value
 392         if self.ownerElement is not None:
 393             _clear_id_cache(self.ownerElement)
 394         self.childNodes[0].data = value
 395 
 396     nodeValue = value = property(_get_value, _set_value)
 397 
 398     def _get_prefix(self):
 399         return self._prefix
 400 
 401     def _set_prefix(self, prefix):
 402         nsuri = self.namespaceURI
 403         if prefix == "xmlns":
 404             if nsuri and nsuri != XMLNS_NAMESPACE:
 405                 raise xml.dom.NamespaceErr(
 406                     "illegal use of 'xmlns' prefix for the wrong namespace")
 407         self._prefix = prefix
 408         if prefix is None:
 409             newName = self.localName
 410         else:
 411             newName = "%s:%s" % (prefix, self.localName)
 412         if self.ownerElement:
 413             _clear_id_cache(self.ownerElement)
 414         self.name = newName
 415 
 416     prefix = property(_get_prefix, _set_prefix)
 417 
 418     def unlink(self):
 419         # This implementation does not call the base implementation
 420         # since most of that is not needed, and the expense of the
 421         # method call is not warranted.  We duplicate the removal of
 422         # children, but that's all we needed from the base class.
 423         elem = self.ownerElement
 424         if elem is not None:
 425             del elem._attrs[self.nodeName]
 426             del elem._attrsNS[(self.namespaceURI, self.localName)]
 427             if self._is_id:
 428                 self._is_id = False
 429                 elem._magic_id_nodes -= 1
 430                 self.ownerDocument._magic_id_count -= 1
 431         for child in self.childNodes:
 432             child.unlink()
 433         del self.childNodes[:]
 434 
 435     def _get_isId(self):
 436         if self._is_id:
 437             return True
 438         doc = self.ownerDocument
 439         elem = self.ownerElement
 440         if doc is None or elem is None:
 441             return False
 442 
 443         info = doc._get_elem_info(elem)
 444         if info is None:
 445             return False
 446         if self.namespaceURI:
 447             return info.isIdNS(self.namespaceURI, self.localName)
 448         else:
 449             return info.isId(self.nodeName)
 450 
 451     def _get_schemaType(self):
 452         doc = self.ownerDocument
 453         elem = self.ownerElement
 454         if doc is None or elem is None:
 455             return _no_type
 456 
 457         info = doc._get_elem_info(elem)
 458         if info is None:
 459             return _no_type
 460         if self.namespaceURI:
 461             return info.getAttributeTypeNS(self.namespaceURI, self.localName)
 462         else:
 463             return info.getAttributeType(self.nodeName)
 464 
 465 defproperty(Attr, "isId",       doc="True if this attribute is an ID.")
 466 defproperty(Attr, "localName",  doc="Namespace-local name of this attribute.")
 467 defproperty(Attr, "schemaType", doc="Schema type for this attribute.")
 468 
 469 
 470 class NamedNodeMap(object):
 471     """The attribute list is a transient interface to the underlying
 472     dictionaries.  Mutations here will change the underlying element's
 473     dictionary.
 474 
 475     Ordering is imposed artificially and does not reflect the order of
 476     attributes as found in an input document.
 477     """
 478 
 479     __slots__ = ('_attrs', '_attrsNS', '_ownerElement')
 480 
 481     def __init__(self, attrs, attrsNS, ownerElement):
 482         self._attrs = attrs
 483         self._attrsNS = attrsNS
 484         self._ownerElement = ownerElement
 485 
 486     def _get_length(self):
 487         return len(self._attrs)
 488 
 489     def item(self, index):
 490         try:
 491             return self[list(self._attrs.keys())[index]]
 492         except IndexError:
 493             return None
 494 
 495     def items(self):
 496         L = []
 497         for node in self._attrs.values():
 498             L.append((node.nodeName, node.value))
 499         return L
 500 
 501     def itemsNS(self):
 502         L = []
 503         for node in self._attrs.values():
 504             L.append(((node.namespaceURI, node.localName), node.value))
 505         return L
 506 
 507     def __contains__(self, key):
 508         if isinstance(key, str):
 509             return key in self._attrs
 510         else:
 511             return key in self._attrsNS
 512 
 513     def keys(self):
 514         return self._attrs.keys()
 515 
 516     def keysNS(self):
 517         return self._attrsNS.keys()
 518 
 519     def values(self):
 520         return self._attrs.values()
 521 
 522     def get(self, name, value=None):
 523         return self._attrs.get(name, value)
 524 
 525     __len__ = _get_length
 526 
 527     def _cmp(self, other):
 528         if self._attrs is getattr(other, "_attrs", None):
 529             return 0
 530         else:
 531             return (id(self) > id(other)) - (id(self) < id(other))
 532 
 533     def __eq__(self, other):
 534         return self._cmp(other) == 0
 535 
 536     def __ge__(self, other):
 537         return self._cmp(other) >= 0
 538 
 539     def __gt__(self, other):
 540         return self._cmp(other) > 0
 541 
 542     def __le__(self, other):
 543         return self._cmp(other) <= 0
 544 
 545     def __lt__(self, other):
 546         return self._cmp(other) < 0
 547 
 548     def __getitem__(self, attname_or_tuple):
 549         if isinstance(attname_or_tuple, tuple):
 550             return self._attrsNS[attname_or_tuple]
 551         else:
 552             return self._attrs[attname_or_tuple]
 553 
 554     # same as set
 555     def __setitem__(self, attname, value):
 556         if isinstance(value, str):
 557             try:
 558                 node = self._attrs[attname]
 559             except KeyError:
 560                 node = Attr(attname)
 561                 node.ownerDocument = self._ownerElement.ownerDocument
 562                 self.setNamedItem(node)
 563             node.value = value
 564         else:
 565             if not isinstance(value, Attr):
 566                 raise TypeError("value must be a string or Attr object")
 567             node = value
 568             self.setNamedItem(node)
 569 
 570     def getNamedItem(self, name):
 571         try:
 572             return self._attrs[name]
 573         except KeyError:
 574             return None
 575 
 576     def getNamedItemNS(self, namespaceURI, localName):
 577         try:
 578             return self._attrsNS[(namespaceURI, localName)]
 579         except KeyError:
 580             return None
 581 
 582     def removeNamedItem(self, name):
 583         n = self.getNamedItem(name)
 584         if n is not None:
 585             _clear_id_cache(self._ownerElement)
 586             del self._attrs[n.nodeName]
 587             del self._attrsNS[(n.namespaceURI, n.localName)]
 588             if hasattr(n, 'ownerElement'):
 589                 n.ownerElement = None
 590             return n
 591         else:
 592             raise xml.dom.NotFoundErr()
 593 
 594     def removeNamedItemNS(self, namespaceURI, localName):
 595         n = self.getNamedItemNS(namespaceURI, localName)
 596         if n is not None:
 597             _clear_id_cache(self._ownerElement)
 598             del self._attrsNS[(n.namespaceURI, n.localName)]
 599             del self._attrs[n.nodeName]
 600             if hasattr(n, 'ownerElement'):
 601                 n.ownerElement = None
 602             return n
 603         else:
 604             raise xml.dom.NotFoundErr()
 605 
 606     def setNamedItem(self, node):
 607         if not isinstance(node, Attr):
 608             raise xml.dom.HierarchyRequestErr(
 609                 "%s cannot be child of %s" % (repr(node), repr(self)))
 610         old = self._attrs.get(node.name)
 611         if old:
 612             old.unlink()
 613         self._attrs[node.name] = node
 614         self._attrsNS[(node.namespaceURI, node.localName)] = node
 615         node.ownerElement = self._ownerElement
 616         _clear_id_cache(node.ownerElement)
 617         return old
 618 
 619     def setNamedItemNS(self, node):
 620         return self.setNamedItem(node)
 621 
 622     def __delitem__(self, attname_or_tuple):
 623         node = self[attname_or_tuple]
 624         _clear_id_cache(node.ownerElement)
 625         node.unlink()
 626 
 627     def __getstate__(self):
 628         return self._attrs, self._attrsNS, self._ownerElement
 629 
 630     def __setstate__(self, state):
 631         self._attrs, self._attrsNS, self._ownerElement = state
 632 
 633 defproperty(NamedNodeMap, "length",
 634             doc="Number of nodes in the NamedNodeMap.")
 635 
 636 AttributeList = NamedNodeMap
 637 
 638 
 639 class TypeInfo(object):
 640     __slots__ = 'namespace', 'name'
 641 
 642     def __init__(self, namespace, name):
 643         self.namespace = namespace
 644         self.name = name
 645 
 646     def __repr__(self):
 647         if self.namespace:
 648             return "<%s %r (from %r)>" % (self.__class__.__name__, self.name,
 649                                           self.namespace)
 650         else:
 651             return "<%s %r>" % (self.__class__.__name__, self.name)
 652 
 653     def _get_name(self):
 654         return self.name
 655 
 656     def _get_namespace(self):
 657         return self.namespace
 658 
 659 _no_type = TypeInfo(None, None)
 660 
 661 class Element(Node):
 662     __slots__=('ownerDocument', 'parentNode', 'tagName', 'nodeName', 'prefix',
 663                'namespaceURI', '_localName', 'childNodes', '_attrs', '_attrsNS',
 664                'nextSibling', 'previousSibling')
 665     nodeType = Node.ELEMENT_NODE
 666     nodeValue = None
 667     schemaType = _no_type
 668 
 669     _magic_id_nodes = 0
 670 
 671     _child_node_types = (Node.ELEMENT_NODE,
 672                          Node.PROCESSING_INSTRUCTION_NODE,
 673                          Node.COMMENT_NODE,
 674                          Node.TEXT_NODE,
 675                          Node.CDATA_SECTION_NODE,
 676                          Node.ENTITY_REFERENCE_NODE)
 677 
 678     def __init__(self, tagName, namespaceURI=EMPTY_NAMESPACE, prefix=None,
 679                  localName=None):
 680         self.parentNode = None
 681         self.tagName = self.nodeName = tagName
 682         self.prefix = prefix
 683         self.namespaceURI = namespaceURI
 684         self.childNodes = NodeList()
 685         self.nextSibling = self.previousSibling = None
 686 
 687         # Attribute dictionaries are lazily created
 688         # attributes are double-indexed:
 689         #    tagName -> Attribute
 690         #    URI,localName -> Attribute
 691         # in the future: consider lazy generation
 692         # of attribute objects this is too tricky
 693         # for now because of headaches with
 694         # namespaces.
 695         self._attrs = None
 696         self._attrsNS = None
 697 
 698     def _ensure_attributes(self):
 699         if self._attrs is None:
 700             self._attrs = {}
 701             self._attrsNS = {}
 702 
 703     def _get_localName(self):
 704         try:
 705             return self._localName
 706         except AttributeError:
 707             return self.tagName.split(":", 1)[-1]
 708 
 709     def _get_tagName(self):
 710         return self.tagName
 711 
 712     def unlink(self):
 713         if self._attrs is not None:
 714             for attr in list(self._attrs.values()):
 715                 attr.unlink()
 716         self._attrs = None
 717         self._attrsNS = None
 718         Node.unlink(self)
 719 
 720     def getAttribute(self, attname):
 721         if self._attrs is None:
 722             return ""
 723         try:
 724             return self._attrs[attname].value
 725         except KeyError:
 726             return ""
 727 
 728     def getAttributeNS(self, namespaceURI, localName):
 729         if self._attrsNS is None:
 730             return ""
 731         try:
 732             return self._attrsNS[(namespaceURI, localName)].value
 733         except KeyError:
 734             return ""
 735 
 736     def setAttribute(self, attname, value):
 737         attr = self.getAttributeNode(attname)
 738         if attr is None:
 739             attr = Attr(attname)
 740             attr.value = value # also sets nodeValue
 741             attr.ownerDocument = self.ownerDocument
 742             self.setAttributeNode(attr)
 743         elif value != attr.value:
 744             attr.value = value
 745             if attr.isId:
 746                 _clear_id_cache(self)
 747 
 748     def setAttributeNS(self, namespaceURI, qualifiedName, value):
 749         prefix, localname = _nssplit(qualifiedName)
 750         attr = self.getAttributeNodeNS(namespaceURI, localname)
 751         if attr is None:
 752             attr = Attr(qualifiedName, namespaceURI, localname, prefix)
 753             attr.value = value
 754             attr.ownerDocument = self.ownerDocument
 755             self.setAttributeNode(attr)
 756         else:
 757             if value != attr.value:
 758                 attr.value = value
 759                 if attr.isId:
 760                     _clear_id_cache(self)
 761             if attr.prefix != prefix:
 762                 attr.prefix = prefix
 763                 attr.nodeName = qualifiedName
 764 
 765     def getAttributeNode(self, attrname):
 766         if self._attrs is None:
 767             return None
 768         return self._attrs.get(attrname)
 769 
 770     def getAttributeNodeNS(self, namespaceURI, localName):
 771         if self._attrsNS is None:
 772             return None
 773         return self._attrsNS.get((namespaceURI, localName))
 774 
 775     def setAttributeNode(self, attr):
 776         if attr.ownerElement not in (None, self):
 777             raise xml.dom.InuseAttributeErr("attribute node already owned")
 778         self._ensure_attributes()
 779         old1 = self._attrs.get(attr.name, None)
 780         if old1 is not None:
 781             self.removeAttributeNode(old1)
 782         old2 = self._attrsNS.get((attr.namespaceURI, attr.localName), None)
 783         if old2 is not None and old2 is not old1:
 784             self.removeAttributeNode(old2)
 785         _set_attribute_node(self, attr)
 786 
 787         if old1 is not attr:
 788             # It might have already been part of this node, in which case
 789             # it doesn't represent a change, and should not be returned.
 790             return old1
 791         if old2 is not attr:
 792             return old2
 793 
 794     setAttributeNodeNS = setAttributeNode
 795 
 796     def removeAttribute(self, name):
 797         if self._attrsNS is None:
 798             raise xml.dom.NotFoundErr()
 799         try:
 800             attr = self._attrs[name]
 801         except KeyError:
 802             raise xml.dom.NotFoundErr()
 803         self.removeAttributeNode(attr)
 804 
 805     def removeAttributeNS(self, namespaceURI, localName):
 806         if self._attrsNS is None:
 807             raise xml.dom.NotFoundErr()
 808         try:
 809             attr = self._attrsNS[(namespaceURI, localName)]
 810         except KeyError:
 811             raise xml.dom.NotFoundErr()
 812         self.removeAttributeNode(attr)
 813 
 814     def removeAttributeNode(self, node):
 815         if node is None:
 816             raise xml.dom.NotFoundErr()
 817         try:
 818             self._attrs[node.name]
 819         except KeyError:
 820             raise xml.dom.NotFoundErr()
 821         _clear_id_cache(self)
 822         node.unlink()
 823         # Restore this since the node is still useful and otherwise
 824         # unlinked
 825         node.ownerDocument = self.ownerDocument
 826 
 827     removeAttributeNodeNS = removeAttributeNode
 828 
 829     def hasAttribute(self, name):
 830         if self._attrs is None:
 831             return False
 832         return name in self._attrs
 833 
 834     def hasAttributeNS(self, namespaceURI, localName):
 835         if self._attrsNS is None:
 836             return False
 837         return (namespaceURI, localName) in self._attrsNS
 838 
 839     def getElementsByTagName(self, name):
 840         return _get_elements_by_tagName_helper(self, name, NodeList())
 841 
 842     def getElementsByTagNameNS(self, namespaceURI, localName):
 843         return _get_elements_by_tagName_ns_helper(
 844             self, namespaceURI, localName, NodeList())
 845 
 846     def __repr__(self):
 847         return "<DOM Element: %s at %#x>" % (self.tagName, id(self))
 848 
 849     def writexml(self, writer, indent="", addindent="", newl=""):
 850         # indent = current indentation
 851         # addindent = indentation to add to higher levels
 852         # newl = newline string
 853         writer.write(indent+"<" + self.tagName)
 854 
 855         attrs = self._get_attributes()
 856         a_names = sorted(attrs.keys())
 857 
 858         for a_name in a_names:
 859             writer.write(" %s=\"" % a_name)
 860             _write_data(writer, attrs[a_name].value)
 861             writer.write("\"")
 862         if self.childNodes:
 863             writer.write(">")
 864             if (len(self.childNodes) == 1 and
 865                 self.childNodes[0].nodeType == Node.TEXT_NODE):
 866                 self.childNodes[0].writexml(writer, '', '', '')
 867             else:
 868                 writer.write(newl)
 869                 for node in self.childNodes:
 870                     node.writexml(writer, indent+addindent, addindent, newl)
 871                 writer.write(indent)
 872             writer.write("</%s>%s" % (self.tagName, newl))
 873         else:
 874             writer.write("/>%s"%(newl))
 875 
 876     def _get_attributes(self):
 877         self._ensure_attributes()
 878         return NamedNodeMap(self._attrs, self._attrsNS, self)
 879 
 880     def hasAttributes(self):
 881         if self._attrs:
 882             return True
 883         else:
 884             return False
 885 
 886     # DOM Level 3 attributes, based on the 22 Oct 2002 draft
 887 
 888     def setIdAttribute(self, name):
 889         idAttr = self.getAttributeNode(name)
 890         self.setIdAttributeNode(idAttr)
 891 
 892     def setIdAttributeNS(self, namespaceURI, localName):
 893         idAttr = self.getAttributeNodeNS(namespaceURI, localName)
 894         self.setIdAttributeNode(idAttr)
 895 
 896     def setIdAttributeNode(self, idAttr):
 897         if idAttr is None or not self.isSameNode(idAttr.ownerElement):
 898             raise xml.dom.NotFoundErr()
 899         if _get_containing_entref(self) is not None:
 900             raise xml.dom.NoModificationAllowedErr()
 901         if not idAttr._is_id:
 902             idAttr._is_id = True
 903             self._magic_id_nodes += 1
 904             self.ownerDocument._magic_id_count += 1
 905             _clear_id_cache(self)
 906 
 907 defproperty(Element, "attributes",
 908             doc="NamedNodeMap of attributes on the element.")
 909 defproperty(Element, "localName",
 910             doc="Namespace-local name of this element.")
 911 
 912 
 913 def _set_attribute_node(element, attr):
 914     _clear_id_cache(element)
 915     element._ensure_attributes()
 916     element._attrs[attr.name] = attr
 917     element._attrsNS[(attr.namespaceURI, attr.localName)] = attr
 918 
 919     # This creates a circular reference, but Element.unlink()
 920     # breaks the cycle since the references to the attribute
 921     # dictionaries are tossed.
 922     attr.ownerElement = element
 923 
 924 class Childless:
 925     """Mixin that makes childless-ness easy to implement and avoids
 926     the complexity of the Node methods that deal with children.
 927     """
 928     __slots__ = ()
 929 
 930     attributes = None
 931     childNodes = EmptyNodeList()
 932     firstChild = None
 933     lastChild = None
 934 
 935     def _get_firstChild(self):
 936         return None
 937 
 938     def _get_lastChild(self):
 939         return None
 940 
 941     def appendChild(self, node):
 942         raise xml.dom.HierarchyRequestErr(
 943             self.nodeName + " nodes cannot have children")
 944 
 945     def hasChildNodes(self):
 946         return False
 947 
 948     def insertBefore(self, newChild, refChild):
 949         raise xml.dom.HierarchyRequestErr(
 950             self.nodeName + " nodes do not have children")
 951 
 952     def removeChild(self, oldChild):
 953         raise xml.dom.NotFoundErr(
 954             self.nodeName + " nodes do not have children")
 955 
 956     def normalize(self):
 957         # For childless nodes, normalize() has nothing to do.
 958         pass
 959 
 960     def replaceChild(self, newChild, oldChild):
 961         raise xml.dom.HierarchyRequestErr(
 962             self.nodeName + " nodes do not have children")
 963 
 964 
 965 class ProcessingInstruction(Childless, Node):
 966     nodeType = Node.PROCESSING_INSTRUCTION_NODE
 967     __slots__ = ('target', 'data')
 968 
 969     def __init__(self, target, data):
 970         self.target = target
 971         self.data = data
 972 
 973     # nodeValue is an alias for data
 974     def _get_nodeValue(self):
 975         return self.data
 976     def _set_nodeValue(self, value):
 977         self.data = value
 978     nodeValue = property(_get_nodeValue, _set_nodeValue)
 979 
 980     # nodeName is an alias for target
 981     def _get_nodeName(self):
 982         return self.target
 983     def _set_nodeName(self, value):
 984         self.target = value
 985     nodeName = property(_get_nodeName, _set_nodeName)
 986 
 987     def writexml(self, writer, indent="", addindent="", newl=""):
 988         writer.write("%s<?%s %s?>%s" % (indent,self.target, self.data, newl))
 989 
 990 
 991 class CharacterData(Childless, Node):
 992     __slots__=('_data', 'ownerDocument','parentNode', 'previousSibling', 'nextSibling')
 993 
 994     def __init__(self):
 995         self.ownerDocument = self.parentNode = None
 996         self.previousSibling = self.nextSibling = None
 997         self._data = ''
 998         Node.__init__(self)
 999 
1000     def _get_length(self):
1001         return len(self.data)
1002     __len__ = _get_length
1003 
1004     def _get_data(self):
1005         return self._data
1006     def _set_data(self, data):
1007         self._data = data
1008 
1009     data = nodeValue = property(_get_data, _set_data)
1010 
1011     def __repr__(self):
1012         data = self.data
1013         if len(data) > 10:
1014             dotdotdot = "..."
1015         else:
1016             dotdotdot = ""
1017         return '<DOM %s node "%r%s">' % (
1018             self.__class__.__name__, data[0:10], dotdotdot)
1019 
1020     def substringData(self, offset, count):
1021         if offset < 0:
1022             raise xml.dom.IndexSizeErr("offset cannot be negative")
1023         if offset >= len(self.data):
1024             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
1025         if count < 0:
1026             raise xml.dom.IndexSizeErr("count cannot be negative")
1027         return self.data[offset:offset+count]
1028 
1029     def appendData(self, arg):
1030         self.data = self.data + arg
1031 
1032     def insertData(self, offset, arg):
1033         if offset < 0:
1034             raise xml.dom.IndexSizeErr("offset cannot be negative")
1035         if offset >= len(self.data):
1036             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
1037         if arg:
1038             self.data = "%s%s%s" % (
1039                 self.data[:offset], arg, self.data[offset:])
1040 
1041     def deleteData(self, offset, count):
1042         if offset < 0:
1043             raise xml.dom.IndexSizeErr("offset cannot be negative")
1044         if offset >= len(self.data):
1045             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
1046         if count < 0:
1047             raise xml.dom.IndexSizeErr("count cannot be negative")
1048         if count:
1049             self.data = self.data[:offset] + self.data[offset+count:]
1050 
1051     def replaceData(self, offset, count, arg):
1052         if offset < 0:
1053             raise xml.dom.IndexSizeErr("offset cannot be negative")
1054         if offset >= len(self.data):
1055             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
1056         if count < 0:
1057             raise xml.dom.IndexSizeErr("count cannot be negative")
1058         if count:
1059             self.data = "%s%s%s" % (
1060                 self.data[:offset], arg, self.data[offset+count:])
1061 
1062 defproperty(CharacterData, "length", doc="Length of the string data.")
1063 
1064 
1065 class Text(CharacterData):
1066     __slots__ = ()
1067 
1068     nodeType = Node.TEXT_NODE
1069     nodeName = "#text"
1070     attributes = None
1071 
1072     def splitText(self, offset):
1073         if offset < 0 or offset > len(self.data):
1074             raise xml.dom.IndexSizeErr("illegal offset value")
1075         newText = self.__class__()
1076         newText.data = self.data[offset:]
1077         newText.ownerDocument = self.ownerDocument
1078         next = self.nextSibling
1079         if self.parentNode and self in self.parentNode.childNodes:
1080             if next is None:
1081                 self.parentNode.appendChild(newText)
1082             else:
1083                 self.parentNode.insertBefore(newText, next)
1084         self.data = self.data[:offset]
1085         return newText
1086 
1087     def writexml(self, writer, indent="", addindent="", newl=""):
1088         _write_data(writer, "%s%s%s" % (indent, self.data, newl))
1089 
1090     # DOM Level 3 (WD 9 April 2002)
1091 
1092     def _get_wholeText(self):
1093         L = [self.data]
1094         n = self.previousSibling
1095         while n is not None:
1096             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
1097                 L.insert(0, n.data)
1098                 n = n.previousSibling
1099             else:
1100                 break
1101         n = self.nextSibling
1102         while n is not None:
1103             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
1104                 L.append(n.data)
1105                 n = n.nextSibling
1106             else:
1107                 break
1108         return ''.join(L)
1109 
1110     def replaceWholeText(self, content):
1111         # XXX This needs to be seriously changed if minidom ever
1112         # supports EntityReference nodes.
1113         parent = self.parentNode
1114         n = self.previousSibling
1115         while n is not None:
1116             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
1117                 next = n.previousSibling
1118                 parent.removeChild(n)
1119                 n = next
1120             else:
1121                 break
1122         n = self.nextSibling
1123         if not content:
1124             parent.removeChild(self)
1125         while n is not None:
1126             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
1127                 next = n.nextSibling
1128                 parent.removeChild(n)
1129                 n = next
1130             else:
1131                 break
1132         if content:
1133             self.data = content
1134             return self
1135         else:
1136             return None
1137 
1138     def _get_isWhitespaceInElementContent(self):
1139         if self.data.strip():
1140             return False
1141         elem = _get_containing_element(self)
1142         if elem is None:
1143             return False
1144         info = self.ownerDocument._get_elem_info(elem)
1145         if info is None:
1146             return False
1147         else:
1148             return info.isElementContent()
1149 
1150 defproperty(Text, "isWhitespaceInElementContent",
1151             doc="True iff this text node contains only whitespace"
1152                 " and is in element content.")
1153 defproperty(Text, "wholeText",
1154             doc="The text of all logically-adjacent text nodes.")
1155 
1156 
1157 def _get_containing_element(node):
1158     c = node.parentNode
1159     while c is not None:
1160         if c.nodeType == Node.ELEMENT_NODE:
1161             return c
1162         c = c.parentNode
1163     return None
1164 
1165 def _get_containing_entref(node):
1166     c = node.parentNode
1167     while c is not None:
1168         if c.nodeType == Node.ENTITY_REFERENCE_NODE:
1169             return c
1170         c = c.parentNode
1171     return None
1172 
1173 
1174 class Comment(CharacterData):
1175     nodeType = Node.COMMENT_NODE
1176     nodeName = "#comment"
1177 
1178     def __init__(self, data):
1179         CharacterData.__init__(self)
1180         self._data = data
1181 
1182     def writexml(self, writer, indent="", addindent="", newl=""):
1183         if "--" in self.data:
1184             raise ValueError("'--' is not allowed in a comment node")
1185         writer.write("%s<!--%s-->%s" % (indent, self.data, newl))
1186 
1187 
1188 class CDATASection(Text):
1189     __slots__ = ()
1190 
1191     nodeType = Node.CDATA_SECTION_NODE
1192     nodeName = "#cdata-section"
1193 
1194     def writexml(self, writer, indent="", addindent="", newl=""):
1195         if self.data.find("]]>") >= 0:
1196             raise ValueError("']]>' not allowed in a CDATA section")
1197         writer.write("<![CDATA[%s]]>" % self.data)
1198 
1199 
1200 class ReadOnlySequentialNamedNodeMap(object):
1201     __slots__ = '_seq',
1202 
1203     def __init__(self, seq=()):
1204         # seq should be a list or tuple
1205         self._seq = seq
1206 
1207     def __len__(self):
1208         return len(self._seq)
1209 
1210     def _get_length(self):
1211         return len(self._seq)
1212 
1213     def getNamedItem(self, name):
1214         for n in self._seq:
1215             if n.nodeName == name:
1216                 return n
1217 
1218     def getNamedItemNS(self, namespaceURI, localName):
1219         for n in self._seq:
1220             if n.namespaceURI == namespaceURI and n.localName == localName:
1221                 return n
1222 
1223     def __getitem__(self, name_or_tuple):
1224         if isinstance(name_or_tuple, tuple):
1225             node = self.getNamedItemNS(*name_or_tuple)
1226         else:
1227             node = self.getNamedItem(name_or_tuple)
1228         if node is None:
1229             raise KeyError(name_or_tuple)
1230         return node
1231 
1232     def item(self, index):
1233         if index < 0:
1234             return None
1235         try:
1236             return self._seq[index]
1237         except IndexError:
1238             return None
1239 
1240     def removeNamedItem(self, name):
1241         raise xml.dom.NoModificationAllowedErr(
1242             "NamedNodeMap instance is read-only")
1243 
1244     def removeNamedItemNS(self, namespaceURI, localName):
1245         raise xml.dom.NoModificationAllowedErr(
1246             "NamedNodeMap instance is read-only")
1247 
1248     def setNamedItem(self, node):
1249         raise xml.dom.NoModificationAllowedErr(
1250             "NamedNodeMap instance is read-only")
1251 
1252     def setNamedItemNS(self, node):
1253         raise xml.dom.NoModificationAllowedErr(
1254             "NamedNodeMap instance is read-only")
1255 
1256     def __getstate__(self):
1257         return [self._seq]
1258 
1259     def __setstate__(self, state):
1260         self._seq = state[0]
1261 
1262 defproperty(ReadOnlySequentialNamedNodeMap, "length",
1263             doc="Number of entries in the NamedNodeMap.")
1264 
1265 
1266 class Identified:
1267     """Mix-in class that supports the publicId and systemId attributes."""
1268 
1269     __slots__ = 'publicId', 'systemId'
1270 
1271     def _identified_mixin_init(self, publicId, systemId):
1272         self.publicId = publicId
1273         self.systemId = systemId
1274 
1275     def _get_publicId(self):
1276         return self.publicId
1277 
1278     def _get_systemId(self):
1279         return self.systemId
1280 
1281 class DocumentType(Identified, Childless, Node):
1282     nodeType = Node.DOCUMENT_TYPE_NODE
1283     nodeValue = None
1284     name = None
1285     publicId = None
1286     systemId = None
1287     internalSubset = None
1288 
1289     def __init__(self, qualifiedName):
1290         self.entities = ReadOnlySequentialNamedNodeMap()
1291         self.notations = ReadOnlySequentialNamedNodeMap()
1292         if qualifiedName:
1293             prefix, localname = _nssplit(qualifiedName)
1294             self.name = localname
1295         self.nodeName = self.name
1296 
1297     def _get_internalSubset(self):
1298         return self.internalSubset
1299 
1300     def cloneNode(self, deep):
1301         if self.ownerDocument is None:
1302             # it's ok
1303             clone = DocumentType(None)
1304             clone.name = self.name
1305             clone.nodeName = self.name
1306             operation = xml.dom.UserDataHandler.NODE_CLONED
1307             if deep:
1308                 clone.entities._seq = []
1309                 clone.notations._seq = []
1310                 for n in self.notations._seq:
1311                     notation = Notation(n.nodeName, n.publicId, n.systemId)
1312                     clone.notations._seq.append(notation)
1313                     n._call_user_data_handler(operation, n, notation)
1314                 for e in self.entities._seq:
1315                     entity = Entity(e.nodeName, e.publicId, e.systemId,
1316                                     e.notationName)
1317                     entity.actualEncoding = e.actualEncoding
1318                     entity.encoding = e.encoding
1319                     entity.version = e.version
1320                     clone.entities._seq.append(entity)
1321                     e._call_user_data_handler(operation, n, entity)
1322             self._call_user_data_handler(operation, self, clone)
1323             return clone
1324         else:
1325             return None
1326 
1327     def writexml(self, writer, indent="", addindent="", newl=""):
1328         writer.write("<!DOCTYPE ")
1329         writer.write(self.name)
1330         if self.publicId:
1331             writer.write("%s  PUBLIC '%s'%s  '%s'"
1332                          % (newl, self.publicId, newl, self.systemId))
1333         elif self.systemId:
1334             writer.write("%s  SYSTEM '%s'" % (newl, self.systemId))
1335         if self.internalSubset is not None:
1336             writer.write(" [")
1337             writer.write(self.internalSubset)
1338             writer.write("]")
1339         writer.write(">"+newl)
1340 
1341 class Entity(Identified, Node):
1342     attributes = None
1343     nodeType = Node.ENTITY_NODE
1344     nodeValue = None
1345 
1346     actualEncoding = None
1347     encoding = None
1348     version = None
1349 
1350     def __init__(self, name, publicId, systemId, notation):
1351         self.nodeName = name
1352         self.notationName = notation
1353         self.childNodes = NodeList()
1354         self._identified_mixin_init(publicId, systemId)
1355 
1356     def _get_actualEncoding(self):
1357         return self.actualEncoding
1358 
1359     def _get_encoding(self):
1360         return self.encoding
1361 
1362     def _get_version(self):
1363         return self.version
1364 
1365     def appendChild(self, newChild):
1366         raise xml.dom.HierarchyRequestErr(
1367             "cannot append children to an entity node")
1368 
1369     def insertBefore(self, newChild, refChild):
1370         raise xml.dom.HierarchyRequestErr(
1371             "cannot insert children below an entity node")
1372 
1373     def removeChild(self, oldChild):
1374         raise xml.dom.HierarchyRequestErr(
1375             "cannot remove children from an entity node")
1376 
1377     def replaceChild(self, newChild, oldChild):
1378         raise xml.dom.HierarchyRequestErr(
1379             "cannot replace children of an entity node")
1380 
1381 class Notation(Identified, Childless, Node):
1382     nodeType = Node.NOTATION_NODE
1383     nodeValue = None
1384 
1385     def __init__(self, name, publicId, systemId):
1386         self.nodeName = name
1387         self._identified_mixin_init(publicId, systemId)
1388 
1389 
1390 class DOMImplementation(DOMImplementationLS):
1391     _features = [("core", "1.0"),
1392                  ("core", "2.0"),
1393                  ("core", None),
1394                  ("xml", "1.0"),
1395                  ("xml", "2.0"),
1396                  ("xml", None),
1397                  ("ls-load", "3.0"),
1398                  ("ls-load", None),
1399                  ]
1400 
1401     def hasFeature(self, feature, version):
1402         if version == "":
1403             version = None
1404         return (feature.lower(), version) in self._features
1405 
1406     def createDocument(self, namespaceURI, qualifiedName, doctype):
1407         if doctype and doctype.parentNode is not None:
1408             raise xml.dom.WrongDocumentErr(
1409                 "doctype object owned by another DOM tree")
1410         doc = self._create_document()
1411 
1412         add_root_element = not (namespaceURI is None
1413                                 and qualifiedName is None
1414                                 and doctype is None)
1415 
1416         if not qualifiedName and add_root_element:
1417             # The spec is unclear what to raise here; SyntaxErr
1418             # would be the other obvious candidate. Since Xerces raises
1419             # InvalidCharacterErr, and since SyntaxErr is not listed
1420             # for createDocument, that seems to be the better choice.
1421             # XXX: need to check for illegal characters here and in
1422             # createElement.
1423 
1424             # DOM Level III clears this up when talking about the return value
1425             # of this function.  If namespaceURI, qName and DocType are
1426             # Null the document is returned without a document element
1427             # Otherwise if doctype or namespaceURI are not None
1428             # Then we go back to the above problem
1429             raise xml.dom.InvalidCharacterErr("Element with no name")
1430 
1431         if add_root_element:
1432             prefix, localname = _nssplit(qualifiedName)
1433             if prefix == "xml" \
1434                and namespaceURI != "http://www.w3.org/XML/1998/namespace":
1435                 raise xml.dom.NamespaceErr("illegal use of 'xml' prefix")
1436             if prefix and not namespaceURI:
1437                 raise xml.dom.NamespaceErr(
1438                     "illegal use of prefix without namespaces")
1439             element = doc.createElementNS(namespaceURI, qualifiedName)
1440             if doctype:
1441                 doc.appendChild(doctype)
1442             doc.appendChild(element)
1443 
1444         if doctype:
1445             doctype.parentNode = doctype.ownerDocument = doc
1446 
1447         doc.doctype = doctype
1448         doc.implementation = self
1449         return doc
1450 
1451     def createDocumentType(self, qualifiedName, publicId, systemId):
1452         doctype = DocumentType(qualifiedName)
1453         doctype.publicId = publicId
1454         doctype.systemId = systemId
1455         return doctype
1456 
1457     # DOM Level 3 (WD 9 April 2002)
1458 
1459     def getInterface(self, feature):
1460         if self.hasFeature(feature, None):
1461             return self
1462         else:
1463             return None
1464 
1465     # internal
1466     def _create_document(self):
1467         return Document()
1468 
1469 class ElementInfo(object):
1470     """Object that represents content-model information for an element.
1471 
1472     This implementation is not expected to be used in practice; DOM
1473     builders should provide implementations which do the right thing
1474     using information available to it.
1475 
1476     """
1477 
1478     __slots__ = 'tagName',
1479 
1480     def __init__(self, name):
1481         self.tagName = name
1482 
1483     def getAttributeType(self, aname):
1484         return _no_type
1485 
1486     def getAttributeTypeNS(self, namespaceURI, localName):
1487         return _no_type
1488 
1489     def isElementContent(self):
1490         return False
1491 
1492     def isEmpty(self):
1493         """Returns true iff this element is declared to have an EMPTY
1494         content model."""
1495         return False
1496 
1497     def isId(self, aname):
1498         """Returns true iff the named attribute is a DTD-style ID."""
1499         return False
1500 
1501     def isIdNS(self, namespaceURI, localName):
1502         """Returns true iff the identified attribute is a DTD-style ID."""
1503         return False
1504 
1505     def __getstate__(self):
1506         return self.tagName
1507 
1508     def __setstate__(self, state):
1509         self.tagName = state
1510 
1511 def _clear_id_cache(node):
1512     if node.nodeType == Node.DOCUMENT_NODE:
1513         node._id_cache.clear()
1514         node._id_search_stack = None
1515     elif _in_document(node):
1516         node.ownerDocument._id_cache.clear()
1517         node.ownerDocument._id_search_stack= None
1518 
1519 class Document(Node, DocumentLS):
1520     __slots__ = ('_elem_info', 'doctype',
1521                  '_id_search_stack', 'childNodes', '_id_cache')
1522     _child_node_types = (Node.ELEMENT_NODE, Node.PROCESSING_INSTRUCTION_NODE,
1523                          Node.COMMENT_NODE, Node.DOCUMENT_TYPE_NODE)
1524 
1525     implementation = DOMImplementation()
1526     nodeType = Node.DOCUMENT_NODE
1527     nodeName = "#document"
1528     nodeValue = None
1529     attributes = None
1530     parentNode = None
1531     previousSibling = nextSibling = None
1532 
1533 
1534     # Document attributes from Level 3 (WD 9 April 2002)
1535 
1536     actualEncoding = None
1537     encoding = None
1538     standalone = None
1539     version = None
1540     strictErrorChecking = False
1541     errorHandler = None
1542     documentURI = None
1543 
1544     _magic_id_count = 0
1545 
1546     def __init__(self):
1547         self.doctype = None
1548         self.childNodes = NodeList()
1549         # mapping of (namespaceURI, localName) -> ElementInfo
1550         #        and tagName -> ElementInfo
1551         self._elem_info = {}
1552         self._id_cache = {}
1553         self._id_search_stack = None
1554 
1555     def _get_elem_info(self, element):
1556         if element.namespaceURI:
1557             key = element.namespaceURI, element.localName
1558         else:
1559             key = element.tagName
1560         return self._elem_info.get(key)
1561 
1562     def _get_actualEncoding(self):
1563         return self.actualEncoding
1564 
1565     def _get_doctype(self):
1566         return self.doctype
1567 
1568     def _get_documentURI(self):
1569         return self.documentURI
1570 
1571     def _get_encoding(self):
1572         return self.encoding
1573 
1574     def _get_errorHandler(self):
1575         return self.errorHandler
1576 
1577     def _get_standalone(self):
1578         return self.standalone
1579 
1580     def _get_strictErrorChecking(self):
1581         return self.strictErrorChecking
1582 
1583     def _get_version(self):
1584         return self.version
1585 
1586     def appendChild(self, node):
1587         if node.nodeType not in self._child_node_types:
1588             raise xml.dom.HierarchyRequestErr(
1589                 "%s cannot be child of %s" % (repr(node), repr(self)))
1590         if node.parentNode is not None:
1591             # This needs to be done before the next test since this
1592             # may *be* the document element, in which case it should
1593             # end up re-ordered to the end.
1594             node.parentNode.removeChild(node)
1595 
1596         if node.nodeType == Node.ELEMENT_NODE \
1597            and self._get_documentElement():
1598             raise xml.dom.HierarchyRequestErr(
1599                 "two document elements disallowed")
1600         return Node.appendChild(self, node)
1601 
1602     def removeChild(self, oldChild):
1603         try:
1604             self.childNodes.remove(oldChild)
1605         except ValueError:
1606             raise xml.dom.NotFoundErr()
1607         oldChild.nextSibling = oldChild.previousSibling = None
1608         oldChild.parentNode = None
1609         if self.documentElement is oldChild:
1610             self.documentElement = None
1611 
1612         return oldChild
1613 
1614     def _get_documentElement(self):
1615         for node in self.childNodes:
1616             if node.nodeType == Node.ELEMENT_NODE:
1617                 return node
1618 
1619     def unlink(self):
1620         if self.doctype is not None:
1621             self.doctype.unlink()
1622             self.doctype = None
1623         Node.unlink(self)
1624 
1625     def cloneNode(self, deep):
1626         if not deep:
1627             return None
1628         clone = self.implementation.createDocument(None, None, None)
1629         clone.encoding = self.encoding
1630         clone.standalone = self.standalone
1631         clone.version = self.version
1632         for n in self.childNodes:
1633             childclone = _clone_node(n, deep, clone)
1634             assert childclone.ownerDocument.isSameNode(clone)
1635             clone.childNodes.append(childclone)
1636             if childclone.nodeType == Node.DOCUMENT_NODE:
1637                 assert clone.documentElement is None
1638             elif childclone.nodeType == Node.DOCUMENT_TYPE_NODE:
1639                 assert clone.doctype is None
1640                 clone.doctype = childclone
1641             childclone.parentNode = clone
1642         self._call_user_data_handler(xml.dom.UserDataHandler.NODE_CLONED,
1643                                      self, clone)
1644         return clone
1645 
1646     def createDocumentFragment(self):
1647         d = DocumentFragment()
1648         d.ownerDocument = self
1649         return d
1650 
1651     def createElement(self, tagName):
1652         e = Element(tagName)
1653         e.ownerDocument = self
1654         return e
1655 
1656     def createTextNode(self, data):
1657         if not isinstance(data, str):
1658             raise TypeError("node contents must be a string")
1659         t = Text()
1660         t.data = data
1661         t.ownerDocument = self
1662         return t
1663 
1664     def createCDATASection(self, data):
1665         if not isinstance(data, str):
1666             raise TypeError("node contents must be a string")
1667         c = CDATASection()
1668         c.data = data
1669         c.ownerDocument = self
1670         return c
1671 
1672     def createComment(self, data):
1673         c = Comment(data)
1674         c.ownerDocument = self
1675         return c
1676 
1677     def createProcessingInstruction(self, target, data):
1678         p = ProcessingInstruction(target, data)
1679         p.ownerDocument = self
1680         return p
1681 
1682     def createAttribute(self, qName):
1683         a = Attr(qName)
1684         a.ownerDocument = self
1685         a.value = ""
1686         return a
1687 
1688     def createElementNS(self, namespaceURI, qualifiedName):
1689         prefix, localName = _nssplit(qualifiedName)
1690         e = Element(qualifiedName, namespaceURI, prefix)
1691         e.ownerDocument = self
1692         return e
1693 
1694     def createAttributeNS(self, namespaceURI, qualifiedName):
1695         prefix, localName = _nssplit(qualifiedName)
1696         a = Attr(qualifiedName, namespaceURI, localName, prefix)
1697         a.ownerDocument = self
1698         a.value = ""
1699         return a
1700 
1701     # A couple of implementation-specific helpers to create node types
1702     # not supported by the W3C DOM specs:
1703 
1704     def _create_entity(self, name, publicId, systemId, notationName):
1705         e = Entity(name, publicId, systemId, notationName)
1706         e.ownerDocument = self
1707         return e
1708 
1709     def _create_notation(self, name, publicId, systemId):
1710         n = Notation(name, publicId, systemId)
1711         n.ownerDocument = self
1712         return n
1713 
1714     def getElementById(self, id):
1715         if id in self._id_cache:
1716             return self._id_cache[id]
1717         if not (self._elem_info or self._magic_id_count):
1718             return None
1719 
1720         stack = self._id_search_stack
1721         if stack is None:
1722             # we never searched before, or the cache has been cleared
1723             stack = [self.documentElement]
1724             self._id_search_stack = stack
1725         elif not stack:
1726             # Previous search was completed and cache is still valid;
1727             # no matching node.
1728             return None
1729 
1730         result = None
1731         while stack:
1732             node = stack.pop()
1733             # add child elements to stack for continued searching
1734             stack.extend([child for child in node.childNodes
1735                           if child.nodeType in _nodeTypes_with_children])
1736             # check this node
1737             info = self._get_elem_info(node)
1738             if info:
1739                 # We have to process all ID attributes before
1740                 # returning in order to get all the attributes set to
1741                 # be IDs using Element.setIdAttribute*().
1742                 for attr in node.attributes.values():
1743                     if attr.namespaceURI:
1744                         if info.isIdNS(attr.namespaceURI, attr.localName):
1745                             self._id_cache[attr.value] = node
1746                             if attr.value == id:
1747                                 result = node
1748                             elif not node._magic_id_nodes:
1749                                 break
1750                     elif info.isId(attr.name):
1751                         self._id_cache[attr.value] = node
1752                         if attr.value == id:
1753                             result = node
1754                         elif not node._magic_id_nodes:
1755                             break
1756                     elif attr._is_id:
1757                         self._id_cache[attr.value] = node
1758                         if attr.value == id:
1759                             result = node
1760                         elif node._magic_id_nodes == 1:
1761                             break
1762             elif node._magic_id_nodes:
1763                 for attr in node.attributes.values():
1764                     if attr._is_id:
1765                         self._id_cache[attr.value] = node
1766                         if attr.value == id:
1767                             result = node
1768             if result is not None:
1769                 break
1770         return result
1771 
1772     def getElementsByTagName(self, name):
1773         return _get_elements_by_tagName_helper(self, name, NodeList())
1774 
1775     def getElementsByTagNameNS(self, namespaceURI, localName):
1776         return _get_elements_by_tagName_ns_helper(
1777             self, namespaceURI, localName, NodeList())
1778 
1779     def isSupported(self, feature, version):
1780         return self.implementation.hasFeature(feature, version)
1781 
1782     def importNode(self, node, deep):
1783         if node.nodeType == Node.DOCUMENT_NODE:
1784             raise xml.dom.NotSupportedErr("cannot import document nodes")
1785         elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
1786             raise xml.dom.NotSupportedErr("cannot import document type nodes")
1787         return _clone_node(node, deep, self)
1788 
1789     def writexml(self, writer, indent="", addindent="", newl="", encoding=None):
1790         if encoding is None:
1791             writer.write('<?xml version="1.0" ?>'+newl)
1792         else:
1793             writer.write('<?xml version="1.0" encoding="%s"?>%s' % (
1794                 encoding, newl))
1795         for node in self.childNodes:
1796             node.writexml(writer, indent, addindent, newl)
1797 
1798     # DOM Level 3 (WD 9 April 2002)
1799 
1800     def renameNode(self, n, namespaceURI, name):
1801         if n.ownerDocument is not self:
1802             raise xml.dom.WrongDocumentErr(
1803                 "cannot rename nodes from other documents;\n"
1804                 "expected %s,\nfound %s" % (self, n.ownerDocument))
1805         if n.nodeType not in (Node.ELEMENT_NODE, Node.ATTRIBUTE_NODE):
1806             raise xml.dom.NotSupportedErr(
1807                 "renameNode() only applies to element and attribute nodes")
1808         if namespaceURI != EMPTY_NAMESPACE:
1809             if ':' in name:
1810                 prefix, localName = name.split(':', 1)
1811                 if (  prefix == "xmlns"
1812                       and namespaceURI != xml.dom.XMLNS_NAMESPACE):
1813                     raise xml.dom.NamespaceErr(
1814                         "illegal use of 'xmlns' prefix")
1815             else:
1816                 if (  name == "xmlns"
1817                       and namespaceURI != xml.dom.XMLNS_NAMESPACE
1818                       and n.nodeType == Node.ATTRIBUTE_NODE):
1819                     raise xml.dom.NamespaceErr(
1820                         "illegal use of the 'xmlns' attribute")
1821                 prefix = None
1822                 localName = name
1823         else:
1824             prefix = None
1825             localName = None
1826         if n.nodeType == Node.ATTRIBUTE_NODE:
1827             element = n.ownerElement
1828             if element is not None:
1829                 is_id = n._is_id
1830                 element.removeAttributeNode(n)
1831         else:
1832             element = None
1833         n.prefix = prefix
1834         n._localName = localName
1835         n.namespaceURI = namespaceURI
1836         n.nodeName = name
1837         if n.nodeType == Node.ELEMENT_NODE:
1838             n.tagName = name
1839         else:
1840             # attribute node
1841             n.name = name
1842             if element is not None:
1843                 element.setAttributeNode(n)
1844                 if is_id:
1845                     element.setIdAttributeNode(n)
1846         # It's not clear from a semantic perspective whether we should
1847         # call the user data handlers for the NODE_RENAMED event since
1848         # we're re-using the existing node.  The draft spec has been
1849         # interpreted as meaning "no, don't call the handler unless a
1850         # new node is created."
1851         return n
1852 
1853 defproperty(Document, "documentElement",
1854             doc="Top-level element of this document.")
1855 
1856 
1857 def _clone_node(node, deep, newOwnerDocument):
1858     """
1859     Clone a node and give it the new owner document.
1860     Called by Node.cloneNode and Document.importNode
1861     """
1862     if node.ownerDocument.isSameNode(newOwnerDocument):
1863         operation = xml.dom.UserDataHandler.NODE_CLONED
1864     else:
1865         operation = xml.dom.UserDataHandler.NODE_IMPORTED
1866     if node.nodeType == Node.ELEMENT_NODE:
1867         clone = newOwnerDocument.createElementNS(node.namespaceURI,
1868                                                  node.nodeName)
1869         for attr in node.attributes.values():
1870             clone.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value)
1871             a = clone.getAttributeNodeNS(attr.namespaceURI, attr.localName)
1872             a.specified = attr.specified
1873 
1874         if deep:
1875             for child in node.childNodes:
1876                 c = _clone_node(child, deep, newOwnerDocument)
1877                 clone.appendChild(c)
1878 
1879     elif node.nodeType == Node.DOCUMENT_FRAGMENT_NODE:
1880         clone = newOwnerDocument.createDocumentFragment()
1881         if deep:
1882             for child in node.childNodes:
1883                 c = _clone_node(child, deep, newOwnerDocument)
1884                 clone.appendChild(c)
1885 
1886     elif node.nodeType == Node.TEXT_NODE:
1887         clone = newOwnerDocument.createTextNode(node.data)
1888     elif node.nodeType == Node.CDATA_SECTION_NODE:
1889         clone = newOwnerDocument.createCDATASection(node.data)
1890     elif node.nodeType == Node.PROCESSING_INSTRUCTION_NODE:
1891         clone = newOwnerDocument.createProcessingInstruction(node.target,
1892                                                              node.data)
1893     elif node.nodeType == Node.COMMENT_NODE:
1894         clone = newOwnerDocument.createComment(node.data)
1895     elif node.nodeType == Node.ATTRIBUTE_NODE:
1896         clone = newOwnerDocument.createAttributeNS(node.namespaceURI,
1897                                                    node.nodeName)
1898         clone.specified = True
1899         clone.value = node.value
1900     elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
1901         assert node.ownerDocument is not newOwnerDocument
1902         operation = xml.dom.UserDataHandler.NODE_IMPORTED
1903         clone = newOwnerDocument.implementation.createDocumentType(
1904             node.name, node.publicId, node.systemId)
1905         clone.ownerDocument = newOwnerDocument
1906         if deep:
1907             clone.entities._seq = []
1908             clone.notations._seq = []
1909             for n in node.notations._seq:
1910                 notation = Notation(n.nodeName, n.publicId, n.systemId)
1911                 notation.ownerDocument = newOwnerDocument
1912                 clone.notations._seq.append(notation)
1913                 if hasattr(n, '_call_user_data_handler'):
1914                     n._call_user_data_handler(operation, n, notation)
1915             for e in node.entities._seq:
1916                 entity = Entity(e.nodeName, e.publicId, e.systemId,
1917                                 e.notationName)
1918                 entity.actualEncoding = e.actualEncoding
1919                 entity.encoding = e.encoding
1920                 entity.version = e.version
1921                 entity.ownerDocument = newOwnerDocument
1922                 clone.entities._seq.append(entity)
1923                 if hasattr(e, '_call_user_data_handler'):
1924                     e._call_user_data_handler(operation, n, entity)
1925     else:
1926         # Note the cloning of Document and DocumentType nodes is
1927         # implementation specific.  minidom handles those cases
1928         # directly in the cloneNode() methods.
1929         raise xml.dom.NotSupportedErr("Cannot clone node %s" % repr(node))
1930 
1931     # Check for _call_user_data_handler() since this could conceivably
1932     # used with other DOM implementations (one of the FourThought
1933     # DOMs, perhaps?).
1934     if hasattr(node, '_call_user_data_handler'):
1935         node._call_user_data_handler(operation, node, clone)
1936     return clone
1937 
1938 
1939 def _nssplit(qualifiedName):
1940     fields = qualifiedName.split(':', 1)
1941     if len(fields) == 2:
1942         return fields
1943     else:
1944         return (None, fields[0])
1945 
1946 
1947 def _do_pulldom_parse(func, args, kwargs):
1948     events = func(*args, **kwargs)
1949     toktype, rootNode = events.getEvent()
1950     events.expandNode(rootNode)
1951     events.clear()
1952     return rootNode
1953 
1954 def parse(file, parser=None, bufsize=None):
1955     """Parse a file into a DOM by filename or file object."""
1956     if parser is None and not bufsize:
1957         from xml.dom import expatbuilder
1958         return expatbuilder.parse(file)
1959     else:
1960         from xml.dom import pulldom
1961         return _do_pulldom_parse(pulldom.parse, (file,),
1962             {'parser': parser, 'bufsize': bufsize})
1963 
1964 def parseString(string, parser=None):
1965     """Parse a file into a DOM from a string."""
1966     if parser is None:
1967         from xml.dom import expatbuilder
1968         return expatbuilder.parseString(string)
1969     else:
1970         from xml.dom import pulldom
1971         return _do_pulldom_parse(pulldom.parseString, (string,),
1972                                  {'parser': parser})
1973 
1974 def getDOMImplementation(features=None):
1975     if features:
1976         if isinstance(features, str):
1977             features = domreg._parse_feature_string(features)
1978         for f, v in features:
1979             if not Document.implementation.hasFeature(f, v):
1980                 return None
1981     return Document.implementation
xml.dom.minidom

 

posted on 2018-01-29 22:27  lmgsanm  阅读(1228)  评论(0)  编辑  收藏  举报