1 """\

     2 minidom.py -- a lightweight DOM implementation.

     3 

     4 parse("foo.xml")

     5 

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

     7 

     8 Todo:

     9 =====

    10  * convenience methods for getting elements and text.

    11  * more testing

    12  * bring some of the writer and linearizer code into conformance with this

    13         interface

    14  * SAX 2 namespaces

    15 """

    16 

    17 import xml.dom

    18 

    19 from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE, domreg

    20 from xml.dom.minicompat import *

    21 from xml.dom.xmlbuilder import DOMImplementationLS, DocumentLS

    22 

    23 # This is used by the ID-cache invalidation checks; the list isn't

    24 # actually complete, since the nodes being checked will never be the

    25 # DOCUMENT_NODE or DOCUMENT_FRAGMENT_NODE.  (The node being checked is

    26 # the node being added or removed, not the node being modified.)

    27 #

    28 _nodeTypes_with_children = (xml.dom.Node.ELEMENT_NODE,

    29                             xml.dom.Node.ENTITY_REFERENCE_NODE)

    30 

    31 

    32 class Node(xml.dom.Node):

    33     namespaceURI = None # this is non-null only for elements and attributes

    34     parentNode = None

    35     ownerDocument = None

    36     nextSibling = None

    37     previousSibling = None

    38 

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

    40 

    41     def __nonzero__(self):

    42         return True

    43 

    44     def toxml(self, encoding = None):

    45         return self.toprettyxml("", "", encoding)

    46 

    47     def toprettyxml(self, indent="\t", newl="\n", encoding = None):

    48         # indent = the indentation string to prepend, per level

    49         # newl = the newline string to append

    50         writer = _get_StringIO()

    51         if encoding is not None:

    52             import codecs

    53             # Can't use codecs.getwriter to preserve 2.0 compatibility

    54             writer = codecs.lookup(encoding)[3](writer)

    55         if self.nodeType == Node.DOCUMENT_NODE:

    56             # Can pass encoding only to document, to put it into XML header

    57             self.writexml(writer, "", indent, newl, encoding)

    58         else:

    59             self.writexml(writer, "", indent, newl)

    60         return writer.getvalue()

    61 

    62     def hasChildNodes(self):

    63         if self.childNodes:

    64             return True

    65         else:

    66             return False

    67 

    68     def _get_childNodes(self):

    69         return self.childNodes

    70 

    71     def _get_firstChild(self):

    72         if self.childNodes:

    73             return self.childNodes[0]

    74 

    75     def _get_lastChild(self):

    76         if self.childNodes:

    77             return self.childNodes[-1]

    78 

    79     def insertBefore(self, newChild, refChild):

    80         if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:

    81             for c in tuple(newChild.childNodes):

    82                 self.insertBefore(c, refChild)

    83             ### The DOM does not clearly specify what to return in this case

    84             return newChild

    85         if newChild.nodeType not in self._child_node_types:

    86             raise xml.dom.HierarchyRequestErr(

    87                 "%s cannot be child of %s" % (repr(newChild), repr(self)))

    88         if newChild.parentNode is not None:

    89             newChild.parentNode.removeChild(newChild)

    90         if refChild is None:

    91             self.appendChild(newChild)

    92         else:

    93             try:

    94                 index = self.childNodes.index(refChild)

    95             except ValueError:

    96                 raise xml.dom.NotFoundErr()

    97             if newChild.nodeType in _nodeTypes_with_children:

    98                 _clear_id_cache(self)

    99             self.childNodes.insert(index, newChild)

   100             newChild.nextSibling = refChild

   101             refChild.previousSibling = newChild

   102             if index:

   103                 node = self.childNodes[index-1]

   104                 node.nextSibling = newChild

   105                 newChild.previousSibling = node

   106             else:

   107                 newChild.previousSibling = None

   108             newChild.parentNode = self

   109         return newChild

   110 

   111     def appendChild(self, node):

   112         if node.nodeType == self.DOCUMENT_FRAGMENT_NODE:

   113             for c in tuple(node.childNodes):

   114                 self.appendChild(c)

   115             ### The DOM does not clearly specify what to return in this case

   116             return node

   117         if node.nodeType not in self._child_node_types:

   118             raise xml.dom.HierarchyRequestErr(

   119                 "%s cannot be child of %s" % (repr(node), repr(self)))

   120         elif node.nodeType in _nodeTypes_with_children:

   121             _clear_id_cache(self)

   122         if node.parentNode is not None:

   123             node.parentNode.removeChild(node)

   124         _append_child(self, node)

   125         node.nextSibling = None

   126         return node

   127 

   128     def replaceChild(self, newChild, oldChild):

   129         if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:

   130             refChild = oldChild.nextSibling

   131             self.removeChild(oldChild)

   132             return self.insertBefore(newChild, refChild)

   133         if newChild.nodeType not in self._child_node_types:

   134             raise xml.dom.HierarchyRequestErr(

   135                 "%s cannot be child of %s" % (repr(newChild), repr(self)))

   136         if newChild is oldChild:

   137             return

   138         if newChild.parentNode is not None:

   139             newChild.parentNode.removeChild(newChild)

   140         try:

   141             index = self.childNodes.index(oldChild)

   142         except ValueError:

   143             raise xml.dom.NotFoundErr()

   144         self.childNodes[index] = newChild

   145         newChild.parentNode = self

   146         oldChild.parentNode = None

   147         if (newChild.nodeType in _nodeTypes_with_children

   148             or oldChild.nodeType in _nodeTypes_with_children):

   149             _clear_id_cache(self)

   150         newChild.nextSibling = oldChild.nextSibling

   151         newChild.previousSibling = oldChild.previousSibling

   152         oldChild.nextSibling = None

   153         oldChild.previousSibling = None

   154         if newChild.previousSibling:

   155             newChild.previousSibling.nextSibling = newChild

   156         if newChild.nextSibling:

   157             newChild.nextSibling.previousSibling = newChild

   158         return oldChild

   159 

   160     def removeChild(self, oldChild):

   161         try:

   162             self.childNodes.remove(oldChild)

   163         except ValueError:

   164             raise xml.dom.NotFoundErr()

   165         if oldChild.nextSibling is not None:

   166             oldChild.nextSibling.previousSibling = oldChild.previousSibling

   167         if oldChild.previousSibling is not None:

   168             oldChild.previousSibling.nextSibling = oldChild.nextSibling

   169         oldChild.nextSibling = oldChild.previousSibling = None

   170         if oldChild.nodeType in _nodeTypes_with_children:

   171             _clear_id_cache(self)

   172 

   173         oldChild.parentNode = None

   174         return oldChild

   175 

   176     def normalize(self):

   177         L = []

   178         for child in self.childNodes:

   179             if child.nodeType == Node.TEXT_NODE:

   180                 data = child.data

   181                 if data and L and L[-1].nodeType == child.nodeType:

   182                     # collapse text node

   183                     node = L[-1]

   184                     node.data = node.data + child.data

   185                     node.nextSibling = child.nextSibling

   186                     child.unlink()

   187                 elif data:

   188                     if L:

   189                         L[-1].nextSibling = child

   190                         child.previousSibling = L[-1]

   191                     else:

   192                         child.previousSibling = None

   193                     L.append(child)

   194                 else:

   195                     # empty text node; discard

   196                     child.unlink()

   197             else:

   198                 if L:

   199                     L[-1].nextSibling = child

   200                     child.previousSibling = L[-1]

   201                 else:

   202                     child.previousSibling = None

   203                 L.append(child)

   204                 if child.nodeType == Node.ELEMENT_NODE:

   205                     child.normalize()

   206         self.childNodes[:] = L

   207 

   208     def cloneNode(self, deep):

   209         return _clone_node(self, deep, self.ownerDocument or self)

   210 

   211     def isSupported(self, feature, version):

   212         return self.ownerDocument.implementation.hasFeature(feature, version)

   213 

   214     def _get_localName(self):

   215         # Overridden in Element and Attr where localName can be Non-Null

   216         return None

   217 

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

   219 

   220     def isSameNode(self, other):

   221         return self is other

   222 

   223     def getInterface(self, feature):

   224         if self.isSupported(feature, None):

   225             return self

   226         else:

   227             return None

   228 

   229     # The "user data" functions use a dictionary that is only present

   230     # if some user data has been set, so be careful not to assume it

   231     # exists.

   232 

   233     def getUserData(self, key):

   234         try:

   235             return self._user_data[key][0]

   236         except (AttributeError, KeyError):

   237             return None

   238 

   239     def setUserData(self, key, data, handler):

   240         old = None

   241         try:

   242             d = self._user_data

   243         except AttributeError:

   244             d = {}

   245             self._user_data = d

   246         if d.has_key(key):

   247             old = d[key][0]

   248         if data is None:

   249             # ignore handlers passed for None

   250             handler = None

   251             if old is not None:

   252                 del d[key]

   253         else:

   254             d[key] = (data, handler)

   255         return old

   256 

   257     def _call_user_data_handler(self, operation, src, dst):

   258         if hasattr(self, "_user_data"):

   259             for key, (data, handler) in self._user_data.items():

   260                 if handler is not None:

   261                     handler.handle(operation, key, data, src, dst)

   262 

   263     # minidom-specific API:

   264 

   265     def unlink(self):

   266         self.parentNode = self.ownerDocument = None

   267         if self.childNodes:

   268             for child in self.childNodes:

   269                 child.unlink()

   270             self.childNodes = NodeList()

   271         self.previousSibling = None

   272         self.nextSibling = None

   273 

   274 defproperty(Node, "firstChild", doc="First child node, or None.")

   275 defproperty(Node, "lastChild",  doc="Last child node, or None.")

   276 defproperty(Node, "localName",  doc="Namespace-local name of this node.")

   277 

   278 

   279 def _append_child(self, node):

   280     # fast path with less checks; usable by DOM builders if careful

   281     childNodes = self.childNodes

   282     if childNodes:

   283         last = childNodes[-1]

   284         node.__dict__["previousSibling"] = last

   285         last.__dict__["nextSibling"] = node

   286     childNodes.append(node)

   287     node.__dict__["parentNode"] = self

   288 

   289 def _in_document(node):

   290     # return True iff node is part of a document tree

   291     while node is not None:

   292         if node.nodeType == Node.DOCUMENT_NODE:

   293             return True

   294         node = node.parentNode

   295     return False

   296 

   297 def _write_data(writer, data):

   298     "Writes datachars to writer."

   299     data = data.replace("&", "&amp;").replace("<", "&lt;")

   300     data = data.replace("\"", """).replace(">", ">")

   301     writer.write(data)

   302 

   303 def _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 rc

   310 

   311 def _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) and

   315                 (nsURI == "*" or node.namespaceURI == nsURI)):

   316                 rc.append(node)

   317             _get_elements_by_tagName_ns_helper(node, nsURI, localName, rc)

   318     return rc

   319 

   320 class DocumentFragment(Node):

   321     nodeType = Node.DOCUMENT_FRAGMENT_NODE

   322     nodeName = "#document-fragment"

   323     nodeValue = None

   324     attributes = None

   325     parentNode = None

   326     _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 

   338 class Attr(Node):

   339     nodeType = Node.ATTRIBUTE_NODE

   340     attributes = None

   341     ownerElement = None

   342     specified = False

   343     _is_id = False

   344 

   345     _child_node_types = (Node.TEXT_NODE, Node.ENTITY_REFERENCE_NODE)

   346 

   347     def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None,

   348                  prefix=None):

   349         # skip setattr for performance

   350         d = self.__dict__

   351         d["nodeName"] = d["name"] = qName

   352         d["namespaceURI"] = namespaceURI

   353         d["prefix"] = prefix

   354         d['childNodes'] = NodeList()

   355 

   356         # Add the single child node that represents the value of the attr

   357         self.childNodes.append(Text())

   358 

   359         # nodeValue and value are set elsewhere

   360 

   361     def _get_localName(self):

   362         return self.nodeName.split(":", 1)[-1]

   363 

   364     def _get_name(self):

   365         return self.name

   366 

   367     def _get_specified(self):

   368         return self.specified

   369 

   370     def __setattr__(self, name, value):

   371         d = self.__dict__

   372         if name in ("value", "nodeValue"):

   373             d["value"] = d["nodeValue"] = value

   374             d2 = self.childNodes[0].__dict__

   375             d2["data"] = d2["nodeValue"] = value

   376             if self.ownerElement is not None:

   377                 _clear_id_cache(self.ownerElement)

   378         elif name in ("name", "nodeName"):

   379             d["name"] = d["nodeName"] = value

   380             if self.ownerElement is not None:

   381                 _clear_id_cache(self.ownerElement)

   382         else:

   383             d[name] = value

   384 

   385     def _set_prefix(self, prefix):

   386         nsuri = self.namespaceURI

   387         if prefix == "xmlns":

   388             if nsuri and nsuri != XMLNS_NAMESPACE:

   389                 raise xml.dom.NamespaceErr(

   390                     "illegal use of 'xmlns' prefix for the wrong namespace")

   391         d = self.__dict__

   392         d['prefix'] = prefix

   393         if prefix is None:

   394             newName = self.localName

   395         else:

   396             newName = "%s:%s" % (prefix, self.localName)

   397         if self.ownerElement:

   398             _clear_id_cache(self.ownerElement)

   399         d['nodeName'] = d['name'] = newName

   400 

   401     def _set_value(self, value):

   402         d = self.__dict__

   403         d['value'] = d['nodeValue'] = value

   404         if self.ownerElement:

   405             _clear_id_cache(self.ownerElement)

   406         self.childNodes[0].data = value

   407 

   408     def unlink(self):

   409         # This implementation does not call the base implementation

   410         # since most of that is not needed, and the expense of the

   411         # method call is not warranted.  We duplicate the removal of

   412         # children, but that's all we needed from the base class.

   413         elem = self.ownerElement

   414         if elem is not None:

   415             del elem._attrs[self.nodeName]

   416             del elem._attrsNS[(self.namespaceURI, self.localName)]

   417             if self._is_id:

   418                 self._is_id = False

   419                 elem._magic_id_nodes -= 1

   420                 self.ownerDocument._magic_id_count -= 1

   421         for child in self.childNodes:

   422             child.unlink()

   423         del self.childNodes[:]

   424 

   425     def _get_isId(self):

   426         if self._is_id:

   427             return True

   428         doc = self.ownerDocument

   429         elem = self.ownerElement

   430         if doc is None or elem is None:

   431             return False

   432 

   433         info = doc._get_elem_info(elem)

   434         if info is None:

   435             return False

   436         if self.namespaceURI:

   437             return info.isIdNS(self.namespaceURI, self.localName)

   438         else:

   439             return info.isId(self.nodeName)

   440 

   441     def _get_schemaType(self):

   442         doc = self.ownerDocument

   443         elem = self.ownerElement

   444         if doc is None or elem is None:

   445             return _no_type

   446 

   447         info = doc._get_elem_info(elem)

   448         if info is None:

   449             return _no_type

   450         if self.namespaceURI:

   451             return info.getAttributeTypeNS(self.namespaceURI, self.localName)

   452         else:

   453             return info.getAttributeType(self.nodeName)

   454 

   455 defproperty(Attr, "isId",       doc="True if this attribute is an ID.")

   456 defproperty(Attr, "localName",  doc="Namespace-local name of this attribute.")

   457 defproperty(Attr, "schemaType", doc="Schema type for this attribute.")

   458 

   459 

   460 class NamedNodeMap(object):

   461     """The attribute list is a transient interface to the underlying

   462     dictionaries.  Mutations here will change the underlying element's

   463     dictionary.

   464 

   465     Ordering is imposed artificially and does not reflect the order of

   466     attributes as found in an input document.

   467     """

   468 

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

   470 

   471     def __init__(self, attrs, attrsNS, ownerElement):

   472         self._attrs = attrs

   473         self._attrsNS = attrsNS

   474         self._ownerElement = ownerElement

   475 

   476     def _get_length(self):

   477         return len(self._attrs)

   478 

   479     def item(self, index):

   480         try:

   481             return self[self._attrs.keys()[index]]

   482         except IndexError:

   483             return None

   484 

   485     def items(self):

   486         L = []

   487         for node in self._attrs.values():

   488             L.append((node.nodeName, node.value))

   489         return L

   490 

   491     def itemsNS(self):

   492         L = []

   493         for node in self._attrs.values():

   494             L.append(((node.namespaceURI, node.localName), node.value))

   495         return L

   496 

   497     def has_key(self, key):

   498         if isinstance(key, StringTypes):

   499             return self._attrs.has_key(key)

   500         else:

   501             return self._attrsNS.has_key(key)

   502 

   503     def keys(self):

   504         return self._attrs.keys()

   505 

   506     def keysNS(self):

   507         return self._attrsNS.keys()

   508 

   509     def values(self):

   510         return self._attrs.values()

   511 

   512     def get(self, name, value=None):

   513         return self._attrs.get(name, value)

   514 

   515     __len__ = _get_length

   516 

   517     def __cmp__(self, other):

   518         if self._attrs is getattr(other, "_attrs", None):

   519             return 0

   520         else:

   521             return cmp(id(self), id(other))

   522 

   523     def __getitem__(self, attname_or_tuple):

   524         if isinstance(attname_or_tuple, tuple):

   525             return self._attrsNS[attname_or_tuple]

   526         else:

   527             return self._attrs[attname_or_tuple]

   528 

   529     # same as set

   530     def __setitem__(self, attname, value):

   531         if isinstance(value, StringTypes):

   532             try:

   533                 node = self._attrs[attname]

   534             except KeyError:

   535                 node = Attr(attname)

   536                 node.ownerDocument = self._ownerElement.ownerDocument

   537                 self.setNamedItem(node)

   538             node.value = value

   539         else:

   540             if not isinstance(value, Attr):

   541                 raise TypeError, "value must be a string or Attr object"

   542             node = value

   543             self.setNamedItem(node)

   544 

   545     def getNamedItem(self, name):

   546         try:

   547             return self._attrs[name]

   548         except KeyError:

   549             return None

   550 

   551     def getNamedItemNS(self, namespaceURI, localName):

   552         try:

   553             return self._attrsNS[(namespaceURI, localName)]

   554         except KeyError:

   555             return None

   556 

   557     def removeNamedItem(self, name):

   558         n = self.getNamedItem(name)

   559         if n is not None:

   560             _clear_id_cache(self._ownerElement)

   561             del self._attrs[n.nodeName]

   562             del self._attrsNS[(n.namespaceURI, n.localName)]

   563             if n.__dict__.has_key('ownerElement'):

   564                 n.__dict__['ownerElement'] = None

   565             return n

   566         else:

   567             raise xml.dom.NotFoundErr()

   568 

   569     def removeNamedItemNS(self, namespaceURI, localName):

   570         n = self.getNamedItemNS(namespaceURI, localName)

   571         if n is not None:

   572             _clear_id_cache(self._ownerElement)

   573             del self._attrsNS[(n.namespaceURI, n.localName)]

   574             del self._attrs[n.nodeName]

   575             if n.__dict__.has_key('ownerElement'):

   576                 n.__dict__['ownerElement'] = None

   577             return n

   578         else:

   579             raise xml.dom.NotFoundErr()

   580 

   581     def setNamedItem(self, node):

   582         if not isinstance(node, Attr):

   583             raise xml.dom.HierarchyRequestErr(

   584                 "%s cannot be child of %s" % (repr(node), repr(self)))

   585         old = self._attrs.get(node.name)

   586         if old:

   587             old.unlink()

   588         self._attrs[node.name] = node

   589         self._attrsNS[(node.namespaceURI, node.localName)] = node

   590         node.ownerElement = self._ownerElement

   591         _clear_id_cache(node.ownerElement)

   592         return old

   593 

   594     def setNamedItemNS(self, node):

   595         return self.setNamedItem(node)

   596 

   597     def __delitem__(self, attname_or_tuple):

   598         node = self[attname_or_tuple]

   599         _clear_id_cache(node.ownerElement)

   600         node.unlink()

   601 

   602     def __getstate__(self):

   603         return self._attrs, self._attrsNS, self._ownerElement

   604 

   605     def __setstate__(self, state):

   606         self._attrs, self._attrsNS, self._ownerElement = state

   607 

   608 defproperty(NamedNodeMap, "length",

   609             doc="Number of nodes in the NamedNodeMap.")

   610 

   611 AttributeList = NamedNodeMap

   612 

   613 

   614 class TypeInfo(object):

   615     __slots__ = 'namespace', 'name'

   616 

   617     def __init__(self, namespace, name):

   618         self.namespace = namespace

   619         self.name = name

   620 

   621     def __repr__(self):

   622         if self.namespace:

   623             return "<TypeInfo %r (from %r)>" % (self.name, self.namespace)

   624         else:

   625             return "<TypeInfo %r>" % self.name

   626 

   627     def _get_name(self):

   628         return self.name

   629 

   630     def _get_namespace(self):

   631         return self.namespace

   632 

   633 _no_type = TypeInfo(None, None)

   634 

   635 class Element(Node):

   636     nodeType = Node.ELEMENT_NODE

   637     nodeValue = None

   638     schemaType = _no_type

   639 

   640     _magic_id_nodes = 0

   641 

   642     _child_node_types = (Node.ELEMENT_NODE,

   643                          Node.PROCESSING_INSTRUCTION_NODE,

   644                          Node.COMMENT_NODE,

   645                          Node.TEXT_NODE,

   646                          Node.CDATA_SECTION_NODE,

   647                          Node.ENTITY_REFERENCE_NODE)

   648 

   649     def __init__(self, tagName, namespaceURI=EMPTY_NAMESPACE, prefix=None,

   650                  localName=None):

   651         self.tagName = self.nodeName = tagName

   652         self.prefix = prefix

   653         self.namespaceURI = namespaceURI

   654         self.childNodes = NodeList()

   655 

   656         self._attrs = {}   # attributes are double-indexed:

   657         self._attrsNS = {} #    tagName -> Attribute

   658                            #    URI,localName -> Attribute

   659                            # in the future: consider lazy generation

   660                            # of attribute objects this is too tricky

   661                            # for now because of headaches with

   662                            # namespaces.

   663 

   664     def _get_localName(self):

   665         return self.tagName.split(":", 1)[-1]

   666 

   667     def _get_tagName(self):

   668         return self.tagName

   669 

   670     def unlink(self):

   671         for attr in self._attrs.values():

   672             attr.unlink()

   673         self._attrs = None

   674         self._attrsNS = None

   675         Node.unlink(self)

   676 

   677     def getAttribute(self, attname):

   678         try:

   679             return self._attrs[attname].value

   680         except KeyError:

   681             return ""

   682 

   683     def getAttributeNS(self, namespaceURI, localName):

   684         try:

   685             return self._attrsNS[(namespaceURI, localName)].value

   686         except KeyError:

   687             return ""

   688 

   689     def setAttribute(self, attname, value):

   690         attr = self.getAttributeNode(attname)

   691         if attr is None:

   692             attr = Attr(attname)

   693             # for performance

   694             d = attr.__dict__

   695             d["value"] = d["nodeValue"] = value

   696             d["ownerDocument"] = self.ownerDocument

   697             self.setAttributeNode(attr)

   698         elif value != attr.value:

   699             d = attr.__dict__

   700             d["value"] = d["nodeValue"] = value

   701             if attr.isId:

   702                 _clear_id_cache(self)

   703 

   704     def setAttributeNS(self, namespaceURI, qualifiedName, value):

   705         prefix, localname = _nssplit(qualifiedName)

   706         attr = self.getAttributeNodeNS(namespaceURI, localname)

   707         if attr is None:

   708             # for performance

   709             attr = Attr(qualifiedName, namespaceURI, localname, prefix)

   710             d = attr.__dict__

   711             d["prefix"] = prefix

   712             d["nodeName"] = qualifiedName

   713             d["value"] = d["nodeValue"] = value

   714             d["ownerDocument"] = self.ownerDocument

   715             self.setAttributeNode(attr)

   716         else:

   717             d = attr.__dict__

   718             if value != attr.value:

   719                 d["value"] = d["nodeValue"] = value

   720                 if attr.isId:

   721                     _clear_id_cache(self)

   722             if attr.prefix != prefix:

   723                 d["prefix"] = prefix

   724                 d["nodeName"] = qualifiedName

   725 

   726     def getAttributeNode(self, attrname):

   727         return self._attrs.get(attrname)

   728 

   729     def getAttributeNodeNS(self, namespaceURI, localName):

   730         return self._attrsNS.get((namespaceURI, localName))

   731 

   732     def setAttributeNode(self, attr):

   733         if attr.ownerElement not in (None, self):

   734             raise xml.dom.InuseAttributeErr("attribute node already owned")

   735         old1 = self._attrs.get(attr.name, None)

   736         if old1 is not None:

   737             self.removeAttributeNode(old1)

   738         old2 = self._attrsNS.get((attr.namespaceURI, attr.localName), None)

   739         if old2 is not None and old2 is not old1:

   740             self.removeAttributeNode(old2)

   741         _set_attribute_node(self, attr)

   742 

   743         if old1 is not attr:

   744             # It might have already been part of this node, in which case

   745             # it doesn't represent a change, and should not be returned.

   746             return old1

   747         if old2 is not attr:

   748             return old2

   749 

   750     setAttributeNodeNS = setAttributeNode

   751 

   752     def removeAttribute(self, name):

   753         try:

   754             attr = self._attrs[name]

   755         except KeyError:

   756             raise xml.dom.NotFoundErr()

   757         self.removeAttributeNode(attr)

   758 

   759     def removeAttributeNS(self, namespaceURI, localName):

   760         try:

   761             attr = self._attrsNS[(namespaceURI, localName)]

   762         except KeyError:

   763             raise xml.dom.NotFoundErr()

   764         self.removeAttributeNode(attr)

   765 

   766     def removeAttributeNode(self, node):

   767         if node is None:

   768             raise xml.dom.NotFoundErr()

   769         try:

   770             self._attrs[node.name]

   771         except KeyError:

   772             raise xml.dom.NotFoundErr()

   773         _clear_id_cache(self)

   774         node.unlink()

   775         # Restore this since the node is still useful and otherwise

   776         # unlinked

   777         node.ownerDocument = self.ownerDocument

   778 

   779     removeAttributeNodeNS = removeAttributeNode

   780 

   781     def hasAttribute(self, name):

   782         return self._attrs.has_key(name)

   783 

   784     def hasAttributeNS(self, namespaceURI, localName):

   785         return self._attrsNS.has_key((namespaceURI, localName))

   786 

   787     def getElementsByTagName(self, name):

   788         return _get_elements_by_tagName_helper(self, name, NodeList())

   789 

   790     def getElementsByTagNameNS(self, namespaceURI, localName):

   791         return _get_elements_by_tagName_ns_helper(

   792             self, namespaceURI, localName, NodeList())

   793 

   794     def __repr__(self):

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

   796 

   797     def writexml(self, writer, indent="", addindent="", newl=""):

   798         # indent = current indentation

   799         # addindent = indentation to add to higher levels

   800         # newl = newline string

   801         writer.write(indent+"<" + self.tagName)

   802 

   803         attrs = self._get_attributes()

   804         a_names = attrs.keys()

   805         a_names.sort()

   806 

   807         for a_name in a_names:

   808             writer.write(" %s=\"" % a_name)

   809             _write_data(writer, attrs[a_name].value)

   810             writer.write("\"")

   811         if self.childNodes:

   812             writer.write(">%s"%(newl))

   813             for node in self.childNodes:

   814                 node.writexml(writer,indent+addindent,addindent,newl)

   815             writer.write("%s</%s>%s" % (indent,self.tagName,newl))

   816         else:

   817             writer.write("/>%s"%(newl))

   818 

   819     def _get_attributes(self):

   820         return NamedNodeMap(self._attrs, self._attrsNS, self)

   821 

   822     def hasAttributes(self):

   823         if self._attrs:

   824             return True

   825         else:

   826             return False

   827 

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

   829 

   830     def setIdAttribute(self, name):

   831         idAttr = self.getAttributeNode(name)

   832         self.setIdAttributeNode(idAttr)

   833 

   834     def setIdAttributeNS(self, namespaceURI, localName):

   835         idAttr = self.getAttributeNodeNS(namespaceURI, localName)

   836         self.setIdAttributeNode(idAttr)

   837 

   838     def setIdAttributeNode(self, idAttr):

   839         if idAttr is None or not self.isSameNode(idAttr.ownerElement):

   840             raise xml.dom.NotFoundErr()

   841         if _get_containing_entref(self) is not None:

   842             raise xml.dom.NoModificationAllowedErr()

   843         if not idAttr._is_id:

   844             idAttr.__dict__['_is_id'] = True

   845             self._magic_id_nodes += 1

   846             self.ownerDocument._magic_id_count += 1

   847             _clear_id_cache(self)

   848 

   849 defproperty(Element, "attributes",

   850             doc="NamedNodeMap of attributes on the element.")

   851 defproperty(Element, "localName",

   852             doc="Namespace-local name of this element.")

   853 

   854 

   855 def _set_attribute_node(element, attr):

   856     _clear_id_cache(element)

   857     element._attrs[attr.name] = attr

   858     element._attrsNS[(attr.namespaceURI, attr.localName)] = attr

   859 

   860     # This creates a circular reference, but Element.unlink()

   861     # breaks the cycle since the references to the attribute

   862     # dictionaries are tossed.

   863     attr.__dict__['ownerElement'] = element

   864 

   865 

   866 class Childless:

   867     """Mixin that makes childless-ness easy to implement and avoids

   868     the complexity of the Node methods that deal with children.

   869     """

   870 

   871     attributes = None

   872     childNodes = EmptyNodeList()

   873     firstChild = None

   874     lastChild = None

   875 

   876     def _get_firstChild(self):

   877         return None

   878 

   879     def _get_lastChild(self):

   880         return None

   881 

   882     def appendChild(self, node):

   883         raise xml.dom.HierarchyRequestErr(

   884             self.nodeName + " nodes cannot have children")

   885 

   886     def hasChildNodes(self):

   887         return False

   888 

   889     def insertBefore(self, newChild, refChild):

   890         raise xml.dom.HierarchyRequestErr(

   891             self.nodeName + " nodes do not have children")

   892 

   893     def removeChild(self, oldChild):

   894         raise xml.dom.NotFoundErr(

   895             self.nodeName + " nodes do not have children")

   896 

   897     def replaceChild(self, newChild, oldChild):

   898         raise xml.dom.HierarchyRequestErr(

   899             self.nodeName + " nodes do not have children")

   900 

   901 

   902 class ProcessingInstruction(Childless, Node):

   903     nodeType = Node.PROCESSING_INSTRUCTION_NODE

   904 

   905     def __init__(self, target, data):

   906         self.target = self.nodeName = target

   907         self.data = self.nodeValue = data

   908 

   909     def _get_data(self):

   910         return self.data

   911     def _set_data(self, value):

   912         d = self.__dict__

   913         d['data'] = d['nodeValue'] = value

   914 

   915     def _get_target(self):

   916         return self.target

   917     def _set_target(self, value):

   918         d = self.__dict__

   919         d['target'] = d['nodeName'] = value

   920 

   921     def __setattr__(self, name, value):

   922         if name == "data" or name == "nodeValue":

   923             self.__dict__['data'] = self.__dict__['nodeValue'] = value

   924         elif name == "target" or name == "nodeName":

   925             self.__dict__['target'] = self.__dict__['nodeName'] = value

   926         else:

   927             self.__dict__[name] = value

   928 

   929     def writexml(self, writer, indent="", addindent="", newl=""):

   930         writer.write("%s<?%s %s?>%s" % (indent,self.target, self.data, newl))

   931 

   932 

   933 class CharacterData(Childless, Node):

   934     def _get_length(self):

   935         return len(self.data)

   936     __len__ = _get_length

   937 

   938     def _get_data(self):

   939         return self.__dict__['data']

   940     def _set_data(self, data):

   941         d = self.__dict__

   942         d['data'] = d['nodeValue'] = data

   943 

   944     _get_nodeValue = _get_data

   945     _set_nodeValue = _set_data

   946 

   947     def __setattr__(self, name, value):

   948         if name == "data" or name == "nodeValue":

   949             self.__dict__['data'] = self.__dict__['nodeValue'] = value

   950         else:

   951             self.__dict__[name] = value

   952 

   953     def __repr__(self):

   954         data = self.data

   955         if len(data) > 10:

   956             dotdotdot = "..."

   957         else:

   958             dotdotdot = ""

   959         return "<DOM %s node \"%s%s\">" % (

   960             self.__class__.__name__, data[0:10], dotdotdot)

   961 

   962     def substringData(self, offset, count):

   963         if offset < 0:

   964             raise xml.dom.IndexSizeErr("offset cannot be negative")

   965         if offset >= len(self.data):

   966             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")

   967         if count < 0:

   968             raise xml.dom.IndexSizeErr("count cannot be negative")

   969         return self.data[offset:offset+count]

   970 

   971     def appendData(self, arg):

   972         self.data = self.data + arg

   973 

   974     def insertData(self, offset, arg):

   975         if offset < 0:

   976             raise xml.dom.IndexSizeErr("offset cannot be negative")

   977         if offset >= len(self.data):

   978             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")

   979         if arg:

   980             self.data = "%s%s%s" % (

   981                 self.data[:offset], arg, self.data[offset:])

   982 

   983     def deleteData(self, offset, count):

   984         if offset < 0:

   985             raise xml.dom.IndexSizeErr("offset cannot be negative")

   986         if offset >= len(self.data):

   987             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")

   988         if count < 0:

   989             raise xml.dom.IndexSizeErr("count cannot be negative")

   990         if count:

   991             self.data = self.data[:offset] + self.data[offset+count:]

   992 

   993     def replaceData(self, offset, count, arg):

   994         if offset < 0:

   995             raise xml.dom.IndexSizeErr("offset cannot be negative")

   996         if offset >= len(self.data):

   997             raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")

   998         if count < 0:

   999             raise xml.dom.IndexSizeErr("count cannot be negative")

  1000         if count:

  1001             self.data = "%s%s%s" % (

  1002                 self.data[:offset], arg, self.data[offset+count:])

  1003 

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

  1005 

  1006 

  1007 class Text(CharacterData):

  1008     # Make sure we don't add an instance __dict__ if we don't already

  1009     # have one, at least when that's possible:

  1010     # XXX this does not work, CharacterData is an old-style class

  1011     # __slots__ = ()

  1012 

  1013     nodeType = Node.TEXT_NODE

  1014     nodeName = "#text"

  1015     attributes = None

  1016 

  1017     def splitText(self, offset):

  1018         if offset < 0 or offset > len(self.data):

  1019             raise xml.dom.IndexSizeErr("illegal offset value")

  1020         newText = self.__class__()

  1021         newText.data = self.data[offset:]

  1022         newText.ownerDocument = self.ownerDocument

  1023         next = self.nextSibling

  1024         if self.parentNode and self in self.parentNode.childNodes:

  1025             if next is None:

  1026                 self.parentNode.appendChild(newText)

  1027             else:

  1028                 self.parentNode.insertBefore(newText, next)

  1029         self.data = self.data[:offset]

  1030         return newText

  1031 

  1032     def writexml(self, writer, indent="", addindent="", newl=""):

  1033         _write_data(writer, "%s%s%s"%(indent, self.data, newl))

  1034 

  1035     # DOM Level 3 (WD 9 April 2002)

  1036 

  1037     def _get_wholeText(self):

  1038         L = [self.data]

  1039         n = self.previousSibling

  1040         while n is not None:

  1041             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):

  1042                 L.insert(0, n.data)

  1043                 n = n.previousSibling

  1044             else:

  1045                 break

  1046         n = self.nextSibling

  1047         while n is not None:

  1048             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):

  1049                 L.append(n.data)

  1050                 n = n.nextSibling

  1051             else:

  1052                 break

  1053         return ''.join(L)

  1054 

  1055     def replaceWholeText(self, content):

  1056         # XXX This needs to be seriously changed if minidom ever

  1057         # supports EntityReference nodes.

  1058         parent = self.parentNode

  1059         n = self.previousSibling

  1060         while n is not None:

  1061             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):

  1062                 next = n.previousSibling

  1063                 parent.removeChild(n)

  1064                 n = next

  1065             else:

  1066                 break

  1067         n = self.nextSibling

  1068         if not content:

  1069             parent.removeChild(self)

  1070         while n is not None:

  1071             if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):

  1072                 next = n.nextSibling

  1073                 parent.removeChild(n)

  1074                 n = next

  1075             else:

  1076                 break

  1077         if content:

  1078             d = self.__dict__

  1079             d['data'] = content

  1080             d['nodeValue'] = content

  1081             return self

  1082         else:

  1083             return None

  1084 

  1085     def _get_isWhitespaceInElementContent(self):

  1086         if self.data.strip():

  1087             return False

  1088         elem = _get_containing_element(self)

  1089         if elem is None:

  1090             return False

  1091         info = self.ownerDocument._get_elem_info(elem)

  1092         if info is None:

  1093             return False

  1094         else:

  1095             return info.isElementContent()

  1096 

  1097 defproperty(Text, "isWhitespaceInElementContent",

  1098             doc="True iff this text node contains only whitespace"

  1099                 " and is in element content.")

  1100 defproperty(Text, "wholeText",

  1101             doc="The text of all logically-adjacent text nodes.")

  1102 

  1103 

  1104 def _get_containing_element(node):

  1105     c = node.parentNode

  1106     while c is not None:

  1107         if c.nodeType == Node.ELEMENT_NODE:

  1108             return c

  1109         c = c.parentNode

  1110     return None

  1111 

  1112 def _get_containing_entref(node):

  1113     c = node.parentNode

  1114     while c is not None:

  1115         if c.nodeType == Node.ENTITY_REFERENCE_NODE:

  1116             return c

  1117         c = c.parentNode

  1118     return None

  1119 

  1120 

  1121 class Comment(Childless, CharacterData):

  1122     nodeType = Node.COMMENT_NODE

  1123     nodeName = "#comment"

  1124 

  1125     def __init__(self, data):

  1126         self.data = self.nodeValue = data

  1127 

  1128     def writexml(self, writer, indent="", addindent="", newl=""):

  1129         writer.write("%s<!--%s-->%s" % (indent, self.data, newl))

  1130 

  1131 

  1132 class CDATASection(Text):

  1133     # Make sure we don't add an instance __dict__ if we don't already

  1134     # have one, at least when that's possible:

  1135     # XXX this does not work, Text is an old-style class