"""Simple implementation of the Level 1 DOM.

Namespaces and other minor Level 2 features are also supported.

parse("foo.xml")

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

Todo:

=====

* convenience methods for getting elements and text.

* more testing

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

interface

* SAX 2 namespaces

"""

import io

import xml.dom

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

from xml.dom.minicompat import *

from xml.dom.xmlbuilder import DOMImplementationLS, DocumentLS

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

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

# DOCUMENT_NODE or DOCUMENT_FRAGMENT_NODE. (The node being checked is

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

#

_nodeTypes_with_children = (xml.dom.Node.ELEMENT_NODE,

xml.dom.Node.ENTITY_REFERENCE_NODE)

class Node(xml.dom.Node):

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

parentNode = None

ownerDocument = None

nextSibling = None

previousSibling = None

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

def __bool__(self):

return True

def toxml(self, encoding=None, standalone=None):

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

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

standalone=None):

if encoding is None:

writer = io.StringIO()

else:

writer = io.TextIOWrapper(io.BytesIO(),

encoding=encoding,

errors="xmlcharrefreplace",

newline='\n')

if self.nodeType == Node.DOCUMENT_NODE:

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

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

else:

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

if encoding is None:

return writer.getvalue()

else:

return writer.detach().getvalue()

def hasChildNodes(self):

return bool(self.childNodes)

def _get_childNodes(self):

return self.childNodes

def _get_firstChild(self):

if self.childNodes:

return self.childNodes[0]

def _get_lastChild(self):

if self.childNodes:

return self.childNodes[-1]

def insertBefore(self, newChild, refChild):

if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:

for c in tuple(newChild.childNodes):

self.insertBefore(c, refChild)

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

return newChild

if newChild.nodeType not in self._child_node_types:

