+++ /dev/null
-"""Simple implementation of the Level 1 DOM.\r
-\r
-Namespaces and other minor Level 2 features are also supported.\r
-\r
-parse("foo.xml")\r
-\r
-parseString("<foo><bar/></foo>")\r
-\r
-Todo:\r
-=====\r
- * convenience methods for getting elements and text.\r
- * more testing\r
- * bring some of the writer and linearizer code into conformance with this\r
- interface\r
- * SAX 2 namespaces\r
-"""\r
-\r
-import xml.dom\r
-\r
-from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE, domreg\r
-from xml.dom.minicompat import *\r
-from xml.dom.xmlbuilder import DOMImplementationLS, DocumentLS\r
-\r
-# This is used by the ID-cache invalidation checks; the list isn't\r
-# actually complete, since the nodes being checked will never be the\r
-# DOCUMENT_NODE or DOCUMENT_FRAGMENT_NODE. (The node being checked is\r
-# the node being added or removed, not the node being modified.)\r
-#\r
-_nodeTypes_with_children = (xml.dom.Node.ELEMENT_NODE,\r
- xml.dom.Node.ENTITY_REFERENCE_NODE)\r
-\r
-\r
-class Node(xml.dom.Node):\r
- namespaceURI = None # this is non-null only for elements and attributes\r
- parentNode = None\r
- ownerDocument = None\r
- nextSibling = None\r
- previousSibling = None\r
-\r
- prefix = EMPTY_PREFIX # non-null only for NS elements and attributes\r
-\r
- def __nonzero__(self):\r
- return True\r
-\r
- def toxml(self, encoding = None):\r
- return self.toprettyxml("", "", encoding)\r
-\r
- def toprettyxml(self, indent="\t", newl="\n", encoding = None):\r
- # indent = the indentation string to prepend, per level\r
- # newl = the newline string to append\r
- writer = _get_StringIO()\r
- if encoding is not None:\r
- import codecs\r
- # Can't use codecs.getwriter to preserve 2.0 compatibility\r
- writer = codecs.lookup(encoding)[3](writer)\r
- if self.nodeType == Node.DOCUMENT_NODE:\r
- # Can pass encoding only to document, to put it into XML header\r
- self.writexml(writer, "", indent, newl, encoding)\r
- else:\r
- self.writexml(writer, "", indent, newl)\r
- return writer.getvalue()\r
-\r
- def hasChildNodes(self):\r
- if self.childNodes:\r
- return True\r
- else:\r
- return False\r
-\r
- def _get_childNodes(self):\r
- return self.childNodes\r
-\r
- def _get_firstChild(self):\r
- if self.childNodes:\r
- return self.childNodes[0]\r
-\r
- def _get_lastChild(self):\r
- if self.childNodes:\r
- return self.childNodes[-1]\r
-\r
- def insertBefore(self, newChild, refChild):\r
- if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:\r
- for c in tuple(newChild.childNodes):\r
- self.insertBefore(c, refChild)\r
- ### The DOM does not clearly specify what to return in this case\r
- return newChild\r
- if newChild.nodeType not in self._child_node_types:\r
- raise xml.dom.HierarchyRequestErr(\r
- "%s cannot be child of %s" % (repr(newChild), repr(self)))\r
- if newChild.parentNode is not None:\r
- newChild.parentNode.removeChild(newChild)\r
- if refChild is None:\r
- self.appendChild(newChild)\r
- else:\r
- try:\r
- index = self.childNodes.index(refChild)\r
- except ValueError:\r
- raise xml.dom.NotFoundErr()\r
- if newChild.nodeType in _nodeTypes_with_children:\r
- _clear_id_cache(self)\r
- self.childNodes.insert(index, newChild)\r
- newChild.nextSibling = refChild\r
- refChild.previousSibling = newChild\r
- if index:\r
- node = self.childNodes[index-1]\r
- node.nextSibling = newChild\r
- newChild.previousSibling = node\r
- else:\r
- newChild.previousSibling = None\r
- newChild.parentNode = self\r
- return newChild\r
-\r
- def appendChild(self, node):\r
- if node.nodeType == self.DOCUMENT_FRAGMENT_NODE:\r
- for c in tuple(node.childNodes):\r
- self.appendChild(c)\r
- ### The DOM does not clearly specify what to return in this case\r
- return node\r
- if node.nodeType not in self._child_node_types:\r
- raise xml.dom.HierarchyRequestErr(\r
- "%s cannot be child of %s" % (repr(node), repr(self)))\r
- elif node.nodeType in _nodeTypes_with_children:\r
- _clear_id_cache(self)\r
- if node.parentNode is not None:\r
- node.parentNode.removeChild(node)\r
- _append_child(self, node)\r
- node.nextSibling = None\r
- return node\r
-\r
- def replaceChild(self, newChild, oldChild):\r
- if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:\r
- refChild = oldChild.nextSibling\r
- self.removeChild(oldChild)\r
- return self.insertBefore(newChild, refChild)\r
- if newChild.nodeType not in self._child_node_types:\r
- raise xml.dom.HierarchyRequestErr(\r
- "%s cannot be child of %s" % (repr(newChild), repr(self)))\r
- if newChild is oldChild:\r
- return\r
- if newChild.parentNode is not None:\r
- newChild.parentNode.removeChild(newChild)\r
- try:\r
- index = self.childNodes.index(oldChild)\r
- except ValueError:\r
- raise xml.dom.NotFoundErr()\r
- self.childNodes[index] = newChild\r
- newChild.parentNode = self\r
- oldChild.parentNode = None\r
- if (newChild.nodeType in _nodeTypes_with_children\r
- or oldChild.nodeType in _nodeTypes_with_children):\r
- _clear_id_cache(self)\r
- newChild.nextSibling = oldChild.nextSibling\r
- newChild.previousSibling = oldChild.previousSibling\r
- oldChild.nextSibling = None\r
- oldChild.previousSibling = None\r
- if newChild.previousSibling:\r
- newChild.previousSibling.nextSibling = newChild\r
- if newChild.nextSibling:\r
- newChild.nextSibling.previousSibling = newChild\r
- return oldChild\r
-\r
- def removeChild(self, oldChild):\r
- try:\r
- self.childNodes.remove(oldChild)\r
- except ValueError:\r
- raise xml.dom.NotFoundErr()\r
- if oldChild.nextSibling is not None:\r
- oldChild.nextSibling.previousSibling = oldChild.previousSibling\r
- if oldChild.previousSibling is not None:\r
- oldChild.previousSibling.nextSibling = oldChild.nextSibling\r
- oldChild.nextSibling = oldChild.previousSibling = None\r
- if oldChild.nodeType in _nodeTypes_with_children:\r
- _clear_id_cache(self)\r
-\r
- oldChild.parentNode = None\r
- return oldChild\r
-\r
- def normalize(self):\r
- L = []\r
- for child in self.childNodes:\r
- if child.nodeType == Node.TEXT_NODE:\r
- if not child.data:\r
- # empty text node; discard\r
- if L:\r
- L[-1].nextSibling = child.nextSibling\r
- if child.nextSibling:\r
- child.nextSibling.previousSibling = child.previousSibling\r
- child.unlink()\r
- elif L and L[-1].nodeType == child.nodeType:\r
- # collapse text node\r
- node = L[-1]\r
- node.data = node.data + child.data\r
- node.nextSibling = child.nextSibling\r
- if child.nextSibling:\r
- child.nextSibling.previousSibling = node\r
- child.unlink()\r
- else:\r
- L.append(child)\r
- else:\r
- L.append(child)\r
- if child.nodeType == Node.ELEMENT_NODE:\r
- child.normalize()\r
- self.childNodes[:] = L\r
-\r
- def cloneNode(self, deep):\r
- return _clone_node(self, deep, self.ownerDocument or self)\r
-\r
- def isSupported(self, feature, version):\r
- return self.ownerDocument.implementation.hasFeature(feature, version)\r
-\r
- def _get_localName(self):\r
- # Overridden in Element and Attr where localName can be Non-Null\r
- return None\r
-\r
- # Node interfaces from Level 3 (WD 9 April 2002)\r
-\r
- def isSameNode(self, other):\r
- return self is other\r
-\r
- def getInterface(self, feature):\r
- if self.isSupported(feature, None):\r
- return self\r
- else:\r
- return None\r
-\r
- # The "user data" functions use a dictionary that is only present\r
- # if some user data has been set, so be careful not to assume it\r
- # exists.\r
-\r
- def getUserData(self, key):\r
- try:\r
- return self._user_data[key][0]\r
- except (AttributeError, KeyError):\r
- return None\r
-\r
- def setUserData(self, key, data, handler):\r
- old = None\r
- try:\r
- d = self._user_data\r
- except AttributeError:\r
- d = {}\r
- self._user_data = d\r
- if key in d:\r
- old = d[key][0]\r
- if data is None:\r
- # ignore handlers passed for None\r
- handler = None\r
- if old is not None:\r
- del d[key]\r
- else:\r
- d[key] = (data, handler)\r
- return old\r
-\r
- def _call_user_data_handler(self, operation, src, dst):\r
- if hasattr(self, "_user_data"):\r
- for key, (data, handler) in self._user_data.items():\r
- if handler is not None:\r
- handler.handle(operation, key, data, src, dst)\r
-\r
- # minidom-specific API:\r
-\r
- def unlink(self):\r
- self.parentNode = self.ownerDocument = None\r
- if self.childNodes:\r
- for child in self.childNodes:\r
- child.unlink()\r
- self.childNodes = NodeList()\r
- self.previousSibling = None\r
- self.nextSibling = None\r
-\r
-defproperty(Node, "firstChild", doc="First child node, or None.")\r
-defproperty(Node, "lastChild", doc="Last child node, or None.")\r
-defproperty(Node, "localName", doc="Namespace-local name of this node.")\r
-\r
-\r
-def _append_child(self, node):\r
- # fast path with less checks; usable by DOM builders if careful\r
- childNodes = self.childNodes\r
- if childNodes:\r
- last = childNodes[-1]\r
- node.__dict__["previousSibling"] = last\r
- last.__dict__["nextSibling"] = node\r
- childNodes.append(node)\r
- node.__dict__["parentNode"] = self\r
-\r
-def _in_document(node):\r
- # return True iff node is part of a document tree\r
- while node is not None:\r
- if node.nodeType == Node.DOCUMENT_NODE:\r
- return True\r
- node = node.parentNode\r
- return False\r
-\r
-def _write_data(writer, data):\r
- "Writes datachars to writer."\r
- if data:\r
- data = data.replace("&", "&").replace("<", "<"). \\r
- replace("\"", """).replace(">", ">")\r
- writer.write(data)\r
-\r
-def _get_elements_by_tagName_helper(parent, name, rc):\r
- for node in parent.childNodes:\r
- if node.nodeType == Node.ELEMENT_NODE and \\r
- (name == "*" or node.tagName == name):\r
- rc.append(node)\r
- _get_elements_by_tagName_helper(node, name, rc)\r
- return rc\r
-\r
-def _get_elements_by_tagName_ns_helper(parent, nsURI, localName, rc):\r
- for node in parent.childNodes:\r
- if node.nodeType == Node.ELEMENT_NODE:\r
- if ((localName == "*" or node.localName == localName) and\r
- (nsURI == "*" or node.namespaceURI == nsURI)):\r
- rc.append(node)\r
- _get_elements_by_tagName_ns_helper(node, nsURI, localName, rc)\r
- return rc\r
-\r
-class DocumentFragment(Node):\r
- nodeType = Node.DOCUMENT_FRAGMENT_NODE\r
- nodeName = "#document-fragment"\r
- nodeValue = None\r
- attributes = None\r
- parentNode = None\r
- _child_node_types = (Node.ELEMENT_NODE,\r
- Node.TEXT_NODE,\r
- Node.CDATA_SECTION_NODE,\r
- Node.ENTITY_REFERENCE_NODE,\r
- Node.PROCESSING_INSTRUCTION_NODE,\r
- Node.COMMENT_NODE,\r
- Node.NOTATION_NODE)\r
-\r
- def __init__(self):\r
- self.childNodes = NodeList()\r
-\r
-\r
-class Attr(Node):\r
- nodeType = Node.ATTRIBUTE_NODE\r
- attributes = None\r
- ownerElement = None\r
- specified = False\r
- _is_id = False\r
-\r
- _child_node_types = (Node.TEXT_NODE, Node.ENTITY_REFERENCE_NODE)\r
-\r
- def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None,\r
- prefix=None):\r
- # skip setattr for performance\r
- d = self.__dict__\r
- d["nodeName"] = d["name"] = qName\r
- d["namespaceURI"] = namespaceURI\r
- d["prefix"] = prefix\r
- d['childNodes'] = NodeList()\r
-\r
- # Add the single child node that represents the value of the attr\r
- self.childNodes.append(Text())\r
-\r
- # nodeValue and value are set elsewhere\r
-\r
- def _get_localName(self):\r
- return self.nodeName.split(":", 1)[-1]\r
-\r
- def _get_specified(self):\r
- return self.specified\r
-\r
- def __setattr__(self, name, value):\r
- d = self.__dict__\r
- if name in ("value", "nodeValue"):\r
- d["value"] = d["nodeValue"] = value\r
- d2 = self.childNodes[0].__dict__\r
- d2["data"] = d2["nodeValue"] = value\r
- if self.ownerElement is not None:\r
- _clear_id_cache(self.ownerElement)\r
- elif name in ("name", "nodeName"):\r
- d["name"] = d["nodeName"] = value\r
- if self.ownerElement is not None:\r
- _clear_id_cache(self.ownerElement)\r
- else:\r
- d[name] = value\r
-\r
- def _set_prefix(self, prefix):\r
- nsuri = self.namespaceURI\r
- if prefix == "xmlns":\r
- if nsuri and nsuri != XMLNS_NAMESPACE:\r
- raise xml.dom.NamespaceErr(\r
- "illegal use of 'xmlns' prefix for the wrong namespace")\r
- d = self.__dict__\r
- d['prefix'] = prefix\r
- if prefix is None:\r
- newName = self.localName\r
- else:\r
- newName = "%s:%s" % (prefix, self.localName)\r
- if self.ownerElement:\r
- _clear_id_cache(self.ownerElement)\r
- d['nodeName'] = d['name'] = newName\r
-\r
- def _set_value(self, value):\r
- d = self.__dict__\r
- d['value'] = d['nodeValue'] = value\r
- if self.ownerElement:\r
- _clear_id_cache(self.ownerElement)\r
- self.childNodes[0].data = value\r
-\r
- def unlink(self):\r
- # This implementation does not call the base implementation\r
- # since most of that is not needed, and the expense of the\r
- # method call is not warranted. We duplicate the removal of\r
- # children, but that's all we needed from the base class.\r
- elem = self.ownerElement\r
- if elem is not None:\r
- del elem._attrs[self.nodeName]\r
- del elem._attrsNS[(self.namespaceURI, self.localName)]\r
- if self._is_id:\r
- self._is_id = False\r
- elem._magic_id_nodes -= 1\r
- self.ownerDocument._magic_id_count -= 1\r
- for child in self.childNodes:\r
- child.unlink()\r
- del self.childNodes[:]\r
-\r
- def _get_isId(self):\r
- if self._is_id:\r
- return True\r
- doc = self.ownerDocument\r
- elem = self.ownerElement\r
- if doc is None or elem is None:\r
- return False\r
-\r
- info = doc._get_elem_info(elem)\r
- if info is None:\r
- return False\r
- if self.namespaceURI:\r
- return info.isIdNS(self.namespaceURI, self.localName)\r
- else:\r
- return info.isId(self.nodeName)\r
-\r
- def _get_schemaType(self):\r
- doc = self.ownerDocument\r
- elem = self.ownerElement\r
- if doc is None or elem is None:\r
- return _no_type\r
-\r
- info = doc._get_elem_info(elem)\r
- if info is None:\r
- return _no_type\r
- if self.namespaceURI:\r
- return info.getAttributeTypeNS(self.namespaceURI, self.localName)\r
- else:\r
- return info.getAttributeType(self.nodeName)\r
-\r
-defproperty(Attr, "isId", doc="True if this attribute is an ID.")\r
-defproperty(Attr, "localName", doc="Namespace-local name of this attribute.")\r
-defproperty(Attr, "schemaType", doc="Schema type for this attribute.")\r
-\r
-\r
-class NamedNodeMap(object):\r
- """The attribute list is a transient interface to the underlying\r
- dictionaries. Mutations here will change the underlying element's\r
- dictionary.\r
-\r
- Ordering is imposed artificially and does not reflect the order of\r
- attributes as found in an input document.\r
- """\r
-\r
- __slots__ = ('_attrs', '_attrsNS', '_ownerElement')\r
-\r
- def __init__(self, attrs, attrsNS, ownerElement):\r
- self._attrs = attrs\r
- self._attrsNS = attrsNS\r
- self._ownerElement = ownerElement\r
-\r
- def _get_length(self):\r
- return len(self._attrs)\r
-\r
- def item(self, index):\r
- try:\r
- return self[self._attrs.keys()[index]]\r
- except IndexError:\r
- return None\r
-\r
- def items(self):\r
- L = []\r
- for node in self._attrs.values():\r
- L.append((node.nodeName, node.value))\r
- return L\r
-\r
- def itemsNS(self):\r
- L = []\r
- for node in self._attrs.values():\r
- L.append(((node.namespaceURI, node.localName), node.value))\r
- return L\r
-\r
- def has_key(self, key):\r
- if isinstance(key, StringTypes):\r
- return key in self._attrs\r
- else:\r
- return key in self._attrsNS\r
-\r
- def keys(self):\r
- return self._attrs.keys()\r
-\r
- def keysNS(self):\r
- return self._attrsNS.keys()\r
-\r
- def values(self):\r
- return self._attrs.values()\r
-\r
- def get(self, name, value=None):\r
- return self._attrs.get(name, value)\r
-\r
- __len__ = _get_length\r
-\r
- __hash__ = None # Mutable type can't be correctly hashed\r
- def __cmp__(self, other):\r
- if self._attrs is getattr(other, "_attrs", None):\r
- return 0\r
- else:\r
- return cmp(id(self), id(other))\r
-\r
- def __getitem__(self, attname_or_tuple):\r
- if isinstance(attname_or_tuple, tuple):\r
- return self._attrsNS[attname_or_tuple]\r
- else:\r
- return self._attrs[attname_or_tuple]\r
-\r
- # same as set\r
- def __setitem__(self, attname, value):\r
- if isinstance(value, StringTypes):\r
- try:\r
- node = self._attrs[attname]\r
- except KeyError:\r
- node = Attr(attname)\r
- node.ownerDocument = self._ownerElement.ownerDocument\r
- self.setNamedItem(node)\r
- node.value = value\r
- else:\r
- if not isinstance(value, Attr):\r
- raise TypeError, "value must be a string or Attr object"\r
- node = value\r
- self.setNamedItem(node)\r
-\r
- def getNamedItem(self, name):\r
- try:\r
- return self._attrs[name]\r
- except KeyError:\r
- return None\r
-\r
- def getNamedItemNS(self, namespaceURI, localName):\r
- try:\r
- return self._attrsNS[(namespaceURI, localName)]\r
- except KeyError:\r
- return None\r
-\r
- def removeNamedItem(self, name):\r
- n = self.getNamedItem(name)\r
- if n is not None:\r
- _clear_id_cache(self._ownerElement)\r
- del self._attrs[n.nodeName]\r
- del self._attrsNS[(n.namespaceURI, n.localName)]\r
- if 'ownerElement' in n.__dict__:\r
- n.__dict__['ownerElement'] = None\r
- return n\r
- else:\r
- raise xml.dom.NotFoundErr()\r
-\r
- def removeNamedItemNS(self, namespaceURI, localName):\r
- n = self.getNamedItemNS(namespaceURI, localName)\r
- if n is not None:\r
- _clear_id_cache(self._ownerElement)\r
- del self._attrsNS[(n.namespaceURI, n.localName)]\r
- del self._attrs[n.nodeName]\r
- if 'ownerElement' in n.__dict__:\r
- n.__dict__['ownerElement'] = None\r
- return n\r
- else:\r
- raise xml.dom.NotFoundErr()\r
-\r
- def setNamedItem(self, node):\r
- if not isinstance(node, Attr):\r
- raise xml.dom.HierarchyRequestErr(\r
- "%s cannot be child of %s" % (repr(node), repr(self)))\r
- old = self._attrs.get(node.name)\r
- if old:\r
- old.unlink()\r
- self._attrs[node.name] = node\r
- self._attrsNS[(node.namespaceURI, node.localName)] = node\r
- node.ownerElement = self._ownerElement\r
- _clear_id_cache(node.ownerElement)\r
- return old\r
-\r
- def setNamedItemNS(self, node):\r
- return self.setNamedItem(node)\r
-\r
- def __delitem__(self, attname_or_tuple):\r
- node = self[attname_or_tuple]\r
- _clear_id_cache(node.ownerElement)\r
- node.unlink()\r
-\r
- def __getstate__(self):\r
- return self._attrs, self._attrsNS, self._ownerElement\r
-\r
- def __setstate__(self, state):\r
- self._attrs, self._attrsNS, self._ownerElement = state\r
-\r
-defproperty(NamedNodeMap, "length",\r
- doc="Number of nodes in the NamedNodeMap.")\r
-\r
-AttributeList = NamedNodeMap\r
-\r
-\r
-class TypeInfo(object):\r
- __slots__ = 'namespace', 'name'\r
-\r
- def __init__(self, namespace, name):\r
- self.namespace = namespace\r
- self.name = name\r
-\r
- def __repr__(self):\r
- if self.namespace:\r
- return "<TypeInfo %r (from %r)>" % (self.name, self.namespace)\r
- else:\r
- return "<TypeInfo %r>" % self.name\r
-\r
- def _get_name(self):\r
- return self.name\r
-\r
- def _get_namespace(self):\r
- return self.namespace\r
-\r
-_no_type = TypeInfo(None, None)\r
-\r
-class Element(Node):\r
- nodeType = Node.ELEMENT_NODE\r
- nodeValue = None\r
- schemaType = _no_type\r
-\r
- _magic_id_nodes = 0\r
-\r
- _child_node_types = (Node.ELEMENT_NODE,\r
- Node.PROCESSING_INSTRUCTION_NODE,\r
- Node.COMMENT_NODE,\r
- Node.TEXT_NODE,\r
- Node.CDATA_SECTION_NODE,\r
- Node.ENTITY_REFERENCE_NODE)\r
-\r
- def __init__(self, tagName, namespaceURI=EMPTY_NAMESPACE, prefix=None,\r
- localName=None):\r
- self.tagName = self.nodeName = tagName\r
- self.prefix = prefix\r
- self.namespaceURI = namespaceURI\r
- self.childNodes = NodeList()\r
-\r
- self._attrs = {} # attributes are double-indexed:\r
- self._attrsNS = {} # tagName -> Attribute\r
- # URI,localName -> Attribute\r
- # in the future: consider lazy generation\r
- # of attribute objects this is too tricky\r
- # for now because of headaches with\r
- # namespaces.\r
-\r
- def _get_localName(self):\r
- return self.tagName.split(":", 1)[-1]\r
-\r
- def _get_tagName(self):\r
- return self.tagName\r
-\r
- def unlink(self):\r
- for attr in self._attrs.values():\r
- attr.unlink()\r
- self._attrs = None\r
- self._attrsNS = None\r
- Node.unlink(self)\r
-\r
- def getAttribute(self, attname):\r
- try:\r
- return self._attrs[attname].value\r
- except KeyError:\r
- return ""\r
-\r
- def getAttributeNS(self, namespaceURI, localName):\r
- try:\r
- return self._attrsNS[(namespaceURI, localName)].value\r
- except KeyError:\r
- return ""\r
-\r
- def setAttribute(self, attname, value):\r
- attr = self.getAttributeNode(attname)\r
- if attr is None:\r
- attr = Attr(attname)\r
- # for performance\r
- d = attr.__dict__\r
- d["value"] = d["nodeValue"] = value\r
- d["ownerDocument"] = self.ownerDocument\r
- self.setAttributeNode(attr)\r
- elif value != attr.value:\r
- d = attr.__dict__\r
- d["value"] = d["nodeValue"] = value\r
- if attr.isId:\r
- _clear_id_cache(self)\r
-\r
- def setAttributeNS(self, namespaceURI, qualifiedName, value):\r
- prefix, localname = _nssplit(qualifiedName)\r
- attr = self.getAttributeNodeNS(namespaceURI, localname)\r
- if attr is None:\r
- # for performance\r
- attr = Attr(qualifiedName, namespaceURI, localname, prefix)\r
- d = attr.__dict__\r
- d["prefix"] = prefix\r
- d["nodeName"] = qualifiedName\r
- d["value"] = d["nodeValue"] = value\r
- d["ownerDocument"] = self.ownerDocument\r
- self.setAttributeNode(attr)\r
- else:\r
- d = attr.__dict__\r
- if value != attr.value:\r
- d["value"] = d["nodeValue"] = value\r
- if attr.isId:\r
- _clear_id_cache(self)\r
- if attr.prefix != prefix:\r
- d["prefix"] = prefix\r
- d["nodeName"] = qualifiedName\r
-\r
- def getAttributeNode(self, attrname):\r
- return self._attrs.get(attrname)\r
-\r
- def getAttributeNodeNS(self, namespaceURI, localName):\r
- return self._attrsNS.get((namespaceURI, localName))\r
-\r
- def setAttributeNode(self, attr):\r
- if attr.ownerElement not in (None, self):\r
- raise xml.dom.InuseAttributeErr("attribute node already owned")\r
- old1 = self._attrs.get(attr.name, None)\r
- if old1 is not None:\r
- self.removeAttributeNode(old1)\r
- old2 = self._attrsNS.get((attr.namespaceURI, attr.localName), None)\r
- if old2 is not None and old2 is not old1:\r
- self.removeAttributeNode(old2)\r
- _set_attribute_node(self, attr)\r
-\r
- if old1 is not attr:\r
- # It might have already been part of this node, in which case\r
- # it doesn't represent a change, and should not be returned.\r
- return old1\r
- if old2 is not attr:\r
- return old2\r
-\r
- setAttributeNodeNS = setAttributeNode\r
-\r
- def removeAttribute(self, name):\r
- try:\r
- attr = self._attrs[name]\r
- except KeyError:\r
- raise xml.dom.NotFoundErr()\r
- self.removeAttributeNode(attr)\r
-\r
- def removeAttributeNS(self, namespaceURI, localName):\r
- try:\r
- attr = self._attrsNS[(namespaceURI, localName)]\r
- except KeyError:\r
- raise xml.dom.NotFoundErr()\r
- self.removeAttributeNode(attr)\r
-\r
- def removeAttributeNode(self, node):\r
- if node is None:\r
- raise xml.dom.NotFoundErr()\r
- try:\r
- self._attrs[node.name]\r
- except KeyError:\r
- raise xml.dom.NotFoundErr()\r
- _clear_id_cache(self)\r
- node.unlink()\r
- # Restore this since the node is still useful and otherwise\r
- # unlinked\r
- node.ownerDocument = self.ownerDocument\r
-\r
- removeAttributeNodeNS = removeAttributeNode\r
-\r
- def hasAttribute(self, name):\r
- return name in self._attrs\r
-\r
- def hasAttributeNS(self, namespaceURI, localName):\r
- return (namespaceURI, localName) in self._attrsNS\r
-\r
- def getElementsByTagName(self, name):\r
- return _get_elements_by_tagName_helper(self, name, NodeList())\r
-\r
- def getElementsByTagNameNS(self, namespaceURI, localName):\r
- return _get_elements_by_tagName_ns_helper(\r
- self, namespaceURI, localName, NodeList())\r
-\r
- def __repr__(self):\r
- return "<DOM Element: %s at %#x>" % (self.tagName, id(self))\r
-\r
- def writexml(self, writer, indent="", addindent="", newl=""):\r
- # indent = current indentation\r
- # addindent = indentation to add to higher levels\r
- # newl = newline string\r
- writer.write(indent+"<" + self.tagName)\r
-\r
- attrs = self._get_attributes()\r
- a_names = attrs.keys()\r
- a_names.sort()\r
-\r
- for a_name in a_names:\r
- writer.write(" %s=\"" % a_name)\r
- _write_data(writer, attrs[a_name].value)\r
- writer.write("\"")\r
- if self.childNodes:\r
- writer.write(">")\r
- if (len(self.childNodes) == 1 and\r
- self.childNodes[0].nodeType == Node.TEXT_NODE):\r
- self.childNodes[0].writexml(writer, '', '', '')\r
- else:\r
- writer.write(newl)\r
- for node in self.childNodes:\r
- node.writexml(writer, indent+addindent, addindent, newl)\r
- writer.write(indent)\r
- writer.write("</%s>%s" % (self.tagName, newl))\r
- else:\r
- writer.write("/>%s"%(newl))\r
-\r
- def _get_attributes(self):\r
- return NamedNodeMap(self._attrs, self._attrsNS, self)\r
-\r
- def hasAttributes(self):\r
- if self._attrs:\r
- return True\r
- else:\r
- return False\r
-\r
- # DOM Level 3 attributes, based on the 22 Oct 2002 draft\r
-\r
- def setIdAttribute(self, name):\r
- idAttr = self.getAttributeNode(name)\r
- self.setIdAttributeNode(idAttr)\r
-\r
- def setIdAttributeNS(self, namespaceURI, localName):\r
- idAttr = self.getAttributeNodeNS(namespaceURI, localName)\r
- self.setIdAttributeNode(idAttr)\r
-\r
- def setIdAttributeNode(self, idAttr):\r
- if idAttr is None or not self.isSameNode(idAttr.ownerElement):\r
- raise xml.dom.NotFoundErr()\r
- if _get_containing_entref(self) is not None:\r
- raise xml.dom.NoModificationAllowedErr()\r
- if not idAttr._is_id:\r
- idAttr.__dict__['_is_id'] = True\r
- self._magic_id_nodes += 1\r
- self.ownerDocument._magic_id_count += 1\r
- _clear_id_cache(self)\r
-\r
-defproperty(Element, "attributes",\r
- doc="NamedNodeMap of attributes on the element.")\r
-defproperty(Element, "localName",\r
- doc="Namespace-local name of this element.")\r
-\r
-\r
-def _set_attribute_node(element, attr):\r
- _clear_id_cache(element)\r
- element._attrs[attr.name] = attr\r
- element._attrsNS[(attr.namespaceURI, attr.localName)] = attr\r
-\r
- # This creates a circular reference, but Element.unlink()\r
- # breaks the cycle since the references to the attribute\r
- # dictionaries are tossed.\r
- attr.__dict__['ownerElement'] = element\r
-\r
-\r
-class Childless:\r
- """Mixin that makes childless-ness easy to implement and avoids\r
- the complexity of the Node methods that deal with children.\r
- """\r
-\r
- attributes = None\r
- childNodes = EmptyNodeList()\r
- firstChild = None\r
- lastChild = None\r
-\r
- def _get_firstChild(self):\r
- return None\r
-\r
- def _get_lastChild(self):\r
- return None\r
-\r
- def appendChild(self, node):\r
- raise xml.dom.HierarchyRequestErr(\r
- self.nodeName + " nodes cannot have children")\r
-\r
- def hasChildNodes(self):\r
- return False\r
-\r
- def insertBefore(self, newChild, refChild):\r
- raise xml.dom.HierarchyRequestErr(\r
- self.nodeName + " nodes do not have children")\r
-\r
- def removeChild(self, oldChild):\r
- raise xml.dom.NotFoundErr(\r
- self.nodeName + " nodes do not have children")\r
-\r
- def normalize(self):\r
- # For childless nodes, normalize() has nothing to do.\r
- pass\r
-\r
- def replaceChild(self, newChild, oldChild):\r
- raise xml.dom.HierarchyRequestErr(\r
- self.nodeName + " nodes do not have children")\r
-\r
-\r
-class ProcessingInstruction(Childless, Node):\r
- nodeType = Node.PROCESSING_INSTRUCTION_NODE\r
-\r
- def __init__(self, target, data):\r
- self.target = self.nodeName = target\r
- self.data = self.nodeValue = data\r
-\r
- def _get_data(self):\r
- return self.data\r
- def _set_data(self, value):\r
- d = self.__dict__\r
- d['data'] = d['nodeValue'] = value\r
-\r
- def _get_target(self):\r
- return self.target\r
- def _set_target(self, value):\r
- d = self.__dict__\r
- d['target'] = d['nodeName'] = value\r
-\r
- def __setattr__(self, name, value):\r
- if name == "data" or name == "nodeValue":\r
- self.__dict__['data'] = self.__dict__['nodeValue'] = value\r
- elif name == "target" or name == "nodeName":\r
- self.__dict__['target'] = self.__dict__['nodeName'] = value\r
- else:\r
- self.__dict__[name] = value\r
-\r
- def writexml(self, writer, indent="", addindent="", newl=""):\r
- writer.write("%s<?%s %s?>%s" % (indent,self.target, self.data, newl))\r
-\r
-\r
-class CharacterData(Childless, Node):\r
- def _get_length(self):\r
- return len(self.data)\r
- __len__ = _get_length\r
-\r
- def _get_data(self):\r
- return self.__dict__['data']\r
- def _set_data(self, data):\r
- d = self.__dict__\r
- d['data'] = d['nodeValue'] = data\r
-\r
- _get_nodeValue = _get_data\r
- _set_nodeValue = _set_data\r
-\r
- def __setattr__(self, name, value):\r
- if name == "data" or name == "nodeValue":\r
- self.__dict__['data'] = self.__dict__['nodeValue'] = value\r
- else:\r
- self.__dict__[name] = value\r
-\r
- def __repr__(self):\r
- data = self.data\r
- if len(data) > 10:\r
- dotdotdot = "..."\r
- else:\r
- dotdotdot = ""\r
- return '<DOM %s node "%r%s">' % (\r
- self.__class__.__name__, data[0:10], dotdotdot)\r
-\r
- def substringData(self, offset, count):\r
- if offset < 0:\r
- raise xml.dom.IndexSizeErr("offset cannot be negative")\r
- if offset >= len(self.data):\r
- raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")\r
- if count < 0:\r
- raise xml.dom.IndexSizeErr("count cannot be negative")\r
- return self.data[offset:offset+count]\r
-\r
- def appendData(self, arg):\r
- self.data = self.data + arg\r
-\r
- def insertData(self, offset, arg):\r
- if offset < 0:\r
- raise xml.dom.IndexSizeErr("offset cannot be negative")\r
- if offset >= len(self.data):\r
- raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")\r
- if arg:\r
- self.data = "%s%s%s" % (\r
- self.data[:offset], arg, self.data[offset:])\r
-\r
- def deleteData(self, offset, count):\r
- if offset < 0:\r
- raise xml.dom.IndexSizeErr("offset cannot be negative")\r
- if offset >= len(self.data):\r
- raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")\r
- if count < 0:\r
- raise xml.dom.IndexSizeErr("count cannot be negative")\r
- if count:\r
- self.data = self.data[:offset] + self.data[offset+count:]\r
-\r
- def replaceData(self, offset, count, arg):\r
- if offset < 0:\r
- raise xml.dom.IndexSizeErr("offset cannot be negative")\r
- if offset >= len(self.data):\r
- raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")\r
- if count < 0:\r
- raise xml.dom.IndexSizeErr("count cannot be negative")\r
- if count:\r
- self.data = "%s%s%s" % (\r
- self.data[:offset], arg, self.data[offset+count:])\r
-\r
-defproperty(CharacterData, "length", doc="Length of the string data.")\r
-\r
-\r
-class Text(CharacterData):\r
- # Make sure we don't add an instance __dict__ if we don't already\r
- # have one, at least when that's possible:\r
- # XXX this does not work, CharacterData is an old-style class\r
- # __slots__ = ()\r
-\r
- nodeType = Node.TEXT_NODE\r
- nodeName = "#text"\r
- attributes = None\r
-\r
- def splitText(self, offset):\r
- if offset < 0 or offset > len(self.data):\r
- raise xml.dom.IndexSizeErr("illegal offset value")\r
- newText = self.__class__()\r
- newText.data = self.data[offset:]\r
- newText.ownerDocument = self.ownerDocument\r
- next = self.nextSibling\r
- if self.parentNode and self in self.parentNode.childNodes:\r
- if next is None:\r
- self.parentNode.appendChild(newText)\r
- else:\r
- self.parentNode.insertBefore(newText, next)\r
- self.data = self.data[:offset]\r
- return newText\r
-\r
- def writexml(self, writer, indent="", addindent="", newl=""):\r
- _write_data(writer, "%s%s%s" % (indent, self.data, newl))\r
-\r
- # DOM Level 3 (WD 9 April 2002)\r
-\r
- def _get_wholeText(self):\r
- L = [self.data]\r
- n = self.previousSibling\r
- while n is not None:\r
- if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):\r
- L.insert(0, n.data)\r
- n = n.previousSibling\r
- else:\r
- break\r
- n = self.nextSibling\r
- while n is not None:\r
- if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):\r
- L.append(n.data)\r
- n = n.nextSibling\r
- else:\r
- break\r
- return ''.join(L)\r
-\r
- def replaceWholeText(self, content):\r
- # XXX This needs to be seriously changed if minidom ever\r
- # supports EntityReference nodes.\r
- parent = self.parentNode\r
- n = self.previousSibling\r
- while n is not None:\r
- if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):\r
- next = n.previousSibling\r
- parent.removeChild(n)\r
- n = next\r
- else:\r
- break\r
- n = self.nextSibling\r
- if not content:\r
- parent.removeChild(self)\r
- while n is not None:\r
- if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):\r
- next = n.nextSibling\r
- parent.removeChild(n)\r
- n = next\r
- else:\r
- break\r
- if content:\r
- d = self.__dict__\r
- d['data'] = content\r
- d['nodeValue'] = content\r
- return self\r
- else:\r
- return None\r
-\r
- def _get_isWhitespaceInElementContent(self):\r
- if self.data.strip():\r
- return False\r
- elem = _get_containing_element(self)\r
- if elem is None:\r
- return False\r
- info = self.ownerDocument._get_elem_info(elem)\r
- if info is None:\r
- return False\r
- else:\r
- return info.isElementContent()\r
-\r
-defproperty(Text, "isWhitespaceInElementContent",\r
- doc="True iff this text node contains only whitespace"\r
- " and is in element content.")\r
-defproperty(Text, "wholeText",\r
- doc="The text of all logically-adjacent text nodes.")\r
-\r
-\r
-def _get_containing_element(node):\r
- c = node.parentNode\r
- while c is not None:\r
- if c.nodeType == Node.ELEMENT_NODE:\r
- return c\r
- c = c.parentNode\r
- return None\r
-\r
-def _get_containing_entref(node):\r
- c = node.parentNode\r
- while c is not None:\r
- if c.nodeType == Node.ENTITY_REFERENCE_NODE:\r
- return c\r
- c = c.parentNode\r
- return None\r
-\r
-\r
-class Comment(Childless, CharacterData):\r
- nodeType = Node.COMMENT_NODE\r
- nodeName = "#comment"\r
-\r
- def __init__(self, data):\r
- self.data = self.nodeValue = data\r
-\r
- def writexml(self, writer, indent="", addindent="", newl=""):\r
- if "--" in self.data:\r
- raise ValueError("'--' is not allowed in a comment node")\r
- writer.write("%s<!--%s-->%s" % (indent, self.data, newl))\r
-\r
-\r
-class CDATASection(Text):\r
- # Make sure we don't add an instance __dict__ if we don't already\r
- # have one, at least when that's possible:\r
- # XXX this does not work, Text is an old-style class\r
- # __slots__ = ()\r
-\r
- nodeType = Node.CDATA_SECTION_NODE\r
- nodeName = "#cdata-section"\r
-\r
- def writexml(self, writer, indent="", addindent="", newl=""):\r
- if self.data.find("]]>") >= 0:\r
- raise ValueError("']]>' not allowed in a CDATA section")\r
- writer.write("<![CDATA[%s]]>" % self.data)\r
-\r
-\r
-class ReadOnlySequentialNamedNodeMap(object):\r
- __slots__ = '_seq',\r
-\r
- def __init__(self, seq=()):\r
- # seq should be a list or tuple\r
- self._seq = seq\r
-\r
- def __len__(self):\r
- return len(self._seq)\r
-\r
- def _get_length(self):\r
- return len(self._seq)\r
-\r
- def getNamedItem(self, name):\r
- for n in self._seq:\r
- if n.nodeName == name:\r
- return n\r
-\r
- def getNamedItemNS(self, namespaceURI, localName):\r
- for n in self._seq:\r
- if n.namespaceURI == namespaceURI and n.localName == localName:\r
- return n\r
-\r
- def __getitem__(self, name_or_tuple):\r
- if isinstance(name_or_tuple, tuple):\r
- node = self.getNamedItemNS(*name_or_tuple)\r
- else:\r
- node = self.getNamedItem(name_or_tuple)\r
- if node is None:\r
- raise KeyError, name_or_tuple\r
- return node\r
-\r
- def item(self, index):\r
- if index < 0:\r
- return None\r
- try:\r
- return self._seq[index]\r
- except IndexError:\r
- return None\r
-\r
- def removeNamedItem(self, name):\r
- raise xml.dom.NoModificationAllowedErr(\r
- "NamedNodeMap instance is read-only")\r
-\r
- def removeNamedItemNS(self, namespaceURI, localName):\r
- raise xml.dom.NoModificationAllowedErr(\r
- "NamedNodeMap instance is read-only")\r
-\r
- def setNamedItem(self, node):\r
- raise xml.dom.NoModificationAllowedErr(\r
- "NamedNodeMap instance is read-only")\r
-\r
- def setNamedItemNS(self, node):\r
- raise xml.dom.NoModificationAllowedErr(\r
- "NamedNodeMap instance is read-only")\r
-\r
- def __getstate__(self):\r
- return [self._seq]\r
-\r
- def __setstate__(self, state):\r
- self._seq = state[0]\r
-\r
-defproperty(ReadOnlySequentialNamedNodeMap, "length",\r
- doc="Number of entries in the NamedNodeMap.")\r
-\r
-\r
-class Identified:\r
- """Mix-in class that supports the publicId and systemId attributes."""\r
-\r
- # XXX this does not work, this is an old-style class\r
- # __slots__ = 'publicId', 'systemId'\r
-\r
- def _identified_mixin_init(self, publicId, systemId):\r
- self.publicId = publicId\r
- self.systemId = systemId\r
-\r
- def _get_publicId(self):\r
- return self.publicId\r
-\r
- def _get_systemId(self):\r
- return self.systemId\r
-\r
-class DocumentType(Identified, Childless, Node):\r
- nodeType = Node.DOCUMENT_TYPE_NODE\r
- nodeValue = None\r
- name = None\r
- publicId = None\r
- systemId = None\r
- internalSubset = None\r
-\r
- def __init__(self, qualifiedName):\r
- self.entities = ReadOnlySequentialNamedNodeMap()\r
- self.notations = ReadOnlySequentialNamedNodeMap()\r
- if qualifiedName:\r
- prefix, localname = _nssplit(qualifiedName)\r
- self.name = localname\r
- self.nodeName = self.name\r
-\r
- def _get_internalSubset(self):\r
- return self.internalSubset\r
-\r
- def cloneNode(self, deep):\r
- if self.ownerDocument is None:\r
- # it's ok\r
- clone = DocumentType(None)\r
- clone.name = self.name\r
- clone.nodeName = self.name\r
- operation = xml.dom.UserDataHandler.NODE_CLONED\r
- if deep:\r
- clone.entities._seq = []\r
- clone.notations._seq = []\r
- for n in self.notations._seq:\r
- notation = Notation(n.nodeName, n.publicId, n.systemId)\r
- clone.notations._seq.append(notation)\r
- n._call_user_data_handler(operation, n, notation)\r
- for e in self.entities._seq:\r
- entity = Entity(e.nodeName, e.publicId, e.systemId,\r
- e.notationName)\r
- entity.actualEncoding = e.actualEncoding\r
- entity.encoding = e.encoding\r
- entity.version = e.version\r
- clone.entities._seq.append(entity)\r
- e._call_user_data_handler(operation, n, entity)\r
- self._call_user_data_handler(operation, self, clone)\r
- return clone\r
- else:\r
- return None\r
-\r
- def writexml(self, writer, indent="", addindent="", newl=""):\r
- writer.write("<!DOCTYPE ")\r
- writer.write(self.name)\r
- if self.publicId:\r
- writer.write("%s PUBLIC '%s'%s '%s'"\r
- % (newl, self.publicId, newl, self.systemId))\r
- elif self.systemId:\r
- writer.write("%s SYSTEM '%s'" % (newl, self.systemId))\r
- if self.internalSubset is not None:\r
- writer.write(" [")\r
- writer.write(self.internalSubset)\r
- writer.write("]")\r
- writer.write(">"+newl)\r
-\r
-class Entity(Identified, Node):\r
- attributes = None\r
- nodeType = Node.ENTITY_NODE\r
- nodeValue = None\r
-\r
- actualEncoding = None\r
- encoding = None\r
- version = None\r
-\r
- def __init__(self, name, publicId, systemId, notation):\r
- self.nodeName = name\r
- self.notationName = notation\r
- self.childNodes = NodeList()\r
- self._identified_mixin_init(publicId, systemId)\r
-\r
- def _get_actualEncoding(self):\r
- return self.actualEncoding\r
-\r
- def _get_encoding(self):\r
- return self.encoding\r
-\r
- def _get_version(self):\r
- return self.version\r
-\r
- def appendChild(self, newChild):\r
- raise xml.dom.HierarchyRequestErr(\r
- "cannot append children to an entity node")\r
-\r
- def insertBefore(self, newChild, refChild):\r
- raise xml.dom.HierarchyRequestErr(\r
- "cannot insert children below an entity node")\r
-\r
- def removeChild(self, oldChild):\r
- raise xml.dom.HierarchyRequestErr(\r
- "cannot remove children from an entity node")\r
-\r
- def replaceChild(self, newChild, oldChild):\r
- raise xml.dom.HierarchyRequestErr(\r
- "cannot replace children of an entity node")\r
-\r
-class Notation(Identified, Childless, Node):\r
- nodeType = Node.NOTATION_NODE\r
- nodeValue = None\r
-\r
- def __init__(self, name, publicId, systemId):\r
- self.nodeName = name\r
- self._identified_mixin_init(publicId, systemId)\r
-\r
-\r
-class DOMImplementation(DOMImplementationLS):\r
- _features = [("core", "1.0"),\r
- ("core", "2.0"),\r
- ("core", None),\r
- ("xml", "1.0"),\r
- ("xml", "2.0"),\r
- ("xml", None),\r
- ("ls-load", "3.0"),\r
- ("ls-load", None),\r
- ]\r
-\r
- def hasFeature(self, feature, version):\r
- if version == "":\r
- version = None\r
- return (feature.lower(), version) in self._features\r
-\r
- def createDocument(self, namespaceURI, qualifiedName, doctype):\r
- if doctype and doctype.parentNode is not None:\r
- raise xml.dom.WrongDocumentErr(\r
- "doctype object owned by another DOM tree")\r
- doc = self._create_document()\r
-\r
- add_root_element = not (namespaceURI is None\r
- and qualifiedName is None\r
- and doctype is None)\r
-\r
- if not qualifiedName and add_root_element:\r
- # The spec is unclear what to raise here; SyntaxErr\r
- # would be the other obvious candidate. Since Xerces raises\r
- # InvalidCharacterErr, and since SyntaxErr is not listed\r
- # for createDocument, that seems to be the better choice.\r
- # XXX: need to check for illegal characters here and in\r
- # createElement.\r
-\r
- # DOM Level III clears this up when talking about the return value\r
- # of this function. If namespaceURI, qName and DocType are\r
- # Null the document is returned without a document element\r
- # Otherwise if doctype or namespaceURI are not None\r
- # Then we go back to the above problem\r
- raise xml.dom.InvalidCharacterErr("Element with no name")\r
-\r
- if add_root_element:\r
- prefix, localname = _nssplit(qualifiedName)\r
- if prefix == "xml" \\r
- and namespaceURI != "http://www.w3.org/XML/1998/namespace":\r
- raise xml.dom.NamespaceErr("illegal use of 'xml' prefix")\r
- if prefix and not namespaceURI:\r
- raise xml.dom.NamespaceErr(\r
- "illegal use of prefix without namespaces")\r
- element = doc.createElementNS(namespaceURI, qualifiedName)\r
- if doctype:\r
- doc.appendChild(doctype)\r
- doc.appendChild(element)\r
-\r
- if doctype:\r
- doctype.parentNode = doctype.ownerDocument = doc\r
-\r
- doc.doctype = doctype\r
- doc.implementation = self\r
- return doc\r
-\r
- def createDocumentType(self, qualifiedName, publicId, systemId):\r
- doctype = DocumentType(qualifiedName)\r
- doctype.publicId = publicId\r
- doctype.systemId = systemId\r
- return doctype\r
-\r
- # DOM Level 3 (WD 9 April 2002)\r
-\r
- def getInterface(self, feature):\r
- if self.hasFeature(feature, None):\r
- return self\r
- else:\r
- return None\r
-\r
- # internal\r
- def _create_document(self):\r
- return Document()\r
-\r
-class ElementInfo(object):\r
- """Object that represents content-model information for an element.\r
-\r
- This implementation is not expected to be used in practice; DOM\r
- builders should provide implementations which do the right thing\r
- using information available to it.\r
-\r
- """\r
-\r
- __slots__ = 'tagName',\r
-\r
- def __init__(self, name):\r
- self.tagName = name\r
-\r
- def getAttributeType(self, aname):\r
- return _no_type\r
-\r
- def getAttributeTypeNS(self, namespaceURI, localName):\r
- return _no_type\r
-\r
- def isElementContent(self):\r
- return False\r
-\r
- def isEmpty(self):\r
- """Returns true iff this element is declared to have an EMPTY\r
- content model."""\r
- return False\r
-\r
- def isId(self, aname):\r
- """Returns true iff the named attribute is a DTD-style ID."""\r
- return False\r
-\r
- def isIdNS(self, namespaceURI, localName):\r
- """Returns true iff the identified attribute is a DTD-style ID."""\r
- return False\r
-\r
- def __getstate__(self):\r
- return self.tagName\r
-\r
- def __setstate__(self, state):\r
- self.tagName = state\r
-\r
-def _clear_id_cache(node):\r
- if node.nodeType == Node.DOCUMENT_NODE:\r
- node._id_cache.clear()\r
- node._id_search_stack = None\r
- elif _in_document(node):\r
- node.ownerDocument._id_cache.clear()\r
- node.ownerDocument._id_search_stack= None\r
-\r
-class Document(Node, DocumentLS):\r
- _child_node_types = (Node.ELEMENT_NODE, Node.PROCESSING_INSTRUCTION_NODE,\r
- Node.COMMENT_NODE, Node.DOCUMENT_TYPE_NODE)\r
-\r
- nodeType = Node.DOCUMENT_NODE\r
- nodeName = "#document"\r
- nodeValue = None\r
- attributes = None\r
- doctype = None\r
- parentNode = None\r
- previousSibling = nextSibling = None\r
-\r
- implementation = DOMImplementation()\r
-\r
- # Document attributes from Level 3 (WD 9 April 2002)\r
-\r
- actualEncoding = None\r
- encoding = None\r
- standalone = None\r
- version = None\r
- strictErrorChecking = False\r
- errorHandler = None\r
- documentURI = None\r
-\r
- _magic_id_count = 0\r
-\r
- def __init__(self):\r
- self.childNodes = NodeList()\r
- # mapping of (namespaceURI, localName) -> ElementInfo\r
- # and tagName -> ElementInfo\r
- self._elem_info = {}\r
- self._id_cache = {}\r
- self._id_search_stack = None\r
-\r
- def _get_elem_info(self, element):\r
- if element.namespaceURI:\r
- key = element.namespaceURI, element.localName\r
- else:\r
- key = element.tagName\r
- return self._elem_info.get(key)\r
-\r
- def _get_actualEncoding(self):\r
- return self.actualEncoding\r
-\r
- def _get_doctype(self):\r
- return self.doctype\r
-\r
- def _get_documentURI(self):\r
- return self.documentURI\r
-\r
- def _get_encoding(self):\r
- return self.encoding\r
-\r
- def _get_errorHandler(self):\r
- return self.errorHandler\r
-\r
- def _get_standalone(self):\r
- return self.standalone\r
-\r
- def _get_strictErrorChecking(self):\r
- return self.strictErrorChecking\r
-\r
- def _get_version(self):\r
- return self.version\r
-\r
- def appendChild(self, node):\r
- if node.nodeType not in self._child_node_types:\r
- raise xml.dom.HierarchyRequestErr(\r
- "%s cannot be child of %s" % (repr(node), repr(self)))\r
- if node.parentNode is not None:\r
- # This needs to be done before the next test since this\r
- # may *be* the document element, in which case it should\r
- # end up re-ordered to the end.\r
- node.parentNode.removeChild(node)\r
-\r
- if node.nodeType == Node.ELEMENT_NODE \\r
- and self._get_documentElement():\r
- raise xml.dom.HierarchyRequestErr(\r
- "two document elements disallowed")\r
- return Node.appendChild(self, node)\r
-\r
- def removeChild(self, oldChild):\r
- try:\r
- self.childNodes.remove(oldChild)\r
- except ValueError:\r
- raise xml.dom.NotFoundErr()\r
- oldChild.nextSibling = oldChild.previousSibling = None\r
- oldChild.parentNode = None\r
- if self.documentElement is oldChild:\r
- self.documentElement = None\r
-\r
- return oldChild\r
-\r
- def _get_documentElement(self):\r
- for node in self.childNodes:\r
- if node.nodeType == Node.ELEMENT_NODE:\r
- return node\r
-\r
- def unlink(self):\r
- if self.doctype is not None:\r
- self.doctype.unlink()\r
- self.doctype = None\r
- Node.unlink(self)\r
-\r
- def cloneNode(self, deep):\r
- if not deep:\r
- return None\r
- clone = self.implementation.createDocument(None, None, None)\r
- clone.encoding = self.encoding\r
- clone.standalone = self.standalone\r
- clone.version = self.version\r
- for n in self.childNodes:\r
- childclone = _clone_node(n, deep, clone)\r
- assert childclone.ownerDocument.isSameNode(clone)\r
- clone.childNodes.append(childclone)\r
- if childclone.nodeType == Node.DOCUMENT_NODE:\r
- assert clone.documentElement is None\r
- elif childclone.nodeType == Node.DOCUMENT_TYPE_NODE:\r
- assert clone.doctype is None\r
- clone.doctype = childclone\r
- childclone.parentNode = clone\r
- self._call_user_data_handler(xml.dom.UserDataHandler.NODE_CLONED,\r
- self, clone)\r
- return clone\r
-\r
- def createDocumentFragment(self):\r
- d = DocumentFragment()\r
- d.ownerDocument = self\r
- return d\r
-\r
- def createElement(self, tagName):\r
- e = Element(tagName)\r
- e.ownerDocument = self\r
- return e\r
-\r
- def createTextNode(self, data):\r
- if not isinstance(data, StringTypes):\r
- raise TypeError, "node contents must be a string"\r
- t = Text()\r
- t.data = data\r
- t.ownerDocument = self\r
- return t\r
-\r
- def createCDATASection(self, data):\r
- if not isinstance(data, StringTypes):\r
- raise TypeError, "node contents must be a string"\r
- c = CDATASection()\r
- c.data = data\r
- c.ownerDocument = self\r
- return c\r
-\r
- def createComment(self, data):\r
- c = Comment(data)\r
- c.ownerDocument = self\r
- return c\r
-\r
- def createProcessingInstruction(self, target, data):\r
- p = ProcessingInstruction(target, data)\r
- p.ownerDocument = self\r
- return p\r
-\r
- def createAttribute(self, qName):\r
- a = Attr(qName)\r
- a.ownerDocument = self\r
- a.value = ""\r
- return a\r
-\r
- def createElementNS(self, namespaceURI, qualifiedName):\r
- prefix, localName = _nssplit(qualifiedName)\r
- e = Element(qualifiedName, namespaceURI, prefix)\r
- e.ownerDocument = self\r
- return e\r
-\r
- def createAttributeNS(self, namespaceURI, qualifiedName):\r
- prefix, localName = _nssplit(qualifiedName)\r
- a = Attr(qualifiedName, namespaceURI, localName, prefix)\r
- a.ownerDocument = self\r
- a.value = ""\r
- return a\r
-\r
- # A couple of implementation-specific helpers to create node types\r
- # not supported by the W3C DOM specs:\r
-\r
- def _create_entity(self, name, publicId, systemId, notationName):\r
- e = Entity(name, publicId, systemId, notationName)\r
- e.ownerDocument = self\r
- return e\r
-\r
- def _create_notation(self, name, publicId, systemId):\r
- n = Notation(name, publicId, systemId)\r
- n.ownerDocument = self\r
- return n\r
-\r
- def getElementById(self, id):\r
- if id in self._id_cache:\r
- return self._id_cache[id]\r
- if not (self._elem_info or self._magic_id_count):\r
- return None\r
-\r
- stack = self._id_search_stack\r
- if stack is None:\r
- # we never searched before, or the cache has been cleared\r
- stack = [self.documentElement]\r
- self._id_search_stack = stack\r
- elif not stack:\r
- # Previous search was completed and cache is still valid;\r
- # no matching node.\r
- return None\r
-\r
- result = None\r
- while stack:\r
- node = stack.pop()\r
- # add child elements to stack for continued searching\r
- stack.extend([child for child in node.childNodes\r
- if child.nodeType in _nodeTypes_with_children])\r
- # check this node\r
- info = self._get_elem_info(node)\r
- if info:\r
- # We have to process all ID attributes before\r
- # returning in order to get all the attributes set to\r
- # be IDs using Element.setIdAttribute*().\r
- for attr in node.attributes.values():\r
- if attr.namespaceURI:\r
- if info.isIdNS(attr.namespaceURI, attr.localName):\r
- self._id_cache[attr.value] = node\r
- if attr.value == id:\r
- result = node\r
- elif not node._magic_id_nodes:\r
- break\r
- elif info.isId(attr.name):\r
- self._id_cache[attr.value] = node\r
- if attr.value == id:\r
- result = node\r
- elif not node._magic_id_nodes:\r
- break\r
- elif attr._is_id:\r
- self._id_cache[attr.value] = node\r
- if attr.value == id:\r
- result = node\r
- elif node._magic_id_nodes == 1:\r
- break\r
- elif node._magic_id_nodes:\r
- for attr in node.attributes.values():\r
- if attr._is_id:\r
- self._id_cache[attr.value] = node\r
- if attr.value == id:\r
- result = node\r
- if result is not None:\r
- break\r
- return result\r
-\r
- def getElementsByTagName(self, name):\r
- return _get_elements_by_tagName_helper(self, name, NodeList())\r
-\r
- def getElementsByTagNameNS(self, namespaceURI, localName):\r
- return _get_elements_by_tagName_ns_helper(\r
- self, namespaceURI, localName, NodeList())\r
-\r
- def isSupported(self, feature, version):\r
- return self.implementation.hasFeature(feature, version)\r
-\r
- def importNode(self, node, deep):\r
- if node.nodeType == Node.DOCUMENT_NODE:\r
- raise xml.dom.NotSupportedErr("cannot import document nodes")\r
- elif node.nodeType == Node.DOCUMENT_TYPE_NODE:\r
- raise xml.dom.NotSupportedErr("cannot import document type nodes")\r
- return _clone_node(node, deep, self)\r
-\r
- def writexml(self, writer, indent="", addindent="", newl="",\r
- encoding = None):\r
- if encoding is None:\r
- writer.write('<?xml version="1.0" ?>'+newl)\r
- else:\r
- writer.write('<?xml version="1.0" encoding="%s"?>%s' % (encoding, newl))\r
- for node in self.childNodes:\r
- node.writexml(writer, indent, addindent, newl)\r
-\r
- # DOM Level 3 (WD 9 April 2002)\r
-\r
- def renameNode(self, n, namespaceURI, name):\r
- if n.ownerDocument is not self:\r
- raise xml.dom.WrongDocumentErr(\r
- "cannot rename nodes from other documents;\n"\r
- "expected %s,\nfound %s" % (self, n.ownerDocument))\r
- if n.nodeType not in (Node.ELEMENT_NODE, Node.ATTRIBUTE_NODE):\r
- raise xml.dom.NotSupportedErr(\r
- "renameNode() only applies to element and attribute nodes")\r
- if namespaceURI != EMPTY_NAMESPACE:\r
- if ':' in name:\r
- prefix, localName = name.split(':', 1)\r
- if ( prefix == "xmlns"\r
- and namespaceURI != xml.dom.XMLNS_NAMESPACE):\r
- raise xml.dom.NamespaceErr(\r
- "illegal use of 'xmlns' prefix")\r
- else:\r
- if ( name == "xmlns"\r
- and namespaceURI != xml.dom.XMLNS_NAMESPACE\r
- and n.nodeType == Node.ATTRIBUTE_NODE):\r
- raise xml.dom.NamespaceErr(\r
- "illegal use of the 'xmlns' attribute")\r
- prefix = None\r
- localName = name\r
- else:\r
- prefix = None\r
- localName = None\r
- if n.nodeType == Node.ATTRIBUTE_NODE:\r
- element = n.ownerElement\r
- if element is not None:\r
- is_id = n._is_id\r
- element.removeAttributeNode(n)\r
- else:\r
- element = None\r
- # avoid __setattr__\r
- d = n.__dict__\r
- d['prefix'] = prefix\r
- d['localName'] = localName\r
- d['namespaceURI'] = namespaceURI\r
- d['nodeName'] = name\r
- if n.nodeType == Node.ELEMENT_NODE:\r
- d['tagName'] = name\r
- else:\r
- # attribute node\r
- d['name'] = name\r
- if element is not None:\r
- element.setAttributeNode(n)\r
- if is_id:\r
- element.setIdAttributeNode(n)\r
- # It's not clear from a semantic perspective whether we should\r
- # call the user data handlers for the NODE_RENAMED event since\r
- # we're re-using the existing node. The draft spec has been\r
- # interpreted as meaning "no, don't call the handler unless a\r
- # new node is created."\r
- return n\r
-\r
-defproperty(Document, "documentElement",\r
- doc="Top-level element of this document.")\r
-\r
-\r
-def _clone_node(node, deep, newOwnerDocument):\r
- """\r
- Clone a node and give it the new owner document.\r
- Called by Node.cloneNode and Document.importNode\r
- """\r
- if node.ownerDocument.isSameNode(newOwnerDocument):\r
- operation = xml.dom.UserDataHandler.NODE_CLONED\r
- else:\r
- operation = xml.dom.UserDataHandler.NODE_IMPORTED\r
- if node.nodeType == Node.ELEMENT_NODE:\r
- clone = newOwnerDocument.createElementNS(node.namespaceURI,\r
- node.nodeName)\r
- for attr in node.attributes.values():\r
- clone.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value)\r
- a = clone.getAttributeNodeNS(attr.namespaceURI, attr.localName)\r
- a.specified = attr.specified\r
-\r
- if deep:\r
- for child in node.childNodes:\r
- c = _clone_node(child, deep, newOwnerDocument)\r
- clone.appendChild(c)\r
-\r
- elif node.nodeType == Node.DOCUMENT_FRAGMENT_NODE:\r
- clone = newOwnerDocument.createDocumentFragment()\r
- if deep:\r
- for child in node.childNodes:\r
- c = _clone_node(child, deep, newOwnerDocument)\r
- clone.appendChild(c)\r
-\r
- elif node.nodeType == Node.TEXT_NODE:\r
- clone = newOwnerDocument.createTextNode(node.data)\r
- elif node.nodeType == Node.CDATA_SECTION_NODE:\r
- clone = newOwnerDocument.createCDATASection(node.data)\r
- elif node.nodeType == Node.PROCESSING_INSTRUCTION_NODE:\r
- clone = newOwnerDocument.createProcessingInstruction(node.target,\r
- node.data)\r
- elif node.nodeType == Node.COMMENT_NODE:\r
- clone = newOwnerDocument.createComment(node.data)\r
- elif node.nodeType == Node.ATTRIBUTE_NODE:\r
- clone = newOwnerDocument.createAttributeNS(node.namespaceURI,\r
- node.nodeName)\r
- clone.specified = True\r
- clone.value = node.value\r
- elif node.nodeType == Node.DOCUMENT_TYPE_NODE:\r
- assert node.ownerDocument is not newOwnerDocument\r
- operation = xml.dom.UserDataHandler.NODE_IMPORTED\r
- clone = newOwnerDocument.implementation.createDocumentType(\r
- node.name, node.publicId, node.systemId)\r
- clone.ownerDocument = newOwnerDocument\r
- if deep:\r
- clone.entities._seq = []\r
- clone.notations._seq = []\r
- for n in node.notations._seq:\r
- notation = Notation(n.nodeName, n.publicId, n.systemId)\r
- notation.ownerDocument = newOwnerDocument\r
- clone.notations._seq.append(notation)\r
- if hasattr(n, '_call_user_data_handler'):\r
- n._call_user_data_handler(operation, n, notation)\r
- for e in node.entities._seq:\r
- entity = Entity(e.nodeName, e.publicId, e.systemId,\r
- e.notationName)\r
- entity.actualEncoding = e.actualEncoding\r
- entity.encoding = e.encoding\r
- entity.version = e.version\r
- entity.ownerDocument = newOwnerDocument\r
- clone.entities._seq.append(entity)\r
- if hasattr(e, '_call_user_data_handler'):\r
- e._call_user_data_handler(operation, n, entity)\r
- else:\r
- # Note the cloning of Document and DocumentType nodes is\r
- # implementation specific. minidom handles those cases\r
- # directly in the cloneNode() methods.\r
- raise xml.dom.NotSupportedErr("Cannot clone node %s" % repr(node))\r
-\r
- # Check for _call_user_data_handler() since this could conceivably\r
- # used with other DOM implementations (one of the FourThought\r
- # DOMs, perhaps?).\r
- if hasattr(node, '_call_user_data_handler'):\r
- node._call_user_data_handler(operation, node, clone)\r
- return clone\r
-\r
-\r
-def _nssplit(qualifiedName):\r
- fields = qualifiedName.split(':', 1)\r
- if len(fields) == 2:\r
- return fields\r
- else:\r
- return (None, fields[0])\r
-\r
-\r
-def _get_StringIO():\r
- # we can't use cStringIO since it doesn't support Unicode strings\r
- from StringIO import StringIO\r
- return StringIO()\r
-\r
-def _do_pulldom_parse(func, args, kwargs):\r
- events = func(*args, **kwargs)\r
- toktype, rootNode = events.getEvent()\r
- events.expandNode(rootNode)\r
- events.clear()\r
- return rootNode\r
-\r
-def parse(file, parser=None, bufsize=None):\r
- """Parse a file into a DOM by filename or file object."""\r
- if parser is None and not bufsize:\r
- from xml.dom import expatbuilder\r
- return expatbuilder.parse(file)\r
- else:\r
- from xml.dom import pulldom\r
- return _do_pulldom_parse(pulldom.parse, (file,),\r
- {'parser': parser, 'bufsize': bufsize})\r
-\r
-def parseString(string, parser=None):\r
- """Parse a file into a DOM from a string."""\r
- if parser is None:\r
- from xml.dom import expatbuilder\r
- return expatbuilder.parseString(string)\r
- else:\r
- from xml.dom import pulldom\r
- return _do_pulldom_parse(pulldom.parseString, (string,),\r
- {'parser': parser})\r
-\r
-def getDOMImplementation(features=None):\r
- if features:\r
- if isinstance(features, StringTypes):\r
- features = domreg._parse_feature_string(features)\r
- for f, v in features:\r
- if not Document.implementation.hasFeature(f, v):\r
- return None\r
- return Document.implementation\r
projects / mirror_edk2.git / blobdiff