raise xml.dom.HierarchyRequestErr(

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

if newChild.parentNode is not None:

newChild.parentNode.removeChild(newChild)

if refChild is None:

self.appendChild(newChild)

else:

try:

index = self.childNodes.index(refChild)

except ValueError:

raise xml.dom.NotFoundErr()

if newChild.nodeType in _nodeTypes_with_children:

_clear_id_cache(self)

self.childNodes.insert(index, newChild)

newChild.nextSibling = refChild

refChild.previousSibling = newChild

if index:

node = self.childNodes[index-1]

node.nextSibling = newChild

newChild.previousSibling = node

else:

newChild.previousSibling = None

newChild.parentNode = self

return newChild

def appendChild(self, node):

if node.nodeType == self.DOCUMENT_FRAGMENT_NODE:

for c in tuple(node.childNodes):

self.appendChild(c)

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

return node

if node.nodeType not in self._child_node_types:

raise xml.dom.HierarchyRequestErr(

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

elif node.nodeType in _nodeTypes_with_children:

_clear_id_cache(self)

if node.parentNode is not None:

node.parentNode.removeChild(node)

_append_child(self, node)

node.nextSibling = None

return node

def replaceChild(self, newChild, oldChild):

if newChild.nodeType == self.DOCUMENT_FRAGMENT_NODE:

refChild = oldChild.nextSibling

self.removeChild(oldChild)

return self.insertBefore(newChild, refChild)

if newChild.nodeType not in self._child_node_types:

raise xml.dom.HierarchyRequestErr(

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

if newChild is oldChild:

return

if newChild.parentNode is not None:

newChild.parentNode.removeChild(newChild)

try:

index = self.childNodes.index(oldChild)

except ValueError:

raise xml.dom.NotFoundErr()

self.childNodes[index] = newChild

newChild.parentNode = self

oldChild.parentNode = None

if (newChild.nodeType in _nodeTypes_with_children

or oldChild.nodeType in _nodeTypes_with_children):

_clear_id_cache(self)

newChild.nextSibling = oldChild.nextSibling

newChild.previousSibling = oldChild.previousSibling

oldChild.nextSibling = None

oldChild.previousSibling = None

if newChild.previousSibling:

newChild.previousSibling.nextSibling = newChild

if newChild.nextSibling:

newChild.nextSibling.previousSibling = newChild

return oldChild

def removeChild(self, oldChild):

try:

self.childNodes.remove(oldChild)

except ValueError:

raise xml.dom.NotFoundErr()

if oldChild.nextSibling is not None:

oldChild.nextSibling.previousSibling = oldChild.previousSibling

if oldChild.previousSibling is not None:

oldChild.previousSibling.nextSibling = oldChild.nextSibling

oldChild.nextSibling = oldChild.previousSibling = None

if oldChild.nodeType in _nodeTypes_with_children:

_clear_id_cache(self)

oldChild.parentNode = None

return oldChild

def normalize(self):

L = []

for child in self.childNodes:

if child.nodeType == Node.TEXT_NODE:

if not child.data:

# empty text node; discard

if L:

L[-1].nextSibling = child.nextSibling

if child.nextSibling:

child.nextSibling.previousSibling = child.previousSibling

child.unlink()

elif L and L[-1].nodeType == child.nodeType:

# collapse text node

node = L[-1]

node.data = node.data + child.data

node.nextSibling = child.nextSibling

if child.nextSibling:

child.nextSibling.previousSibling = node

child.unlink()

else:

L.append(child)

else:

L.append(child)

if child.nodeType == Node.ELEMENT_NODE:

child.normalize()

self.childNodes[:] = L

def cloneNode(self, deep):

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

def isSupported(self, feature, version):

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

def _get_localName(self):

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

return None

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

def isSameNode(self, other):

return self is other

def getInterface(self, feature):

if self.isSupported(feature, None):

return self

else:

return None

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

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

# exists.

def getUserData(self, key):

try:

return self._user_data[key][0]

except (AttributeError, KeyError):

return None

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

old = None

try:

d = self._user_data

except AttributeError:

d = {}

self._user_data = d

if key in d:

old = d[key][0]

if data is None:

# ignore handlers passed for None

handler = None

if old is not None:

del d[key]

else:

d[key] = (data, handler)

return old

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

if hasattr(self, "_user_data"):

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

if handler is not None:

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

# minidom-specific API:

def unlink(self):

self.parentNode = self.ownerDocument = None

if self.childNodes:

for child in self.childNodes:

child.unlink()

self.childNodes = NodeList()

self.previousSibling = None

self.nextSibling = None

# A Node is its own context manager, to ensure that an unlink() call occurs.

# This is similar to how a file object works.

def __enter__(self):

return self

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

self.unlink()

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

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

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

def _append_child(self, node):

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

childNodes = self.childNodes

if childNodes:

last = childNodes[-1]

node.previousSibling = last

last.nextSibling = node

childNodes.append(node)

node.parentNode = self

def _write_data(writer, text, attr):

"Writes datachars to writer."

if not text:

return

# See the comments in ElementTree.py for behavior and

# implementation details.

if "&" in text:

text = text.replace("&", "&amp;")

if "<" in text:

text = text.replace("<", "&lt;")

if ">" in text:

text = text.replace(">", "&gt;")

if attr:

if '"' in text:

text = text.replace('"', "&quot;")

if "\r" in text:

text = text.replace("\r", "&#13;")

if "\n" in text:

text = text.replace("\n", "&#10;")

if "\t" in text:

text = text.replace("\t", "&#9;")

writer.write(text)

def _get_elements_by_tagName_helper(parent, name, rc):

for node in parent.childNodes:

if node.nodeType == Node.ELEMENT_NODE and \

(name == "*" or node.tagName == name):

rc.append(node)

_get_elements_by_tagName_helper(node, name, rc)

return rc

def _get_elements_by_tagName_ns_helper(parent, nsURI, localName, rc):

for node in parent.childNodes:

if node.nodeType == Node.ELEMENT_NODE:

if ((localName == "*" or node.localName == localName) and

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

rc.append(node)

_get_elements_by_tagName_ns_helper(node, nsURI, localName, rc)

return rc

class DocumentFragment(Node):

nodeType = Node.DOCUMENT_FRAGMENT_NODE

nodeName = "#document-fragment"

nodeValue = None

attributes = None

parentNode = None

_child_node_types = (Node.ELEMENT_NODE,

Node.TEXT_NODE,

Node.CDATA_SECTION_NODE,

Node.ENTITY_REFERENCE_NODE,

Node.PROCESSING_INSTRUCTION_NODE,

Node.COMMENT_NODE,

Node.NOTATION_NODE)

def __init__(self):

self.childNodes = NodeList()

class Attr(Node):

__slots__=('_name', '_value', 'namespaceURI',

'_prefix', 'childNodes', '_localName', 'ownerDocument', 'ownerElement')

nodeType = Node.ATTRIBUTE_NODE

attributes = None

specified = False

_is_id = False

_child_node_types = (Node.TEXT_NODE, Node.ENTITY_REFERENCE_NODE)

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

prefix=None):

self.ownerElement = None

self.ownerDocument = None

self._name = qName

self.namespaceURI = namespaceURI

self._prefix = prefix

if localName is not None:

self._localName = localName

self.childNodes = NodeList()

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

self.childNodes.append(Text())

# nodeValue and value are set elsewhere

def _get_localName(self):

try:

return self._localName

except AttributeError:

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

def _get_specified(self):

return self.specified

def _get_name(self):

return self._name

def _set_name(self, value):

self._name = value

if self.ownerElement is not None:

_clear_id_cache(self.ownerElement)

nodeName = name = property(_get_name, _set_name)

def _get_value(self):

return self._value

def _set_value(self, value):

self._value = value

self.childNodes[0].data = value

if self.ownerElement is not None:

_clear_id_cache(self.ownerElement)

self.childNodes[0].data = value

nodeValue = value = property(_get_value, _set_value)

def _get_prefix(self):

return self._prefix

def _set_prefix(self, prefix):

nsuri = self.namespaceURI

if prefix == "xmlns":

if nsuri and nsuri != XMLNS_NAMESPACE:

raise xml.dom.NamespaceErr(

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

self._prefix = prefix

if prefix is None:

newName = self.localName

else:

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

if self.ownerElement:

_clear_id_cache(self.ownerElement)

self.name = newName

prefix = property(_get_prefix, _set_prefix)

def unlink(self):

# This implementation does not call the base implementation

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

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

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

elem = self.ownerElement

if elem is not None:

del elem._attrs[self.nodeName]

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

if self._is_id:

self._is_id = False

elem._magic_id_nodes -= 1

self.ownerDocument._magic_id_count -= 1

for child in self.childNodes:

child.unlink()

del self.childNodes[:]

def _get_isId(self):

if self._is_id:

return True

doc = self.ownerDocument

elem = self.ownerElement

if doc is None or elem is None:

return False

info = doc._get_elem_info(elem)

if info is None:

return False

if self.namespaceURI:

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

else:

return info.isId(self.nodeName)

def _get_schemaType(self):

doc = self.ownerDocument

elem = self.ownerElement

if doc is None or elem is None:

return _no_type

info = doc._get_elem_info(elem)

if info is None:

return _no_type

if self.namespaceURI:

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

else:

return info.getAttributeType(self.nodeName)

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

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

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

class NamedNodeMap(object):

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

dictionaries. Mutations here will change the underlying element's

dictionary.

Ordering is imposed artificially and does not reflect the order of

attributes as found in an input document.

"""

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

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

self._attrs = attrs

self._attrsNS = attrsNS

self._ownerElement = ownerElement

def _get_length(self):

return len(self._attrs)

def item(self, index):

try:

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

except IndexError:

return None

def items(self):

L = []

for node in self._attrs.values():

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

return L

def itemsNS(self):

L = []

for node in self._attrs.values():

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

return L

def __contains__(self, key):

if isinstance(key, str):

return key in self._attrs

else:

return key in self._attrsNS

def keys(self):

return self._attrs.keys()

def keysNS(self):

return self._attrsNS.keys()

def values(self):

return self._attrs.values()

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

return self._attrs.get(name, value)

__len__ = _get_length

def _cmp(self, other):

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

return 0

else:

return (id(self) > id(other)) - (id(self) < id(other))

def __eq__(self, other):

return self._cmp(other) == 0

def __ge__(self, other):

return self._cmp(other) >= 0

def __gt__(self, other):

return self._cmp(other) > 0

def __le__(self, other):

return self._cmp(other) <= 0

def __lt__(self, other):

return self._cmp(other) < 0

def __getitem__(self, attname_or_tuple):

if isinstance(attname_or_tuple, tuple):

return self._attrsNS[attname_or_tuple]

else:

return self._attrs[attname_or_tuple]

# same as set

def __setitem__(self, attname, value):

if isinstance(value, str):

try:

node = self._attrs[attname]

except KeyError:

node = Attr(attname)

node.ownerDocument = self._ownerElement.ownerDocument

self.setNamedItem(node)

node.value = value

else:

if not isinstance(value, Attr):

raise TypeError("value must be a string or Attr object")

node = value

self.setNamedItem(node)

def getNamedItem(self, name):

try:

return self._attrs[name]

except KeyError:

return None

def getNamedItemNS(self, namespaceURI, localName):

try:

return self._attrsNS[(namespaceURI, localName)]

except KeyError:

return None

def removeNamedItem(self, name):

n = self.getNamedItem(name)

if n is not None:

_clear_id_cache(self._ownerElement)

del self._attrs[n.nodeName]

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

if hasattr(n, 'ownerElement'):

n.ownerElement = None

return n

else:

raise xml.dom.NotFoundErr()

def removeNamedItemNS(self, namespaceURI, localName):

n = self.getNamedItemNS(namespaceURI, localName)

if n is not None:

_clear_id_cache(self._ownerElement)

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

del self._attrs[n.nodeName]

if hasattr(n, 'ownerElement'):

n.ownerElement = None

return n

else:

raise xml.dom.NotFoundErr()

def setNamedItem(self, node):

if not isinstance(node, Attr):

raise xml.dom.HierarchyRequestErr(

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

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

if old:

old.unlink()

self._attrs[node.name] = node

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

node.ownerElement = self._ownerElement

_clear_id_cache(node.ownerElement)

return old

def setNamedItemNS(self, node):

return self.setNamedItem(node)

def __delitem__(self, attname_or_tuple):

node = self[attname_or_tuple]

_clear_id_cache(node.ownerElement)

node.unlink()

def __getstate__(self):

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

def __setstate__(self, state):

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

defproperty(NamedNodeMap, "length",

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

AttributeList = NamedNodeMap

class TypeInfo(object):

__slots__ = 'namespace', 'name'

def __init__(self, namespace, name):

self.namespace = namespace

self.name = name

def __repr__(self):

if self.namespace:

return "<%s %r (from %r)>" % (self.__class__.__name__, self.name,

self.namespace)

else:

return "<%s %r>" % (self.__class__.__name__, self.name)

def _get_name(self):

return self.name

def _get_namespace(self):

return self.namespace

_no_type = TypeInfo(None, None)

class Element(Node):

__slots__=('ownerDocument', 'parentNode', 'tagName', 'nodeName', 'prefix',

'namespaceURI', '_localName', 'childNodes', '_attrs', '_attrsNS',

'nextSibling', 'previousSibling')

nodeType = Node.ELEMENT_NODE

nodeValue = None

schemaType = _no_type

_magic_id_nodes = 0

_child_node_types = (Node.ELEMENT_NODE,

Node.PROCESSING_INSTRUCTION_NODE,

Node.COMMENT_NODE,

Node.TEXT_NODE,

Node.CDATA_SECTION_NODE,

Node.ENTITY_REFERENCE_NODE)

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

localName=None):

self.ownerDocument = None

self.parentNode = None

self.tagName = self.nodeName = tagName

self.prefix = prefix

self.namespaceURI = namespaceURI

self.childNodes = NodeList()

self.nextSibling = self.previousSibling = None

# Attribute dictionaries are lazily created

# attributes are double-indexed:

# tagName -> Attribute

# URI,localName -> Attribute

# in the future: consider lazy generation

# of attribute objects this is too tricky

# for now because of headaches with

# namespaces.

self._attrs = None

self._attrsNS = None

def _ensure_attributes(self):

if self._attrs is None:

self._attrs = {}

self._attrsNS = {}

def _get_localName(self):

try:

return self._localName

except AttributeError:

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

def _get_tagName(self):

return self.tagName

def unlink(self):

if self._attrs is not None:

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

attr.unlink()

self._attrs = None

self._attrsNS = None

Node.unlink(self)

def getAttribute(self, attname):

"""Returns the value of the specified attribute.

Returns the value of the element's attribute named attname as

a string. An empty string is returned if the element does not

have such an attribute. Note that an empty string may also be

returned as an explicitly given attribute value, use the

hasAttribute method to distinguish these two cases.

"""

if self._attrs is None:

return ""

try:

return self._attrs[attname].value

except KeyError:

return ""

def getAttributeNS(self, namespaceURI, localName):

if self._attrsNS is None:

return ""

try:

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

except KeyError:

return ""

def setAttribute(self, attname, value):

attr = self.getAttributeNode(attname)

if attr is None:

attr = Attr(attname)

attr.value = value # also sets nodeValue

attr.ownerDocument = self.ownerDocument

self.setAttributeNode(attr)

elif value != attr.value:

attr.value = value

if attr.isId:

_clear_id_cache(self)

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

prefix, localname = _nssplit(qualifiedName)

attr = self.getAttributeNodeNS(namespaceURI, localname)

if attr is None:

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

attr.value = value

attr.ownerDocument = self.ownerDocument

self.setAttributeNode(attr)

else:

if value != attr.value:

attr.value = value

if attr.isId:

_clear_id_cache(self)

if attr.prefix != prefix:

attr.prefix = prefix

attr.nodeName = qualifiedName

def getAttributeNode(self, attrname):

if self._attrs is None:

return None

return self._attrs.get(attrname)

def getAttributeNodeNS(self, namespaceURI, localName):

if self._attrsNS is None:

return None

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

def setAttributeNode(self, attr):

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

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

self._ensure_attributes()

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

if old1 is not None:

self.removeAttributeNode(old1)

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

if old2 is not None and old2 is not old1:

self.removeAttributeNode(old2)

_set_attribute_node(self, attr)

if old1 is not attr:

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

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

return old1

if old2 is not attr:

return old2

setAttributeNodeNS = setAttributeNode

def removeAttribute(self, name):

if self._attrsNS is None:

raise xml.dom.NotFoundErr()

try:

attr = self._attrs[name]

except KeyError:

raise xml.dom.NotFoundErr()

self.removeAttributeNode(attr)

def removeAttributeNS(self, namespaceURI, localName):

if self._attrsNS is None:

raise xml.dom.NotFoundErr()

try:

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

except KeyError:

raise xml.dom.NotFoundErr()

self.removeAttributeNode(attr)

def removeAttributeNode(self, node):

if node is None:

raise xml.dom.NotFoundErr()

try:

self._attrs[node.name]

except KeyError:

raise xml.dom.NotFoundErr()

_clear_id_cache(self)

node.unlink()

# Restore this since the node is still useful and otherwise

# unlinked

node.ownerDocument = self.ownerDocument

return node

removeAttributeNodeNS = removeAttributeNode

def hasAttribute(self, name):

"""Checks whether the element has an attribute with the specified name.

Returns True if the element has an attribute with the specified name.

Otherwise, returns False.

"""

if self._attrs is None:

return False

return name in self._attrs

def hasAttributeNS(self, namespaceURI, localName):

if self._attrsNS is None:

return False

return (namespaceURI, localName) in self._attrsNS

def getElementsByTagName(self, name):

"""Returns all descendant elements with the given tag name.

Returns the list of all descendant elements (not direct children

only) with the specified tag name.

"""

return _get_elements_by_tagName_helper(self, name, NodeList())

def getElementsByTagNameNS(self, namespaceURI, localName):

return _get_elements_by_tagName_ns_helper(

self, namespaceURI, localName, NodeList())

def __repr__(self):

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

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

"""Write an XML element to a file-like object

Write the element to the writer object that must provide

a write method (e.g. a file or StringIO object).

"""

# indent = current indentation

# addindent = indentation to add to higher levels

# newl = newline string

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

attrs = self._get_attributes()

for a_name in attrs.keys():

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

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

writer.write("\"")

if self.childNodes:

writer.write(">")

if (len(self.childNodes) == 1 and

self.childNodes[0].nodeType in (

Node.TEXT_NODE, Node.CDATA_SECTION_NODE)):

self.childNodes[0].writexml(writer, '', '', '')

else:

writer.write(newl)

for node in self.childNodes:

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

writer.write(indent)

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

else:

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

def _get_attributes(self):

self._ensure_attributes()

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

def hasAttributes(self):

if self._attrs:

return True

else:

return False

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

def setIdAttribute(self, name):

idAttr = self.getAttributeNode(name)

self.setIdAttributeNode(idAttr)

def setIdAttributeNS(self, namespaceURI, localName):

idAttr = self.getAttributeNodeNS(namespaceURI, localName)

self.setIdAttributeNode(idAttr)

def setIdAttributeNode(self, idAttr):

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

raise xml.dom.NotFoundErr()

if _get_containing_entref(self) is not None:

raise xml.dom.NoModificationAllowedErr()

if not idAttr._is_id:

idAttr._is_id = True

self._magic_id_nodes += 1

self.ownerDocument._magic_id_count += 1

_clear_id_cache(self)

defproperty(Element, "attributes",

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

defproperty(Element, "localName",

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

def _set_attribute_node(element, attr):

_clear_id_cache(element)

element._ensure_attributes()

element._attrs[attr.name] = attr

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

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

# breaks the cycle since the references to the attribute

# dictionaries are tossed.

attr.ownerElement = element

class Childless:

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

the complexity of the Node methods that deal with children.

"""

__slots__ = ()

attributes = None

childNodes = EmptyNodeList()

firstChild = None

lastChild = None

def _get_firstChild(self):

return None

def _get_lastChild(self):

return None

def appendChild(self, node):

raise xml.dom.HierarchyRequestErr(

self.nodeName + " nodes cannot have children")

def hasChildNodes(self):

return False

def insertBefore(self, newChild, refChild):

raise xml.dom.HierarchyRequestErr(

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

def removeChild(self, oldChild):

raise xml.dom.NotFoundErr(

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

def normalize(self):

# For childless nodes, normalize() has nothing to do.

pass

def replaceChild(self, newChild, oldChild):

raise xml.dom.HierarchyRequestErr(

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