🐐 GOAT Shell

Current path: tmp/



⬆️ Go up:

πŸ“„ Viewing: phpriFIm7

U

e5dοΏ½οΏ½@s,dZddlZddlTeejd<eejd<dS)z1Interface to the Expat non-validating XML parser.οΏ½N)οΏ½*zxml.parsers.expat.modelzxml.parsers.expat.errors)οΏ½__doc__οΏ½sysZpyexpatZmodelοΏ½modulesοΏ½errorsοΏ½rrοΏ½)/usr/lib64/python3.8/xml/parsers/expat.pyοΏ½<module>s
U

e5dοΏ½οΏ½@sdS)NοΏ½rrrοΏ½,/usr/lib64/python3.8/xml/parsers/__init__.pyοΏ½<module>οΏ½U

e5dοΏ½οΏ½@s,dZddlZddlTeejd<eejd<dS)z1Interface to the Expat non-validating XML parser.οΏ½N)οΏ½*zxml.parsers.expat.modelzxml.parsers.expat.errors)οΏ½__doc__οΏ½sysZpyexpatZmodelοΏ½modulesοΏ½errorsοΏ½rrοΏ½)/usr/lib64/python3.8/xml/parsers/expat.pyοΏ½<module>s
U

e5dοΏ½οΏ½@sdZdS)zοΏ½Python interfaces to XML parsers.

This package contains one module:

expat -- Python wrapper for James Clark's Expat parser, with namespace
         support.

N)οΏ½__doc__οΏ½rrοΏ½,/usr/lib64/python3.8/xml/parsers/__init__.pyοΏ½<module>οΏ½U

e5dοΏ½οΏ½@sdZdS)zοΏ½Python interfaces to XML parsers.

This package contains one module:

expat -- Python wrapper for James Clark's Expat parser, with namespace
         support.

N)οΏ½__doc__οΏ½rrοΏ½,/usr/lib64/python3.8/xml/parsers/__init__.pyοΏ½<module>οΏ½U

e5dοΏ½οΏ½@s(ddlZddlTeejd<eejd<dS)οΏ½N)οΏ½*zxml.parsers.expat.modelzxml.parsers.expat.errors)οΏ½sysZpyexpatZmodelοΏ½modulesοΏ½errorsοΏ½rrοΏ½)/usr/lib64/python3.8/xml/parsers/expat.pyοΏ½<module>s
"""Interface to the Expat non-validating XML parser."""
import sys

from pyexpat import *

# provide pyexpat submodules as xml.parsers.expat submodules
sys.modules['xml.parsers.expat.model'] = model
sys.modules['xml.parsers.expat.errors'] = errors
"""Python interfaces to XML parsers.

This package contains one module:

expat -- Python wrapper for James Clark's Expat parser, with namespace
         support.

"""
"""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):
        return self.toprettyxml("", "", encoding)

    def toprettyxml(self, indent="\t", newl="\n", encoding=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)
        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 _in_document(node):
    # return True iff node is part of a document tree
    while node is not None:
        if node.nodeType == Node.DOCUMENT_NODE:
            return True
        node = node.parentNode
    return False

def _write_data(writer, data):
    "Writes datachars to writer."
    if data:
        data = data.replace("&", "&amp;").replace("<", "&lt;"). \
                    replace("\"", "&quot;").replace(">", "&gt;")
        writer.write(data)

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._name = qName
        self.namespaceURI = namespaceURI
        self._prefix = prefix
        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.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):
        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):
        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):
        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=""):
        # 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)
            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")


class ProcessingInstruction(Childless, Node):
    nodeType = Node.PROCESSING_INSTRUCTION_NODE
    __slots__ = ('target', 'data')

    def __init__(self, target, data):
        self.target = target
        self.data = data

    # nodeValue is an alias for data
    def _get_nodeValue(self):
        return self.data
    def _set_nodeValue(self, value):
        self.data = value
    nodeValue = property(_get_nodeValue, _set_nodeValue)

    # nodeName is an alias for target
    def _get_nodeName(self):
        return self.target
    def _set_nodeName(self, value):
        self.target = value
    nodeName = property(_get_nodeName, _set_nodeName)

    def writexml(self, writer, indent="", addindent="", newl=""):
        writer.write("%s<?%s %s?>%s" % (indent,self.target, self.data, newl))


class CharacterData(Childless, Node):
    __slots__=('_data', 'ownerDocument','parentNode', 'previousSibling', 'nextSibling')

    def __init__(self):
        self.ownerDocument = self.parentNode = None
        self.previousSibling = self.nextSibling = None
        self._data = ''
        Node.__init__(self)

    def _get_length(self):
        return len(self.data)
    __len__ = _get_length

    def _get_data(self):
        return self._data
    def _set_data(self, data):
        self._data = data

    data = nodeValue = property(_get_data, _set_data)

    def __repr__(self):
        data = self.data
        if len(data) > 10:
            dotdotdot = "..."
        else:
            dotdotdot = ""
        return '<DOM %s node "%r%s">' % (
            self.__class__.__name__, data[0:10], dotdotdot)

    def substringData(self, offset, count):
        if offset < 0:
            raise xml.dom.IndexSizeErr("offset cannot be negative")
        if offset >= len(self.data):
            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
        if count < 0:
            raise xml.dom.IndexSizeErr("count cannot be negative")
        return self.data[offset:offset+count]

    def appendData(self, arg):
        self.data = self.data + arg

    def insertData(self, offset, arg):
        if offset < 0:
            raise xml.dom.IndexSizeErr("offset cannot be negative")
        if offset >= len(self.data):
            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
        if arg:
            self.data = "%s%s%s" % (
                self.data[:offset], arg, self.data[offset:])

    def deleteData(self, offset, count):
        if offset < 0:
            raise xml.dom.IndexSizeErr("offset cannot be negative")
        if offset >= len(self.data):
            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
        if count < 0:
            raise xml.dom.IndexSizeErr("count cannot be negative")
        if count:
            self.data = self.data[:offset] + self.data[offset+count:]

    def replaceData(self, offset, count, arg):
        if offset < 0:
            raise xml.dom.IndexSizeErr("offset cannot be negative")
        if offset >= len(self.data):
            raise xml.dom.IndexSizeErr("offset cannot be beyond end of data")
        if count < 0:
            raise xml.dom.IndexSizeErr("count cannot be negative")
        if count:
            self.data = "%s%s%s" % (
                self.data[:offset], arg, self.data[offset+count:])

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


class Text(CharacterData):
    __slots__ = ()

    nodeType = Node.TEXT_NODE
    nodeName = "#text"
    attributes = None

    def splitText(self, offset):
        if offset < 0 or offset > len(self.data):
            raise xml.dom.IndexSizeErr("illegal offset value")
        newText = self.__class__()
        newText.data = self.data[offset:]
        newText.ownerDocument = self.ownerDocument
        next = self.nextSibling
        if self.parentNode and self in self.parentNode.childNodes:
            if next is None:
                self.parentNode.appendChild(newText)
            else:
                self.parentNode.insertBefore(newText, next)
        self.data = self.data[:offset]
        return newText

    def writexml(self, writer, indent="", addindent="", newl=""):
        _write_data(writer, "%s%s%s" % (indent, self.data, newl))

    # DOM Level 3 (WD 9 April 2002)

    def _get_wholeText(self):
        L = [self.data]
        n = self.previousSibling
        while n is not None:
            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                L.insert(0, n.data)
                n = n.previousSibling
            else:
                break
        n = self.nextSibling
        while n is not None:
            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                L.append(n.data)
                n = n.nextSibling
            else:
                break
        return ''.join(L)

    def replaceWholeText(self, content):
        # XXX This needs to be seriously changed if minidom ever
        # supports EntityReference nodes.
        parent = self.parentNode
        n = self.previousSibling
        while n is not None:
            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                next = n.previousSibling
                parent.removeChild(n)
                n = next
            else:
                break
        n = self.nextSibling
        if not content:
            parent.removeChild(self)
        while n is not None:
            if n.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
                next = n.nextSibling
                parent.removeChild(n)
                n = next
            else:
                break
        if content:
            self.data = content
            return self
        else:
            return None

    def _get_isWhitespaceInElementContent(self):
        if self.data.strip():
            return False
        elem = _get_containing_element(self)
        if elem is None:
            return False
        info = self.ownerDocument._get_elem_info(elem)
        if info is None:
            return False
        else:
            return info.isElementContent()

defproperty(Text, "isWhitespaceInElementContent",
            doc="True iff this text node contains only whitespace"
                " and is in element content.")
defproperty(Text, "wholeText",
            doc="The text of all logically-adjacent text nodes.")


def _get_containing_element(node):
    c = node.parentNode
    while c is not None:
        if c.nodeType == Node.ELEMENT_NODE:
            return c
        c = c.parentNode
    return None

def _get_containing_entref(node):
    c = node.parentNode
    while c is not None:
        if c.nodeType == Node.ENTITY_REFERENCE_NODE:
            return c
        c = c.parentNode
    return None


class Comment(CharacterData):
    nodeType = Node.COMMENT_NODE
    nodeName = "#comment"

    def __init__(self, data):
        CharacterData.__init__(self)
        self._data = data

    def writexml(self, writer, indent="", addindent="", newl=""):
        if "--" in self.data:
            raise ValueError("'--' is not allowed in a comment node")
        writer.write("%s<!--%s-->%s" % (indent, self.data, newl))


class CDATASection(Text):
    __slots__ = ()

    nodeType = Node.CDATA_SECTION_NODE
    nodeName = "#cdata-section"

    def writexml(self, writer, indent="", addindent="", newl=""):
        if self.data.find("]]>") >= 0:
            raise ValueError("']]>' not allowed in a CDATA section")
        writer.write("<![CDATA[%s]]>" % self.data)


class ReadOnlySequentialNamedNodeMap(object):
    __slots__ = '_seq',

    def __init__(self, seq=()):
        # seq should be a list or tuple
        self._seq = seq

    def __len__(self):
        return len(self._seq)

    def _get_length(self):
        return len(self._seq)

    def getNamedItem(self, name):
        for n in self._seq:
            if n.nodeName == name:
                return n

    def getNamedItemNS(self, namespaceURI, localName):
        for n in self._seq:
            if n.namespaceURI == namespaceURI and n.localName == localName:
                return n

    def __getitem__(self, name_or_tuple):
        if isinstance(name_or_tuple, tuple):
            node = self.getNamedItemNS(*name_or_tuple)
        else:
            node = self.getNamedItem(name_or_tuple)
        if node is None:
            raise KeyError(name_or_tuple)
        return node

    def item(self, index):
        if index < 0:
            return None
        try:
            return self._seq[index]
        except IndexError:
            return None

    def removeNamedItem(self, name):
        raise xml.dom.NoModificationAllowedErr(
            "NamedNodeMap instance is read-only")

    def removeNamedItemNS(self, namespaceURI, localName):
        raise xml.dom.NoModificationAllowedErr(
            "NamedNodeMap instance is read-only")

    def setNamedItem(self, node):
        raise xml.dom.NoModificationAllowedErr(
            "NamedNodeMap instance is read-only")

    def setNamedItemNS(self, node):
        raise xml.dom.NoModificationAllowedErr(
            "NamedNodeMap instance is read-only")

    def __getstate__(self):
        return [self._seq]

    def __setstate__(self, state):
        self._seq = state[0]

defproperty(ReadOnlySequentialNamedNodeMap, "length",
            doc="Number of entries in the NamedNodeMap.")


class Identified:
    """Mix-in class that supports the publicId and systemId attributes."""

    __slots__ = 'publicId', 'systemId'

    def _identified_mixin_init(self, publicId, systemId):
        self.publicId = publicId
        self.systemId = systemId

    def _get_publicId(self):
        return self.publicId

    def _get_systemId(self):
        return self.systemId

class DocumentType(Identified, Childless, Node):
    nodeType = Node.DOCUMENT_TYPE_NODE
    nodeValue = None
    name = None
    publicId = None
    systemId = None
    internalSubset = None

    def __init__(self, qualifiedName):
        self.entities = ReadOnlySequentialNamedNodeMap()
        self.notations = ReadOnlySequentialNamedNodeMap()
        if qualifiedName:
            prefix, localname = _nssplit(qualifiedName)
            self.name = localname
        self.nodeName = self.name

    def _get_internalSubset(self):
        return self.internalSubset

    def cloneNode(self, deep):
        if self.ownerDocument is None:
            # it's ok
            clone = DocumentType(None)
            clone.name = self.name
            clone.nodeName = self.name
            operation = xml.dom.UserDataHandler.NODE_CLONED
            if deep:
                clone.entities._seq = []
                clone.notations._seq = []
                for n in self.notations._seq:
                    notation = Notation(n.nodeName, n.publicId, n.systemId)
                    clone.notations._seq.append(notation)
                    n._call_user_data_handler(operation, n, notation)
                for e in self.entities._seq:
                    entity = Entity(e.nodeName, e.publicId, e.systemId,
                                    e.notationName)
                    entity.actualEncoding = e.actualEncoding
                    entity.encoding = e.encoding
                    entity.version = e.version
                    clone.entities._seq.append(entity)
                    e._call_user_data_handler(operation, e, entity)
            self._call_user_data_handler(operation, self, clone)
            return clone
        else:
            return None

    def writexml(self, writer, indent="", addindent="", newl=""):
        writer.write("<!DOCTYPE ")
        writer.write(self.name)
        if self.publicId:
            writer.write("%s  PUBLIC '%s'%s  '%s'"
                         % (newl, self.publicId, newl, self.systemId))
        elif self.systemId:
            writer.write("%s  SYSTEM '%s'" % (newl, self.systemId))
        if self.internalSubset is not None:
            writer.write(" [")
            writer.write(self.internalSubset)
            writer.write("]")
        writer.write(">"+newl)

class Entity(Identified, Node):
    attributes = None
    nodeType = Node.ENTITY_NODE
    nodeValue = None

    actualEncoding = None
    encoding = None
    version = None

    def __init__(self, name, publicId, systemId, notation):
        self.nodeName = name
        self.notationName = notation
        self.childNodes = NodeList()
        self._identified_mixin_init(publicId, systemId)

    def _get_actualEncoding(self):
        return self.actualEncoding

    def _get_encoding(self):
        return self.encoding

    def _get_version(self):
        return self.version

    def appendChild(self, newChild):
        raise xml.dom.HierarchyRequestErr(
            "cannot append children to an entity node")

    def insertBefore(self, newChild, refChild):
        raise xml.dom.HierarchyRequestErr(
            "cannot insert children below an entity node")

    def removeChild(self, oldChild):
        raise xml.dom.HierarchyRequestErr(
            "cannot remove children from an entity node")

    def replaceChild(self, newChild, oldChild):
        raise xml.dom.HierarchyRequestErr(
            "cannot replace children of an entity node")

class Notation(Identified, Childless, Node):
    nodeType = Node.NOTATION_NODE
    nodeValue = None

    def __init__(self, name, publicId, systemId):
        self.nodeName = name
        self._identified_mixin_init(publicId, systemId)


class DOMImplementation(DOMImplementationLS):
    _features = [("core", "1.0"),
                 ("core", "2.0"),
                 ("core", None),
                 ("xml", "1.0"),
                 ("xml", "2.0"),
                 ("xml", None),
                 ("ls-load", "3.0"),
                 ("ls-load", None),
                 ]

    def hasFeature(self, feature, version):
        if version == "":
            version = None
        return (feature.lower(), version) in self._features

    def createDocument(self, namespaceURI, qualifiedName, doctype):
        if doctype and doctype.parentNode is not None:
            raise xml.dom.WrongDocumentErr(
                "doctype object owned by another DOM tree")
        doc = self._create_document()

        add_root_element = not (namespaceURI is None
                                and qualifiedName is None
                                and doctype is None)

        if not qualifiedName and add_root_element:
            # The spec is unclear what to raise here; SyntaxErr
            # would be the other obvious candidate. Since Xerces raises
            # InvalidCharacterErr, and since SyntaxErr is not listed
            # for createDocument, that seems to be the better choice.
            # XXX: need to check for illegal characters here and in
            # createElement.

            # DOM Level III clears this up when talking about the return value
            # of this function.  If namespaceURI, qName and DocType are
            # Null the document is returned without a document element
            # Otherwise if doctype or namespaceURI are not None
            # Then we go back to the above problem
            raise xml.dom.InvalidCharacterErr("Element with no name")

        if add_root_element:
            prefix, localname = _nssplit(qualifiedName)
            if prefix == "xml" \
               and namespaceURI != "http://www.w3.org/XML/1998/namespace":
                raise xml.dom.NamespaceErr("illegal use of 'xml' prefix")
            if prefix and not namespaceURI:
                raise xml.dom.NamespaceErr(
                    "illegal use of prefix without namespaces")
            element = doc.createElementNS(namespaceURI, qualifiedName)
            if doctype:
                doc.appendChild(doctype)
            doc.appendChild(element)

        if doctype:
            doctype.parentNode = doctype.ownerDocument = doc

        doc.doctype = doctype
        doc.implementation = self
        return doc

    def createDocumentType(self, qualifiedName, publicId, systemId):
        doctype = DocumentType(qualifiedName)
        doctype.publicId = publicId
        doctype.systemId = systemId
        return doctype

    # DOM Level 3 (WD 9 April 2002)

    def getInterface(self, feature):
        if self.hasFeature(feature, None):
            return self
        else:
            return None

    # internal
    def _create_document(self):
        return Document()

class ElementInfo(object):
    """Object that represents content-model information for an element.

    This implementation is not expected to be used in practice; DOM
    builders should provide implementations which do the right thing
    using information available to it.

    """

    __slots__ = 'tagName',

    def __init__(self, name):
        self.tagName = name

    def getAttributeType(self, aname):
        return _no_type

    def getAttributeTypeNS(self, namespaceURI, localName):
        return _no_type

    def isElementContent(self):
        return False

    def isEmpty(self):
        """Returns true iff this element is declared to have an EMPTY
        content model."""
        return False

    def isId(self, aname):
        """Returns true iff the named attribute is a DTD-style ID."""
        return False

    def isIdNS(self, namespaceURI, localName):
        """Returns true iff the identified attribute is a DTD-style ID."""
        return False

    def __getstate__(self):
        return self.tagName

    def __setstate__(self, state):
        self.tagName = state

def _clear_id_cache(node):
    if node.nodeType == Node.DOCUMENT_NODE:
        node._id_cache.clear()
        node._id_search_stack = None
    elif _in_document(node):
        node.ownerDocument._id_cache.clear()
        node.ownerDocument._id_search_stack= None

class Document(Node, DocumentLS):
    __slots__ = ('_elem_info', 'doctype',
                 '_id_search_stack', 'childNodes', '_id_cache')
    _child_node_types = (Node.ELEMENT_NODE, Node.PROCESSING_INSTRUCTION_NODE,
                         Node.COMMENT_NODE, Node.DOCUMENT_TYPE_NODE)

    implementation = DOMImplementation()
    nodeType = Node.DOCUMENT_NODE
    nodeName = "#document"
    nodeValue = None
    attributes = None
    parentNode = None
    previousSibling = nextSibling = None


    # Document attributes from Level 3 (WD 9 April 2002)

    actualEncoding = None
    encoding = None
    standalone = None
    version = None
    strictErrorChecking = False
    errorHandler = None
    documentURI = None

    _magic_id_count = 0

    def __init__(self):
        self.doctype = None
        self.childNodes = NodeList()
        # mapping of (namespaceURI, localName) -> ElementInfo
        #        and tagName -> ElementInfo
        self._elem_info = {}
        self._id_cache = {}
        self._id_search_stack = None

    def _get_elem_info(self, element):
        if element.namespaceURI:
            key = element.namespaceURI, element.localName
        else:
            key = element.tagName
        return self._elem_info.get(key)

    def _get_actualEncoding(self):
        return self.actualEncoding

    def _get_doctype(self):
        return self.doctype

    def _get_documentURI(self):
        return self.documentURI

    def _get_encoding(self):
        return self.encoding

    def _get_errorHandler(self):
        return self.errorHandler

    def _get_standalone(self):
        return self.standalone

    def _get_strictErrorChecking(self):
        return self.strictErrorChecking

    def _get_version(self):
        return self.version

    def appendChild(self, node):
        if node.nodeType not in self._child_node_types:
            raise xml.dom.HierarchyRequestErr(
                "%s cannot be child of %s" % (repr(node), repr(self)))
        if node.parentNode is not None:
            # This needs to be done before the next test since this
            # may *be* the document element, in which case it should
            # end up re-ordered to the end.
            node.parentNode.removeChild(node)

        if node.nodeType == Node.ELEMENT_NODE \
           and self._get_documentElement():
            raise xml.dom.HierarchyRequestErr(
                "two document elements disallowed")
        return Node.appendChild(self, node)

    def removeChild(self, oldChild):
        try:
            self.childNodes.remove(oldChild)
        except ValueError:
            raise xml.dom.NotFoundErr()
        oldChild.nextSibling = oldChild.previousSibling = None
        oldChild.parentNode = None
        if self.documentElement is oldChild:
            self.documentElement = None

        return oldChild

    def _get_documentElement(self):
        for node in self.childNodes:
            if node.nodeType == Node.ELEMENT_NODE:
                return node

    def unlink(self):
        if self.doctype is not None:
            self.doctype.unlink()
            self.doctype = None
        Node.unlink(self)

    def cloneNode(self, deep):
        if not deep:
            return None
        clone = self.implementation.createDocument(None, None, None)
        clone.encoding = self.encoding
        clone.standalone = self.standalone
        clone.version = self.version
        for n in self.childNodes:
            childclone = _clone_node(n, deep, clone)
            assert childclone.ownerDocument.isSameNode(clone)
            clone.childNodes.append(childclone)
            if childclone.nodeType == Node.DOCUMENT_NODE:
                assert clone.documentElement is None
            elif childclone.nodeType == Node.DOCUMENT_TYPE_NODE:
                assert clone.doctype is None
                clone.doctype = childclone
            childclone.parentNode = clone
        self._call_user_data_handler(xml.dom.UserDataHandler.NODE_CLONED,
                                     self, clone)
        return clone

    def createDocumentFragment(self):
        d = DocumentFragment()
        d.ownerDocument = self
        return d

    def createElement(self, tagName):
        e = Element(tagName)
        e.ownerDocument = self
        return e

    def createTextNode(self, data):
        if not isinstance(data, str):
            raise TypeError("node contents must be a string")
        t = Text()
        t.data = data
        t.ownerDocument = self
        return t

    def createCDATASection(self, data):
        if not isinstance(data, str):
            raise TypeError("node contents must be a string")
        c = CDATASection()
        c.data = data
        c.ownerDocument = self
        return c

    def createComment(self, data):
        c = Comment(data)
        c.ownerDocument = self
        return c

    def createProcessingInstruction(self, target, data):
        p = ProcessingInstruction(target, data)
        p.ownerDocument = self
        return p

    def createAttribute(self, qName):
        a = Attr(qName)
        a.ownerDocument = self
        a.value = ""
        return a

    def createElementNS(self, namespaceURI, qualifiedName):
        prefix, localName = _nssplit(qualifiedName)
        e = Element(qualifiedName, namespaceURI, prefix)
        e.ownerDocument = self
        return e

    def createAttributeNS(self, namespaceURI, qualifiedName):
        prefix, localName = _nssplit(qualifiedName)
        a = Attr(qualifiedName, namespaceURI, localName, prefix)
        a.ownerDocument = self
        a.value = ""
        return a

    # A couple of implementation-specific helpers to create node types
    # not supported by the W3C DOM specs:

    def _create_entity(self, name, publicId, systemId, notationName):
        e = Entity(name, publicId, systemId, notationName)
        e.ownerDocument = self
        return e

    def _create_notation(self, name, publicId, systemId):
        n = Notation(name, publicId, systemId)
        n.ownerDocument = self
        return n

    def getElementById(self, id):
        if id in self._id_cache:
            return self._id_cache[id]
        if not (self._elem_info or self._magic_id_count):
            return None

        stack = self._id_search_stack
        if stack is None:
            # we never searched before, or the cache has been cleared
            stack = [self.documentElement]
            self._id_search_stack = stack
        elif not stack:
            # Previous search was completed and cache is still valid;
            # no matching node.
            return None

        result = None
        while stack:
            node = stack.pop()
            # add child elements to stack for continued searching
            stack.extend([child for child in node.childNodes
                          if child.nodeType in _nodeTypes_with_children])
            # check this node
            info = self._get_elem_info(node)
            if info:
                # We have to process all ID attributes before
                # returning in order to get all the attributes set to
                # be IDs using Element.setIdAttribute*().
                for attr in node.attributes.values():
                    if attr.namespaceURI:
                        if info.isIdNS(attr.namespaceURI, attr.localName):
                            self._id_cache[attr.value] = node
                            if attr.value == id:
                                result = node
                            elif not node._magic_id_nodes:
                                break
                    elif info.isId(attr.name):
                        self._id_cache[attr.value] = node
                        if attr.value == id:
                            result = node
                        elif not node._magic_id_nodes:
                            break
                    elif attr._is_id:
                        self._id_cache[attr.value] = node
                        if attr.value == id:
                            result = node
                        elif node._magic_id_nodes == 1:
                            break
            elif node._magic_id_nodes:
                for attr in node.attributes.values():
                    if attr._is_id:
                        self._id_cache[attr.value] = node
                        if attr.value == id:
                            result = node
            if result is not None:
                break
        return result

    def getElementsByTagName(self, 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 isSupported(self, feature, version):
        return self.implementation.hasFeature(feature, version)

    def importNode(self, node, deep):
        if node.nodeType == Node.DOCUMENT_NODE:
            raise xml.dom.NotSupportedErr("cannot import document nodes")
        elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
            raise xml.dom.NotSupportedErr("cannot import document type nodes")
        return _clone_node(node, deep, self)

    def writexml(self, writer, indent="", addindent="", newl="", encoding=None):
        if encoding is None:
            writer.write('<?xml version="1.0" ?>'+newl)
        else:
            writer.write('<?xml version="1.0" encoding="%s"?>%s' % (
                encoding, newl))
        for node in self.childNodes:
            node.writexml(writer, indent, addindent, newl)

    # DOM Level 3 (WD 9 April 2002)

    def renameNode(self, n, namespaceURI, name):
        if n.ownerDocument is not self:
            raise xml.dom.WrongDocumentErr(
                "cannot rename nodes from other documents;\n"
                "expected %s,\nfound %s" % (self, n.ownerDocument))
        if n.nodeType not in (Node.ELEMENT_NODE, Node.ATTRIBUTE_NODE):
            raise xml.dom.NotSupportedErr(
                "renameNode() only applies to element and attribute nodes")
        if namespaceURI != EMPTY_NAMESPACE:
            if ':' in name:
                prefix, localName = name.split(':', 1)
                if (  prefix == "xmlns"
                      and namespaceURI != xml.dom.XMLNS_NAMESPACE):
                    raise xml.dom.NamespaceErr(
                        "illegal use of 'xmlns' prefix")
            else:
                if (  name == "xmlns"
                      and namespaceURI != xml.dom.XMLNS_NAMESPACE
                      and n.nodeType == Node.ATTRIBUTE_NODE):
                    raise xml.dom.NamespaceErr(
                        "illegal use of the 'xmlns' attribute")
                prefix = None
                localName = name
        else:
            prefix = None
            localName = None
        if n.nodeType == Node.ATTRIBUTE_NODE:
            element = n.ownerElement
            if element is not None:
                is_id = n._is_id
                element.removeAttributeNode(n)
        else:
            element = None
        n.prefix = prefix
        n._localName = localName
        n.namespaceURI = namespaceURI
        n.nodeName = name
        if n.nodeType == Node.ELEMENT_NODE:
            n.tagName = name
        else:
            # attribute node
            n.name = name
            if element is not None:
                element.setAttributeNode(n)
                if is_id:
                    element.setIdAttributeNode(n)
        # It's not clear from a semantic perspective whether we should
        # call the user data handlers for the NODE_RENAMED event since
        # we're re-using the existing node.  The draft spec has been
        # interpreted as meaning "no, don't call the handler unless a
        # new node is created."
        return n

defproperty(Document, "documentElement",
            doc="Top-level element of this document.")


def _clone_node(node, deep, newOwnerDocument):
    """
    Clone a node and give it the new owner document.
    Called by Node.cloneNode and Document.importNode
    """
    if node.ownerDocument.isSameNode(newOwnerDocument):
        operation = xml.dom.UserDataHandler.NODE_CLONED
    else:
        operation = xml.dom.UserDataHandler.NODE_IMPORTED
    if node.nodeType == Node.ELEMENT_NODE:
        clone = newOwnerDocument.createElementNS(node.namespaceURI,
                                                 node.nodeName)
        for attr in node.attributes.values():
            clone.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value)
            a = clone.getAttributeNodeNS(attr.namespaceURI, attr.localName)
            a.specified = attr.specified

        if deep:
            for child in node.childNodes:
                c = _clone_node(child, deep, newOwnerDocument)
                clone.appendChild(c)

    elif node.nodeType == Node.DOCUMENT_FRAGMENT_NODE:
        clone = newOwnerDocument.createDocumentFragment()
        if deep:
            for child in node.childNodes:
                c = _clone_node(child, deep, newOwnerDocument)
                clone.appendChild(c)

    elif node.nodeType == Node.TEXT_NODE:
        clone = newOwnerDocument.createTextNode(node.data)
    elif node.nodeType == Node.CDATA_SECTION_NODE:
        clone = newOwnerDocument.createCDATASection(node.data)
    elif node.nodeType == Node.PROCESSING_INSTRUCTION_NODE:
        clone = newOwnerDocument.createProcessingInstruction(node.target,
                                                             node.data)
    elif node.nodeType == Node.COMMENT_NODE:
        clone = newOwnerDocument.createComment(node.data)
    elif node.nodeType == Node.ATTRIBUTE_NODE:
        clone = newOwnerDocument.createAttributeNS(node.namespaceURI,
                                                   node.nodeName)
        clone.specified = True
        clone.value = node.value
    elif node.nodeType == Node.DOCUMENT_TYPE_NODE:
        assert node.ownerDocument is not newOwnerDocument
        operation = xml.dom.UserDataHandler.NODE_IMPORTED
        clone = newOwnerDocument.implementation.createDocumentType(
            node.name, node.publicId, node.systemId)
        clone.ownerDocument = newOwnerDocument
        if deep:
            clone.entities._seq = []
            clone.notations._seq = []
            for n in node.notations._seq:
                notation = Notation(n.nodeName, n.publicId, n.systemId)
                notation.ownerDocument = newOwnerDocument
                clone.notations._seq.append(notation)
                if hasattr(n, '_call_user_data_handler'):
                    n._call_user_data_handler(operation, n, notation)
            for e in node.entities._seq:
                entity = Entity(e.nodeName, e.publicId, e.systemId,
                                e.notationName)
                entity.actualEncoding = e.actualEncoding
                entity.encoding = e.encoding
                entity.version = e.version
                entity.ownerDocument = newOwnerDocument
                clone.entities._seq.append(entity)
                if hasattr(e, '_call_user_data_handler'):
                    e._call_user_data_handler(operation, e, entity)
    else:
        # Note the cloning of Document and DocumentType nodes is
        # implementation specific.  minidom handles those cases
        # directly in the cloneNode() methods.
        raise xml.dom.NotSupportedErr("Cannot clone node %s" % repr(node))

    # Check for _call_user_data_handler() since this could conceivably
    # used with other DOM implementations (one of the FourThought
    # DOMs, perhaps?).
    if hasattr(node, '_call_user_data_handler'):
        node._call_user_data_handler(operation, node, clone)
    return clone


def _nssplit(qualifiedName):
    fields = qualifiedName.split(':', 1)
    if len(fields) == 2:
        return fields
    else:
        return (None, fields[0])


def _do_pulldom_parse(func, args, kwargs):
    events = func(*args, **kwargs)
    toktype, rootNode = events.getEvent()
    events.expandNode(rootNode)
    events.clear()
    return rootNode

def parse(file, parser=None, bufsize=None):
    """Parse a file into a DOM by filename or file object."""
    if parser is None and not bufsize:
        from xml.dom import expatbuilder
        return expatbuilder.parse(file)
    else:
        from xml.dom import pulldom
        return _do_pulldom_parse(pulldom.parse, (file,),
            {'parser': parser, 'bufsize': bufsize})

def parseString(string, parser=None):
    """Parse a file into a DOM from a string."""
    if parser is None:
        from xml.dom import expatbuilder
        return expatbuilder.parseString(string)
    else:
        from xml.dom import pulldom
        return _do_pulldom_parse(pulldom.parseString, (string,),
                                 {'parser': parser})

def getDOMImplementation(features=None):
    if features:
        if isinstance(features, str):
            features = domreg._parse_feature_string(features)
        for f, v in features:
            if not Document.implementation.hasFeature(f, v):
                return None
    return Document.implementation
"""Python version compatibility support for minidom.

This module contains internal implementation details and
should not be imported; use xml.dom.minidom instead.
"""

# This module should only be imported using "import *".
#
# The following names are defined:
#
#   NodeList      -- lightest possible NodeList implementation
#
#   EmptyNodeList -- lightest possible NodeList that is guaranteed to
#                    remain empty (immutable)
#
#   StringTypes   -- tuple of defined string types
#
#   defproperty   -- function used in conjunction with GetattrMagic;
#                    using these together is needed to make them work
#                    as efficiently as possible in both Python 2.2+
#                    and older versions.  For example:
#
#                        class MyClass(GetattrMagic):
#                            def _get_myattr(self):
#                                return something
#
#                        defproperty(MyClass, "myattr",
#                                    "return some value")
#
#                    For Python 2.2 and newer, this will construct a
#                    property object on the class, which avoids
#                    needing to override __getattr__().  It will only
#                    work for read-only attributes.
#
#                    For older versions of Python, inheriting from
#                    GetattrMagic will use the traditional
#                    __getattr__() hackery to achieve the same effect,
#                    but less efficiently.
#
#                    defproperty() should be used for each version of
#                    the relevant _get_<property>() function.

__all__ = ["NodeList", "EmptyNodeList", "StringTypes", "defproperty"]

import xml.dom

StringTypes = (str,)


class NodeList(list):
    __slots__ = ()

    def item(self, index):
        if 0 <= index < len(self):
            return self[index]

    def _get_length(self):
        return len(self)

    def _set_length(self, value):
        raise xml.dom.NoModificationAllowedErr(
            "attempt to modify read-only attribute 'length'")

    length = property(_get_length, _set_length,
                      doc="The number of nodes in the NodeList.")

    # For backward compatibility
    def __setstate__(self, state):
        if state is None:
            state = []
        self[:] = state


class EmptyNodeList(tuple):
    __slots__ = ()

    def __add__(self, other):
        NL = NodeList()
        NL.extend(other)
        return NL

    def __radd__(self, other):
        NL = NodeList()
        NL.extend(other)
        return NL

    def item(self, index):
        return None

    def _get_length(self):
        return 0

    def _set_length(self, value):
        raise xml.dom.NoModificationAllowedErr(
            "attempt to modify read-only attribute 'length'")

    length = property(_get_length, _set_length,
                      doc="The number of nodes in the NodeList.")


def defproperty(klass, name, doc):
    get = getattr(klass, ("_get_" + name))
    def set(self, value, name=name):
        raise xml.dom.NoModificationAllowedErr(
            "attempt to modify read-only attribute " + repr(name))
    assert not hasattr(klass, "_set_" + name), \
           "expected not to find _set_" + name
    prop = property(get, set, doc=doc)
    setattr(klass, name, prop)
"""Implementation of the DOM Level 3 'LS-Load' feature."""

import copy
import warnings
import xml.dom

from xml.dom.NodeFilter import NodeFilter


__all__ = ["DOMBuilder", "DOMEntityResolver", "DOMInputSource"]


class Options:
    """Features object that has variables set for each DOMBuilder feature.

    The DOMBuilder class uses an instance of this class to pass settings to
    the ExpatBuilder class.
    """

    # Note that the DOMBuilder class in LoadSave constrains which of these
    # values can be set using the DOM Level 3 LoadSave feature.

    namespaces = 1
    namespace_declarations = True
    validation = False
    external_parameter_entities = True
    external_general_entities = True
    external_dtd_subset = True
    validate_if_schema = False
    validate = False
    datatype_normalization = False
    create_entity_ref_nodes = True
    entities = True
    whitespace_in_element_content = True
    cdata_sections = True
    comments = True
    charset_overrides_xml_encoding = True
    infoset = False
    supported_mediatypes_only = False

    errorHandler = None
    filter = None


class DOMBuilder:
    entityResolver = None
    errorHandler = None
    filter = None

    ACTION_REPLACE = 1
    ACTION_APPEND_AS_CHILDREN = 2
    ACTION_INSERT_AFTER = 3
    ACTION_INSERT_BEFORE = 4

    _legal_actions = (ACTION_REPLACE, ACTION_APPEND_AS_CHILDREN,
                      ACTION_INSERT_AFTER, ACTION_INSERT_BEFORE)

    def __init__(self):
        self._options = Options()

    def _get_entityResolver(self):
        return self.entityResolver
    def _set_entityResolver(self, entityResolver):
        self.entityResolver = entityResolver

    def _get_errorHandler(self):
        return self.errorHandler
    def _set_errorHandler(self, errorHandler):
        self.errorHandler = errorHandler

    def _get_filter(self):
        return self.filter
    def _set_filter(self, filter):
        self.filter = filter

    def setFeature(self, name, state):
        if self.supportsFeature(name):
            state = state and 1 or 0
            try:
                settings = self._settings[(_name_xform(name), state)]
            except KeyError:
                raise xml.dom.NotSupportedErr(
                    "unsupported feature: %r" % (name,)) from None
            else:
                for name, value in settings:
                    setattr(self._options, name, value)
        else:
            raise xml.dom.NotFoundErr("unknown feature: " + repr(name))

    def supportsFeature(self, name):
        return hasattr(self._options, _name_xform(name))

    def canSetFeature(self, name, state):
        key = (_name_xform(name), state and 1 or 0)
        return key in self._settings

    # This dictionary maps from (feature,value) to a list of
    # (option,value) pairs that should be set on the Options object.
    # If a (feature,value) setting is not in this dictionary, it is
    # not supported by the DOMBuilder.
    #
    _settings = {
        ("namespace_declarations", 0): [
            ("namespace_declarations", 0)],
        ("namespace_declarations", 1): [
            ("namespace_declarations", 1)],
        ("validation", 0): [
            ("validation", 0)],
        ("external_general_entities", 0): [
            ("external_general_entities", 0)],
        ("external_general_entities", 1): [
            ("external_general_entities", 1)],
        ("external_parameter_entities", 0): [
            ("external_parameter_entities", 0)],
        ("external_parameter_entities", 1): [
            ("external_parameter_entities", 1)],
        ("validate_if_schema", 0): [
            ("validate_if_schema", 0)],
        ("create_entity_ref_nodes", 0): [
            ("create_entity_ref_nodes", 0)],
        ("create_entity_ref_nodes", 1): [
            ("create_entity_ref_nodes", 1)],
        ("entities", 0): [
            ("create_entity_ref_nodes", 0),
            ("entities", 0)],
        ("entities", 1): [
            ("entities", 1)],
        ("whitespace_in_element_content", 0): [
            ("whitespace_in_element_content", 0)],
        ("whitespace_in_element_content", 1): [
            ("whitespace_in_element_content", 1)],
        ("cdata_sections", 0): [
            ("cdata_sections", 0)],
        ("cdata_sections", 1): [
            ("cdata_sections", 1)],
        ("comments", 0): [
            ("comments", 0)],
        ("comments", 1): [
            ("comments", 1)],
        ("charset_overrides_xml_encoding", 0): [
            ("charset_overrides_xml_encoding", 0)],
        ("charset_overrides_xml_encoding", 1): [
            ("charset_overrides_xml_encoding", 1)],
        ("infoset", 0): [],
        ("infoset", 1): [
            ("namespace_declarations", 0),
            ("validate_if_schema", 0),
            ("create_entity_ref_nodes", 0),
            ("entities", 0),
            ("cdata_sections", 0),
            ("datatype_normalization", 1),
            ("whitespace_in_element_content", 1),
            ("comments", 1),
            ("charset_overrides_xml_encoding", 1)],
        ("supported_mediatypes_only", 0): [
            ("supported_mediatypes_only", 0)],
        ("namespaces", 0): [
            ("namespaces", 0)],
        ("namespaces", 1): [
            ("namespaces", 1)],
    }

    def getFeature(self, name):
        xname = _name_xform(name)
        try:
            return getattr(self._options, xname)
        except AttributeError:
            if name == "infoset":
                options = self._options
                return (options.datatype_normalization
                        and options.whitespace_in_element_content
                        and options.comments
                        and options.charset_overrides_xml_encoding
                        and not (options.namespace_declarations
                                 or options.validate_if_schema
                                 or options.create_entity_ref_nodes
                                 or options.entities
                                 or options.cdata_sections))
            raise xml.dom.NotFoundErr("feature %s not known" % repr(name))

    def parseURI(self, uri):
        if self.entityResolver:
            input = self.entityResolver.resolveEntity(None, uri)
        else:
            input = DOMEntityResolver().resolveEntity(None, uri)
        return self.parse(input)

    def parse(self, input):
        options = copy.copy(self._options)
        options.filter = self.filter
        options.errorHandler = self.errorHandler
        fp = input.byteStream
        if fp is None and options.systemId:
            import urllib.request
            fp = urllib.request.urlopen(input.systemId)
        return self._parse_bytestream(fp, options)

    def parseWithContext(self, input, cnode, action):
        if action not in self._legal_actions:
            raise ValueError("not a legal action")
        raise NotImplementedError("Haven't written this yet...")

    def _parse_bytestream(self, stream, options):
        import xml.dom.expatbuilder
        builder = xml.dom.expatbuilder.makeBuilder(options)
        return builder.parseFile(stream)


def _name_xform(name):
    return name.lower().replace('-', '_')


class DOMEntityResolver(object):
    __slots__ = '_opener',

    def resolveEntity(self, publicId, systemId):
        assert systemId is not None
        source = DOMInputSource()
        source.publicId = publicId
        source.systemId = systemId
        source.byteStream = self._get_opener().open(systemId)

        # determine the encoding if the transport provided it
        source.encoding = self._guess_media_encoding(source)

        # determine the base URI is we can
        import posixpath, urllib.parse
        parts = urllib.parse.urlparse(systemId)
        scheme, netloc, path, params, query, fragment = parts
        # XXX should we check the scheme here as well?
        if path and not path.endswith("/"):
            path = posixpath.dirname(path) + "/"
            parts = scheme, netloc, path, params, query, fragment
            source.baseURI = urllib.parse.urlunparse(parts)

        return source

    def _get_opener(self):
        try:
            return self._opener
        except AttributeError:
            self._opener = self._create_opener()
            return self._opener

    def _create_opener(self):
        import urllib.request
        return urllib.request.build_opener()

    def _guess_media_encoding(self, source):
        info = source.byteStream.info()
        if "Content-Type" in info:
            for param in info.getplist():
                if param.startswith("charset="):
                    return param.split("=", 1)[1].lower()


class DOMInputSource(object):
    __slots__ = ('byteStream', 'characterStream', 'stringData',
                 'encoding', 'publicId', 'systemId', 'baseURI')

    def __init__(self):
        self.byteStream = None
        self.characterStream = None
        self.stringData = None
        self.encoding = None
        self.publicId = None
        self.systemId = None
        self.baseURI = None

    def _get_byteStream(self):
        return self.byteStream
    def _set_byteStream(self, byteStream):
        self.byteStream = byteStream

    def _get_characterStream(self):
        return self.characterStream
    def _set_characterStream(self, characterStream):
        self.characterStream = characterStream

    def _get_stringData(self):
        return self.stringData
    def _set_stringData(self, data):
        self.stringData = data

    def _get_encoding(self):
        return self.encoding
    def _set_encoding(self, encoding):
        self.encoding = encoding

    def _get_publicId(self):
        return self.publicId
    def _set_publicId(self, publicId):
        self.publicId = publicId

    def _get_systemId(self):
        return self.systemId
    def _set_systemId(self, systemId):
        self.systemId = systemId

    def _get_baseURI(self):
        return self.baseURI
    def _set_baseURI(self, uri):
        self.baseURI = uri


class DOMBuilderFilter:
    """Element filter which can be used to tailor construction of
    a DOM instance.
    """

    # There's really no need for this class; concrete implementations
    # should just implement the endElement() and startElement()
    # methods as appropriate.  Using this makes it easy to only
    # implement one of them.

    FILTER_ACCEPT = 1
    FILTER_REJECT = 2
    FILTER_SKIP = 3
    FILTER_INTERRUPT = 4

    whatToShow = NodeFilter.SHOW_ALL

    def _get_whatToShow(self):
        return self.whatToShow

    def acceptNode(self, element):
        return self.FILTER_ACCEPT

    def startContainer(self, element):
        return self.FILTER_ACCEPT

del NodeFilter


class DocumentLS:
    """Mixin to create documents that conform to the load/save spec."""

    async_ = False

    def _get_async(self):
        return False

    def _set_async(self, flag):
        if flag:
            raise xml.dom.NotSupportedErr(
                "asynchronous document loading is not supported")

    def abort(self):
        # What does it mean to "clear" a document?  Does the
        # documentElement disappear?
        raise NotImplementedError(
            "haven't figured out what this means yet")

    def load(self, uri):
        raise NotImplementedError("haven't written this yet")

    def loadXML(self, source):
        raise NotImplementedError("haven't written this yet")

    def saveXML(self, snode):
        if snode is None:
            snode = self
        elif snode.ownerDocument is not self:
            raise xml.dom.WrongDocumentErr()
        return snode.toxml()


class DOMImplementationLS:
    MODE_SYNCHRONOUS = 1
    MODE_ASYNCHRONOUS = 2

    def createDOMBuilder(self, mode, schemaType):
        if schemaType is not None:
            raise xml.dom.NotSupportedErr(
                "schemaType not yet supported")
        if mode == self.MODE_SYNCHRONOUS:
            return DOMBuilder()
        if mode == self.MODE_ASYNCHRONOUS:
            raise xml.dom.NotSupportedErr(
                "asynchronous builders are not supported")
        raise ValueError("unknown value for mode")

    def createDOMWriter(self):
        raise NotImplementedError(
            "the writer interface hasn't been written yet!")

    def createDOMInputSource(self):
        return DOMInputSource()
"""Facility to use the Expat parser to load a minidom instance
from a string or file.

This avoids all the overhead of SAX and pulldom to gain performance.
"""

# Warning!
#
# This module is tightly bound to the implementation details of the
# minidom DOM and can't be used with other DOM implementations.  This
# is due, in part, to a lack of appropriate methods in the DOM (there is
# no way to create Entity and Notation nodes via the DOM Level 2
# interface), and for performance.  The latter is the cause of some fairly
# cryptic code.
#
# Performance hacks:
#
#   -  .character_data_handler() has an extra case in which continuing
#      data is appended to an existing Text node; this can be a
#      speedup since pyexpat can break up character data into multiple
#      callbacks even though we set the buffer_text attribute on the
#      parser.  This also gives us the advantage that we don't need a
#      separate normalization pass.
#
#   -  Determining that a node exists is done using an identity comparison
#      with None rather than a truth test; this avoids searching for and
#      calling any methods on the node object if it exists.  (A rather
#      nice speedup is achieved this way as well!)

from xml.dom import xmlbuilder, minidom, Node
from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE
from xml.parsers import expat
from xml.dom.minidom import _append_child, _set_attribute_node
from xml.dom.NodeFilter import NodeFilter

TEXT_NODE = Node.TEXT_NODE
CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE
DOCUMENT_NODE = Node.DOCUMENT_NODE

FILTER_ACCEPT = xmlbuilder.DOMBuilderFilter.FILTER_ACCEPT
FILTER_REJECT = xmlbuilder.DOMBuilderFilter.FILTER_REJECT
FILTER_SKIP = xmlbuilder.DOMBuilderFilter.FILTER_SKIP
FILTER_INTERRUPT = xmlbuilder.DOMBuilderFilter.FILTER_INTERRUPT

theDOMImplementation = minidom.getDOMImplementation()

# Expat typename -> TypeInfo
_typeinfo_map = {
    "CDATA":    minidom.TypeInfo(None, "cdata"),
    "ENUM":     minidom.TypeInfo(None, "enumeration"),
    "ENTITY":   minidom.TypeInfo(None, "entity"),
    "ENTITIES": minidom.TypeInfo(None, "entities"),
    "ID":       minidom.TypeInfo(None, "id"),
    "IDREF":    minidom.TypeInfo(None, "idref"),
    "IDREFS":   minidom.TypeInfo(None, "idrefs"),
    "NMTOKEN":  minidom.TypeInfo(None, "nmtoken"),
    "NMTOKENS": minidom.TypeInfo(None, "nmtokens"),
    }

class ElementInfo(object):
    __slots__ = '_attr_info', '_model', 'tagName'

    def __init__(self, tagName, model=None):
        self.tagName = tagName
        self._attr_info = []
        self._model = model

    def __getstate__(self):
        return self._attr_info, self._model, self.tagName

    def __setstate__(self, state):
        self._attr_info, self._model, self.tagName = state

    def getAttributeType(self, aname):
        for info in self._attr_info:
            if info[1] == aname:
                t = info[-2]
                if t[0] == "(":
                    return _typeinfo_map["ENUM"]
                else:
                    return _typeinfo_map[info[-2]]
        return minidom._no_type

    def getAttributeTypeNS(self, namespaceURI, localName):
        return minidom._no_type

    def isElementContent(self):
        if self._model:
            type = self._model[0]
            return type not in (expat.model.XML_CTYPE_ANY,
                                expat.model.XML_CTYPE_MIXED)
        else:
            return False

    def isEmpty(self):
        if self._model:
            return self._model[0] == expat.model.XML_CTYPE_EMPTY
        else:
            return False

    def isId(self, aname):
        for info in self._attr_info:
            if info[1] == aname:
                return info[-2] == "ID"
        return False

    def isIdNS(self, euri, ename, auri, aname):
        # not sure this is meaningful
        return self.isId((auri, aname))

def _intern(builder, s):
    return builder._intern_setdefault(s, s)

def _parse_ns_name(builder, name):
    assert ' ' in name
    parts = name.split(' ')
    intern = builder._intern_setdefault
    if len(parts) == 3:
        uri, localname, prefix = parts
        prefix = intern(prefix, prefix)
        qname = "%s:%s" % (prefix, localname)
        qname = intern(qname, qname)
        localname = intern(localname, localname)
    elif len(parts) == 2:
        uri, localname = parts
        prefix = EMPTY_PREFIX
        qname = localname = intern(localname, localname)
    else:
        raise ValueError("Unsupported syntax: spaces in URIs not supported: %r" % name)
    return intern(uri, uri), localname, prefix, qname


class ExpatBuilder:
    """Document builder that uses Expat to build a ParsedXML.DOM document
    instance."""

    def __init__(self, options=None):
        if options is None:
            options = xmlbuilder.Options()
        self._options = options
        if self._options.filter is not None:
            self._filter = FilterVisibilityController(self._options.filter)
        else:
            self._filter = None
            # This *really* doesn't do anything in this case, so
            # override it with something fast & minimal.
            self._finish_start_element = id
        self._parser = None
        self.reset()

    def createParser(self):
        """Create a new parser object."""
        return expat.ParserCreate()

    def getParser(self):
        """Return the parser object, creating a new one if needed."""
        if not self._parser:
            self._parser = self.createParser()
            self._intern_setdefault = self._parser.intern.setdefault
            self._parser.buffer_text = True
            self._parser.ordered_attributes = True
            self._parser.specified_attributes = True
            self.install(self._parser)
        return self._parser

    def reset(self):
        """Free all data structures used during DOM construction."""
        self.document = theDOMImplementation.createDocument(
            EMPTY_NAMESPACE, None, None)
        self.curNode = self.document
        self._elem_info = self.document._elem_info
        self._cdata = False

    def install(self, parser):
        """Install the callbacks needed to build the DOM into the parser."""
        # This creates circular references!
        parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler
        parser.StartElementHandler = self.first_element_handler
        parser.EndElementHandler = self.end_element_handler
        parser.ProcessingInstructionHandler = self.pi_handler
        if self._options.entities:
            parser.EntityDeclHandler = self.entity_decl_handler
        parser.NotationDeclHandler = self.notation_decl_handler
        if self._options.comments:
            parser.CommentHandler = self.comment_handler
        if self._options.cdata_sections:
            parser.StartCdataSectionHandler = self.start_cdata_section_handler
            parser.EndCdataSectionHandler = self.end_cdata_section_handler
            parser.CharacterDataHandler = self.character_data_handler_cdata
        else:
            parser.CharacterDataHandler = self.character_data_handler
        parser.ExternalEntityRefHandler = self.external_entity_ref_handler
        parser.XmlDeclHandler = self.xml_decl_handler
        parser.ElementDeclHandler = self.element_decl_handler
        parser.AttlistDeclHandler = self.attlist_decl_handler

    def parseFile(self, file):
        """Parse a document from a file object, returning the document
        node."""
        parser = self.getParser()
        first_buffer = True
        try:
            while 1:
                buffer = file.read(16*1024)
                if not buffer:
                    break
                parser.Parse(buffer, 0)
                if first_buffer and self.document.documentElement:
                    self._setup_subset(buffer)
                first_buffer = False
            parser.Parse("", True)
        except ParseEscape:
            pass
        doc = self.document
        self.reset()
        self._parser = None
        return doc

    def parseString(self, string):
        """Parse a document from a string, returning the document node."""
        parser = self.getParser()
        try:
            parser.Parse(string, True)
            self._setup_subset(string)
        except ParseEscape:
            pass
        doc = self.document
        self.reset()
        self._parser = None
        return doc

    def _setup_subset(self, buffer):
        """Load the internal subset if there might be one."""
        if self.document.doctype:
            extractor = InternalSubsetExtractor()
            extractor.parseString(buffer)
            subset = extractor.getSubset()
            self.document.doctype.internalSubset = subset

    def start_doctype_decl_handler(self, doctypeName, systemId, publicId,
                                   has_internal_subset):
        doctype = self.document.implementation.createDocumentType(
            doctypeName, publicId, systemId)
        doctype.ownerDocument = self.document
        _append_child(self.document, doctype)
        self.document.doctype = doctype
        if self._filter and self._filter.acceptNode(doctype) == FILTER_REJECT:
            self.document.doctype = None
            del self.document.childNodes[-1]
            doctype = None
            self._parser.EntityDeclHandler = None
            self._parser.NotationDeclHandler = None
        if has_internal_subset:
            if doctype is not None:
                doctype.entities._seq = []
                doctype.notations._seq = []
            self._parser.CommentHandler = None
            self._parser.ProcessingInstructionHandler = None
            self._parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler

    def end_doctype_decl_handler(self):
        if self._options.comments:
            self._parser.CommentHandler = self.comment_handler
        self._parser.ProcessingInstructionHandler = self.pi_handler
        if not (self._elem_info or self._filter):
            self._finish_end_element = id

    def pi_handler(self, target, data):
        node = self.document.createProcessingInstruction(target, data)
        _append_child(self.curNode, node)
        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:
            self.curNode.removeChild(node)

    def character_data_handler_cdata(self, data):
        childNodes = self.curNode.childNodes
        if self._cdata:
            if (  self._cdata_continue
                  and childNodes[-1].nodeType == CDATA_SECTION_NODE):
                childNodes[-1].appendData(data)
                return
            node = self.document.createCDATASection(data)
            self._cdata_continue = True
        elif childNodes and childNodes[-1].nodeType == TEXT_NODE:
            node = childNodes[-1]
            value = node.data + data
            node.data = value
            return
        else:
            node = minidom.Text()
            node.data = data
            node.ownerDocument = self.document
        _append_child(self.curNode, node)

    def character_data_handler(self, data):
        childNodes = self.curNode.childNodes
        if childNodes and childNodes[-1].nodeType == TEXT_NODE:
            node = childNodes[-1]
            node.data = node.data + data
            return
        node = minidom.Text()
        node.data = node.data + data
        node.ownerDocument = self.document
        _append_child(self.curNode, node)

    def entity_decl_handler(self, entityName, is_parameter_entity, value,
                            base, systemId, publicId, notationName):
        if is_parameter_entity:
            # we don't care about parameter entities for the DOM
            return
        if not self._options.entities:
            return
        node = self.document._create_entity(entityName, publicId,
                                            systemId, notationName)
        if value is not None:
            # internal entity
            # node *should* be readonly, but we'll cheat
            child = self.document.createTextNode(value)
            node.childNodes.append(child)
        self.document.doctype.entities._seq.append(node)
        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:
            del self.document.doctype.entities._seq[-1]

    def notation_decl_handler(self, notationName, base, systemId, publicId):
        node = self.document._create_notation(notationName, publicId, systemId)
        self.document.doctype.notations._seq.append(node)
        if self._filter and self._filter.acceptNode(node) == FILTER_ACCEPT:
            del self.document.doctype.notations._seq[-1]

    def comment_handler(self, data):
        node = self.document.createComment(data)
        _append_child(self.curNode, node)
        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:
            self.curNode.removeChild(node)

    def start_cdata_section_handler(self):
        self._cdata = True
        self._cdata_continue = False

    def end_cdata_section_handler(self):
        self._cdata = False
        self._cdata_continue = False

    def external_entity_ref_handler(self, context, base, systemId, publicId):
        return 1

    def first_element_handler(self, name, attributes):
        if self._filter is None and not self._elem_info:
            self._finish_end_element = id
        self.getParser().StartElementHandler = self.start_element_handler
        self.start_element_handler(name, attributes)

    def start_element_handler(self, name, attributes):
        node = self.document.createElement(name)
        _append_child(self.curNode, node)
        self.curNode = node

        if attributes:
            for i in range(0, len(attributes), 2):
                a = minidom.Attr(attributes[i], EMPTY_NAMESPACE,
                                 None, EMPTY_PREFIX)
                value = attributes[i+1]
                a.value = value
                a.ownerDocument = self.document
                _set_attribute_node(node, a)

        if node is not self.document.documentElement:
            self._finish_start_element(node)

    def _finish_start_element(self, node):
        if self._filter:
            # To be general, we'd have to call isSameNode(), but this
            # is sufficient for minidom:
            if node is self.document.documentElement:
                return
            filt = self._filter.startContainer(node)
            if filt == FILTER_REJECT:
                # ignore this node & all descendents
                Rejecter(self)
            elif filt == FILTER_SKIP:
                # ignore this node, but make it's children become
                # children of the parent node
                Skipper(self)
            else:
                return
            self.curNode = node.parentNode
            node.parentNode.removeChild(node)
            node.unlink()

    # If this ever changes, Namespaces.end_element_handler() needs to
    # be changed to match.
    #
    def end_element_handler(self, name):
        curNode = self.curNode
        self.curNode = curNode.parentNode
        self._finish_end_element(curNode)

    def _finish_end_element(self, curNode):
        info = self._elem_info.get(curNode.tagName)
        if info:
            self._handle_white_text_nodes(curNode, info)
        if self._filter:
            if curNode is self.document.documentElement:
                return
            if self._filter.acceptNode(curNode) == FILTER_REJECT:
                self.curNode.removeChild(curNode)
                curNode.unlink()

    def _handle_white_text_nodes(self, node, info):
        if (self._options.whitespace_in_element_content
            or not info.isElementContent()):
            return

        # We have element type information and should remove ignorable
        # whitespace; identify for text nodes which contain only
        # whitespace.
        L = []
        for child in node.childNodes:
            if child.nodeType == TEXT_NODE and not child.data.strip():
                L.append(child)

        # Remove ignorable whitespace from the tree.
        for child in L:
            node.removeChild(child)

    def element_decl_handler(self, name, model):
        info = self._elem_info.get(name)
        if info is None:
            self._elem_info[name] = ElementInfo(name, model)
        else:
            assert info._model is None
            info._model = model

    def attlist_decl_handler(self, elem, name, type, default, required):
        info = self._elem_info.get(elem)
        if info is None:
            info = ElementInfo(elem)
            self._elem_info[elem] = info
        info._attr_info.append(
            [None, name, None, None, default, 0, type, required])

    def xml_decl_handler(self, version, encoding, standalone):
        self.document.version = version
        self.document.encoding = encoding
        # This is still a little ugly, thanks to the pyexpat API. ;-(
        if standalone >= 0:
            if standalone:
                self.document.standalone = True
            else:
                self.document.standalone = False


# Don't include FILTER_INTERRUPT, since that's checked separately
# where allowed.
_ALLOWED_FILTER_RETURNS = (FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP)

class FilterVisibilityController(object):
    """Wrapper around a DOMBuilderFilter which implements the checks
    to make the whatToShow filter attribute work."""

    __slots__ = 'filter',

    def __init__(self, filter):
        self.filter = filter

    def startContainer(self, node):
        mask = self._nodetype_mask[node.nodeType]
        if self.filter.whatToShow & mask:
            val = self.filter.startContainer(node)
            if val == FILTER_INTERRUPT:
                raise ParseEscape
            if val not in _ALLOWED_FILTER_RETURNS:
                raise ValueError(
                      "startContainer() returned illegal value: " + repr(val))
            return val
        else:
            return FILTER_ACCEPT

    def acceptNode(self, node):
        mask = self._nodetype_mask[node.nodeType]
        if self.filter.whatToShow & mask:
            val = self.filter.acceptNode(node)
            if val == FILTER_INTERRUPT:
                raise ParseEscape
            if val == FILTER_SKIP:
                # move all child nodes to the parent, and remove this node
                parent = node.parentNode
                for child in node.childNodes[:]:
                    parent.appendChild(child)
                # node is handled by the caller
                return FILTER_REJECT
            if val not in _ALLOWED_FILTER_RETURNS:
                raise ValueError(
                      "acceptNode() returned illegal value: " + repr(val))
            return val
        else:
            return FILTER_ACCEPT

    _nodetype_mask = {
        Node.ELEMENT_NODE:                NodeFilter.SHOW_ELEMENT,
        Node.ATTRIBUTE_NODE:              NodeFilter.SHOW_ATTRIBUTE,
        Node.TEXT_NODE:                   NodeFilter.SHOW_TEXT,
        Node.CDATA_SECTION_NODE:          NodeFilter.SHOW_CDATA_SECTION,
        Node.ENTITY_REFERENCE_NODE:       NodeFilter.SHOW_ENTITY_REFERENCE,
        Node.ENTITY_NODE:                 NodeFilter.SHOW_ENTITY,
        Node.PROCESSING_INSTRUCTION_NODE: NodeFilter.SHOW_PROCESSING_INSTRUCTION,
        Node.COMMENT_NODE:                NodeFilter.SHOW_COMMENT,
        Node.DOCUMENT_NODE:               NodeFilter.SHOW_DOCUMENT,
        Node.DOCUMENT_TYPE_NODE:          NodeFilter.SHOW_DOCUMENT_TYPE,
        Node.DOCUMENT_FRAGMENT_NODE:      NodeFilter.SHOW_DOCUMENT_FRAGMENT,
        Node.NOTATION_NODE:               NodeFilter.SHOW_NOTATION,
        }


class FilterCrutch(object):
    __slots__ = '_builder', '_level', '_old_start', '_old_end'

    def __init__(self, builder):
        self._level = 0
        self._builder = builder
        parser = builder._parser
        self._old_start = parser.StartElementHandler
        self._old_end = parser.EndElementHandler
        parser.StartElementHandler = self.start_element_handler
        parser.EndElementHandler = self.end_element_handler

class Rejecter(FilterCrutch):
    __slots__ = ()

    def __init__(self, builder):
        FilterCrutch.__init__(self, builder)
        parser = builder._parser
        for name in ("ProcessingInstructionHandler",
                     "CommentHandler",
                     "CharacterDataHandler",
                     "StartCdataSectionHandler",
                     "EndCdataSectionHandler",
                     "ExternalEntityRefHandler",
                     ):
            setattr(parser, name, None)

    def start_element_handler(self, *args):
        self._level = self._level + 1

    def end_element_handler(self, *args):
        if self._level == 0:
            # restore the old handlers
            parser = self._builder._parser
            self._builder.install(parser)
            parser.StartElementHandler = self._old_start
            parser.EndElementHandler = self._old_end
        else:
            self._level = self._level - 1

class Skipper(FilterCrutch):
    __slots__ = ()

    def start_element_handler(self, *args):
        node = self._builder.curNode
        self._old_start(*args)
        if self._builder.curNode is not node:
            self._level = self._level + 1

    def end_element_handler(self, *args):
        if self._level == 0:
            # We're popping back out of the node we're skipping, so we
            # shouldn't need to do anything but reset the handlers.
            self._builder._parser.StartElementHandler = self._old_start
            self._builder._parser.EndElementHandler = self._old_end
            self._builder = None
        else:
            self._level = self._level - 1
            self._old_end(*args)


# framework document used by the fragment builder.
# Takes a string for the doctype, subset string, and namespace attrs string.

_FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID = \
    "http://xml.python.org/entities/fragment-builder/internal"

_FRAGMENT_BUILDER_TEMPLATE = (
    '''\
<!DOCTYPE wrapper
  %%s [
  <!ENTITY fragment-builder-internal
    SYSTEM "%s">
%%s
]>
<wrapper %%s
>&fragment-builder-internal;</wrapper>'''
    % _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID)


class FragmentBuilder(ExpatBuilder):
    """Builder which constructs document fragments given XML source
    text and a context node.

    The context node is expected to provide information about the
    namespace declarations which are in scope at the start of the
    fragment.
    """

    def __init__(self, context, options=None):
        if context.nodeType == DOCUMENT_NODE:
            self.originalDocument = context
            self.context = context
        else:
            self.originalDocument = context.ownerDocument
            self.context = context
        ExpatBuilder.__init__(self, options)

    def reset(self):
        ExpatBuilder.reset(self)
        self.fragment = None

    def parseFile(self, file):
        """Parse a document fragment from a file object, returning the
        fragment node."""
        return self.parseString(file.read())

    def parseString(self, string):
        """Parse a document fragment from a string, returning the
        fragment node."""
        self._source = string
        parser = self.getParser()
        doctype = self.originalDocument.doctype
        ident = ""
        if doctype:
            subset = doctype.internalSubset or self._getDeclarations()
            if doctype.publicId:
                ident = ('PUBLIC "%s" "%s"'
                         % (doctype.publicId, doctype.systemId))
            elif doctype.systemId:
                ident = 'SYSTEM "%s"' % doctype.systemId
        else:
            subset = ""
        nsattrs = self._getNSattrs() # get ns decls from node's ancestors
        document = _FRAGMENT_BUILDER_TEMPLATE % (ident, subset, nsattrs)
        try:
            parser.Parse(document, 1)
        except:
            self.reset()
            raise
        fragment = self.fragment
        self.reset()
##         self._parser = None
        return fragment

    def _getDeclarations(self):
        """Re-create the internal subset from the DocumentType node.

        This is only needed if we don't already have the
        internalSubset as a string.
        """
        doctype = self.context.ownerDocument.doctype
        s = ""
        if doctype:
            for i in range(doctype.notations.length):
                notation = doctype.notations.item(i)
                if s:
                    s = s + "\n  "
                s = "%s<!NOTATION %s" % (s, notation.nodeName)
                if notation.publicId:
                    s = '%s PUBLIC "%s"\n             "%s">' \
                        % (s, notation.publicId, notation.systemId)
                else:
                    s = '%s SYSTEM "%s">' % (s, notation.systemId)
            for i in range(doctype.entities.length):
                entity = doctype.entities.item(i)
                if s:
                    s = s + "\n  "
                s = "%s<!ENTITY %s" % (s, entity.nodeName)
                if entity.publicId:
                    s = '%s PUBLIC "%s"\n             "%s"' \
                        % (s, entity.publicId, entity.systemId)
                elif entity.systemId:
                    s = '%s SYSTEM "%s"' % (s, entity.systemId)
                else:
                    s = '%s "%s"' % (s, entity.firstChild.data)
                if entity.notationName:
                    s = "%s NOTATION %s" % (s, entity.notationName)
                s = s + ">"
        return s

    def _getNSattrs(self):
        return ""

    def external_entity_ref_handler(self, context, base, systemId, publicId):
        if systemId == _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID:
            # this entref is the one that we made to put the subtree
            # in; all of our given input is parsed in here.
            old_document = self.document
            old_cur_node = self.curNode
            parser = self._parser.ExternalEntityParserCreate(context)
            # put the real document back, parse into the fragment to return
            self.document = self.originalDocument
            self.fragment = self.document.createDocumentFragment()
            self.curNode = self.fragment
            try:
                parser.Parse(self._source, 1)
            finally:
                self.curNode = old_cur_node
                self.document = old_document
                self._source = None
            return -1
        else:
            return ExpatBuilder.external_entity_ref_handler(
                self, context, base, systemId, publicId)


class Namespaces:
    """Mix-in class for builders; adds support for namespaces."""

    def _initNamespaces(self):
        # list of (prefix, uri) ns declarations.  Namespace attrs are
        # constructed from this and added to the element's attrs.
        self._ns_ordered_prefixes = []

    def createParser(self):
        """Create a new namespace-handling parser."""
        parser = expat.ParserCreate(namespace_separator=" ")
        parser.namespace_prefixes = True
        return parser

    def install(self, parser):
        """Insert the namespace-handlers onto the parser."""
        ExpatBuilder.install(self, parser)
        if self._options.namespace_declarations:
            parser.StartNamespaceDeclHandler = (
                self.start_namespace_decl_handler)

    def start_namespace_decl_handler(self, prefix, uri):
        """Push this namespace declaration on our storage."""
        self._ns_ordered_prefixes.append((prefix, uri))

    def start_element_handler(self, name, attributes):
        if ' ' in name:
            uri, localname, prefix, qname = _parse_ns_name(self, name)
        else:
            uri = EMPTY_NAMESPACE
            qname = name
            localname = None
            prefix = EMPTY_PREFIX
        node = minidom.Element(qname, uri, prefix, localname)
        node.ownerDocument = self.document
        _append_child(self.curNode, node)
        self.curNode = node

        if self._ns_ordered_prefixes:
            for prefix, uri in self._ns_ordered_prefixes:
                if prefix:
                    a = minidom.Attr(_intern(self, 'xmlns:' + prefix),
                                     XMLNS_NAMESPACE, prefix, "xmlns")
                else:
                    a = minidom.Attr("xmlns", XMLNS_NAMESPACE,
                                     "xmlns", EMPTY_PREFIX)
                a.value = uri
                a.ownerDocument = self.document
                _set_attribute_node(node, a)
            del self._ns_ordered_prefixes[:]

        if attributes:
            node._ensure_attributes()
            _attrs = node._attrs
            _attrsNS = node._attrsNS
            for i in range(0, len(attributes), 2):
                aname = attributes[i]
                value = attributes[i+1]
                if ' ' in aname:
                    uri, localname, prefix, qname = _parse_ns_name(self, aname)
                    a = minidom.Attr(qname, uri, localname, prefix)
                    _attrs[qname] = a
                    _attrsNS[(uri, localname)] = a
                else:
                    a = minidom.Attr(aname, EMPTY_NAMESPACE,
                                     aname, EMPTY_PREFIX)
                    _attrs[aname] = a
                    _attrsNS[(EMPTY_NAMESPACE, aname)] = a
                a.ownerDocument = self.document
                a.value = value
                a.ownerElement = node

    if __debug__:
        # This only adds some asserts to the original
        # end_element_handler(), so we only define this when -O is not
        # used.  If changing one, be sure to check the other to see if
        # it needs to be changed as well.
        #
        def end_element_handler(self, name):
            curNode = self.curNode
            if ' ' in name:
                uri, localname, prefix, qname = _parse_ns_name(self, name)
                assert (curNode.namespaceURI == uri
                        and curNode.localName == localname
                        and curNode.prefix == prefix), \
                        "element stack messed up! (namespace)"
            else:
                assert curNode.nodeName == name, \
                       "element stack messed up - bad nodeName"
                assert curNode.namespaceURI == EMPTY_NAMESPACE, \
                       "element stack messed up - bad namespaceURI"
            self.curNode = curNode.parentNode
            self._finish_end_element(curNode)


class ExpatBuilderNS(Namespaces, ExpatBuilder):
    """Document builder that supports namespaces."""

    def reset(self):
        ExpatBuilder.reset(self)
        self._initNamespaces()


class FragmentBuilderNS(Namespaces, FragmentBuilder):
    """Fragment builder that supports namespaces."""

    def reset(self):
        FragmentBuilder.reset(self)
        self._initNamespaces()

    def _getNSattrs(self):
        """Return string of namespace attributes from this element and
        ancestors."""
        # XXX This needs to be re-written to walk the ancestors of the
        # context to build up the namespace information from
        # declarations, elements, and attributes found in context.
        # Otherwise we have to store a bunch more data on the DOM
        # (though that *might* be more reliable -- not clear).
        attrs = ""
        context = self.context
        L = []
        while context:
            if hasattr(context, '_ns_prefix_uri'):
                for prefix, uri in context._ns_prefix_uri.items():
                    # add every new NS decl from context to L and attrs string
                    if prefix in L:
                        continue
                    L.append(prefix)
                    if prefix:
                        declname = "xmlns:" + prefix
                    else:
                        declname = "xmlns"
                    if attrs:
                        attrs = "%s\n    %s='%s'" % (attrs, declname, uri)
                    else:
                        attrs = " %s='%s'" % (declname, uri)
            context = context.parentNode
        return attrs


class ParseEscape(Exception):
    """Exception raised to short-circuit parsing in InternalSubsetExtractor."""
    pass

class InternalSubsetExtractor(ExpatBuilder):
    """XML processor which can rip out the internal document type subset."""

    subset = None

    def getSubset(self):
        """Return the internal subset as a string."""
        return self.subset

    def parseFile(self, file):
        try:
            ExpatBuilder.parseFile(self, file)
        except ParseEscape:
            pass

    def parseString(self, string):
        try:
            ExpatBuilder.parseString(self, string)
        except ParseEscape:
            pass

    def install(self, parser):
        parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler
        parser.StartElementHandler = self.start_element_handler

    def start_doctype_decl_handler(self, name, publicId, systemId,
                                   has_internal_subset):
        if has_internal_subset:
            parser = self.getParser()
            self.subset = []
            parser.DefaultHandler = self.subset.append
            parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler
        else:
            raise ParseEscape()

    def end_doctype_decl_handler(self):
        s = ''.join(self.subset).replace('\r\n', '\n').replace('\r', '\n')
        self.subset = s
        raise ParseEscape()

    def start_element_handler(self, name, attrs):
        raise ParseEscape()


def parse(file, namespaces=True):
    """Parse a document, returning the resulting Document node.

    'file' may be either a file name or an open file object.
    """
    if namespaces:
        builder = ExpatBuilderNS()
    else:
        builder = ExpatBuilder()

    if isinstance(file, str):
        with open(file, 'rb') as fp:
            result = builder.parseFile(fp)
    else:
        result = builder.parseFile(file)
    return result


def parseString(string, namespaces=True):
    """Parse a document from a string, returning the resulting
    Document node.
    """
    if namespaces:
        builder = ExpatBuilderNS()
    else:
        builder = ExpatBuilder()
    return builder.parseString(string)


def parseFragment(file, context, namespaces=True):
    """Parse a fragment of a document, given the context from which it
    was originally extracted.  context should be the parent of the
    node(s) which are in the fragment.

    'file' may be either a file name or an open file object.
    """
    if namespaces:
        builder = FragmentBuilderNS(context)
    else:
        builder = FragmentBuilder(context)

    if isinstance(file, str):
        with open(file, 'rb') as fp:
            result = builder.parseFile(fp)
    else:
        result = builder.parseFile(file)
    return result


def parseFragmentString(string, context, namespaces=True):
    """Parse a fragment of a document from a string, given the context
    from which it was originally extracted.  context should be the
    parent of the node(s) which are in the fragment.
    """
    if namespaces:
        builder = FragmentBuilderNS(context)
    else:
        builder = FragmentBuilder(context)
    return builder.parseString(string)


def makeBuilder(options):
    """Create a builder based on an Options object."""
    if options.namespaces:
        return ExpatBuilderNS(options)
    else:
        return ExpatBuilder(options)
import xml.sax
import xml.sax.handler

START_ELEMENT = "START_ELEMENT"
END_ELEMENT = "END_ELEMENT"
COMMENT = "COMMENT"
START_DOCUMENT = "START_DOCUMENT"
END_DOCUMENT = "END_DOCUMENT"
PROCESSING_INSTRUCTION = "PROCESSING_INSTRUCTION"
IGNORABLE_WHITESPACE = "IGNORABLE_WHITESPACE"
CHARACTERS = "CHARACTERS"

class PullDOM(xml.sax.ContentHandler):
    _locator = None
    document = None

    def __init__(self, documentFactory=None):
        from xml.dom import XML_NAMESPACE
        self.documentFactory = documentFactory
        self.firstEvent = [None, None]
        self.lastEvent = self.firstEvent
        self.elementStack = []
        self.push = self.elementStack.append
        try:
            self.pop = self.elementStack.pop
        except AttributeError:
            # use class' pop instead
            pass
        self._ns_contexts = [{XML_NAMESPACE:'xml'}] # contains uri -> prefix dicts
        self._current_context = self._ns_contexts[-1]
        self.pending_events = []

    def pop(self):
        result = self.elementStack[-1]
        del self.elementStack[-1]
        return result

    def setDocumentLocator(self, locator):
        self._locator = locator

    def startPrefixMapping(self, prefix, uri):
        if not hasattr(self, '_xmlns_attrs'):
            self._xmlns_attrs = []
        self._xmlns_attrs.append((prefix or 'xmlns', uri))
        self._ns_contexts.append(self._current_context.copy())
        self._current_context[uri] = prefix or None

    def endPrefixMapping(self, prefix):
        self._current_context = self._ns_contexts.pop()

    def startElementNS(self, name, tagName , attrs):
        # Retrieve xml namespace declaration attributes.
        xmlns_uri = 'http://www.w3.org/2000/xmlns/'
        xmlns_attrs = getattr(self, '_xmlns_attrs', None)
        if xmlns_attrs is not None:
            for aname, value in xmlns_attrs:
                attrs._attrs[(xmlns_uri, aname)] = value
            self._xmlns_attrs = []
        uri, localname = name
        if uri:
            # When using namespaces, the reader may or may not
            # provide us with the original name. If not, create
            # *a* valid tagName from the current context.
            if tagName is None:
                prefix = self._current_context[uri]
                if prefix:
                    tagName = prefix + ":" + localname
                else:
                    tagName = localname
            if self.document:
                node = self.document.createElementNS(uri, tagName)
            else:
                node = self.buildDocument(uri, tagName)
        else:
            # When the tagname is not prefixed, it just appears as
            # localname
            if self.document:
                node = self.document.createElement(localname)
            else:
                node = self.buildDocument(None, localname)

        for aname,value in attrs.items():
            a_uri, a_localname = aname
            if a_uri == xmlns_uri:
                if a_localname == 'xmlns':
                    qname = a_localname
                else:
                    qname = 'xmlns:' + a_localname
                attr = self.document.createAttributeNS(a_uri, qname)
                node.setAttributeNodeNS(attr)
            elif a_uri:
                prefix = self._current_context[a_uri]
                if prefix:
                    qname = prefix + ":" + a_localname
                else:
                    qname = a_localname
                attr = self.document.createAttributeNS(a_uri, qname)
                node.setAttributeNodeNS(attr)
            else:
                attr = self.document.createAttribute(a_localname)
                node.setAttributeNode(attr)
            attr.value = value

        self.lastEvent[1] = [(START_ELEMENT, node), None]
        self.lastEvent = self.lastEvent[1]
        self.push(node)

    def endElementNS(self, name, tagName):
        self.lastEvent[1] = [(END_ELEMENT, self.pop()), None]
        self.lastEvent = self.lastEvent[1]

    def startElement(self, name, attrs):
        if self.document:
            node = self.document.createElement(name)
        else:
            node = self.buildDocument(None, name)

        for aname,value in attrs.items():
            attr = self.document.createAttribute(aname)
            attr.value = value
            node.setAttributeNode(attr)

        self.lastEvent[1] = [(START_ELEMENT, node), None]
        self.lastEvent = self.lastEvent[1]
        self.push(node)

    def endElement(self, name):
        self.lastEvent[1] = [(END_ELEMENT, self.pop()), None]
        self.lastEvent = self.lastEvent[1]

    def comment(self, s):
        if self.document:
            node = self.document.createComment(s)
            self.lastEvent[1] = [(COMMENT, node), None]
            self.lastEvent = self.lastEvent[1]
        else:
            event = [(COMMENT, s), None]
            self.pending_events.append(event)

    def processingInstruction(self, target, data):
        if self.document:
            node = self.document.createProcessingInstruction(target, data)
            self.lastEvent[1] = [(PROCESSING_INSTRUCTION, node), None]
            self.lastEvent = self.lastEvent[1]
        else:
            event = [(PROCESSING_INSTRUCTION, target, data), None]
            self.pending_events.append(event)

    def ignorableWhitespace(self, chars):
        node = self.document.createTextNode(chars)
        self.lastEvent[1] = [(IGNORABLE_WHITESPACE, node), None]
        self.lastEvent = self.lastEvent[1]

    def characters(self, chars):
        node = self.document.createTextNode(chars)
        self.lastEvent[1] = [(CHARACTERS, node), None]
        self.lastEvent = self.lastEvent[1]

    def startDocument(self):
        if self.documentFactory is None:
            import xml.dom.minidom
            self.documentFactory = xml.dom.minidom.Document.implementation

    def buildDocument(self, uri, tagname):
        # Can't do that in startDocument, since we need the tagname
        # XXX: obtain DocumentType
        node = self.documentFactory.createDocument(uri, tagname, None)
        self.document = node
        self.lastEvent[1] = [(START_DOCUMENT, node), None]
        self.lastEvent = self.lastEvent[1]
        self.push(node)
        # Put everything we have seen so far into the document
        for e in self.pending_events:
            if e[0][0] == PROCESSING_INSTRUCTION:
                _,target,data = e[0]
                n = self.document.createProcessingInstruction(target, data)
                e[0] = (PROCESSING_INSTRUCTION, n)
            elif e[0][0] == COMMENT:
                n = self.document.createComment(e[0][1])
                e[0] = (COMMENT, n)
            else:
                raise AssertionError("Unknown pending event ",e[0][0])
            self.lastEvent[1] = e
            self.lastEvent = e
        self.pending_events = None
        return node.firstChild

    def endDocument(self):
        self.lastEvent[1] = [(END_DOCUMENT, self.document), None]
        self.pop()

    def clear(self):
        "clear(): Explicitly release parsing structures"
        self.document = None

class ErrorHandler:
    def warning(self, exception):
        print(exception)
    def error(self, exception):
        raise exception
    def fatalError(self, exception):
        raise exception

class DOMEventStream:
    def __init__(self, stream, parser, bufsize):
        self.stream = stream
        self.parser = parser
        self.bufsize = bufsize
        if not hasattr(self.parser, 'feed'):
            self.getEvent = self._slurp
        self.reset()

    def reset(self):
        self.pulldom = PullDOM()
        # This content handler relies on namespace support
        self.parser.setFeature(xml.sax.handler.feature_namespaces, 1)
        self.parser.setContentHandler(self.pulldom)

    def __getitem__(self, pos):
        import warnings
        warnings.warn(
            "DOMEventStream's __getitem__ method ignores 'pos' parameter. "
            "Use iterator protocol instead.",
            DeprecationWarning,
            stacklevel=2
        )
        rc = self.getEvent()
        if rc:
            return rc
        raise IndexError

    def __next__(self):
        rc = self.getEvent()
        if rc:
            return rc
        raise StopIteration

    def __iter__(self):
        return self

    def expandNode(self, node):
        event = self.getEvent()
        parents = [node]
        while event:
            token, cur_node = event
            if cur_node is node:
                return
            if token != END_ELEMENT:
                parents[-1].appendChild(cur_node)
            if token == START_ELEMENT:
                parents.append(cur_node)
            elif token == END_ELEMENT:
                del parents[-1]
            event = self.getEvent()

    def getEvent(self):
        # use IncrementalParser interface, so we get the desired
        # pull effect
        if not self.pulldom.firstEvent[1]:
            self.pulldom.lastEvent = self.pulldom.firstEvent
        while not self.pulldom.firstEvent[1]:
            buf = self.stream.read(self.bufsize)
            if not buf:
                self.parser.close()
                return None
            self.parser.feed(buf)
        rc = self.pulldom.firstEvent[1][0]
        self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]
        return rc

    def _slurp(self):
        """ Fallback replacement for getEvent() using the
            standard SAX2 interface, which means we slurp the
            SAX events into memory (no performance gain, but
            we are compatible to all SAX parsers).
        """
        self.parser.parse(self.stream)
        self.getEvent = self._emit
        return self._emit()

    def _emit(self):
        """ Fallback replacement for getEvent() that emits
            the events that _slurp() read previously.
        """
        rc = self.pulldom.firstEvent[1][0]
        self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]
        return rc

    def clear(self):
        """clear(): Explicitly release parsing objects"""
        self.pulldom.clear()
        del self.pulldom
        self.parser = None
        self.stream = None

class SAX2DOM(PullDOM):

    def startElementNS(self, name, tagName , attrs):
        PullDOM.startElementNS(self, name, tagName, attrs)
        curNode = self.elementStack[-1]
        parentNode = self.elementStack[-2]
        parentNode.appendChild(curNode)

    def startElement(self, name, attrs):
        PullDOM.startElement(self, name, attrs)
        curNode = self.elementStack[-1]
        parentNode = self.elementStack[-2]
        parentNode.appendChild(curNode)

    def processingInstruction(self, target, data):
        PullDOM.processingInstruction(self, target, data)
        node = self.lastEvent[0][1]
        parentNode = self.elementStack[-1]
        parentNode.appendChild(node)

    def ignorableWhitespace(self, chars):
        PullDOM.ignorableWhitespace(self, chars)
        node = self.lastEvent[0][1]
        parentNode = self.elementStack[-1]
        parentNode.appendChild(node)

    def characters(self, chars):
        PullDOM.characters(self, chars)
        node = self.lastEvent[0][1]
        parentNode = self.elementStack[-1]
        parentNode.appendChild(node)


default_bufsize = (2 ** 14) - 20

def parse(stream_or_string, parser=None, bufsize=None):
    if bufsize is None:
        bufsize = default_bufsize
    if isinstance(stream_or_string, str):
        stream = open(stream_or_string, 'rb')
    else:
        stream = stream_or_string
    if not parser:
        parser = xml.sax.make_parser()
    return DOMEventStream(stream, parser, bufsize)

def parseString(string, parser=None):
    from io import StringIO

    bufsize = len(string)
    buf = StringIO(string)
    if not parser:
        parser = xml.sax.make_parser()
    return DOMEventStream(buf, parser, bufsize)
"""Registration facilities for DOM. This module should not be used
directly. Instead, the functions getDOMImplementation and
registerDOMImplementation should be imported from xml.dom."""

# This is a list of well-known implementations.  Well-known names
# should be published by posting to xml-sig@python.org, and are
# subsequently recorded in this file.

import sys

well_known_implementations = {
    'minidom':'xml.dom.minidom',
    '4DOM': 'xml.dom.DOMImplementation',
    }

# DOM implementations not officially registered should register
# themselves with their

registered = {}

def registerDOMImplementation(name, factory):
    """registerDOMImplementation(name, factory)

    Register the factory function with the name. The factory function
    should return an object which implements the DOMImplementation
    interface. The factory function can either return the same object,
    or a new one (e.g. if that implementation supports some
    customization)."""

    registered[name] = factory

def _good_enough(dom, features):
    "_good_enough(dom, features) -> Return 1 if the dom offers the features"
    for f,v in features:
        if not dom.hasFeature(f,v):
            return 0
    return 1

def getDOMImplementation(name=None, features=()):
    """getDOMImplementation(name = None, features = ()) -> DOM implementation.

    Return a suitable DOM implementation. The name is either
    well-known, the module name of a DOM implementation, or None. If
    it is not None, imports the corresponding module and returns
    DOMImplementation object if the import succeeds.

    If name is not given, consider the available implementations to
    find one with the required feature set. If no implementation can
    be found, raise an ImportError. The features list must be a sequence
    of (feature, version) pairs which are passed to hasFeature."""

    import os
    creator = None
    mod = well_known_implementations.get(name)
    if mod:
        mod = __import__(mod, {}, {}, ['getDOMImplementation'])
        return mod.getDOMImplementation()
    elif name:
        return registered[name]()
    elif not sys.flags.ignore_environment and "PYTHON_DOM" in os.environ:
        return getDOMImplementation(name = os.environ["PYTHON_DOM"])

    # User did not specify a name, try implementations in arbitrary
    # order, returning the one that has the required features
    if isinstance(features, str):
        features = _parse_feature_string(features)
    for creator in registered.values():
        dom = creator()
        if _good_enough(dom, features):
            return dom

    for creator in well_known_implementations.keys():
        try:
            dom = getDOMImplementation(name = creator)
        except Exception: # typically ImportError, or AttributeError
            continue
        if _good_enough(dom, features):
            return dom

    raise ImportError("no suitable DOM implementation found")

def _parse_feature_string(s):
    features = []
    parts = s.split()
    i = 0
    length = len(parts)
    while i < length:
        feature = parts[i]
        if feature[0] in "0123456789":
            raise ValueError("bad feature name: %r" % (feature,))
        i = i + 1
        version = None
        if i < length:
            v = parts[i]
            if v[0] in "0123456789":
                i = i + 1
                version = v
        features.append((feature, version))
    return tuple(features)
U

e5d{
οΏ½@s<ddlZdddοΏ½ZiZddοΏ½ZddοΏ½Zdd
dοΏ½Zdd
οΏ½ZdS)οΏ½Nzxml.dom.minidomzxml.dom.DOMImplementation)ZminidomZ4DOMcCs|t|<dS)N)οΏ½
registered)οΏ½nameοΏ½factoryοΏ½rοΏ½&/usr/lib64/python3.8/xml/dom/domreg.pyοΏ½registerDOMImplementations	rcCs$|D]\}}|οΏ½||οΏ½sdSqdS)NrοΏ½)Z
hasFeature)οΏ½domοΏ½featuresοΏ½fοΏ½vrrrοΏ½_good_enough sr
rc	CsοΏ½ddl}d}tοΏ½|οΏ½}|r2t|iidgοΏ½}|οΏ½οΏ½S|r@t|οΏ½Stjjsbd|j	krbt|j	ddοΏ½St
|tοΏ½rtt|οΏ½}tοΏ½
οΏ½D]}|οΏ½}t||οΏ½r||Sq|tοΏ½οΏ½D]>}zt|dοΏ½}Wntk
rοΏ½YqοΏ½YnXt||οΏ½rοΏ½|SqοΏ½tdοΏ½οΏ½dS)NrοΏ½getDOMImplementationZ
PYTHON_DOM)rz$no suitable DOM implementation found)οΏ½osοΏ½well_known_implementationsοΏ½getοΏ½
__import__rrοΏ½sysοΏ½flagsοΏ½ignore_environmentοΏ½environοΏ½
isinstanceοΏ½strοΏ½_parse_feature_stringοΏ½valuesr
οΏ½keysοΏ½	ExceptionοΏ½ImportError)rr
rZcreatorοΏ½modr	rrrr's0








rcCsοΏ½g}|οΏ½οΏ½}d}t|οΏ½}||krοΏ½||}|ddkrBtd|fοΏ½οΏ½|d}d}||krv||}|ddkrv|d}|}|οΏ½||fοΏ½qt|οΏ½S)NrοΏ½
0123456789zbad feature name: %rr)οΏ½splitοΏ½lenοΏ½
ValueErrorοΏ½appendοΏ½tuple)οΏ½sr
οΏ½partsοΏ½iZlengthZfeatureοΏ½versionrrrrrRs"r)Nr)rrrrr
rrrrrrοΏ½<module>	sοΏ½
+U

e5d{
οΏ½@s@dZddlZdddοΏ½ZiZddοΏ½Zdd	οΏ½ZdddοΏ½Zd
dοΏ½ZdS)zοΏ½Registration facilities for DOM. This module should not be used
directly. Instead, the functions getDOMImplementation and
registerDOMImplementation should be imported from xml.dom.οΏ½Nzxml.dom.minidomzxml.dom.DOMImplementation)ZminidomZ4DOMcCs|t|<dS)aIregisterDOMImplementation(name, factory)

    Register the factory function with the name. The factory function
    should return an object which implements the DOMImplementation
    interface. The factory function can either return the same object,
    or a new one (e.g. if that implementation supports some
    customization).N)οΏ½
registered)οΏ½nameοΏ½factoryοΏ½rοΏ½&/usr/lib64/python3.8/xml/dom/domreg.pyοΏ½registerDOMImplementations	rcCs$|D]\}}|οΏ½||οΏ½sdSqdS)zF_good_enough(dom, features) -> Return 1 if the dom offers the featuresrοΏ½)Z
hasFeature)οΏ½domοΏ½featuresοΏ½fοΏ½vrrrοΏ½_good_enough sr
rc	CsοΏ½ddl}d}tοΏ½|οΏ½}|r2t|iidgοΏ½}|οΏ½οΏ½S|r@t|οΏ½Stjjsbd|j	krbt|j	ddοΏ½St
|tοΏ½rtt|οΏ½}tοΏ½
οΏ½D]}|οΏ½}t||οΏ½r||Sq|tοΏ½οΏ½D]>}zt|dοΏ½}Wntk
rοΏ½YqοΏ½YnXt||οΏ½rοΏ½|SqοΏ½tdοΏ½οΏ½dS)aSgetDOMImplementation(name = None, features = ()) -> DOM implementation.

    Return a suitable DOM implementation. The name is either
    well-known, the module name of a DOM implementation, or None. If
    it is not None, imports the corresponding module and returns
    DOMImplementation object if the import succeeds.

    If name is not given, consider the available implementations to
    find one with the required feature set. If no implementation can
    be found, raise an ImportError. The features list must be a sequence
    of (feature, version) pairs which are passed to hasFeature.rNοΏ½getDOMImplementationZ
PYTHON_DOM)rz$no suitable DOM implementation found)οΏ½osοΏ½well_known_implementationsοΏ½getοΏ½
__import__rrοΏ½sysοΏ½flagsοΏ½ignore_environmentοΏ½environοΏ½
isinstanceοΏ½strοΏ½_parse_feature_stringοΏ½valuesr
οΏ½keysοΏ½	ExceptionοΏ½ImportError)rr
rZcreatorοΏ½modr	rrrr's0








rcCsοΏ½g}|οΏ½οΏ½}d}t|οΏ½}||krοΏ½||}|ddkrBtd|fοΏ½οΏ½|d}d}||krv||}|ddkrv|d}|}|οΏ½||fοΏ½qt|οΏ½S)NrοΏ½
0123456789zbad feature name: %rr)οΏ½splitοΏ½lenοΏ½
ValueErrorοΏ½appendοΏ½tuple)οΏ½sr
οΏ½partsοΏ½iZlengthZfeatureοΏ½versionrrrrrRs"r)Nr)οΏ½__doc__rrrrr
rrrrrrοΏ½<module>sοΏ½
+U

e5d)οΏ½@sοΏ½dZddlZddlZddlmZmZmZmZddlTddl	m
Z
mZejj
jejj
jfZGddοΏ½dejj
οΏ½Z
ee
dd	d
οΏ½ee
ddd
οΏ½ee
d
dd
οΏ½ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZGddοΏ½de
οΏ½ZGddοΏ½de
οΏ½Zeeddd
οΏ½eed
dd
οΏ½eed d!d
οΏ½Gd"d#οΏ½d#eοΏ½Zeed$d%d
οΏ½eZGd&d'οΏ½d'eοΏ½ZeddοΏ½ZGd(d)οΏ½d)e
οΏ½Zeed*d+d
οΏ½eed
d,d
οΏ½d-d.οΏ½ZGd/d0οΏ½d0οΏ½Z Gd1d2οΏ½d2e e
οΏ½Z!Gd3d4οΏ½d4e e
οΏ½Z"ee"d$d5d
οΏ½Gd6d7οΏ½d7e"οΏ½Z#ee#d8d9d
οΏ½ee#d:d;d
οΏ½d<d=οΏ½Z$d>d?οΏ½Z%Gd@dAοΏ½dAe"οΏ½Z&GdBdCοΏ½dCe#οΏ½Z'GdDdEοΏ½dEeοΏ½Z(ee(d$dFd
οΏ½GdGdHοΏ½dHοΏ½Z)GdIdJοΏ½dJe)e e
οΏ½Z*GdKdLοΏ½dLe)e
οΏ½Z+GdMdNοΏ½dNe)e e
οΏ½Z,GdOdPοΏ½dPe
οΏ½Z-GdQdRοΏ½dReοΏ½Z.dSdTοΏ½Z/GdUdVοΏ½dVe
eοΏ½Z0ee0dWdXd
οΏ½dYdZοΏ½Z1d[d\οΏ½Z2d]d^οΏ½Z3ded_d`οΏ½Z4dfdadbοΏ½Z5dgdcddοΏ½Z6dS)hacSimple 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
οΏ½N)οΏ½EMPTY_NAMESPACEοΏ½EMPTY_PREFIXοΏ½XMLNS_NAMESPACEοΏ½domreg)οΏ½*)οΏ½DOMImplementationLSοΏ½
DocumentLSc@sοΏ½eZdZdZdZdZdZdZeZ	ddοΏ½Z
d2ddοΏ½Zd3dd	οΏ½Zd
dοΏ½Z
dd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd d!οΏ½Zd"d#οΏ½Zd$d%οΏ½Zd&d'οΏ½Zd(d)οΏ½Zd*d+οΏ½Zd,d-οΏ½Zd.d/οΏ½Zd0d1οΏ½Z dS)4οΏ½NodeNcCsdS)NTοΏ½οΏ½οΏ½selfr
r
οΏ½'/usr/lib64/python3.8/xml/dom/minidom.pyοΏ½__bool__+sz
Node.__bool__cCs|οΏ½dd|οΏ½SοΏ½NοΏ½)οΏ½toprettyxml)rοΏ½encodingr
r
r
οΏ½toxml.sz
Node.toxmlοΏ½	οΏ½
cCsx|dkrtοΏ½οΏ½}ntjtοΏ½οΏ½|dddοΏ½}|jtjkrH|οΏ½|d|||οΏ½n|οΏ½|d||οΏ½|dkrh|οΏ½οΏ½S|οΏ½	οΏ½οΏ½οΏ½SdS)NοΏ½xmlcharrefreplacer)rοΏ½errorsοΏ½newliner)
οΏ½ioοΏ½StringIOοΏ½
TextIOWrapperοΏ½BytesIOοΏ½nodeTyper	οΏ½
DOCUMENT_NODEοΏ½writexmlοΏ½getvalueοΏ½detach)rοΏ½indentοΏ½newlrοΏ½writerr
r
r
r1s

οΏ½zNode.toprettyxmlcCs
t|jοΏ½SοΏ½N)οΏ½boolοΏ½
childNodesrr
r
r
οΏ½
hasChildNodesCszNode.hasChildNodescCs|jSr%οΏ½r'rr
r
r
οΏ½_get_childNodesFszNode._get_childNodescCs|jr|jdSdSοΏ½Nrr)rr
r
r
οΏ½_get_firstChildIszNode._get_firstChildcCs|jr|jdSdSοΏ½NοΏ½οΏ½οΏ½r)rr
r
r
οΏ½_get_lastChildMszNode._get_lastChildcCs
|j|jkr,t|jοΏ½D]}|οΏ½||οΏ½q|S|j|jkrTtjοΏ½dt	|οΏ½t	|οΏ½fοΏ½οΏ½|j
dk	rj|j
οΏ½|οΏ½|dkr~|οΏ½|οΏ½nοΏ½z|jοΏ½
|οΏ½}Wntk
rοΏ½tjοΏ½οΏ½οΏ½YnX|jtkrοΏ½t|οΏ½|jοΏ½||οΏ½||_||_|rοΏ½|j|d}||_||_nd|_||_
|S)NοΏ½%s cannot be child of %sοΏ½)rοΏ½DOCUMENT_FRAGMENT_NODEοΏ½tupler'οΏ½insertBeforeοΏ½_child_node_typesοΏ½xmlοΏ½domοΏ½HierarchyRequestErrοΏ½reprοΏ½
parentNodeοΏ½removeChildοΏ½appendChildοΏ½indexοΏ½
ValueErrorοΏ½NotFoundErrοΏ½_nodeTypes_with_childrenοΏ½_clear_id_cacheοΏ½insertοΏ½nextSiblingοΏ½previousSibling)rοΏ½newChildοΏ½refChildοΏ½cr=οΏ½noder
r
r
r4Qs8οΏ½

zNode.insertBeforecCsοΏ½|j|jkr*t|jοΏ½D]}|οΏ½|οΏ½q|S|j|jkrTtjοΏ½dt	|οΏ½t	|οΏ½fοΏ½οΏ½n|jt
krft|οΏ½|jdk	r||jοΏ½
|οΏ½t||οΏ½d|_|SοΏ½Nr0)rr2r3r'r<r5r6r7r8r9r@rAr:r;οΏ½
_append_childrC)rrHrGr
r
r
r<qsοΏ½


zNode.appendChildcCs|j|jkr(|j}|οΏ½|οΏ½|οΏ½||οΏ½S|j|jkrPtjοΏ½dt	|οΏ½t	|οΏ½fοΏ½οΏ½||kr\dS|j
dk	rr|j
οΏ½|οΏ½z|jοΏ½|οΏ½}Wnt
k
rοΏ½tjοΏ½οΏ½οΏ½YnX||j|<||_
d|_
|jtksοΏ½|jtkrοΏ½t|οΏ½|j|_|j|_d|_d|_|jrοΏ½||j_|jοΏ½r||j_|SrI)rr2rCr;r4r5r6r7r8r9r:r'r=r>r?r@rArD)rrEοΏ½oldChildrFr=r
r
r
οΏ½replaceChildοΏ½s@
οΏ½


οΏ½zNode.replaceChildcCsοΏ½z|jοΏ½|οΏ½Wntk
r.tjοΏ½οΏ½οΏ½YnX|jdk	rD|j|j_|jdk	rX|j|j_d|_|_|jt	krvt
|οΏ½d|_|Sr%)r'οΏ½remover>r6r7r?rCrDrr@rAr:οΏ½rrKr
r
r
r;οΏ½s




zNode.removeChildcCsοΏ½g}|jD]οΏ½}|jtjkrοΏ½|jsJ|r0|j|d_|jr@|j|j_|οΏ½οΏ½qοΏ½|rοΏ½|dj|jkrοΏ½|d}|j|j|_|j|_|jrοΏ½||j_|οΏ½οΏ½qοΏ½|οΏ½|οΏ½q
|οΏ½|οΏ½|jtj	kr
|οΏ½
οΏ½q
||jddοΏ½<dSr-)r'rr	οΏ½	TEXT_NODEοΏ½datarCrDοΏ½unlinkοΏ½appendοΏ½ELEMENT_NODEοΏ½	normalize)rοΏ½LοΏ½childrHr
r
r
rTοΏ½s*





zNode.normalizecCst|||jp|οΏ½Sr%)οΏ½_clone_nodeοΏ½
ownerDocument)rοΏ½deepr
r
r
οΏ½	cloneNodeοΏ½szNode.cloneNodecCs|jjοΏ½||οΏ½Sr%)rXοΏ½implementationοΏ½
hasFeatureοΏ½rοΏ½featureοΏ½versionr
r
r
οΏ½isSupportedοΏ½szNode.isSupportedcCsdSr%r
rr
r
r
οΏ½_get_localNameοΏ½szNode._get_localNamecCs||kSr%r
οΏ½rοΏ½otherr
r
r
οΏ½
isSameNodeοΏ½szNode.isSameNodecCs|οΏ½|dοΏ½r|SdSdSr%)r`οΏ½rr^r
r
r
οΏ½getInterfaceοΏ½szNode.getInterfacec	Cs0z|j|dWSttfk
r*YdSXdSr+)οΏ½
_user_dataοΏ½AttributeErrorοΏ½KeyErrorοΏ½rοΏ½keyr
r
r
οΏ½getUserDataοΏ½szNode.getUserDatacCsnd}z
|j}Wntk
r,i}||_YnX||krB||d}|dkr^d}|dk	rj||=n||f||<|Sr+)rgrh)rrkrPοΏ½handlerοΏ½oldοΏ½dr
r
r
οΏ½setUserDataοΏ½s
zNode.setUserDatacCsDt|dοΏ½r@t|jοΏ½οΏ½οΏ½D]&\}\}}|dk	r|οΏ½|||||οΏ½qdS)Nrg)οΏ½hasattrοΏ½listrgοΏ½itemsZhandle)rοΏ½	operationοΏ½srcZdstrkrPrmr
r
r
οΏ½_call_user_data_handlerοΏ½s
zNode._call_user_data_handlercCs>d|_|_|jr.|jD]}|οΏ½οΏ½qtοΏ½|_d|_d|_dSr%)r:rXr'rQοΏ½NodeListrDrC)rrVr
r
r
rQs

zNode.unlinkcCs|Sr%r
rr
r
r
οΏ½	__enter__szNode.__enter__cCs|οΏ½οΏ½dSr%)rQ)rZetZevοΏ½tbr
r
r
οΏ½__exit__sz
Node.__exit__)N)rrN)!οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½namespaceURIr:rXrCrDrοΏ½prefixrrrr(r*r,r/r4r<rLr;rTrZr`rardrfrlrprvrQrxrzr
r
r
r
r	"s:

  
r	οΏ½
firstChildzFirst child node, or None.)οΏ½docοΏ½	lastChildzLast child node, or None.οΏ½	localNamez"Namespace-local name of this node.cCs2|j}|r|d}||_||_|οΏ½|οΏ½||_dSr-)r'rDrCrRr:)rrHr'Zlastr
r
r
rJs
rJcCs$|dk	r |jtjkrdS|j}qdSοΏ½NTF)rr	rr:οΏ½rHr
r
r
οΏ½_in_document&s
rοΏ½cCs6|r2|οΏ½ddοΏ½οΏ½ddοΏ½οΏ½ddοΏ½οΏ½ddοΏ½}|οΏ½|οΏ½d	S)
zWrites datachars to writer.οΏ½&z&amp;οΏ½<z&lt;οΏ½"z&quot;οΏ½>z&gt;N)οΏ½replaceοΏ½write)r$rPr
r
r
οΏ½_write_data.sοΏ½οΏ½rοΏ½cCsD|jD]8}|jtjkr2|dks(|j|kr2|οΏ½|οΏ½t|||οΏ½q|SοΏ½Nr)r'rr	rSοΏ½tagNamerRοΏ½_get_elements_by_tagName_helper)οΏ½parentοΏ½nameοΏ½rcrHr
r
r
rοΏ½5s
οΏ½οΏ½
rοΏ½cCsX|jD]L}|jtjkr|dks(|j|krD|dks:|j|krD|οΏ½|οΏ½t||||οΏ½q|SrοΏ½)r'rr	rSrοΏ½r~rRοΏ½"_get_elements_by_tagName_ns_helper)rοΏ½ZnsURIrοΏ½rοΏ½rHr
r
r
rοΏ½=s
οΏ½οΏ½
rοΏ½c@sJeZdZejZdZdZdZdZ	ej
ejejej
ejejejfZddοΏ½ZdS)οΏ½DocumentFragmentz#document-fragmentNcCstοΏ½|_dSr%)rwr'rr
r
r
οΏ½__init__TszDocumentFragment.__init__)r{r|r}r	r2rοΏ½nodeNameοΏ½	nodeValueοΏ½
attributesr:rSrOοΏ½CDATA_SECTION_NODEοΏ½ENTITY_REFERENCE_NODEοΏ½PROCESSING_INSTRUCTION_NODEοΏ½COMMENT_NODEοΏ½
NOTATION_NODEr5rοΏ½r
r
r
r
rοΏ½FsοΏ½rοΏ½c@sοΏ½eZdZdZejZdZdZdZ	ej
ejfZe
ddfddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZeeeοΏ½ZZddοΏ½ZddοΏ½ZeeeοΏ½ZZddοΏ½ZddοΏ½ZeeeοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½Attr)οΏ½_nameοΏ½_valuer~οΏ½_prefixr'οΏ½
_localNamerXοΏ½ownerElementNFcCs2d|_||_||_||_tοΏ½|_|jοΏ½tοΏ½οΏ½dSr%)rοΏ½rοΏ½r~rοΏ½rwr'rRοΏ½Text)rοΏ½qNamer~rοΏ½rr
r
r
rοΏ½bsz
Attr.__init__cCs4z|jWStk
r.|jοΏ½ddοΏ½dYSXdSοΏ½NοΏ½:r1r.)rοΏ½rhrοΏ½οΏ½splitrr
r
r
raoszAttr._get_localNamecCs|jSr%)οΏ½	specifiedrr
r
r
οΏ½_get_specifieduszAttr._get_specifiedcCs|jSr%)rοΏ½rr
r
r
οΏ½	_get_namexszAttr._get_namecCs||_|jdk	rt|jοΏ½dSr%)rοΏ½rοΏ½rAοΏ½rοΏ½valuer
r
r
οΏ½	_set_name{s
zAttr._set_namecCs|jSr%)rοΏ½rr
r
r
οΏ½
_get_valueοΏ½szAttr._get_valuecCs6||_||jd_|jdk	r&t|jοΏ½||jd_dSr+)rοΏ½r'rPrοΏ½rArοΏ½r
r
r
οΏ½
_set_valueοΏ½s


zAttr._set_valuecCs|jSr%)rοΏ½rr
r
r
οΏ½_get_prefixοΏ½szAttr._get_prefixcCsd|j}|dkr&|r&|tkr&tjοΏ½dοΏ½οΏ½||_|dkr<|j}nd||jf}|jrZt|jοΏ½||_	dS)NοΏ½xmlnsz5illegal use of 'xmlns' prefix for the wrong namespacez%s:%s)
r~rr6r7οΏ½NamespaceErrrοΏ½rοΏ½rοΏ½rArοΏ½)rrZnsuriZnewNamer
r
r
οΏ½_set_prefixοΏ½sοΏ½
zAttr._set_prefixcCsv|j}|dk	rR|j|j=|j|j|jf=|jrRd|_|jd8_|jj	d8_	|j
D]}|οΏ½οΏ½qX|j
ddοΏ½=dS)NFr1)rοΏ½οΏ½_attrsrοΏ½οΏ½_attrsNSr~rοΏ½οΏ½_is_idοΏ½_magic_id_nodesrXοΏ½_magic_id_countr'rQ)rοΏ½elemrVr
r
r
rQοΏ½s


zAttr.unlinkcCsf|jr
dS|j}|j}|dks&|dkr*dS|οΏ½|οΏ½}|dkr@dS|jrV|οΏ½|j|jοΏ½S|οΏ½|jοΏ½SdSrοΏ½)	rοΏ½rXrοΏ½οΏ½_get_elem_infor~οΏ½isIdNSrοΏ½οΏ½isIdrοΏ½οΏ½rrοΏ½rοΏ½οΏ½infor
r
r
οΏ½	_get_isIdοΏ½s
zAttr._get_isIdcCs\|j}|j}|dks|dkr tS|οΏ½|οΏ½}|dkr6tS|jrL|οΏ½|j|jοΏ½S|οΏ½|jοΏ½SdSr%)	rXrοΏ½οΏ½_no_typerοΏ½r~οΏ½getAttributeTypeNSrοΏ½οΏ½getAttributeTyperοΏ½rοΏ½r
r
r
οΏ½_get_schemaTypeοΏ½s
zAttr._get_schemaType) r{r|r}οΏ½	__slots__r	οΏ½ATTRIBUTE_NODErrοΏ½rοΏ½rοΏ½rOrοΏ½r5rrοΏ½rarοΏ½rοΏ½rοΏ½οΏ½propertyrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrQrοΏ½rοΏ½r
r
r
r
rοΏ½Xs.οΏ½


rοΏ½rοΏ½z True if this attribute is an ID.z'Namespace-local name of this attribute.οΏ½
schemaTypezSchema type for this attribute.c@sοΏ½eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Z	d
dοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
d:ddοΏ½ZeZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd d!οΏ½Zd"d#οΏ½Zd$d%οΏ½Zd&d'οΏ½Zd(d)οΏ½Zd*d+οΏ½Zd,d-οΏ½Zd.d/οΏ½Zd0d1οΏ½Zd2d3οΏ½Zd4d5οΏ½Zd6d7οΏ½Zd8d9οΏ½Z dS);οΏ½NamedNodeMapaThe 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.
    οΏ½rοΏ½rοΏ½οΏ½
_ownerElementcCs||_||_||_dSr%rοΏ½)rοΏ½attrsZattrsNSrοΏ½r
r
r
rοΏ½οΏ½szNamedNodeMap.__init__cCs
t|jοΏ½Sr%)οΏ½lenrοΏ½rr
r
r
οΏ½_get_lengthοΏ½szNamedNodeMap._get_lengthcCs4z|t|jοΏ½οΏ½οΏ½|WStk
r.YdSXdSr%)rrrοΏ½οΏ½keysοΏ½
IndexErrorοΏ½rr=r
r
r
οΏ½itemοΏ½szNamedNodeMap.itemcCs*g}|jοΏ½οΏ½D]}|οΏ½|j|jfοΏ½q|Sr%)rοΏ½οΏ½valuesrRrοΏ½rοΏ½οΏ½rrUrHr
r
r
rsοΏ½szNamedNodeMap.itemscCs0g}|jοΏ½οΏ½D]}|οΏ½|j|jf|jfοΏ½q|Sr%)rοΏ½rοΏ½rRr~rοΏ½rοΏ½rοΏ½r
r
r
οΏ½itemsNSοΏ½szNamedNodeMap.itemsNScCs"t|tοΏ½r||jkS||jkSdSr%)οΏ½
isinstanceοΏ½strrοΏ½rοΏ½rjr
r
r
οΏ½__contains__οΏ½s

zNamedNodeMap.__contains__cCs
|jοΏ½οΏ½Sr%)rοΏ½rοΏ½rr
r
r
rοΏ½szNamedNodeMap.keyscCs
|jοΏ½οΏ½Sr%)rοΏ½rοΏ½rr
r
r
οΏ½keysNSszNamedNodeMap.keysNScCs
|jοΏ½οΏ½Sr%)rοΏ½rοΏ½rr
r
r
rοΏ½szNamedNodeMap.valuesNcCs|jοΏ½||οΏ½Sr%οΏ½rοΏ½οΏ½get)rrοΏ½rοΏ½r
r
r
rοΏ½
szNamedNodeMap.getcCs:|jt|ddοΏ½krdSt|οΏ½t|οΏ½kt|οΏ½t|οΏ½kSdS)NrοΏ½r)rοΏ½οΏ½getattrοΏ½idrbr
r
r
οΏ½_cmpszNamedNodeMap._cmpcCs|οΏ½|οΏ½dkSr+οΏ½rοΏ½rbr
r
r
οΏ½__eq__szNamedNodeMap.__eq__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__ge__szNamedNodeMap.__ge__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__gt__szNamedNodeMap.__gt__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__le__szNamedNodeMap.__le__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__lt__!szNamedNodeMap.__lt__cCs"t|tοΏ½r|j|S|j|SdSr%)rοΏ½r3rοΏ½rοΏ½)rοΏ½attname_or_tupler
r
r
οΏ½__getitem__$s

zNamedNodeMap.__getitem__cCsvt|tοΏ½rRz|j|}Wn0tk
rHt|οΏ½}|jj|_|οΏ½|οΏ½YnX||_n t|tοΏ½sdt	dοΏ½οΏ½|}|οΏ½|οΏ½dS)Nz%value must be a string or Attr object)
rοΏ½rοΏ½rοΏ½rirοΏ½rοΏ½rXοΏ½setNamedItemrοΏ½οΏ½	TypeError)rοΏ½attnamerοΏ½rHr
r
r
οΏ½__setitem__+s


zNamedNodeMap.__setitem__cCs(z|j|WStk
r"YdSXdSr%)rοΏ½riοΏ½rrοΏ½r
r
r
οΏ½getNamedItem:szNamedNodeMap.getNamedItemcCs,z|j||fWStk
r&YdSXdSr%)rοΏ½riοΏ½rr~rοΏ½r
r
r
οΏ½getNamedItemNS@szNamedNodeMap.getNamedItemNScCsX|οΏ½|οΏ½}|dk	rJt|jοΏ½|j|j=|j|j|jf=t|dοΏ½rFd|_	|St
jοΏ½οΏ½οΏ½dSοΏ½NrοΏ½)
rοΏ½rArοΏ½rοΏ½rοΏ½rοΏ½r~rοΏ½rqrοΏ½r6r7r?οΏ½rrοΏ½οΏ½nr
r
r
οΏ½removeNamedItemFs



zNamedNodeMap.removeNamedItemcCsZ|οΏ½||οΏ½}|dk	rLt|jοΏ½|j|j|jf=|j|j=t|dοΏ½rHd|_	|St
jοΏ½οΏ½οΏ½dSrοΏ½)
rοΏ½rArοΏ½rοΏ½r~rοΏ½rοΏ½rοΏ½rqrοΏ½r6r7r?οΏ½rr~rοΏ½rοΏ½r
r
r
οΏ½removeNamedItemNSRs


zNamedNodeMap.removeNamedItemNScCstt|tοΏ½s&tjοΏ½dt|οΏ½t|οΏ½fοΏ½οΏ½|jοΏ½|jοΏ½}|r@|οΏ½	οΏ½||j|j<||j
|j|jf<|j
|_t|jοΏ½|SrI)rοΏ½rοΏ½r6r7r8r9rοΏ½rοΏ½rοΏ½rQrοΏ½r~rοΏ½rοΏ½rοΏ½rA)rrHrnr
r
r
rοΏ½^s
οΏ½
zNamedNodeMap.setNamedItemcCs
|οΏ½|οΏ½Sr%)rοΏ½οΏ½rrHr
r
r
οΏ½setNamedItemNSkszNamedNodeMap.setNamedItemNScCs||}t|jοΏ½|οΏ½οΏ½dSr%)rArοΏ½rQ)rrοΏ½rHr
r
r
οΏ½__delitem__ns
zNamedNodeMap.__delitem__cCs|j|j|jfSr%rοΏ½rr
r
r
οΏ½__getstate__sszNamedNodeMap.__getstate__cCs|\|_|_|_dSr%rοΏ½οΏ½rοΏ½stater
r
r
οΏ½__setstate__vszNamedNodeMap.__setstate__)N)!r{r|r}οΏ½__doc__rοΏ½rοΏ½rοΏ½rοΏ½rsrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½__len__rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
rοΏ½οΏ½s<

rοΏ½Zlengthz$Number of nodes in the NamedNodeMap.c@s0eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
S)οΏ½TypeInfoοΏ½οΏ½	namespacerοΏ½cCs||_||_dSr%r)rrrοΏ½r
r
r
rοΏ½οΏ½szTypeInfo.__init__cCs2|jrd|jj|j|jfSd|jj|jfSdS)Nz<%s %r (from %r)>z<%s %r>)rοΏ½	__class__r{rοΏ½rr
r
r
οΏ½__repr__οΏ½s
οΏ½zTypeInfo.__repr__cCs|jSr%)rοΏ½rr
r
r
rοΏ½οΏ½szTypeInfo._get_namecCs|jSr%)rrr
r
r
οΏ½_get_namespaceοΏ½szTypeInfo._get_namespaceN)r{r|r}rοΏ½rοΏ½rrοΏ½rr
r
r
r
rοΏ½s
rοΏ½c@s eZdZdZejZdZeZ	dZ
ejejejej
ejejfZeddfddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZeZddοΏ½ZddοΏ½Z d d!οΏ½Z!e!Z"d"d#οΏ½Z#d$d%οΏ½Z$d&d'οΏ½Z%d(d)οΏ½Z&d*d+οΏ½Z'd9d-d.οΏ½Z(d/d0οΏ½Z)d1d2οΏ½Z*d3d4οΏ½Z+d5d6οΏ½Z,d7d8οΏ½Z-dS):οΏ½Element)rXr:rοΏ½rοΏ½rr~rοΏ½r'rοΏ½rοΏ½rCrDNrcCsBd|_||_|_||_||_tοΏ½|_d|_|_d|_	d|_
dSr%)r:rοΏ½rοΏ½rr~rwr'rCrDrοΏ½rοΏ½)rrοΏ½r~rrοΏ½r
r
r
rοΏ½οΏ½s
zElement.__init__cCs|jdkri|_i|_dSr%)rοΏ½rοΏ½rr
r
r
οΏ½_ensure_attributesοΏ½s
zElement._ensure_attributescCs4z|jWStk
r.|jοΏ½ddοΏ½dYSXdSrοΏ½)rοΏ½rhrοΏ½rοΏ½rr
r
r
raοΏ½szElement._get_localNamecCs|jSr%οΏ½rοΏ½rr
r
r
οΏ½_get_tagNameοΏ½szElement._get_tagNamecCs@|jdk	r&t|jοΏ½οΏ½οΏ½D]}|οΏ½οΏ½qd|_d|_tοΏ½|οΏ½dSr%)rοΏ½rrrοΏ½rQrοΏ½r	)rοΏ½attrr
r
r
rQοΏ½s

zElement.unlinkcCs8|jdkrdSz|j|jWStk
r2YdSXdSr)rοΏ½rοΏ½ri)rrοΏ½r
r
r
οΏ½getAttributeοΏ½s
zElement.getAttributecCs<|jdkrdSz|j||fjWStk
r6YdSXdSr)rοΏ½rοΏ½rirοΏ½r
r
r
οΏ½getAttributeNSοΏ½s
zElement.getAttributeNScCsV|οΏ½|οΏ½}|dkr4t|οΏ½}||_|j|_|οΏ½|οΏ½n||jkrR||_|jrRt|οΏ½dSr%)οΏ½getAttributeNoderοΏ½rοΏ½rXοΏ½setAttributeNoderοΏ½rA)rrοΏ½rοΏ½r	r
r
r
οΏ½setAttributeοΏ½s

zElement.setAttributecCsοΏ½t|οΏ½\}}|οΏ½||οΏ½}|dkrHt||||οΏ½}||_|j|_|οΏ½|οΏ½n4||jkrf||_|jrft|οΏ½|j|kr|||_||_	dSr%)
οΏ½_nssplitοΏ½getAttributeNodeNSrοΏ½rοΏ½rXr
rοΏ½rArrοΏ½)rr~οΏ½
qualifiedNamerοΏ½rοΏ½	localnamer	r
r
r
οΏ½setAttributeNSοΏ½s

zElement.setAttributeNScCs|jdkrdS|jοΏ½|οΏ½Sr%rοΏ½)rοΏ½attrnamer
r
r
rοΏ½s
zElement.getAttributeNodecCs|jdkrdS|jοΏ½||fοΏ½Sr%)rοΏ½rοΏ½rοΏ½r
r
r
rs
zElement.getAttributeNodeNScCsοΏ½|jd|fkrtjοΏ½dοΏ½οΏ½|οΏ½οΏ½|jοΏ½|jdοΏ½}|dk	rD|οΏ½|οΏ½|j	οΏ½|j
|jfdοΏ½}|dk	rt||k	rt|οΏ½|οΏ½t||οΏ½||k	rοΏ½|S||k	rοΏ½|SdS)Nzattribute node already owned)
rοΏ½r6r7ZInuseAttributeErrrrοΏ½rοΏ½rοΏ½οΏ½removeAttributeNoderοΏ½r~rοΏ½οΏ½_set_attribute_node)rr	Zold1Zold2r
r
r
r
s


zElement.setAttributeNodecCsP|jdkrtjοΏ½οΏ½οΏ½z|j|}Wntk
r@tjοΏ½οΏ½οΏ½YnX|οΏ½|οΏ½dSr%)rοΏ½r6r7r?rοΏ½rir)rrοΏ½r	r
r
r
οΏ½removeAttributes

zElement.removeAttributecCsT|jdkrtjοΏ½οΏ½οΏ½z|j||f}Wntk
rDtjοΏ½οΏ½οΏ½YnX|οΏ½|οΏ½dSr%)rοΏ½r6r7r?rir)rr~rοΏ½r	r
r
r
οΏ½removeAttributeNS%s

zElement.removeAttributeNScCs^|dkrtjοΏ½οΏ½οΏ½z|j|jWntk
r@tjοΏ½οΏ½οΏ½YnXt|οΏ½|οΏ½οΏ½|j|_|Sr%)	r6r7r?rοΏ½rοΏ½rirArQrXrοΏ½r
r
r
r.s
zElement.removeAttributeNodecCs|jdkrdS||jkSοΏ½NFοΏ½rοΏ½rοΏ½r
r
r
οΏ½hasAttribute>s
zElement.hasAttributecCs|jdkrdS||f|jkSr)rοΏ½rοΏ½r
r
r
οΏ½hasAttributeNSCs
zElement.hasAttributeNScCst||tοΏ½οΏ½Sr%οΏ½rοΏ½rwrοΏ½r
r
r
οΏ½getElementsByTagNameHszElement.getElementsByTagNamecCst|||tοΏ½οΏ½Sr%οΏ½rοΏ½rwrοΏ½r
r
r
οΏ½getElementsByTagNameNSKsοΏ½zElement.getElementsByTagNameNScCsd|jt|οΏ½fS)Nz<DOM Element: %s at %#x>)rοΏ½rοΏ½rr
r
r
rOszElement.__repr__rcCsοΏ½|οΏ½|d|jοΏ½|οΏ½οΏ½}|οΏ½οΏ½D],}|οΏ½d|οΏ½t|||jοΏ½|οΏ½dοΏ½q$|jrοΏ½|οΏ½dοΏ½t|jοΏ½dkrοΏ½|jdjt	j
t	jfkrοΏ½|jdοΏ½|dddοΏ½n4|οΏ½|οΏ½|jD]}|οΏ½|||||οΏ½qοΏ½|οΏ½|οΏ½|οΏ½d|j|fοΏ½n|οΏ½d	|οΏ½dS)
NrοΏ½z %s="rοΏ½rοΏ½r1rrz</%s>%sz/>%s)
rοΏ½rοΏ½οΏ½_get_attributesrοΏ½rοΏ½rοΏ½r'rοΏ½rr	rOrοΏ½r)rr$r"οΏ½	addindentr#rοΏ½Za_namerHr
r
r
rRs*

οΏ½οΏ½


zElement.writexmlcCs|οΏ½οΏ½t|j|j|οΏ½Sr%)rrοΏ½rοΏ½rοΏ½rr
r
r
r!mszElement._get_attributescCs|jr
dSdSdSrοΏ½rrr
r
r
οΏ½
hasAttributesqszElement.hasAttributescCs|οΏ½|οΏ½}|οΏ½|οΏ½dSr%)rοΏ½setIdAttributeNode)rrοΏ½οΏ½idAttrr
r
r
οΏ½setIdAttributeys
zElement.setIdAttributecCs|οΏ½||οΏ½}|οΏ½|οΏ½dSr%)rr$)rr~rοΏ½r%r
r
r
οΏ½setIdAttributeNS}szElement.setIdAttributeNScCsj|dks|οΏ½|jοΏ½stjοΏ½οΏ½οΏ½t|οΏ½dk	r4tjοΏ½οΏ½οΏ½|jsfd|_|jd7_|j	j
d7_
t|οΏ½dS)NTr1)rdrοΏ½r6r7r?οΏ½_get_containing_entrefοΏ½NoModificationAllowedErrrοΏ½rοΏ½rXrοΏ½rA)rr%r
r
r
r$οΏ½s

zElement.setIdAttributeNode)rrr).r{r|r}rοΏ½r	rSrrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rOrοΏ½rοΏ½r5rrοΏ½rrarrQr
rrrrrr
ZsetAttributeNodeNSrrrZremoveAttributeNodeNSrrrr rrr!r#r&r'r$r
r
r
r
rοΏ½sTοΏ½οΏ½
		
rrοΏ½z*NamedNodeMap of attributes on the element.z%Namespace-local name of this element.cCs8t|οΏ½|οΏ½οΏ½||j|j<||j|j|jf<||_dSr%)rArrοΏ½rοΏ½rοΏ½r~rοΏ½rοΏ½)οΏ½elementr	r
r
r
rοΏ½s
rc@sfeZdZdZdZdZeοΏ½ZdZdZ	ddοΏ½Z
ddοΏ½Zdd	οΏ½Zd
dοΏ½Z
dd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½	ChildlesszοΏ½Mixin that makes childless-ness easy to implement and avoids
    the complexity of the Node methods that deal with children.
    r
NcCsdSr%r
rr
r
r
r,οΏ½szChildless._get_firstChildcCsdSr%r
rr
r
r
r/οΏ½szChildless._get_lastChildcCstjοΏ½|jdοΏ½οΏ½dS)Nz nodes cannot have childrenοΏ½r6r7r8rοΏ½rοΏ½r
r
r
r<οΏ½sοΏ½zChildless.appendChildcCsdSrr
rr
r
r
r(οΏ½szChildless.hasChildNodescCstjοΏ½|jdοΏ½οΏ½dSοΏ½Nz nodes do not have childrenr,οΏ½rrErFr
r
r
r4οΏ½sοΏ½zChildless.insertBeforecCstjοΏ½|jdοΏ½οΏ½dSr-)r6r7r?rοΏ½rNr
r
r
r;οΏ½sοΏ½zChildless.removeChildcCsdSr%r
rr
r
r
rTοΏ½szChildless.normalizecCstjοΏ½|jdοΏ½οΏ½dSr-r,οΏ½rrErKr
r
r
rLοΏ½sοΏ½zChildless.replaceChild)r{r|r}rοΏ½rοΏ½rοΏ½Z
EmptyNodeListr'rοΏ½rοΏ½r,r/r<r(r4r;rTrLr
r
r
r
r+οΏ½sr+c@s\eZdZejZdZddοΏ½ZddοΏ½ZddοΏ½Z	e
ee	οΏ½Zdd	οΏ½Zd
dοΏ½Z
e
ee
οΏ½Zdd
dοΏ½ZdS)οΏ½ProcessingInstructionοΏ½οΏ½targetrPcCs||_||_dSr%r1)rr2rPr
r
r
rοΏ½οΏ½szProcessingInstruction.__init__cCs|jSr%οΏ½rPrr
r
r
οΏ½_get_nodeValueοΏ½sz$ProcessingInstruction._get_nodeValuecCs
||_dSr%r3rοΏ½r
r
r
οΏ½_set_nodeValueοΏ½sz$ProcessingInstruction._set_nodeValuecCs|jSr%οΏ½r2rr
r
r
οΏ½
_get_nodeNameοΏ½sz#ProcessingInstruction._get_nodeNamecCs
||_dSr%r6rοΏ½r
r
r
οΏ½
_set_nodeNameοΏ½sz#ProcessingInstruction._set_nodeNamercCs|οΏ½d||j|j|fοΏ½dS)Nz
%s<?%s %s?>%s)rοΏ½r2rPοΏ½rr$r"r"r#r
r
r
rοΏ½szProcessingInstruction.writexmlN)rrr)r{r|r}r	rοΏ½rrοΏ½rοΏ½r4r5rοΏ½rοΏ½r7r8rοΏ½rr
r
r
r
r0οΏ½s

r0c@sreZdZdZddοΏ½ZddοΏ½ZeZddοΏ½Zdd	οΏ½Ze	eeοΏ½Z
Zd
dοΏ½Zdd
οΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½
CharacterData)οΏ½_datarXr:rDrCcCs,d|_|_d|_|_d|_tοΏ½|οΏ½dSr)rXr:rDrCr;r	rοΏ½rr
r
r
rοΏ½οΏ½szCharacterData.__init__cCs
t|jοΏ½Sr%)rοΏ½rPrr
r
r
rοΏ½οΏ½szCharacterData._get_lengthcCs|jSr%οΏ½r;rr
r
r
οΏ½	_get_dataοΏ½szCharacterData._get_datacCs
||_dSr%r<οΏ½rrPr
r
r
οΏ½	_set_dataοΏ½szCharacterData._set_datacCs6|j}t|οΏ½dkrd}nd}d|jj|ddοΏ½|fS)NοΏ½
z...rz<DOM %s node "%r%s">r)rPrοΏ½rr{)rrPZ	dotdotdotr
r
r
rοΏ½s
οΏ½zCharacterData.__repr__cCsT|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|dkrBtjοΏ½dοΏ½οΏ½|j|||οΏ½SοΏ½NrοΏ½offset cannot be negativeοΏ½#offset cannot be beyond end of dataοΏ½count cannot be negativeοΏ½r6r7οΏ½IndexSizeErrrοΏ½rPοΏ½rοΏ½offsetοΏ½countr
r
r
οΏ½
substringDataοΏ½szCharacterData.substringDatacCs|j||_dSr%r3)rοΏ½argr
r
r
οΏ½
appendDataszCharacterData.appendDatacCsZ|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|rVd|jd|οΏ½||j|dοΏ½f|_dS)NrrBrCοΏ½%s%s%srE)rrHrKr
r
r
οΏ½
insertData	sοΏ½zCharacterData.insertDatacCsl|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|dkrBtjοΏ½dοΏ½οΏ½|rh|jd|οΏ½|j||dοΏ½|_dSrArErGr
r
r
οΏ½
deleteDataszCharacterData.deleteDatacCsr|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|dkrBtjοΏ½dοΏ½οΏ½|rnd|jd|οΏ½||j||dοΏ½f|_dS)NrrBrCrDrMrE)rrHrIrKr
r
r
οΏ½replaceDatasοΏ½zCharacterData.replaceDataN)r{r|r}rοΏ½rοΏ½rοΏ½rοΏ½r=r?rοΏ½rPrοΏ½rrJrLrNrOrPr
r
r
r
r:οΏ½s			
r:zLength of the string data.c@sHeZdZdZejZdZdZddοΏ½Z	dddοΏ½Z
d	d
οΏ½ZddοΏ½Zd
dοΏ½Z
dS)rοΏ½r
z#textNcCsοΏ½|dks|t|jοΏ½kr"tjοΏ½dοΏ½οΏ½|οΏ½οΏ½}|j|dοΏ½|_|j|_|j}|jr~||jj	kr~|dkrp|jοΏ½
|οΏ½n|jοΏ½||οΏ½|jd|οΏ½|_|S)Nrzillegal offset value)rοΏ½rPr6r7rFrrXrCr:r'r<r4)rrHZnewTextοΏ½nextr
r
r
οΏ½	splitText1szText.splitTextrcCst|d||j|fοΏ½dS)NrM)rοΏ½rPr9r
r
r
r@sz
Text.writexmlcCsοΏ½|jg}|j}|dk	rB|jtjtjfkrB|οΏ½d|jοΏ½|j}qqBq|j}|dk	rz|jtjtjfkrz|οΏ½|jοΏ½|j}qHqzqHdοΏ½	|οΏ½S)Nrr)
rPrDrr	rOrοΏ½rBrCrRοΏ½join)rrUrοΏ½r
r
r
οΏ½_get_wholeTextEszText._get_wholeTextcCsοΏ½|j}|j}|dk	r@|jtjtjfkr@|j}|οΏ½|οΏ½|}qq@q|j}|sT|οΏ½|οΏ½|dk	rοΏ½|jtjtjfkrοΏ½|j}|οΏ½|οΏ½|}qTqοΏ½qT|rοΏ½||_|SdSdSr%)	r:rDrr	rOrοΏ½r;rCrP)rZcontentrοΏ½rοΏ½rQr
r
r
οΏ½replaceWholeTextWs*


zText.replaceWholeTextcCsF|jοΏ½οΏ½rdSt|οΏ½}|dkr"dS|jοΏ½|οΏ½}|dkr:dS|οΏ½οΏ½SdSr)rPοΏ½stripοΏ½_get_containing_elementrXrοΏ½οΏ½isElementContent)rrοΏ½rοΏ½r
r
r
οΏ½!_get_isWhitespaceInElementContentss
z&Text._get_isWhitespaceInElementContent)rrr)r{r|r}rοΏ½r	rOrrοΏ½rοΏ½rRrrTrUrYr
r
r
r
rοΏ½*s
rοΏ½ZisWhitespaceInElementContentzKTrue iff this text node contains only whitespace and is in element content.Z	wholeTextz.The text of all logically-adjacent text nodes.cCs*|j}|dk	r&|jtjkr|S|j}qdSr%)r:rr	rSοΏ½rHrGr
r
r
rWοΏ½srWcCs*|j}|dk	r&|jtjkr|S|j}qdSr%)r:rr	rοΏ½rZr
r
r
r(οΏ½sr(c@s(eZdZejZdZddοΏ½ZdddοΏ½ZdS)	οΏ½Commentz#commentcCstοΏ½|οΏ½||_dSr%)r:rοΏ½r;r>r
r
r
rοΏ½οΏ½s
zComment.__init__rcCs,d|jkrtdοΏ½οΏ½|οΏ½d||j|fοΏ½dS)Nz--z%'--' is not allowed in a comment nodez
%s<!--%s-->%s)rPr>rοΏ½r9r
r
r
rοΏ½s
zComment.writexmlN)rrr)	r{r|r}r	rοΏ½rrοΏ½rοΏ½rr
r
r
r
r[οΏ½sr[c@s$eZdZdZejZdZdddοΏ½ZdS)οΏ½CDATASectionr
z#cdata-sectionrcCs,|jοΏ½dοΏ½dkrtdοΏ½οΏ½|οΏ½d|jοΏ½dS)Nz]]>rz$']]>' not allowed in a CDATA sectionz<![CDATA[%s]]>)rPοΏ½findr>rοΏ½r9r
r
r
rοΏ½szCDATASection.writexmlN)rrr)	r{r|r}rοΏ½r	rοΏ½rrοΏ½rr
r
r
r
r\οΏ½sr\c@szeZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½ReadOnlySequentialNamedNodeMapοΏ½οΏ½_seqr
cCs
||_dSr%r_)rοΏ½seqr
r
r
rοΏ½οΏ½sz'ReadOnlySequentialNamedNodeMap.__init__cCs
t|jοΏ½Sr%οΏ½rοΏ½r`rr
r
r
rοΏ½οΏ½sz&ReadOnlySequentialNamedNodeMap.__len__cCs
t|jοΏ½Sr%rbrr
r
r
rοΏ½οΏ½sz*ReadOnlySequentialNamedNodeMap._get_lengthcCs"|jD]}|j|kr|SqdSr%)r`rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s

z+ReadOnlySequentialNamedNodeMap.getNamedItemcCs,|jD] }|j|kr|j|kr|SqdSr%)r`r~rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s
z-ReadOnlySequentialNamedNodeMap.getNamedItemNScCs4t|tοΏ½r|j|οΏ½}n
|οΏ½|οΏ½}|dkr0t|οΏ½οΏ½|Sr%)rοΏ½r3rοΏ½rοΏ½ri)rZ
name_or_tuplerHr
r
r
rοΏ½οΏ½s

z*ReadOnlySequentialNamedNodeMap.__getitem__cCs4|dkrdSz|j|WStk
r.YdSXdSr+)r`rοΏ½rοΏ½r
r
r
rοΏ½οΏ½sz#ReadOnlySequentialNamedNodeMap.itemcCstjοΏ½dοΏ½οΏ½dSοΏ½Nz"NamedNodeMap instance is read-onlyοΏ½r6r7r)rοΏ½r
r
r
rοΏ½οΏ½sοΏ½z.ReadOnlySequentialNamedNodeMap.removeNamedItemcCstjοΏ½dοΏ½οΏ½dSrcrdrοΏ½r
r
r
rοΏ½οΏ½sοΏ½z0ReadOnlySequentialNamedNodeMap.removeNamedItemNScCstjοΏ½dοΏ½οΏ½dSrcrdrοΏ½r
r
r
rοΏ½οΏ½sοΏ½z+ReadOnlySequentialNamedNodeMap.setNamedItemcCstjοΏ½dοΏ½οΏ½dSrcrdrοΏ½r
r
r
rοΏ½οΏ½sοΏ½z-ReadOnlySequentialNamedNodeMap.setNamedItemNScCs|jgSr%r_rr
r
r
rοΏ½οΏ½sz+ReadOnlySequentialNamedNodeMap.__getstate__cCs|d|_dSr+r_rοΏ½r
r
r
rοΏ½οΏ½sz+ReadOnlySequentialNamedNodeMap.__setstate__N)r
)r{r|r}rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
r^οΏ½s
	r^z&Number of entries in the NamedNodeMap.c@s,eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	S)
οΏ½
Identifiedz@Mix-in class that supports the publicId and systemId attributes.οΏ½οΏ½publicIdοΏ½systemIdcCs||_||_dSr%rf)rrgrhr
r
r
οΏ½_identified_mixin_initοΏ½sz!Identified._identified_mixin_initcCs|jSr%)rgrr
r
r
οΏ½
_get_publicIdοΏ½szIdentified._get_publicIdcCs|jSr%)rhrr
r
r
οΏ½
_get_systemIdοΏ½szIdentified._get_systemIdN)r{r|r}rοΏ½rοΏ½rirjrkr
r
r
r
reοΏ½s
rec@sHeZdZejZdZdZdZdZ	dZ
ddοΏ½ZddοΏ½ZddοΏ½Z
dd	d
οΏ½ZdS)οΏ½DocumentTypeNcCs2tοΏ½|_tοΏ½|_|r&t|οΏ½\}}||_|j|_dSr%)r^οΏ½entitiesοΏ½	notationsrrοΏ½rοΏ½)rrrrr
r
r
rοΏ½
szDocumentType.__init__cCs|jSr%)οΏ½internalSubsetrr
r
r
οΏ½_get_internalSubsetsz DocumentType._get_internalSubsetcCsοΏ½|jdkrοΏ½tdοΏ½}|j|_|j|_tjjj}|rοΏ½g|j_	g|j
_	|j
j	D]2}t|j|j|j
οΏ½}|j
j	οΏ½|οΏ½|οΏ½|||οΏ½qH|jj	D]N}t|j|j|j
|jοΏ½}|j|_|j|_|j|_|jj	οΏ½|οΏ½|οΏ½|||οΏ½qοΏ½|οΏ½|||οΏ½|SdSdSr%)rXrlrοΏ½rοΏ½r6r7οΏ½UserDataHandlerοΏ½NODE_CLONEDrmr`rnοΏ½NotationrgrhrRrvοΏ½EntityοΏ½notationNameοΏ½actualEncodingrr_)rrYοΏ½clonertrοΏ½οΏ½notationοΏ½eοΏ½entityr
r
r
rZs0

οΏ½zDocumentType.cloneNodercCsοΏ½|οΏ½dοΏ½|οΏ½|jοΏ½|jr8|οΏ½d||j||jfοΏ½n|jrR|οΏ½d||jfοΏ½|jdk	r||οΏ½dοΏ½|οΏ½|jοΏ½|οΏ½dοΏ½|οΏ½d|οΏ½dS)Nz
<!DOCTYPE z%s  PUBLIC '%s'%s  '%s'z%s  SYSTEM '%s'z [οΏ½]rοΏ½)rοΏ½rοΏ½rgrhror9r
r
r
r0s
οΏ½


zDocumentType.writexml)rrr)r{r|r}r	οΏ½DOCUMENT_TYPE_NODErrοΏ½rοΏ½rgrhrorοΏ½rprZrr
r
r
r
rlsrlc@sfeZdZdZejZdZdZdZ	dZ
ddοΏ½ZddοΏ½ZddοΏ½Z
dd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½ZddοΏ½ZdS)rtNcCs$||_||_tοΏ½|_|οΏ½||οΏ½dSr%)rοΏ½rurwr'ri)rrοΏ½rgrhrxr
r
r
rοΏ½GszEntity.__init__cCs|jSr%οΏ½rvrr
r
r
οΏ½_get_actualEncodingMszEntity._get_actualEncodingcCs|jSr%οΏ½rrr
r
r
οΏ½
_get_encodingPszEntity._get_encodingcCs|jSr%οΏ½r_rr
r
r
οΏ½_get_versionSszEntity._get_versioncCstjοΏ½dοΏ½οΏ½dS)Nz(cannot append children to an entity nodeοΏ½r6r7r8)rrEr
r
r
r<VsοΏ½zEntity.appendChildcCstjοΏ½dοΏ½οΏ½dS)Nz+cannot insert children below an entity noderοΏ½r.r
r
r
r4ZsοΏ½zEntity.insertBeforecCstjοΏ½dοΏ½οΏ½dS)Nz*cannot remove children from an entity noderοΏ½rNr
r
r
r;^sοΏ½zEntity.removeChildcCstjοΏ½dοΏ½οΏ½dS)Nz)cannot replace children of an entity noderοΏ½r/r
r
r
rLbsοΏ½zEntity.replaceChild)r{r|r}rοΏ½r	ZENTITY_NODErrοΏ½rvrr_rοΏ½r~rοΏ½rοΏ½r<r4r;rLr
r
r
r
rt>srtc@seZdZejZdZddοΏ½ZdS)rsNcCs||_|οΏ½||οΏ½dSr%)rοΏ½ri)rrοΏ½rgrhr
r
r
rοΏ½jszNotation.__init__)r{r|r}r	rοΏ½rrοΏ½rοΏ½r
r
r
r
rsfsrsc@sHeZdZddddddddgZd	d
οΏ½ZddοΏ½Zd
dοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½DOMImplementation)οΏ½coreοΏ½1.0)rοΏ½οΏ½2.0)rοΏ½N)r6rοΏ½)r6rοΏ½)r6N)οΏ½ls-loadz3.0)rοΏ½NcCs|dkrd}|οΏ½οΏ½|f|jkSr)οΏ½lowerοΏ½	_featuresr]r
r
r
r\zszDOMImplementation.hasFeaturec	CsοΏ½|r|jdk	rtjοΏ½dοΏ½οΏ½|οΏ½οΏ½}|dko8|dko8|dk}|sP|rPtjοΏ½dοΏ½οΏ½|rοΏ½t|οΏ½\}}|dkr||dkr|tjοΏ½dοΏ½οΏ½|rοΏ½|sοΏ½tjοΏ½dοΏ½οΏ½|οΏ½||οΏ½}|rοΏ½|οΏ½	|οΏ½|οΏ½	|οΏ½|rοΏ½||_|_
||_||_|S)Nz(doctype object owned by another DOM treezElement with no namer6z$http://www.w3.org/XML/1998/namespacezillegal use of 'xml' prefixz(illegal use of prefix without namespaces)
r:r6r7οΏ½WrongDocumentErrοΏ½_create_documentZInvalidCharacterErrrrοΏ½οΏ½createElementNSr<rXοΏ½doctyper[)	rr~rrοΏ½rοΏ½Zadd_root_elementrrr*r
r
r
οΏ½createDocuments>οΏ½οΏ½οΏ½
οΏ½οΏ½

z DOMImplementation.createDocumentcCst|οΏ½}||_||_|Sr%)rlrgrh)rrrgrhrοΏ½r
r
r
οΏ½createDocumentTypeοΏ½sz$DOMImplementation.createDocumentTypecCs|οΏ½|dοΏ½r|SdSdSr%)r\rer
r
r
rfοΏ½szDOMImplementation.getInterfacecCstοΏ½Sr%)οΏ½Documentrr
r
r
rοΏ½οΏ½sz"DOMImplementation._create_documentN)	r{r|r}rοΏ½r\rοΏ½rοΏ½rfrοΏ½r
r
r
r
rοΏ½osοΏ½
-rοΏ½c@s\eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Z	d
dοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
dS)οΏ½ElementInfozοΏ½Object that represents content-model information for an element.

    This implementation is not expected to be used in practice; DOM
    builders should provide implementations which do the right thing
    using information available to it.

    rcCs
||_dSr%rrοΏ½r
r
r
rοΏ½οΏ½szElementInfo.__init__cCstSr%οΏ½rοΏ½οΏ½rZanamer
r
r
rοΏ½οΏ½szElementInfo.getAttributeTypecCstSr%rοΏ½rοΏ½r
r
r
rοΏ½οΏ½szElementInfo.getAttributeTypeNScCsdSrr
rr
r
r
rXοΏ½szElementInfo.isElementContentcCsdS)zQReturns true iff this element is declared to have an EMPTY
        content model.Fr
rr
r
r
οΏ½isEmptyοΏ½szElementInfo.isEmptycCsdS)z7Returns true iff the named attribute is a DTD-style ID.Fr
rοΏ½r
r
r
rοΏ½οΏ½szElementInfo.isIdcCsdS)z<Returns true iff the identified attribute is a DTD-style ID.Fr
rοΏ½r
r
r
rοΏ½οΏ½szElementInfo.isIdNScCs|jSr%rrr
r
r
rοΏ½οΏ½szElementInfo.__getstate__cCs
||_dSr%rrοΏ½r
r
r
rοΏ½οΏ½szElementInfo.__setstate__N)r{r|r}rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rXrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
rοΏ½οΏ½srοΏ½cCs>|jtjkr|jοΏ½οΏ½d|_nt|οΏ½r:|jjοΏ½οΏ½d|j_dSr%)rr	rοΏ½	_id_cacheοΏ½clearοΏ½_id_search_stackrοΏ½rXrοΏ½r
r
r
rAοΏ½s
rAc@sreZdZdZejejejejfZ	e
οΏ½ZejZ
dZdZdZdZdZZdZdZdZdZdZdZdZdZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½Z ddοΏ½Z!ddοΏ½Z"ddοΏ½Z#ddοΏ½Z$ddοΏ½Z%ddοΏ½Z&ddοΏ½Z'ddοΏ½Z(d d!οΏ½Z)d"d#οΏ½Z*d$d%οΏ½Z+d&d'οΏ½Z,d(d)οΏ½Z-d*d+οΏ½Z.d,d-οΏ½Z/d.d/οΏ½Z0d0d1οΏ½Z1d2d3οΏ½Z2d4d5οΏ½Z3d6d7οΏ½Z4d8d9οΏ½Z5d:d;οΏ½Z6d<d=οΏ½Z7d>d?οΏ½Z8d@dAοΏ½Z9dBdCοΏ½Z:dIdEdFοΏ½Z;dGdHοΏ½Z<dS)JrοΏ½)οΏ½
_elem_inforοΏ½rοΏ½r'rοΏ½z	#documentNFrcCs$d|_tοΏ½|_i|_i|_d|_dSr%)rοΏ½rwr'rοΏ½rοΏ½rοΏ½rr
r
r
rοΏ½s
zDocument.__init__cCs&|jr|j|jf}n|j}|jοΏ½|οΏ½Sr%)r~rοΏ½rοΏ½rοΏ½rοΏ½)rr*rkr
r
r
rοΏ½szDocument._get_elem_infocCs|jSr%r}rr
r
r
r~szDocument._get_actualEncodingcCs|jSr%)rοΏ½rr
r
r
οΏ½_get_doctypeszDocument._get_doctypecCs|jSr%)οΏ½documentURIrr
r
r
οΏ½_get_documentURI!szDocument._get_documentURIcCs|jSr%rrr
r
r
rοΏ½$szDocument._get_encodingcCs|jSr%)οΏ½errorHandlerrr
r
r
οΏ½_get_errorHandler'szDocument._get_errorHandlercCs|jSr%)οΏ½
standalonerr
r
r
οΏ½_get_standalone*szDocument._get_standalonecCs|jSr%)οΏ½strictErrorCheckingrr
r
r
οΏ½_get_strictErrorChecking-sz!Document._get_strictErrorCheckingcCs|jSr%rοΏ½rr
r
r
rοΏ½0szDocument._get_versioncCsj|j|jkr(tjοΏ½dt|οΏ½t|οΏ½fοΏ½οΏ½|jdk	r>|jοΏ½|οΏ½|jtj	kr^|οΏ½
οΏ½r^tjοΏ½dοΏ½οΏ½tοΏ½||οΏ½S)Nr0z two document elements disallowed)rr5r6r7r8r9r:r;r	rSοΏ½_get_documentElementr<rοΏ½r
r
r
r<3sοΏ½
οΏ½οΏ½zDocument.appendChildcCsVz|jοΏ½|οΏ½Wntk
r.tjοΏ½οΏ½οΏ½YnXd|_|_d|_|j	|krRd|_	|Sr%)
r'rMr>r6r7r?rCrDr:οΏ½documentElementrNr
r
r
r;Cs
zDocument.removeChildcCs$|jD]}|jtjkr|SqdSr%)r'rr	rSrοΏ½r
r
r
rοΏ½Os
zDocument._get_documentElementcCs(|jdk	r|jοΏ½οΏ½d|_tοΏ½|οΏ½dSr%)rοΏ½rQr	rr
r
r
rQTs

zDocument.unlinkcCsοΏ½|sdS|jοΏ½dddοΏ½}|j|_|j|_|j|_|jD]B}t|||οΏ½}|jοΏ½|οΏ½|jt	j
kr`n|jt	jkrr||_||_
q6|οΏ½tjjj||οΏ½|Sr%)r[rοΏ½rrοΏ½r_r'rWrRrr	rr|rοΏ½r:rvr6r7rqrr)rrYrwrοΏ½Z
childcloner
r
r
rZZs&
οΏ½zDocument.cloneNodecCstοΏ½}||_|Sr%)rοΏ½rX)rror
r
r
οΏ½createDocumentFragmentoszDocument.createDocumentFragmentcCst|οΏ½}||_|Sr%)rrX)rrοΏ½ryr
r
r
οΏ½
createElementtszDocument.createElementcCs(t|tοΏ½stdοΏ½οΏ½tοΏ½}||_||_|SοΏ½Nznode contents must be a string)rοΏ½rοΏ½rοΏ½rοΏ½rPrX)rrPοΏ½tr
r
r
οΏ½createTextNodeys
zDocument.createTextNodecCs(t|tοΏ½stdοΏ½οΏ½tοΏ½}||_||_|SrοΏ½)rοΏ½rοΏ½rοΏ½r\rPrXοΏ½rrPrGr
r
r
οΏ½createCDATASectionοΏ½s
zDocument.createCDATASectioncCst|οΏ½}||_|Sr%)r[rXrοΏ½r
r
r
οΏ½
createCommentοΏ½szDocument.createCommentcCst||οΏ½}||_|Sr%)r0rX)rr2rPοΏ½pr
r
r
οΏ½createProcessingInstructionοΏ½s
z$Document.createProcessingInstructioncCst|οΏ½}||_d|_|Sr)rοΏ½rXrοΏ½)rrοΏ½οΏ½ar
r
r
οΏ½createAttributeοΏ½szDocument.createAttributecCs"t|οΏ½\}}t|||οΏ½}||_|Sr%)rrrX)rr~rrrοΏ½ryr
r
r
rοΏ½οΏ½szDocument.createElementNScCs*t|οΏ½\}}t||||οΏ½}||_d|_|Sr)rrοΏ½rXrοΏ½)rr~rrrοΏ½rοΏ½r
r
r
οΏ½createAttributeNSοΏ½s
zDocument.createAttributeNScCst||||οΏ½}||_|Sr%)rtrX)rrοΏ½rgrhruryr
r
r
οΏ½_create_entityοΏ½szDocument._create_entitycCst|||οΏ½}||_|Sr%)rsrX)rrοΏ½rgrhrοΏ½r
r
r
οΏ½_create_notationοΏ½szDocument._create_notationcCsοΏ½||jkr|j|S|js$|js$dS|j}|dkrB|jg}||_n|sJdSd}|οΏ½rοΏ½|οΏ½οΏ½}|οΏ½ddοΏ½|jDοΏ½οΏ½|οΏ½|οΏ½}|οΏ½rB|j	οΏ½
οΏ½D]οΏ½}|jrοΏ½|οΏ½|j|j
οΏ½rοΏ½||j|j<|j|krοΏ½|}n|jsοΏ½οΏ½qοΏ½qοΏ½|οΏ½|jοΏ½οΏ½r
||j|j<|j|krοΏ½|}n|jοΏ½s>οΏ½qοΏ½qοΏ½|jrοΏ½||j|j<|j|kοΏ½r.|}qοΏ½|jdkrοΏ½οΏ½qοΏ½qοΏ½n>|jοΏ½rοΏ½|j	οΏ½
οΏ½D]*}|jοΏ½rT||j|j<|j|kοΏ½rT|}οΏ½qT|dk	rNοΏ½qοΏ½qN|S)NcSsg|]}|jtkr|οΏ½qSr
)rr@)οΏ½.0rVr
r
r
οΏ½
<listcomp>οΏ½s
οΏ½z+Document.getElementById.<locals>.<listcomp>r1)rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½popοΏ½extendr'rοΏ½rοΏ½rοΏ½r~rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½)rrοΏ½οΏ½stackοΏ½resultrHrοΏ½r	r
r
r
οΏ½getElementByIdοΏ½sZ






zDocument.getElementByIdcCst||tοΏ½οΏ½Sr%rrοΏ½r
r
r
rοΏ½szDocument.getElementsByTagNamecCst|||tοΏ½οΏ½Sr%rrοΏ½r
r
r
r οΏ½sοΏ½zDocument.getElementsByTagNameNScCs|jοΏ½||οΏ½Sr%)r[r\r]r
r
r
r`οΏ½szDocument.isSupportedcCs>|jtjkrtjοΏ½dοΏ½οΏ½n|jtjkr2tjοΏ½dοΏ½οΏ½t|||οΏ½S)Nzcannot import document nodesz!cannot import document type nodes)rr	rr6r7οΏ½NotSupportedErrr|rW)rrHrYr
r
r
οΏ½
importNodeοΏ½s
zDocument.importNodercCsJ|dkr|οΏ½d|οΏ½n|οΏ½d||fοΏ½|jD]}|οΏ½||||οΏ½q0dS)Nz<?xml version="1.0" ?>z%<?xml version="1.0" encoding="%s"?>%s)rοΏ½r'r)rr$r"r"r#rrHr
r
r
rοΏ½sοΏ½
zDocument.writexmlcCsJ|j|k	r tjοΏ½d||jfοΏ½οΏ½|jtjtjfkr>tjοΏ½dοΏ½οΏ½|t	krοΏ½d|krοΏ½|οΏ½
ddοΏ½\}}|dkrοΏ½|tjjkrοΏ½tjοΏ½dοΏ½οΏ½qοΏ½|dkrοΏ½|tjjkrοΏ½|jtjkrοΏ½tjοΏ½dοΏ½οΏ½d}|}nd}d}|jtjkrοΏ½|j
}|dk	rοΏ½|j}|οΏ½|οΏ½nd}||_||_||_||_|jtjkοΏ½r||_n*||_|dk	οΏ½rF|οΏ½|οΏ½|οΏ½rF|οΏ½|οΏ½|S)Nz?cannot rename nodes from other documents;
expected %s,
found %sz8renameNode() only applies to element and attribute nodesrοΏ½r1rοΏ½zillegal use of 'xmlns' prefixz$illegal use of the 'xmlns' attribute)rXr6r7rοΏ½rr	rSrοΏ½rοΏ½rrοΏ½rrοΏ½rοΏ½rοΏ½rrrοΏ½r~rοΏ½rοΏ½rοΏ½r
r$)rrοΏ½r~rοΏ½rrοΏ½r*Zis_idr
r
r
οΏ½
renameNode	sb
οΏ½οΏ½οΏ½
οΏ½οΏ½
οΏ½
οΏ½οΏ½


zDocument.renameNode)rrrN)=r{r|r}rοΏ½r	rSrοΏ½rοΏ½r|r5rοΏ½r[rrrοΏ½rοΏ½rοΏ½r:rDrCrvrrοΏ½r_rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r~rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r<r;rοΏ½rQrZrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rr r`rοΏ½rrοΏ½r
r
r
r
rοΏ½οΏ½sjοΏ½	
:
rοΏ½rοΏ½z#Top-level element of this document.c
CsοΏ½|jοΏ½|οΏ½rtjjj}n
tjjj}|jtj	krοΏ½|οΏ½
|j|jοΏ½}|j
οΏ½οΏ½D]0}|οΏ½|j|j|jοΏ½|οΏ½|j|jοΏ½}|j|_qH|rοΏ½|jD]}t|||οΏ½}|οΏ½|οΏ½qοΏ½οΏ½n|jtjkrοΏ½|οΏ½οΏ½}|rοΏ½|jD]}t|||οΏ½}|οΏ½|οΏ½qnοΏ½|jtjkrοΏ½|οΏ½|jοΏ½}οΏ½nοΏ½|jtjkοΏ½r|οΏ½|jοΏ½}οΏ½nοΏ½|jtjkοΏ½r>|οΏ½|j |jοΏ½}οΏ½nj|jtj!kοΏ½r\|οΏ½"|jοΏ½}οΏ½nL|jtj#kοΏ½rοΏ½|οΏ½$|j|jοΏ½}d|_|j|_οΏ½n|jtj%kοΏ½rοΏ½tjjj}|j&οΏ½'|j(|j)|j*οΏ½}||_|οΏ½rοΏ½g|j+_,g|j-_,|j-j,D]F}	t.|	j|	j)|	j*οΏ½}
||
_|j-j,οΏ½/|
οΏ½t0|	dοΏ½οΏ½rοΏ½|	οΏ½1||	|
οΏ½οΏ½qοΏ½|j+j,D]b}t2|j|j)|j*|j3οΏ½}|j4|_4|j5|_5|j6|_6||_|j+j,οΏ½/|οΏ½t0|dοΏ½οΏ½r.|οΏ½1|||οΏ½οΏ½q.ntjοΏ½7dt8|οΏ½οΏ½οΏ½t0|dοΏ½οΏ½rοΏ½|οΏ½1|||οΏ½|S)zo
    Clone a node and give it the new owner document.
    Called by Node.cloneNode and Document.importNode
    TrvzCannot clone node %s)9rXrdr6r7rqrrZ
NODE_IMPORTEDrr	rSrοΏ½r~rοΏ½rοΏ½rοΏ½rrοΏ½rrοΏ½rοΏ½r'rWr<r2rοΏ½rOrοΏ½rPrοΏ½rοΏ½rοΏ½rοΏ½r2rοΏ½rοΏ½rοΏ½rοΏ½r|r[rοΏ½rοΏ½rgrhrmr`rnrsrRrqrvrtrurvrr_rοΏ½r9)
rHrYZnewOwnerDocumentrtrwr	rοΏ½rVrGrοΏ½rxryrzr
r
r
rWBsοΏ½
οΏ½


οΏ½οΏ½
οΏ½οΏ½rWcCs,|οΏ½ddοΏ½}t|οΏ½dkr|Sd|dfSdS)NrοΏ½r1οΏ½r)rοΏ½rοΏ½)rZfieldsr
r
r
rοΏ½srcCs,|||οΏ½}|οΏ½οΏ½\}}|οΏ½|οΏ½|οΏ½οΏ½|Sr%)ZgetEventZ
expandNoderοΏ½)οΏ½funcοΏ½argsοΏ½kwargsZeventsZtoktypeZrootNoder
r
r
οΏ½_do_pulldom_parseοΏ½s


rοΏ½cCsH|dkr"|s"ddlm}|οΏ½|οΏ½Sddlm}t|j|f||dοΏ½οΏ½SdS)z3Parse a file into a DOM by filename or file object.NrοΏ½οΏ½expatbuilderοΏ½οΏ½pulldom)οΏ½parserοΏ½bufsize)οΏ½xml.domrοΏ½οΏ½parserοΏ½rοΏ½)οΏ½filerοΏ½rοΏ½rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s

οΏ½rοΏ½cCsB|dkrddlm}|οΏ½|οΏ½Sddlm}t|j|fd|iοΏ½SdS)z&Parse a file into a DOM from a string.NrrοΏ½rοΏ½rοΏ½)rοΏ½rοΏ½οΏ½parseStringrοΏ½rοΏ½)οΏ½stringrοΏ½rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s

οΏ½rοΏ½cCs@|r:t|tοΏ½rtοΏ½|οΏ½}|D]\}}tjοΏ½||οΏ½sdSqtjSr%)rοΏ½rοΏ½rZ_parse_feature_stringrοΏ½r[r\)ZfeaturesοΏ½fοΏ½vr
r
r
οΏ½getDOMImplementationοΏ½s

rοΏ½)NN)N)N)7rοΏ½rrοΏ½r6rrrrZxml.dom.minicompatZxml.dom.xmlbuilderrrr7r	rSrοΏ½r@ZdefpropertyrJrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½objectrοΏ½Z
AttributeListrοΏ½rοΏ½rrr+r0r:rοΏ½rWr(r[r\r^rerlrtrsrοΏ½rοΏ½rArοΏ½rWrrοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
οΏ½<module>sοΏ½οΏ½v
	y$οΏ½
xοΏ½οΏ½)GUοΏ½οΏ½	>οΏ½<(	O*PοΏ½R



U

e5dοΏ½οΏ½@sοΏ½GddοΏ½dοΏ½ZdZdZdZdZdZdZdZd	Zd
Z	dZ
dZd
ZdZ
dZdZdZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGd d!οΏ½d!eοΏ½ZGd"d#οΏ½d#eοΏ½ZGd$d%οΏ½d%eοΏ½ZGd&d'οΏ½d'eοΏ½ZGd(d)οΏ½d)eοΏ½ZGd*d+οΏ½d+eοΏ½ZGd,d-οΏ½d-eοΏ½ZGd.d/οΏ½d/eοΏ½Z Gd0d1οΏ½d1eοΏ½Z!Gd2d3οΏ½d3eοΏ½Z"Gd4d5οΏ½d5οΏ½Z#d6Z$d7Z%d8Z&d9Z'd9Z(dd:l)m*Z*m+Z+d9S);c@s@eZdZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZ
dZd
ZdS)οΏ½NodeοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½	οΏ½
οΏ½οΏ½N)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½	__slots__ZELEMENT_NODEZATTRIBUTE_NODEZ	TEXT_NODEZCDATA_SECTION_NODEZENTITY_REFERENCE_NODEZENTITY_NODEZPROCESSING_INSTRUCTION_NODEZCOMMENT_NODEZ
DOCUMENT_NODEZDOCUMENT_TYPE_NODEZDOCUMENT_FRAGMENT_NODEZ
NOTATION_NODErrrοΏ½(/usr/lib64/python3.8/xml/dom/__init__.pyrs	rrrrrrrr	r
rrr
rοΏ½
οΏ½οΏ½οΏ½c@seZdZddοΏ½ZddοΏ½ZdS)οΏ½DOMExceptioncOs(|jtkrtdοΏ½οΏ½tj|f|οΏ½|οΏ½dS)Nz0DOMException should not be instantiated directly)οΏ½	__class__rοΏ½RuntimeErrorοΏ½	ExceptionοΏ½__init__)οΏ½selfοΏ½argsοΏ½kwrrrrBs

οΏ½zDOMException.__init__cCs|jS)N)οΏ½code)rrrrοΏ½	_get_codeHszDOMException._get_codeN)rrrrr!rrrrr>src@seZdZeZdS)οΏ½IndexSizeErrN)rrrοΏ½INDEX_SIZE_ERRr rrrrr"Lsr"c@seZdZeZdS)οΏ½DomstringSizeErrN)rrrοΏ½DOMSTRING_SIZE_ERRr rrrrr$Osr$c@seZdZeZdS)οΏ½HierarchyRequestErrN)rrrοΏ½HIERARCHY_REQUEST_ERRr rrrrr&Rsr&c@seZdZeZdS)οΏ½WrongDocumentErrN)rrrοΏ½WRONG_DOCUMENT_ERRr rrrrr(Usr(c@seZdZeZdS)οΏ½InvalidCharacterErrN)rrrοΏ½INVALID_CHARACTER_ERRr rrrrr*Xsr*c@seZdZeZdS)οΏ½NoDataAllowedErrN)rrrοΏ½NO_DATA_ALLOWED_ERRr rrrrr,[sr,c@seZdZeZdS)οΏ½NoModificationAllowedErrN)rrrοΏ½NO_MODIFICATION_ALLOWED_ERRr rrrrr.^sr.c@seZdZeZdS)οΏ½NotFoundErrN)rrrοΏ½
NOT_FOUND_ERRr rrrrr0asr0c@seZdZeZdS)οΏ½NotSupportedErrN)rrrοΏ½NOT_SUPPORTED_ERRr rrrrr2dsr2c@seZdZeZdS)οΏ½InuseAttributeErrN)rrrοΏ½INUSE_ATTRIBUTE_ERRr rrrrr4gsr4c@seZdZeZdS)οΏ½InvalidStateErrN)rrrοΏ½INVALID_STATE_ERRr rrrrr6jsr6c@seZdZeZdS)οΏ½	SyntaxErrN)rrrοΏ½
SYNTAX_ERRr rrrrr8msr8c@seZdZeZdS)οΏ½InvalidModificationErrN)rrrοΏ½INVALID_MODIFICATION_ERRr rrrrr:psr:c@seZdZeZdS)οΏ½NamespaceErrN)rrrοΏ½
NAMESPACE_ERRr rrrrr<ssr<c@seZdZeZdS)οΏ½InvalidAccessErrN)rrrοΏ½INVALID_ACCESS_ERRr rrrrr>vsr>c@seZdZeZdS)οΏ½
ValidationErrN)rrrοΏ½VALIDATION_ERRr rrrrr@ysr@c@seZdZdZdZdZdZdS)οΏ½UserDataHandlerrrrrN)rrrZNODE_CLONEDZ
NODE_IMPORTEDZNODE_DELETEDZNODE_RENAMEDrrrrrB|srBz$http://www.w3.org/XML/1998/namespacezhttp://www.w3.org/2000/xmlns/zhttp://www.w3.org/1999/xhtmlN)οΏ½getDOMImplementationοΏ½registerDOMImplementation),rr#r%r'r)r+r-r/r1r3r5r7r9r;r=r?rArrr"r$r&r(r*r,r.r0r2r4r6r8r:r<r>r@rBZ
XML_NAMESPACEZXMLNS_NAMESPACEZXHTML_NAMESPACEZEMPTY_NAMESPACEZEMPTY_PREFIXZdomregrCrDrrrrοΏ½<module>sP
U

e5d'
οΏ½@sJdZddddgZddlZefZGddοΏ½deοΏ½ZGddοΏ½deοΏ½Z	d	dοΏ½Z
dS)
zοΏ½Python version compatibility support for minidom.

This module contains internal implementation details and
should not be imported; use xml.dom.minidom instead.
οΏ½NodeListοΏ½
EmptyNodeListοΏ½StringTypesοΏ½defpropertyοΏ½Nc@s>eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zeeedd	οΏ½Zd
dοΏ½Z	dS)
rοΏ½cCs(d|krt|οΏ½kr$nn||SdSοΏ½NrοΏ½οΏ½lenοΏ½οΏ½selfοΏ½indexrrοΏ½*/usr/lib64/python3.8/xml/dom/minicompat.pyοΏ½item5sz
NodeList.itemcCst|οΏ½SοΏ½NrοΏ½rrrr
οΏ½_get_length9szNodeList._get_lengthcCstjοΏ½dοΏ½οΏ½dSοΏ½Nz.attempt to modify read-only attribute 'length'οΏ½οΏ½xmlοΏ½domοΏ½NoModificationAllowedErrοΏ½rοΏ½valuerrr
οΏ½_set_length<sοΏ½zNodeList._set_lengthοΏ½$The number of nodes in the NodeList.οΏ½οΏ½doccCs|dkrg}||ddοΏ½<dSrr)rοΏ½staterrr
οΏ½__setstate__DszNodeList.__setstate__N)
οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½	__slots__rrrοΏ½propertyοΏ½lengthrrrrr
r2sοΏ½c@sFeZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Ze	eedd
οΏ½Z
dS)rrcCstοΏ½}|οΏ½|οΏ½|SrοΏ½rοΏ½extendοΏ½rοΏ½otherοΏ½NLrrr
οΏ½__add__Ms
zEmptyNodeList.__add__cCstοΏ½}|οΏ½|οΏ½|Srr%r'rrr
οΏ½__radd__Rs
zEmptyNodeList.__radd__cCsdSrrr
rrr
rWszEmptyNodeList.itemcCsdSrrrrrr
rZszEmptyNodeList._get_lengthcCstjοΏ½dοΏ½οΏ½dSrrrrrr
r]sοΏ½zEmptyNodeList._set_lengthrrN)rr r!r"r*r+rrrr#r$rrrr
rJsοΏ½cCs8t|d|οΏ½}|fddοΏ½}t|||dοΏ½}t|||οΏ½dS)NZ_get_cSstjοΏ½dt|οΏ½οΏ½οΏ½dS)Nz&attempt to modify read-only attribute )rrrοΏ½repr)rrοΏ½namerrr
οΏ½setgs
οΏ½zdefproperty.<locals>.setr)οΏ½getattrr#οΏ½setattr)οΏ½klassr-rοΏ½getr.Zproprrr
res)οΏ½__doc__οΏ½__all__Zxml.domrοΏ½strrοΏ½listrοΏ½tuplerrrrrr
οΏ½<module>s*U

e5ds0οΏ½@sοΏ½dZddlZddlZddlZddlmZdddgZGddοΏ½dοΏ½ZGd	dοΏ½dοΏ½Z	d
dοΏ½Z
GddοΏ½deοΏ½ZGd
dοΏ½deοΏ½Z
GddοΏ½dοΏ½Z[GddοΏ½dοΏ½ZGddοΏ½dοΏ½ZdS)z4Implementation of the DOM Level 3 'LS-Load' feature.οΏ½N)οΏ½
NodeFilterοΏ½
DOMBuilderοΏ½DOMEntityResolverοΏ½DOMInputSourcec@s\eZdZdZdZdZdZdZdZdZ	dZ
dZdZdZ
dZdZdZdZdZdZdZdZdZdS)οΏ½OptionszοΏ½Features object that has variables set for each DOMBuilder feature.

    The DOMBuilder class uses an instance of this class to pass settings to
    the ExpatBuilder class.
    οΏ½TFN)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½__doc__οΏ½
namespacesοΏ½namespace_declarationsοΏ½
validationοΏ½external_parameter_entitiesοΏ½external_general_entitiesZexternal_dtd_subsetοΏ½validate_if_schemaZvalidateοΏ½datatype_normalizationοΏ½create_entity_ref_nodesοΏ½entitiesοΏ½whitespace_in_element_contentοΏ½cdata_sectionsοΏ½commentsοΏ½charset_overrides_xml_encodingοΏ½infosetοΏ½supported_mediatypes_onlyοΏ½errorHandlerοΏ½filterοΏ½rrοΏ½*/usr/lib64/python3.8/xml/dom/xmlbuilder.pyr
s(	rc@s&eZdZdZdZdZdZdZdZdZ	eeee	fZ
ddοΏ½Zdd	οΏ½Zd
dοΏ½Z
dd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zdgdgdgdgdgdgd gd!gd"gd#gd"d$gd%gd&gd'gd(gd)gd*gd+gd,gd-ggdd!d"d$d(d.d'd+d-g	d/gd0gd1gd2οΏ½Zd3d4οΏ½Zd5d6οΏ½Zd7d8οΏ½Zd9d:οΏ½Zd;d<οΏ½ZdS)=rNrοΏ½οΏ½οΏ½cCstοΏ½|_dSοΏ½N)rοΏ½_optionsοΏ½οΏ½selfrrrοΏ½__init__:szDOMBuilder.__init__cCs|jSr"οΏ½οΏ½entityResolverr$rrrοΏ½_get_entityResolver=szDOMBuilder._get_entityResolvercCs
||_dSr"r')r%r(rrrοΏ½_set_entityResolver?szDOMBuilder._set_entityResolvercCs|jSr"οΏ½rr$rrrοΏ½_get_errorHandlerBszDOMBuilder._get_errorHandlercCs
||_dSr"r+)r%rrrrοΏ½_set_errorHandlerDszDOMBuilder._set_errorHandlercCs|jSr"οΏ½rr$rrrοΏ½_get_filterGszDOMBuilder._get_filtercCs
||_dSr"r.)r%rrrrοΏ½_set_filterIszDOMBuilder._set_filtercCsοΏ½|οΏ½|οΏ½rt|rdpd}z|jt|οΏ½|f}Wn(tk
rTtjοΏ½d|fοΏ½dοΏ½YqοΏ½X|D]\}}t|j||οΏ½qZntjοΏ½	dt
|οΏ½οΏ½οΏ½dS)Nrrzunsupported feature: %rzunknown feature: )οΏ½supportsFeatureοΏ½	_settingsοΏ½_name_xformοΏ½KeyErrorοΏ½xmlοΏ½domοΏ½NotSupportedErrοΏ½setattrr#οΏ½NotFoundErrοΏ½repr)r%οΏ½nameοΏ½stateZsettingsοΏ½valuerrrοΏ½
setFeatureLs
οΏ½οΏ½zDOMBuilder.setFeaturecCst|jt|οΏ½οΏ½Sr")οΏ½hasattrr#r3)r%r;rrrr1ZszDOMBuilder.supportsFeaturecCst|οΏ½|rdpdf}||jkS)Nrr)r3r2)r%r;r<οΏ½keyrrrοΏ½
canSetFeature]szDOMBuilder.canSetFeatureοΏ½r
rοΏ½r
rοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rr)rrοΏ½rrοΏ½rrοΏ½rr)rBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrU)rr)rrrVrWrXcCsοΏ½t|οΏ½}zt|j|οΏ½WStk
rοΏ½|dkrp|j}|joj|joj|joj|joj|jph|j	ph|j
ph|jph|jYSt
jοΏ½dt|οΏ½οΏ½οΏ½YnXdS)Nrzfeature %s not known)r3οΏ½getattrr#οΏ½AttributeErrorrrrrr
rrrrr5r6r9r:)r%r;ZxnameοΏ½optionsrrrοΏ½
getFeatureοΏ½s0οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½	zDOMBuilder.getFeaturecCs.|jr|jοΏ½d|οΏ½}ntοΏ½οΏ½d|οΏ½}|οΏ½|οΏ½Sr")r(οΏ½
resolveEntityrοΏ½parse)r%οΏ½uriοΏ½inputrrrοΏ½parseURIοΏ½szDOMBuilder.parseURIcCsRtοΏ½|jοΏ½}|j|_|j|_|j}|dkrF|jrFddl}|jοΏ½|jοΏ½}|οΏ½	||οΏ½SοΏ½Nr)
οΏ½copyr#rrοΏ½
byteStreamοΏ½systemIdοΏ½urllib.requestοΏ½requestZurlopenοΏ½_parse_bytestream)r%r`r[οΏ½fpοΏ½urllibrrrr^οΏ½szDOMBuilder.parsecCs||jkrtdοΏ½οΏ½tdοΏ½οΏ½dS)Nznot a legal actionzHaven't written this yet...)οΏ½_legal_actionsοΏ½
ValueErrorοΏ½NotImplementedError)r%r`ZcnodeοΏ½actionrrrοΏ½parseWithContextοΏ½s
zDOMBuilder.parseWithContextcCs ddl}|jjοΏ½|οΏ½}|οΏ½|οΏ½Srb)Zxml.dom.expatbuilderr6ZexpatbuilderZmakeBuilderZ	parseFile)r%οΏ½streamr[r5ZbuilderrrrrhοΏ½szDOMBuilder._parse_bytestream)rr	r
r(rrZACTION_REPLACEZACTION_APPEND_AS_CHILDRENZACTION_INSERT_AFTERZACTION_INSERT_BEFORErkr&r)r*r,r-r/r0r>r1rAr2r\rar^rorhrrrrr-sοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½=
cCs|οΏ½οΏ½οΏ½ddοΏ½S)NοΏ½-οΏ½_)οΏ½lowerοΏ½replace)r;rrrr3οΏ½sr3c@s0eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
S)r)οΏ½_openerc
CsοΏ½tοΏ½}||_||_|οΏ½οΏ½οΏ½|οΏ½|_|οΏ½|οΏ½|_ddl}ddl	}|j
οΏ½|οΏ½}|\}}}	}
}}|	rοΏ½|	οΏ½dοΏ½sοΏ½|οΏ½
|	οΏ½d}	|||	|
||f}|j
οΏ½|οΏ½|_|S)NrοΏ½/)rοΏ½publicIdreοΏ½_get_openerοΏ½openrdοΏ½_guess_media_encodingοΏ½encodingοΏ½	posixpathZurllib.parser^ZurlparseοΏ½endswithοΏ½dirnameZ
urlunparseοΏ½baseURI)
r%rwreοΏ½sourcer|rjοΏ½partsZschemeZnetlocοΏ½pathZparamsZqueryZfragmentrrrr]οΏ½szDOMEntityResolver.resolveEntitycCs2z|jWStk
r,|οΏ½οΏ½|_|jYSXdSr")rurZοΏ½_create_openerr$rrrrxοΏ½s

zDOMEntityResolver._get_openercCsddl}|jοΏ½οΏ½Srb)rfrgZbuild_opener)r%rjrrrrοΏ½οΏ½sz DOMEntityResolver._create_openercCsF|jοΏ½οΏ½}d|krB|οΏ½οΏ½D]&}|οΏ½dοΏ½r|οΏ½ddοΏ½dοΏ½οΏ½SqdS)NzContent-Typezcharset=οΏ½=r)rdοΏ½infoZgetplistοΏ½
startswithοΏ½splitrs)r%rοΏ½rοΏ½ZparamrrrrzοΏ½s


z'DOMEntityResolver._guess_media_encodingN)rr	r
οΏ½	__slots__r]rxrοΏ½rzrrrrrοΏ½s
c@sοΏ½eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd S)!rοΏ½rdοΏ½characterStreamοΏ½
stringDatar{rwrercCs.d|_d|_d|_d|_d|_d|_d|_dSr"rοΏ½r$rrrr&szDOMInputSource.__init__cCs|jSr"οΏ½rdr$rrrοΏ½_get_byteStreamszDOMInputSource._get_byteStreamcCs
||_dSr"rοΏ½)r%rdrrrοΏ½_set_byteStreamszDOMInputSource._set_byteStreamcCs|jSr"οΏ½rοΏ½r$rrrοΏ½_get_characterStreamsz#DOMInputSource._get_characterStreamcCs
||_dSr"rοΏ½)r%rοΏ½rrrοΏ½_set_characterStreamsz#DOMInputSource._set_characterStreamcCs|jSr"οΏ½rοΏ½r$rrrοΏ½_get_stringDataszDOMInputSource._get_stringDatacCs
||_dSr"rοΏ½)r%οΏ½datarrrοΏ½_set_stringDataszDOMInputSource._set_stringDatacCs|jSr"οΏ½r{r$rrrοΏ½
_get_encodingszDOMInputSource._get_encodingcCs
||_dSr"rοΏ½)r%r{rrrοΏ½
_set_encodingszDOMInputSource._set_encodingcCs|jSr"οΏ½rwr$rrrοΏ½
_get_publicId"szDOMInputSource._get_publicIdcCs
||_dSr"rοΏ½)r%rwrrrοΏ½
_set_publicId$szDOMInputSource._set_publicIdcCs|jSr"οΏ½rer$rrrοΏ½
_get_systemId'szDOMInputSource._get_systemIdcCs
||_dSr"rοΏ½)r%rerrrοΏ½
_set_systemId)szDOMInputSource._set_systemIdcCs|jSr"οΏ½rr$rrrοΏ½_get_baseURI,szDOMInputSource._get_baseURIcCs
||_dSr"rοΏ½οΏ½r%r_rrrοΏ½_set_baseURI.szDOMInputSource._set_baseURIN)rr	r
rοΏ½r&rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrrs 	c@s>eZdZdZdZdZdZdZej	Z
ddοΏ½Zdd	οΏ½Zd
dοΏ½Z
dS)
οΏ½DOMBuilderFilterzSElement filter which can be used to tailor construction of
    a DOM instance.
    rrr r!cCs|jSr")οΏ½
whatToShowr$rrrοΏ½_get_whatToShowCsz DOMBuilderFilter._get_whatToShowcCs|jSr"οΏ½οΏ½
FILTER_ACCEPTοΏ½r%ZelementrrrοΏ½
acceptNodeFszDOMBuilderFilter.acceptNodecCs|jSr"rοΏ½rοΏ½rrrοΏ½startContainerIszDOMBuilderFilter.startContainerN)rr	r
rrοΏ½Z
FILTER_REJECTZFILTER_SKIPZFILTER_INTERRUPTrZSHOW_ALLrοΏ½rοΏ½rοΏ½rοΏ½rrrrrοΏ½2s	rοΏ½c@sDeZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Z	d
dοΏ½Z
dS)οΏ½
DocumentLSz=Mixin to create documents that conform to the load/save spec.FcCsdS)NFrr$rrrοΏ½
_get_asyncTszDocumentLS._get_asynccCs|rtjοΏ½dοΏ½οΏ½dS)Nz.asynchronous document loading is not supported)r5r6r7)r%οΏ½flagrrrοΏ½
_set_asyncWsοΏ½zDocumentLS._set_asynccCstdοΏ½οΏ½dS)Nz'haven't figured out what this means yetοΏ½rmr$rrrοΏ½abort\sοΏ½zDocumentLS.abortcCstdοΏ½οΏ½dSοΏ½Nzhaven't written this yetrοΏ½rοΏ½rrrοΏ½loadbszDocumentLS.loadcCstdοΏ½οΏ½dSrοΏ½rοΏ½)r%rοΏ½rrrοΏ½loadXMLeszDocumentLS.loadXMLcCs*|dkr|}n|j|k	r"tjοΏ½οΏ½οΏ½|οΏ½οΏ½Sr")Z
ownerDocumentr5r6ZWrongDocumentErrZtoxml)r%ZsnoderrrοΏ½saveXMLhs


zDocumentLS.saveXMLN)rr	r
rZasync_rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrrοΏ½OsrοΏ½c@s,eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	S)
οΏ½DOMImplementationLSrrcCsF|dk	rtjοΏ½dοΏ½οΏ½||jkr$tοΏ½S||jkr:tjοΏ½dοΏ½οΏ½tdοΏ½οΏ½dS)NzschemaType not yet supportedz'asynchronous builders are not supportedzunknown value for mode)r5r6r7οΏ½MODE_SYNCHRONOUSrοΏ½MODE_ASYNCHRONOUSrl)r%οΏ½modeZ
schemaTyperrrοΏ½createDOMBuildertsοΏ½

οΏ½z$DOMImplementationLS.createDOMBuildercCstdοΏ½οΏ½dS)Nz-the writer interface hasn't been written yet!rοΏ½r$rrrοΏ½createDOMWritersοΏ½z#DOMImplementationLS.createDOMWritercCstοΏ½Sr")rr$rrrοΏ½createDOMInputSourceοΏ½sz(DOMImplementationLS.createDOMInputSourceN)rr	r
rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrrοΏ½ps
rοΏ½)rrcοΏ½warningsZxml.domr5Zxml.dom.NodeFilterrοΏ½__all__rrr3οΏ½objectrrrοΏ½rοΏ½rοΏ½rrrrοΏ½<module>s
 %,1!U

e5d{
οΏ½@s@dZddlZdddοΏ½ZiZddοΏ½Zdd	οΏ½ZdddοΏ½Zd
dοΏ½ZdS)zοΏ½Registration facilities for DOM. This module should not be used
directly. Instead, the functions getDOMImplementation and
registerDOMImplementation should be imported from xml.dom.οΏ½Nzxml.dom.minidomzxml.dom.DOMImplementation)ZminidomZ4DOMcCs|t|<dS)aIregisterDOMImplementation(name, factory)

    Register the factory function with the name. The factory function
    should return an object which implements the DOMImplementation
    interface. The factory function can either return the same object,
    or a new one (e.g. if that implementation supports some
    customization).N)οΏ½
registered)οΏ½nameοΏ½factoryοΏ½rοΏ½&/usr/lib64/python3.8/xml/dom/domreg.pyοΏ½registerDOMImplementations	rcCs$|D]\}}|οΏ½||οΏ½sdSqdS)zF_good_enough(dom, features) -> Return 1 if the dom offers the featuresrοΏ½)Z
hasFeature)οΏ½domοΏ½featuresοΏ½fοΏ½vrrrοΏ½_good_enough sr
rc	CsοΏ½ddl}d}tοΏ½|οΏ½}|r2t|iidgοΏ½}|οΏ½οΏ½S|r@t|οΏ½Stjjsbd|j	krbt|j	ddοΏ½St
|tοΏ½rtt|οΏ½}tοΏ½
οΏ½D]}|οΏ½}t||οΏ½r||Sq|tοΏ½οΏ½D]>}zt|dοΏ½}Wntk
rοΏ½YqοΏ½YnXt||οΏ½rοΏ½|SqοΏ½tdοΏ½οΏ½dS)aSgetDOMImplementation(name = None, features = ()) -> DOM implementation.

    Return a suitable DOM implementation. The name is either
    well-known, the module name of a DOM implementation, or None. If
    it is not None, imports the corresponding module and returns
    DOMImplementation object if the import succeeds.

    If name is not given, consider the available implementations to
    find one with the required feature set. If no implementation can
    be found, raise an ImportError. The features list must be a sequence
    of (feature, version) pairs which are passed to hasFeature.rNοΏ½getDOMImplementationZ
PYTHON_DOM)rz$no suitable DOM implementation found)οΏ½osοΏ½well_known_implementationsοΏ½getοΏ½
__import__rrοΏ½sysοΏ½flagsοΏ½ignore_environmentοΏ½environοΏ½
isinstanceοΏ½strοΏ½_parse_feature_stringοΏ½valuesr
οΏ½keysοΏ½	ExceptionοΏ½ImportError)rr
rZcreatorοΏ½modr	rrrr's0








rcCsοΏ½g}|οΏ½οΏ½}d}t|οΏ½}||krοΏ½||}|ddkrBtd|fοΏ½οΏ½|d}d}||krv||}|ddkrv|d}|}|οΏ½||fοΏ½qt|οΏ½S)NrοΏ½
0123456789zbad feature name: %rr)οΏ½splitοΏ½lenοΏ½
ValueErrorοΏ½appendοΏ½tuple)οΏ½sr
οΏ½partsοΏ½iZlengthZfeatureοΏ½versionrrrrrRs"r)Nr)οΏ½__doc__rrrrr
rrrrrrοΏ½<module>sοΏ½
+U

e5dοΏ½.οΏ½@sοΏ½ddlZddlZdZdZdZdZdZdZdZ	d	Z
Gd
dοΏ½dejjοΏ½Z
Gdd
οΏ½d
οΏ½ZGddοΏ½dοΏ½ZGddοΏ½de
οΏ½ZdZdddοΏ½ZdddοΏ½ZdS)οΏ½NοΏ½
START_ELEMENTοΏ½END_ELEMENTοΏ½COMMENTοΏ½START_DOCUMENTοΏ½END_DOCUMENTοΏ½PROCESSING_INSTRUCTIONοΏ½IGNORABLE_WHITESPACEοΏ½
CHARACTERSc@sοΏ½eZdZdZdZd$ddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Z	dd
οΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd d!οΏ½Zd"d#οΏ½ZdS)%οΏ½PullDOMNcCszddlm}||_ddg|_|j|_g|_|jj|_z|jj|_Wnt	k
rVYnX|dig|_
|j
d|_g|_dS)Nr)οΏ½
XML_NAMESPACEοΏ½xmlοΏ½οΏ½οΏ½)
Zxml.domrοΏ½documentFactoryοΏ½
firstEventοΏ½	lastEventοΏ½elementStackοΏ½appendοΏ½pushοΏ½popοΏ½AttributeErrorοΏ½_ns_contextsοΏ½_current_contextοΏ½pending_events)οΏ½selfrrοΏ½rοΏ½'/usr/lib64/python3.8/xml/dom/pulldom.pyοΏ½__init__s

zPullDOM.__init__cCs|jd}|jd=|SοΏ½Nr
)r)rοΏ½resultrrrr!s
zPullDOM.popcCs
||_dSοΏ½N)οΏ½_locator)rZlocatorrrrοΏ½setDocumentLocator&szPullDOM.setDocumentLocatorcCsHt|dοΏ½sg|_|jοΏ½|pd|fοΏ½|jοΏ½|jοΏ½οΏ½οΏ½|p<d|j|<dS)NοΏ½_xmlns_attrsοΏ½xmlns)οΏ½hasattrr"rrrοΏ½copy)rοΏ½prefixοΏ½urirrrοΏ½startPrefixMapping)s

zPullDOM.startPrefixMappingcCs|jοΏ½οΏ½|_dSr)rrr)rr&rrrοΏ½endPrefixMapping0szPullDOM.endPrefixMappingcCsοΏ½d}t|ddοΏ½}|dk	r:|D]\}}||j||f<qg|_|\}}	|rοΏ½|dkrn|j|}
|
rj|
d|	}n|	}|jrοΏ½|jοΏ½||οΏ½}qοΏ½|οΏ½||οΏ½}n |jrοΏ½|jοΏ½|	οΏ½}n|οΏ½d|	οΏ½}|οΏ½οΏ½D]οΏ½\}}|\}}
||kοΏ½r|
dkrοΏ½|
}nd|
}|jοΏ½	||οΏ½}|οΏ½
|οΏ½nX|οΏ½rF|j|}
|
οΏ½r(|
d|
}n|
}|jοΏ½	||οΏ½}|οΏ½
|οΏ½n|jοΏ½|
οΏ½}|οΏ½|οΏ½||_
qοΏ½t|fdg|jd<|jd|_|οΏ½|οΏ½dS)Nzhttp://www.w3.org/2000/xmlns/r"οΏ½:r#zxmlns:οΏ½)οΏ½getattrοΏ½_attrsr"rοΏ½documentZcreateElementNSοΏ½
buildDocumentοΏ½
createElementοΏ½itemsZcreateAttributeNSZsetAttributeNodeNSοΏ½createAttributeοΏ½setAttributeNodeοΏ½valuerrr)rοΏ½nameοΏ½tagNameοΏ½attrsZ	xmlns_uriZxmlns_attrsοΏ½anamer4r'Z	localnamer&οΏ½nodeZa_uriZa_localnameZqnameοΏ½attrrrrοΏ½startElementNS3sP



zPullDOM.startElementNScCs&t|οΏ½οΏ½fdg|jd<|jd|_dSοΏ½Nr+οΏ½rrr)rr5r6rrrοΏ½endElementNSlszPullDOM.endElementNScCsz|jr|jοΏ½|οΏ½}n|οΏ½d|οΏ½}|οΏ½οΏ½D]$\}}|jοΏ½|οΏ½}||_|οΏ½|οΏ½q(t|fdg|jd<|jd|_|οΏ½	|οΏ½dSr<)
r.r0r/r1r2r4r3rrr)rr5r7r9r8r4r:rrrοΏ½startElementpszPullDOM.startElementcCs&t|οΏ½οΏ½fdg|jd<|jd|_dSr<r=)rr5rrrοΏ½
endElementszPullDOM.endElementcCsN|jr2|jοΏ½|οΏ½}t|fdg|jd<|jd|_nt|fdg}|jοΏ½|οΏ½dSr<)r.οΏ½
createCommentrrrr)rοΏ½sr9οΏ½eventrrrοΏ½commentοΏ½szPullDOM.commentcCsR|jr4|jοΏ½||οΏ½}t|fdg|jd<|jd|_nt||fdg}|jοΏ½|οΏ½dSr<)r.οΏ½createProcessingInstructionrrrr)rοΏ½targetοΏ½datar9rCrrrοΏ½processingInstructionοΏ½szPullDOM.processingInstructioncCs.|jοΏ½|οΏ½}t|fdg|jd<|jd|_dSr<)r.οΏ½createTextNoderrοΏ½rοΏ½charsr9rrrοΏ½ignorableWhitespaceοΏ½szPullDOM.ignorableWhitespacecCs.|jοΏ½|οΏ½}t|fdg|jd<|jd|_dSr<)r.rIr	rrJrrrοΏ½
charactersοΏ½szPullDOM.characterscCs$|jdkr ddl}|jjjj|_dS)Nr)rZxml.dom.minidomZdomZminidomZDocumentοΏ½implementation)rrrrrοΏ½
startDocumentοΏ½s
zPullDOM.startDocumentc	CsοΏ½|jοΏ½||dοΏ½}||_t|fdg|jd<|jd|_|οΏ½|οΏ½|jD]οΏ½}|ddtkrοΏ½|d\}}}|jοΏ½||οΏ½}t|f|d<nD|ddt	krοΏ½|jοΏ½
|ddοΏ½}t	|f|d<ntd|ddοΏ½οΏ½||jd<||_qDd|_|jS)Nr+rzUnknown pending event )
rZcreateDocumentr.rrrrrrErrAοΏ½AssertionErrorZ
firstChild)	rr'Ztagnamer9οΏ½eοΏ½_rFrGοΏ½nrrrr/οΏ½s$


zPullDOM.buildDocumentcCs t|jfdg|jd<|οΏ½οΏ½dSr<)rr.rrοΏ½rrrrοΏ½endDocumentοΏ½szPullDOM.endDocumentcCs
d|_dSr)r.rTrrrοΏ½clearοΏ½sz
PullDOM.clear)N)οΏ½__name__οΏ½
__module__οΏ½__qualname__r r.rrr!r(r)r;r>r?r@rDrHrLrMrOr/rUrVrrrrr

s&
9		r
c@s$eZdZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½ErrorHandlercCst|οΏ½dSr)οΏ½printοΏ½rZ	exceptionrrrοΏ½warningοΏ½szErrorHandler.warningcCs|οΏ½dSrrr\rrrοΏ½errorοΏ½szErrorHandler.errorcCs|οΏ½dSrrr\rrrοΏ½
fatalErrorοΏ½szErrorHandler.fatalErrorN)rWrXrYr]r^r_rrrrrZοΏ½srZc@s\eZdZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZdS)οΏ½DOMEventStreamcCs2||_||_||_t|jdοΏ½s&|j|_|οΏ½οΏ½dS)NοΏ½feed)οΏ½streamοΏ½parserοΏ½bufsizer$οΏ½_slurpοΏ½getEventοΏ½reset)rrbrcrdrrrrοΏ½szDOMEventStream.__init__cCs.tοΏ½|_|jοΏ½tjjjdοΏ½|jοΏ½|jοΏ½dSr<)	r
οΏ½pulldomrcZ
setFeaturerοΏ½saxZhandlerZfeature_namespacesZsetContentHandlerrTrrrrgοΏ½szDOMEventStream.resetcCs0ddl}|jdtddοΏ½|οΏ½οΏ½}|r(|StοΏ½dS)Nrz[DOMEventStream's __getitem__ method ignores 'pos' parameter. Use iterator protocol instead.οΏ½)οΏ½
stacklevel)οΏ½warningsοΏ½warnοΏ½DeprecationWarningrfοΏ½
IndexError)rοΏ½posrlοΏ½rcrrrοΏ½__getitem__οΏ½sοΏ½zDOMEventStream.__getitem__cCs|οΏ½οΏ½}|r|StοΏ½dSr)rfοΏ½
StopIterationοΏ½rrqrrrοΏ½__next__οΏ½szDOMEventStream.__next__cCs|SrrrTrrrοΏ½__iter__οΏ½szDOMEventStream.__iter__cCsl|οΏ½οΏ½}|g}|rh|\}}||kr&dS|tkr<|dοΏ½|οΏ½|tkrP|οΏ½|οΏ½n|tkr^|d=|οΏ½οΏ½}qdSr)rfrοΏ½appendChildrr)rr9rCοΏ½parentsοΏ½tokenZcur_noderrrοΏ½
expandNodeοΏ½szDOMEventStream.expandNodecCs~|jjds|jj|j_|jjdsR|jοΏ½|jοΏ½}|sD|jοΏ½οΏ½dS|jοΏ½|οΏ½q|jjdd}|jjdd|jjd<|SοΏ½Nr+r)	rhrrrbοΏ½readrdrcοΏ½closera)rοΏ½bufrqrrrrfs
zDOMEventStream.getEventcCs|jοΏ½|jοΏ½|j|_|οΏ½οΏ½Sr)rcοΏ½parserbοΏ½_emitrfrTrrrreszDOMEventStream._slurpcCs,|jjdd}|jjdd|jjd<|Sr{)rhrrtrrrrοΏ½szDOMEventStream._emitcCs|jοΏ½οΏ½|`d|_d|_dSr)rhrVrcrbrTrrrrV!s
zDOMEventStream.clearN)
rWrXrYrrgrrrurvrzrfrerοΏ½rVrrrrr`οΏ½s

r`c@s4eZdZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZdS)οΏ½SAX2DOMcCs2tοΏ½||||οΏ½|jd}|jd}|οΏ½|οΏ½dSοΏ½Nr
οΏ½οΏ½οΏ½)r
r;rrw)rr5r6r7οΏ½curNodeοΏ½
parentNoderrrr;*s

zSAX2DOM.startElementNScCs0tοΏ½|||οΏ½|jd}|jd}|οΏ½|οΏ½dSrοΏ½)r
r?rrw)rr5r7rοΏ½rοΏ½rrrr?0s

zSAX2DOM.startElementcCs4tοΏ½|||οΏ½|jdd}|jd}|οΏ½|οΏ½dSοΏ½Nrr+r
)r
rHrrrw)rrFrGr9rοΏ½rrrrH6s
zSAX2DOM.processingInstructioncCs2tοΏ½||οΏ½|jdd}|jd}|οΏ½|οΏ½dSrοΏ½)r
rLrrrwοΏ½rrKr9rοΏ½rrrrL<s
zSAX2DOM.ignorableWhitespacecCs2tοΏ½||οΏ½|jdd}|jd}|οΏ½|οΏ½dSrοΏ½)r
rMrrrwrοΏ½rrrrMBs
zSAX2DOM.charactersN)rWrXrYr;r?rHrLrMrrrrrοΏ½(s
rοΏ½iοΏ½?cCs@|dkrt}t|tοΏ½r"t|dοΏ½}n|}|s4tjοΏ½οΏ½}t|||οΏ½S)NοΏ½rb)οΏ½default_bufsizeοΏ½
isinstanceοΏ½strοΏ½openrriοΏ½make_parserr`)Zstream_or_stringrcrdrbrrrrKs

rcCs6ddlm}t|οΏ½}||οΏ½}|s*tjοΏ½οΏ½}t|||οΏ½S)Nr)οΏ½StringIO)οΏ½iorοΏ½οΏ½lenrrirοΏ½r`)οΏ½stringrcrοΏ½rdr~rrrοΏ½parseStringVs
rοΏ½)NN)N)Zxml.saxrZxml.sax.handlerrrrrrrrr	riZContentHandlerr
rZr`rοΏ½rοΏ½rrοΏ½rrrrοΏ½<module>s"8\!
U

e5dοΏ½οΏ½οΏ½@sdZddlmZmZmZddlmZmZmZddlm	Z	ddl
mZmZddl
mZejZejZejZejjZejjZejjZejjZeοΏ½οΏ½ZeοΏ½ddοΏ½eοΏ½dd	οΏ½eοΏ½dd
οΏ½eοΏ½ddοΏ½eοΏ½ddοΏ½eοΏ½dd
οΏ½eοΏ½ddοΏ½eοΏ½ddοΏ½eοΏ½ddοΏ½dοΏ½	ZGddοΏ½deοΏ½ZddοΏ½ZddοΏ½ZGddοΏ½dοΏ½ZeeefZ GddοΏ½deοΏ½Z!GddοΏ½deοΏ½Z"GddοΏ½de"οΏ½Z#Gd d!οΏ½d!e"οΏ½Z$d"Z%d#e%Z&Gd$d%οΏ½d%eοΏ½Z'Gd&d'οΏ½d'οΏ½Z(Gd(d)οΏ½d)e(eοΏ½Z)Gd*d+οΏ½d+e(e'οΏ½Z*Gd,d-οΏ½d-e+οΏ½Z,Gd.d/οΏ½d/eοΏ½Z-d;d1d2οΏ½Z.d<d3d4οΏ½Z/d=d5d6οΏ½Z0d>d7d8οΏ½Z1d9d:οΏ½Z2dS)?zοΏ½Facility to use the Expat parser to load a minidom instance
from a string or file.

This avoids all the overhead of SAX and pulldom to gain performance.
οΏ½)οΏ½
xmlbuilderοΏ½minidomοΏ½Node)οΏ½EMPTY_NAMESPACEοΏ½EMPTY_PREFIXοΏ½XMLNS_NAMESPACE)οΏ½expat)οΏ½
_append_childοΏ½_set_attribute_node)οΏ½
NodeFilterNZcdataοΏ½enumerationοΏ½entityοΏ½entitiesοΏ½idZidrefZidrefsZnmtokenZnmtokens)	ZCDATAοΏ½ENUMZENTITYZENTITIESοΏ½IDZIDREFZIDREFSZNMTOKENZNMTOKENSc@sZeZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZdS)οΏ½ElementInfoοΏ½οΏ½
_attr_infoοΏ½_modelοΏ½tagNameNcCs||_g|_||_dSοΏ½N)rrr)οΏ½selfrοΏ½modelοΏ½rοΏ½,/usr/lib64/python3.8/xml/dom/expatbuilder.pyοΏ½__init__?szElementInfo.__init__cCs|j|j|jfSrrοΏ½rrrrοΏ½__getstate__DszElementInfo.__getstate__cCs|\|_|_|_dSrr)rοΏ½staterrrοΏ½__setstate__GszElementInfo.__setstate__cCsN|jD]@}|d|kr|d}|ddkr6tdSt|dSqtjS)NοΏ½οΏ½οΏ½οΏ½rοΏ½(r)rοΏ½
_typeinfo_maprοΏ½_no_type)rοΏ½anameοΏ½infoοΏ½trrrοΏ½getAttributeTypeJs
zElementInfo.getAttributeTypecCstjSr)rr%)rZnamespaceURIZ	localNamerrrοΏ½getAttributeTypeNSTszElementInfo.getAttributeTypeNScCs,|jr$|jd}|tjjtjjfkSdSdSοΏ½NrF)rrrZ
XML_CTYPE_ANYZXML_CTYPE_MIXED)rοΏ½typerrrοΏ½isElementContentWs
οΏ½zElementInfo.isElementContentcCs |jr|jdtjjkSdSdSr+)rrrZXML_CTYPE_EMPTYrrrrοΏ½isEmpty_szElementInfo.isEmptycCs,|jD] }|d|kr|ddkSqdS)Nr!r"rF)r)rr&r'rrrοΏ½isIdes
zElementInfo.isIdcCs|οΏ½||fοΏ½Sr)r/)rZeuriZenameZaurir&rrrοΏ½isIdNSkszElementInfo.isIdNS)N)
οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½	__slots__rrr r)r*r-r.r/r0rrrrr<s

rcCs|οΏ½||οΏ½Sr)οΏ½_intern_setdefault)οΏ½builderοΏ½srrrοΏ½_internosr8cCsοΏ½|οΏ½dοΏ½}|j}t|οΏ½dkrR|\}}}|||οΏ½}d||f}|||οΏ½}|||οΏ½}n4t|οΏ½dkrz|\}}t}|||οΏ½}}ntd|οΏ½οΏ½|||οΏ½|||fS)NοΏ½ οΏ½z%s:%sοΏ½z4Unsupported syntax: spaces in URIs not supported: %r)οΏ½splitr5οΏ½lenrοΏ½
ValueError)r6οΏ½nameοΏ½partsοΏ½internοΏ½uriοΏ½	localnameοΏ½prefixοΏ½qnamerrrοΏ½_parse_ns_namers



rFc@sοΏ½eZdZdZd;ddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zdd οΏ½Zd!d"οΏ½Zd#d$οΏ½Zd%d&οΏ½Zd'd(οΏ½Zd)d*οΏ½Zd+d,οΏ½Zd-d.οΏ½Zd/d0οΏ½Zd1d2οΏ½Zd3d4οΏ½Zd5d6οΏ½Zd7d8οΏ½Zd9d:οΏ½ZdS)<οΏ½ExpatBuilderzPDocument builder that uses Expat to build a ParsedXML.DOM document
    instance.NcCsP|dkrtοΏ½οΏ½}||_|jjdk	r2t|jjοΏ½|_nd|_t|_d|_|οΏ½	οΏ½dSr)
rZOptionsοΏ½_optionsοΏ½filterοΏ½FilterVisibilityControllerοΏ½_filterrοΏ½_finish_start_elementοΏ½_parserοΏ½reset)rοΏ½optionsrrrrοΏ½szExpatBuilder.__init__cCstοΏ½οΏ½S)zCreate a new parser object.)rοΏ½ParserCreaterrrrοΏ½createParserοΏ½szExpatBuilder.createParsercCsF|js@|οΏ½οΏ½|_|jjj|_d|j_d|j_d|j_|οΏ½|jοΏ½|jS)z7Return the parser object, creating a new one if needed.T)	rMrQrAοΏ½
setdefaultr5Zbuffer_textZordered_attributesZspecified_attributesοΏ½installrrrrοΏ½	getParserοΏ½s
zExpatBuilder.getParsercCs,tοΏ½tddοΏ½|_|j|_|jj|_d|_dS)z6Free all data structures used during DOM construction.NF)οΏ½theDOMImplementationZcreateDocumentrοΏ½documentοΏ½curNodeοΏ½
_elem_infoοΏ½_cdatarrrrrNοΏ½sοΏ½
zExpatBuilder.resetcCsοΏ½|j|_|j|_|j|_|j|_|jj	r0|j
|_|j|_
|jjrH|j|_|jjrj|j|_|j|_|j|_n|j|_|j|_|j|_|j|_|j|_ dS)z>Install the callbacks needed to build the DOM into the parser.N)!οΏ½start_doctype_decl_handlerοΏ½StartDoctypeDeclHandlerοΏ½first_element_handlerοΏ½StartElementHandlerοΏ½end_element_handlerοΏ½EndElementHandlerοΏ½
pi_handlerοΏ½ProcessingInstructionHandlerrHrοΏ½entity_decl_handlerοΏ½EntityDeclHandlerοΏ½notation_decl_handlerοΏ½NotationDeclHandlerοΏ½commentsοΏ½comment_handlerοΏ½CommentHandlerZcdata_sectionsοΏ½start_cdata_section_handlerοΏ½StartCdataSectionHandlerοΏ½end_cdata_section_handlerοΏ½EndCdataSectionHandlerοΏ½character_data_handler_cdataοΏ½CharacterDataHandlerοΏ½character_data_handlerοΏ½external_entity_ref_handlerοΏ½ExternalEntityRefHandlerοΏ½xml_decl_handlerZXmlDeclHandlerοΏ½element_decl_handlerZElementDeclHandlerοΏ½attlist_decl_handlerZAttlistDeclHandlerοΏ½rοΏ½parserrrrrSοΏ½s$
zExpatBuilder.installcCsοΏ½|οΏ½οΏ½}d}zH|οΏ½dοΏ½}|sqF|οΏ½|dοΏ½|r@|jjr@|οΏ½|οΏ½d}q|οΏ½ddοΏ½Wntk
rhYnX|j}|οΏ½οΏ½d|_|S)zIParse a document from a file object, returning the document
        node.Ti@rFοΏ½N)	rTοΏ½readοΏ½ParserVοΏ½documentElementοΏ½
_setup_subsetοΏ½ParseEscaperNrM)rοΏ½filervZfirst_bufferοΏ½bufferοΏ½docrrrοΏ½	parseFileοΏ½s"

zExpatBuilder.parseFilecCsP|οΏ½οΏ½}z|οΏ½|dοΏ½|οΏ½|οΏ½Wntk
r6YnX|j}|οΏ½οΏ½d|_|S)z<Parse a document from a string, returning the document node.TN)rTryr{r|rVrNrM)rοΏ½stringrvrrrrοΏ½parseStringοΏ½szExpatBuilder.parseStringcCs.|jjr*tοΏ½}|οΏ½|οΏ½|οΏ½οΏ½}||jj_dS)z/Load the internal subset if there might be one.N)rVοΏ½doctypeοΏ½InternalSubsetExtractorrοΏ½οΏ½	getSubsetοΏ½internalSubset)rr~Z	extractorοΏ½subsetrrrr{οΏ½s

zExpatBuilder._setup_subsetcCsοΏ½|jjοΏ½|||οΏ½}|j|_t|j|οΏ½||j_|jrj|jοΏ½|οΏ½tkrjd|j_|jj	d=d}d|j
_d|j
_|rοΏ½|dk	rοΏ½g|j
_g|j_d|j
_d|j
_|j|j
_dSοΏ½NοΏ½οΏ½οΏ½)rVοΏ½implementationZcreateDocumentTypeοΏ½
ownerDocumentr	rοΏ½rKοΏ½
acceptNodeοΏ½
FILTER_REJECTοΏ½
childNodesrMrcrerοΏ½_seqοΏ½	notationsrhraοΏ½end_doctype_decl_handlerοΏ½EndDoctypeDeclHandler)rZdoctypeNameοΏ½systemIdοΏ½publicIdοΏ½has_internal_subsetrοΏ½rrrrZοΏ½s*οΏ½
z'ExpatBuilder.start_doctype_decl_handlercCs2|jjr|j|j_|j|j_|js.|js.t	|_
dSr)rHrfrgrMrhr`rarXrKrοΏ½_finish_end_elementrrrrrοΏ½s


z%ExpatBuilder.end_doctype_decl_handlercCs@|jοΏ½||οΏ½}t|j|οΏ½|jr<|jοΏ½|οΏ½tkr<|jοΏ½|οΏ½dSr)rVZcreateProcessingInstructionr	rWrKrοΏ½rοΏ½οΏ½removeChild)rοΏ½targetοΏ½dataοΏ½noderrrr`szExpatBuilder.pi_handlercCsοΏ½|jj}|jrH|jr4|djtkr4|dοΏ½|οΏ½dS|jοΏ½|οΏ½}d|_nD|rv|djt	krv|d}|j
|}||_
dStοΏ½οΏ½}||_
|j|_
t|j|οΏ½dS)NrοΏ½T)rWrοΏ½rYοΏ½_cdata_continueοΏ½nodeTypeοΏ½CDATA_SECTION_NODEZ
appendDatarVZcreateCDATASectionοΏ½	TEXT_NODErοΏ½rοΏ½TextrοΏ½r	)rrοΏ½rοΏ½rοΏ½οΏ½valuerrrrms$οΏ½
z)ExpatBuilder.character_data_handler_cdatacCs^|jj}|r2|djtkr2|d}|j||_dStοΏ½οΏ½}|j||_|j|_t	|j|οΏ½dSrοΏ½)
rWrοΏ½rοΏ½rοΏ½rοΏ½rrοΏ½rVrοΏ½r	)rrοΏ½rοΏ½rοΏ½rrrro&sz#ExpatBuilder.character_data_handlerc
CsοΏ½|rdS|jjsdS|jοΏ½||||οΏ½}|dk	rF|jοΏ½|οΏ½}	|jοΏ½|	οΏ½|jjjjοΏ½|οΏ½|j	r||j	οΏ½
|οΏ½tkr||jjjjd=dSrοΏ½)rHrrVZ_create_entityZcreateTextNoderοΏ½οΏ½appendrοΏ½rοΏ½rKrοΏ½rοΏ½)
rZ
entityNameZis_parameter_entityrοΏ½οΏ½baserοΏ½rοΏ½οΏ½notationNamerοΏ½οΏ½childrrrrb1s
οΏ½z ExpatBuilder.entity_decl_handlercCsJ|jοΏ½|||οΏ½}|jjjjοΏ½|οΏ½|jrF|jοΏ½|οΏ½tkrF|jjjjd=dSrοΏ½)	rVZ_create_notationrοΏ½rοΏ½rοΏ½rοΏ½rKrοΏ½οΏ½
FILTER_ACCEPT)rrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrdCsz"ExpatBuilder.notation_decl_handlercCs>|jοΏ½|οΏ½}t|j|οΏ½|jr:|jοΏ½|οΏ½tkr:|jοΏ½|οΏ½dSr)rVZ
createCommentr	rWrKrοΏ½rοΏ½rοΏ½)rrοΏ½rοΏ½rrrrgIszExpatBuilder.comment_handlercCsd|_d|_dS)NTFοΏ½rYrοΏ½rrrrriOsz(ExpatBuilder.start_cdata_section_handlercCsd|_d|_dS)NFrοΏ½rrrrrkSsz&ExpatBuilder.end_cdata_section_handlercCsdSοΏ½Nr!r)rοΏ½contextrοΏ½rοΏ½rοΏ½rrrrpWsz(ExpatBuilder.external_entity_ref_handlercCs2|jdkr|jst|_|j|οΏ½οΏ½_|οΏ½||οΏ½dSr)rKrXrrοΏ½οΏ½start_element_handlerrTr])rr?οΏ½
attributesrrrr\Zsz"ExpatBuilder.first_element_handlercCsοΏ½|jοΏ½|οΏ½}t|j|οΏ½||_|rptdt|οΏ½dοΏ½D]<}tοΏ½||tdt	οΏ½}||d}||_
|j|_t||οΏ½q2||jj
k	rοΏ½|οΏ½|οΏ½dS)Nrr;r!)rVZ
createElementr	rWοΏ½ranger=rοΏ½AttrrrrοΏ½rοΏ½r
rzrL)rr?rοΏ½rοΏ½οΏ½iοΏ½arοΏ½rrrrοΏ½`sοΏ½z"ExpatBuilder.start_element_handlercCsj|jrf||jjkrdS|jοΏ½|οΏ½}|tkr4t|οΏ½n|tkrFt|οΏ½ndS|j|_	|jοΏ½
|οΏ½|οΏ½οΏ½dSr)rKrVrzοΏ½startContainerrοΏ½οΏ½RejecterοΏ½FILTER_SKIPοΏ½SkipperοΏ½
parentNoderWrοΏ½οΏ½unlink)rrοΏ½ZfiltrrrrLqs

z"ExpatBuilder._finish_start_elementcCs|j}|j|_|οΏ½|οΏ½dSr)rWrοΏ½rοΏ½)rr?rWrrrr^οΏ½sz ExpatBuilder.end_element_handlercCs\|jοΏ½|jοΏ½}|r|οΏ½||οΏ½|jrX||jjkr4dS|jοΏ½|οΏ½tkrX|j	οΏ½
|οΏ½|οΏ½οΏ½dSr)rXοΏ½getrοΏ½_handle_white_text_nodesrKrVrzrοΏ½rοΏ½rWrοΏ½rοΏ½)rrWr'rrrrοΏ½οΏ½sz ExpatBuilder._finish_end_elementcCsZ|jjs|οΏ½οΏ½sdSg}|jD]"}|jtkr|jοΏ½οΏ½s|οΏ½|οΏ½q|D]}|οΏ½	|οΏ½qFdSr)
rHZwhitespace_in_element_contentr-rοΏ½rοΏ½rοΏ½rοΏ½οΏ½striprοΏ½rοΏ½)rrοΏ½r'οΏ½LrοΏ½rrrrοΏ½οΏ½sοΏ½
z%ExpatBuilder._handle_white_text_nodescCs0|jοΏ½|οΏ½}|dkr&t||οΏ½|j|<n||_dSr)rXrοΏ½rr)rr?rr'rrrrsοΏ½sz!ExpatBuilder.element_decl_handlerc
CsF|jοΏ½|οΏ½}|dkr&t|οΏ½}||j|<|jοΏ½d|dd|d||gοΏ½dSοΏ½Nr)rXrοΏ½rrrοΏ½)rοΏ½elemr?r,οΏ½defaultZrequiredr'rrrrtοΏ½s
οΏ½z!ExpatBuilder.attlist_decl_handlercCs2||j_||j_|dkr.|r&d|j_nd|j_dS)NrTF)rVοΏ½versionοΏ½encodingοΏ½
standalone)rrοΏ½rοΏ½rοΏ½rrrrrοΏ½s
zExpatBuilder.xml_decl_handler)N) r1r2r3οΏ½__doc__rrQrTrNrSrοΏ½rοΏ½r{rZrοΏ½r`rmrorbrdrgrirkrpr\rοΏ½rLr^rοΏ½rοΏ½rsrtrrrrrrrGοΏ½s:

rGc@sοΏ½eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zej	e
jeje
j
eje
jeje
jeje
jeje
jeje
jeje
jeje
jeje
jeje
jej e
j!iZ"d	S)
rJzoWrapper around a DOMBuilderFilter which implements the checks
    to make the whatToShow filter attribute work.οΏ½rIcCs
||_dSrrοΏ½)rrIrrrrοΏ½sz#FilterVisibilityController.__init__cCsT|j|j}|jj|@rL|jοΏ½|οΏ½}|tkr0tοΏ½|tkrHtdt	|οΏ½οΏ½οΏ½|St
SdS)Nz)startContainer() returned illegal value: )οΏ½_nodetype_maskrοΏ½rIοΏ½
whatToShowrοΏ½οΏ½FILTER_INTERRUPTr|οΏ½_ALLOWED_FILTER_RETURNSr>οΏ½reprrοΏ½)rrοΏ½οΏ½maskοΏ½valrrrrοΏ½οΏ½s
οΏ½z)FilterVisibilityController.startContainercCsοΏ½|j|j}|jj|@r||jοΏ½|οΏ½}|tkr0tοΏ½|tkr`|j}|j	ddοΏ½D]}|οΏ½
|οΏ½qLtS|tkrxt
dt|οΏ½οΏ½οΏ½|StSdS)Nz%acceptNode() returned illegal value: )rοΏ½rοΏ½rIrοΏ½rοΏ½rοΏ½r|rοΏ½rοΏ½rοΏ½ZappendChildrοΏ½rοΏ½r>rοΏ½rοΏ½)rrοΏ½rοΏ½rοΏ½οΏ½parentrοΏ½rrrrοΏ½οΏ½s 
οΏ½z%FilterVisibilityController.acceptNodeN)#r1r2r3rοΏ½r4rrοΏ½rοΏ½rZELEMENT_NODErZSHOW_ELEMENTZATTRIBUTE_NODEZSHOW_ATTRIBUTErοΏ½Z	SHOW_TEXTrοΏ½ZSHOW_CDATA_SECTIONZENTITY_REFERENCE_NODEZSHOW_ENTITY_REFERENCEZENTITY_NODEZSHOW_ENTITYZPROCESSING_INSTRUCTION_NODEZSHOW_PROCESSING_INSTRUCTIONZCOMMENT_NODEZSHOW_COMMENTοΏ½
DOCUMENT_NODEZ
SHOW_DOCUMENTZDOCUMENT_TYPE_NODEZSHOW_DOCUMENT_TYPEZDOCUMENT_FRAGMENT_NODEZSHOW_DOCUMENT_FRAGMENTZ
NOTATION_NODEZ
SHOW_NOTATIONrοΏ½rrrrrJοΏ½s<
οΏ½rJc@seZdZdZddοΏ½ZdS)οΏ½FilterCrutch)οΏ½_builderοΏ½_levelοΏ½
_old_startοΏ½_old_endcCs6d|_||_|j}|j|_|j|_|j|_|j|_dSrοΏ½)	rοΏ½rοΏ½rMr]rοΏ½r_rοΏ½rοΏ½r^)rr6rvrrrrszFilterCrutch.__init__N)r1r2r3r4rrrrrrοΏ½srοΏ½c@s(eZdZdZddοΏ½ZddοΏ½ZddοΏ½ZdS)	rοΏ½rcCs,tοΏ½||οΏ½|j}dD]}t||dοΏ½qdS)N)rarhrnrjrlrq)rοΏ½rrMοΏ½setattr)rr6rvr?rrrrszRejecter.__init__cGs|jd|_dSrοΏ½)rοΏ½οΏ½rοΏ½argsrrrrοΏ½szRejecter.start_element_handlercGs@|jdkr0|jj}|jοΏ½|οΏ½|j|_|j|_n|jd|_dSοΏ½Nrr!)rοΏ½rοΏ½rMrSrοΏ½r]rοΏ½r_)rrοΏ½rvrrrr^ s

zRejecter.end_element_handlerN)r1r2r3r4rrοΏ½r^rrrrrοΏ½srοΏ½c@s eZdZdZddοΏ½ZddοΏ½ZdS)rοΏ½rcGs.|jj}|j|οΏ½|jj|k	r*|jd|_dSrοΏ½)rοΏ½rWrοΏ½rοΏ½)rrοΏ½rοΏ½rrrrοΏ½-s
zSkipper.start_element_handlercGsD|jdkr*|j|jj_|j|jj_d|_n|jd|_|j|οΏ½dSrοΏ½)rοΏ½rοΏ½rοΏ½rMr]rοΏ½r_rοΏ½rrrr^3s
zSkipper.end_element_handlerN)r1r2r3r4rοΏ½r^rrrrrοΏ½*srοΏ½z8http://xml.python.org/entities/fragment-builder/internalzοΏ½<!DOCTYPE wrapper
  %%s [
  <!ENTITY fragment-builder-internal
    SYSTEM "%s">
%%s
]>
<wrapper %%s
>&fragment-builder-internal;</wrapper>c@sJeZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
dS)οΏ½FragmentBuilderzοΏ½Builder which constructs document fragments given XML source
    text and a context node.

    The context node is expected to provide information about the
    namespace declarations which are in scope at the start of the
    fragment.
    NcCs6|jtkr||_||_n|j|_||_tοΏ½||οΏ½dSr)rοΏ½rοΏ½οΏ½originalDocumentrοΏ½rοΏ½rGr)rrοΏ½rOrrrr[s
zFragmentBuilder.__init__cCstοΏ½|οΏ½d|_dSr)rGrNοΏ½fragmentrrrrrNds
zFragmentBuilder.resetcCs|οΏ½|οΏ½οΏ½οΏ½S)zRParse a document fragment from a file object, returning the
        fragment node.)rοΏ½rxοΏ½rr}rrrrοΏ½hszFragmentBuilder.parseFilec	CsοΏ½||_|οΏ½οΏ½}|jj}d}|rV|jp*|οΏ½οΏ½}|jrDd|j|jf}qZ|jrZd|j}nd}|οΏ½οΏ½}t	|||f}z|οΏ½
|dοΏ½Wn|οΏ½οΏ½οΏ½YnX|j}|οΏ½οΏ½|S)zMParse a document fragment from a string, returning the
        fragment node.rwzPUBLIC "%s" "%s"zSYSTEM "%s"r!)
οΏ½_sourcerTrοΏ½rοΏ½rοΏ½οΏ½_getDeclarationsrοΏ½rοΏ½οΏ½_getNSattrsοΏ½_FRAGMENT_BUILDER_TEMPLATEryrNrοΏ½)	rrοΏ½rvrοΏ½ZidentrοΏ½ZnsattrsrVrοΏ½rrrrοΏ½ms.
οΏ½zFragmentBuilder.parseStringcCs|jjj}d}|οΏ½rt|jjοΏ½D]R}|jοΏ½|οΏ½}|r<|d}d||jf}|jrdd||j|j	f}q d||j	f}q t|j
jοΏ½D]οΏ½}|j
οΏ½|οΏ½}|rοΏ½|d}d||jf}|jrοΏ½d||j|j	f}n&|j	rοΏ½d||j	f}nd	||jjf}|j
rοΏ½d
||j
f}|d}qοΏ½|S)zοΏ½Re-create the internal subset from the DocumentType node.

        This is only needed if we don't already have the
        internalSubset as a string.
        rwz
  z%s<!NOTATION %sz!%s PUBLIC "%s"
             "%s">z%s SYSTEM "%s">z
%s<!ENTITY %sz %s PUBLIC "%s"
             "%s"z%s SYSTEM "%s"z%s "%s"z%s NOTATION %sοΏ½>)rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½ZlengthοΏ½itemZnodeNamerοΏ½rοΏ½rZ
firstChildrοΏ½rοΏ½)rrοΏ½r7rοΏ½Znotationr
rrrrοΏ½οΏ½s:
οΏ½οΏ½
z FragmentBuilder._getDeclarationscCsdS)NrwrrrrrrοΏ½οΏ½szFragmentBuilder._getNSattrscCs~|tkrh|j}|j}|jοΏ½|οΏ½}|j|_|jοΏ½οΏ½|_|j|_z|οΏ½	|jdοΏ½W5||_||_d|_XdSt
οΏ½|||||οΏ½SdS)Nr!rοΏ½)οΏ½$_FRAGMENT_BUILDER_INTERNAL_SYSTEM_IDrVrWrMZExternalEntityParserCreaterοΏ½ZcreateDocumentFragmentrοΏ½rοΏ½ryrGrp)rrοΏ½rοΏ½rοΏ½rοΏ½Zold_documentZold_cur_nodervrrrrpοΏ½s(οΏ½z+FragmentBuilder.external_entity_ref_handler)N)r1r2r3rοΏ½rrNrοΏ½rοΏ½rοΏ½rοΏ½rprrrrrοΏ½Rs
	$rοΏ½c@s8eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½ZdS)
οΏ½
Namespacesz7Mix-in class for builders; adds support for namespaces.cCs
g|_dSr)οΏ½_ns_ordered_prefixesrrrrοΏ½_initNamespacesοΏ½szNamespaces._initNamespacescCstjddοΏ½}d|_|S)z'Create a new namespace-handling parser.r9)Znamespace_separatorT)rrPZnamespace_prefixesrurrrrQοΏ½szNamespaces.createParsercCs tοΏ½||οΏ½|jjr|j|_dS)z.Insert the namespace-handlers onto the parser.N)rGrSrHZnamespace_declarationsοΏ½start_namespace_decl_handlerZStartNamespaceDeclHandlerrurrrrSοΏ½sοΏ½zNamespaces.installcCs|jοΏ½||fοΏ½dS)z/Push this namespace declaration on our storage.N)rοΏ½rοΏ½)rrDrBrrrrοΏ½οΏ½sz'Namespaces.start_namespace_decl_handlercCsοΏ½d|krt||οΏ½\}}}}nt}|}d}t}tοΏ½||||οΏ½}|j|_t|j|οΏ½||_|j	rοΏ½|j	D]P\}}|rοΏ½tοΏ½
t|d|οΏ½t|dοΏ½}ntοΏ½
dtdtοΏ½}||_
|j|_t||οΏ½qb|j	ddοΏ½=|οΏ½r~|οΏ½οΏ½|j}	|j}
tdt|οΏ½dοΏ½D]οΏ½}||}||d}
d|kοΏ½rDt||οΏ½\}}}}tοΏ½
||||οΏ½}||	|<||
||f<n$tοΏ½
|t|tοΏ½}||	|<||
t|f<|j|_|
|_
||_qοΏ½dS)Nr9οΏ½xmlns:οΏ½xmlnsrr;r!)rFrrrZElementrVrοΏ½r	rWrοΏ½rοΏ½r8rrοΏ½r
Z_ensure_attributesοΏ½_attrsοΏ½_attrsNSrοΏ½r=ZownerElement)rr?rοΏ½rBrCrDrErοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r&rοΏ½rrrrοΏ½οΏ½s^οΏ½οΏ½
οΏ½z Namespaces.start_element_handlerN)
r1r2r3rοΏ½rοΏ½rQrSrοΏ½rοΏ½r^rrrrrοΏ½οΏ½s5rοΏ½c@seZdZdZddοΏ½ZdS)οΏ½ExpatBuilderNSz*Document builder that supports namespaces.cCstοΏ½|οΏ½|οΏ½οΏ½dSr)rGrNrοΏ½rrrrrN)s
zExpatBuilderNS.resetN)r1r2r3rοΏ½rNrrrrrοΏ½&srοΏ½c@s eZdZdZddοΏ½ZddοΏ½ZdS)οΏ½FragmentBuilderNSz*Fragment builder that supports namespaces.cCstοΏ½|οΏ½|οΏ½οΏ½dSr)rοΏ½rNrοΏ½rrrrrN1s
zFragmentBuilderNS.resetcCsοΏ½d}|j}g}|r~t|dοΏ½rv|jοΏ½οΏ½D]N\}}||kr8q&|οΏ½|οΏ½|rPd|}nd}|rhd|||f}q&d||f}q&|j}q|S)zNReturn string of namespace attributes from this element and
        ancestors.rwοΏ½_ns_prefix_urirοΏ½rοΏ½z%s
    %s='%s'z %s='%s')rοΏ½οΏ½hasattrrοΏ½οΏ½itemsrοΏ½rοΏ½)rοΏ½attrsrοΏ½rοΏ½rDrBZdeclnamerrrrοΏ½5s"


zFragmentBuilderNS._getNSattrsN)r1r2r3rοΏ½rNrοΏ½rrrrrοΏ½.srοΏ½c@seZdZdZdS)r|zEException raised to short-circuit parsing in InternalSubsetExtractor.N)r1r2r3rοΏ½rrrrr|Ssr|c@sLeZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Z	d
dοΏ½Z
ddοΏ½ZdS)rοΏ½zBXML processor which can rip out the internal document type subset.NcCs|jS)z'Return the internal subset as a string.)rοΏ½rrrrrοΏ½\sz!InternalSubsetExtractor.getSubsetcCs*ztοΏ½||οΏ½Wntk
r$YnXdSr)rGrοΏ½r|rοΏ½rrrrοΏ½`sz!InternalSubsetExtractor.parseFilecCs*ztοΏ½||οΏ½Wntk
r$YnXdSr)rGrοΏ½r|)rrοΏ½rrrrοΏ½fsz#InternalSubsetExtractor.parseStringcCs|j|_|j|_dSr)rZr[rοΏ½r]rurrrrSlszInternalSubsetExtractor.installcCs0|r&|οΏ½οΏ½}g|_|jj|_|j|_ntοΏ½οΏ½dSr)rTrοΏ½rοΏ½ZDefaultHandlerrοΏ½rοΏ½r|)rr?rοΏ½rοΏ½rοΏ½rvrrrrZps

z2InternalSubsetExtractor.start_doctype_decl_handlercCs,dοΏ½|jοΏ½οΏ½ddοΏ½οΏ½ddοΏ½}||_tοΏ½οΏ½dS)Nrwz
οΏ½
οΏ½
)οΏ½joinrοΏ½οΏ½replacer|)rr7rrrrοΏ½zsz0InternalSubsetExtractor.end_doctype_decl_handlercCs
tοΏ½οΏ½dSr)r|)rr?rοΏ½rrrrοΏ½sz-InternalSubsetExtractor.start_element_handler)r1r2r3rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rSrZrοΏ½rοΏ½rrrrrοΏ½Ws
rοΏ½Tc	CsL|rtοΏ½}ntοΏ½}t|tοΏ½r>t|dοΏ½οΏ½}|οΏ½|οΏ½}W5QRXn
|οΏ½|οΏ½}|S)z{Parse a document, returning the resulting Document node.

    'file' may be either a file name or an open file object.
    οΏ½rb)rοΏ½rGοΏ½
isinstanceοΏ½strοΏ½openrοΏ½)r}οΏ½
namespacesr6οΏ½fpοΏ½resultrrrοΏ½parseοΏ½s

rοΏ½cCs|rtοΏ½}ntοΏ½}|οΏ½|οΏ½S)zOParse a document from a string, returning the resulting
    Document node.
    )rοΏ½rGrοΏ½)rοΏ½rοΏ½r6rrrrοΏ½οΏ½srοΏ½c	CsP|rt|οΏ½}nt|οΏ½}t|tοΏ½rBt|dοΏ½οΏ½}|οΏ½|οΏ½}W5QRXn
|οΏ½|οΏ½}|S)zοΏ½Parse a fragment of a document, given the context from which it
    was originally extracted.  context should be the parent of the
    node(s) which are in the fragment.

    'file' may be either a file name or an open file object.
    rοΏ½)rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½)r}rοΏ½rοΏ½r6rοΏ½rοΏ½rrrοΏ½
parseFragmentοΏ½s


rοΏ½cCs |rt|οΏ½}nt|οΏ½}|οΏ½|οΏ½S)zοΏ½Parse a fragment of a document from a string, given the context
    from which it was originally extracted.  context should be the
    parent of the node(s) which are in the fragment.
    )rοΏ½rοΏ½rοΏ½)rοΏ½rοΏ½rοΏ½r6rrrοΏ½parseFragmentStringοΏ½s
rοΏ½cCs|jrt|οΏ½St|οΏ½SdS)z,Create a builder based on an Options object.N)rοΏ½rοΏ½rG)rOrrrοΏ½makeBuilderοΏ½srοΏ½)T)T)T)T)3rοΏ½Zxml.domrrrrrrZxml.parsersrZxml.dom.minidomr	r
Zxml.dom.NodeFilterrrοΏ½rοΏ½rοΏ½ZDOMBuilderFilterrοΏ½rοΏ½rοΏ½rοΏ½ZgetDOMImplementationrUZTypeInfor$οΏ½objectrr8rFrGrοΏ½rJrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½	Exceptionr|rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrοΏ½<module>sf








οΏ½3C
:οΏ½	οΏ½οΏ½
u_%,



U

e5dοΏ½οΏ½@sοΏ½dZGddοΏ½dοΏ½ZdZdZdZdZdZdZd	Zd
Z	dZ
dZd
ZdZ
dZdZdZdZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGdd οΏ½d eοΏ½ZGd!d"οΏ½d"eοΏ½ZGd#d$οΏ½d$eοΏ½ZGd%d&οΏ½d&eοΏ½ZGd'd(οΏ½d(eοΏ½ZGd)d*οΏ½d*eοΏ½ZGd+d,οΏ½d,eοΏ½ZGd-d.οΏ½d.eοΏ½Z Gd/d0οΏ½d0eοΏ½Z!Gd1d2οΏ½d2eοΏ½Z"Gd3d4οΏ½d4eοΏ½Z#Gd5d6οΏ½d6οΏ½Z$d7Z%d8Z&d9Z'd:Z(d:Z)dd;l*m+Z+m,Z,d:S)<a
W3C Document Object Model implementation for Python.

The Python mapping of the Document Object Model is documented in the
Python Library Reference in the section on the xml.dom package.

This package contains the following modules:

minidom -- A simple implementation of the Level 1 DOM with namespace
           support added (based on the Level 2 specification) and other
           minor Level 2 functionality.

pulldom -- DOM builder supporting on-demand tree-building for selected
           subtrees of the document.

c@sDeZdZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZ
dZd
ZdZdS)οΏ½Nodez$Class giving the NodeType constants.οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½	οΏ½
οΏ½οΏ½N)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½__doc__οΏ½	__slots__ZELEMENT_NODEZATTRIBUTE_NODEZ	TEXT_NODEZCDATA_SECTION_NODEZENTITY_REFERENCE_NODEZENTITY_NODEZPROCESSING_INSTRUCTION_NODEZCOMMENT_NODEZ
DOCUMENT_NODEZDOCUMENT_TYPE_NODEZDOCUMENT_FRAGMENT_NODEZ
NOTATION_NODErrrοΏ½(/usr/lib64/python3.8/xml/dom/__init__.pyrs	rrrrrrrr	r
rrr
rοΏ½
οΏ½οΏ½οΏ½c@s eZdZdZddοΏ½ZddοΏ½ZdS)οΏ½DOMExceptionzmAbstract base class for DOM exceptions.
    Exceptions with specific codes are specializations of this class.cOs(|jtkrtdοΏ½οΏ½tj|f|οΏ½|οΏ½dS)Nz0DOMException should not be instantiated directly)οΏ½	__class__rοΏ½RuntimeErrorοΏ½	ExceptionοΏ½__init__)οΏ½selfοΏ½argsοΏ½kwrrrrBs

οΏ½zDOMException.__init__cCs|jS)N)οΏ½code)rrrrοΏ½	_get_codeHszDOMException._get_codeN)rrrrrr"rrrrr>src@seZdZeZdS)οΏ½IndexSizeErrN)rrrοΏ½INDEX_SIZE_ERRr!rrrrr#Lsr#c@seZdZeZdS)οΏ½DomstringSizeErrN)rrrοΏ½DOMSTRING_SIZE_ERRr!rrrrr%Osr%c@seZdZeZdS)οΏ½HierarchyRequestErrN)rrrοΏ½HIERARCHY_REQUEST_ERRr!rrrrr'Rsr'c@seZdZeZdS)οΏ½WrongDocumentErrN)rrrοΏ½WRONG_DOCUMENT_ERRr!rrrrr)Usr)c@seZdZeZdS)οΏ½InvalidCharacterErrN)rrrοΏ½INVALID_CHARACTER_ERRr!rrrrr+Xsr+c@seZdZeZdS)οΏ½NoDataAllowedErrN)rrrοΏ½NO_DATA_ALLOWED_ERRr!rrrrr-[sr-c@seZdZeZdS)οΏ½NoModificationAllowedErrN)rrrοΏ½NO_MODIFICATION_ALLOWED_ERRr!rrrrr/^sr/c@seZdZeZdS)οΏ½NotFoundErrN)rrrοΏ½
NOT_FOUND_ERRr!rrrrr1asr1c@seZdZeZdS)οΏ½NotSupportedErrN)rrrοΏ½NOT_SUPPORTED_ERRr!rrrrr3dsr3c@seZdZeZdS)οΏ½InuseAttributeErrN)rrrοΏ½INUSE_ATTRIBUTE_ERRr!rrrrr5gsr5c@seZdZeZdS)οΏ½InvalidStateErrN)rrrοΏ½INVALID_STATE_ERRr!rrrrr7jsr7c@seZdZeZdS)οΏ½	SyntaxErrN)rrrοΏ½
SYNTAX_ERRr!rrrrr9msr9c@seZdZeZdS)οΏ½InvalidModificationErrN)rrrοΏ½INVALID_MODIFICATION_ERRr!rrrrr;psr;c@seZdZeZdS)οΏ½NamespaceErrN)rrrοΏ½
NAMESPACE_ERRr!rrrrr=ssr=c@seZdZeZdS)οΏ½InvalidAccessErrN)rrrοΏ½INVALID_ACCESS_ERRr!rrrrr?vsr?c@seZdZeZdS)οΏ½
ValidationErrN)rrrοΏ½VALIDATION_ERRr!rrrrrAysrAc@s eZdZdZdZdZdZdZdS)οΏ½UserDataHandlerzBClass giving the operation constants for UserDataHandler.handle().rrrrN)rrrrZNODE_CLONEDZ
NODE_IMPORTEDZNODE_DELETEDZNODE_RENAMEDrrrrrC|s
rCz$http://www.w3.org/XML/1998/namespacezhttp://www.w3.org/2000/xmlns/zhttp://www.w3.org/1999/xhtmlN)οΏ½getDOMImplementationοΏ½registerDOMImplementation)-rrr$r&r(r*r,r.r0r2r4r6r8r:r<r>r@rBrrr#r%r'r)r+r-r/r1r3r5r7r9r;r=r?rArCZ
XML_NAMESPACEZXMLNS_NAMESPACEZXHTML_NAMESPACEZEMPTY_NAMESPACEZEMPTY_PREFIXZdomregrDrErrrrοΏ½<module>sR
U

e5dοΏ½.οΏ½@sοΏ½ddlZddlZdZdZdZdZdZdZdZ	d	Z
Gd
dοΏ½dejjοΏ½Z
Gdd
οΏ½d
οΏ½ZGddοΏ½dοΏ½ZGddοΏ½de
οΏ½ZdZdddοΏ½ZdddοΏ½ZdS)οΏ½NοΏ½
START_ELEMENTοΏ½END_ELEMENTοΏ½COMMENTοΏ½START_DOCUMENTοΏ½END_DOCUMENTοΏ½PROCESSING_INSTRUCTIONοΏ½IGNORABLE_WHITESPACEοΏ½
CHARACTERSc@sοΏ½eZdZdZdZd$ddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Z	dd
οΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd d!οΏ½Zd"d#οΏ½ZdS)%οΏ½PullDOMNcCszddlm}||_ddg|_|j|_g|_|jj|_z|jj|_Wnt	k
rVYnX|dig|_
|j
d|_g|_dS)Nr)οΏ½
XML_NAMESPACEοΏ½xmlοΏ½οΏ½οΏ½)
Zxml.domrοΏ½documentFactoryοΏ½
firstEventοΏ½	lastEventοΏ½elementStackοΏ½appendοΏ½pushοΏ½popοΏ½AttributeErrorοΏ½_ns_contextsοΏ½_current_contextοΏ½pending_events)οΏ½selfrrοΏ½rοΏ½'/usr/lib64/python3.8/xml/dom/pulldom.pyοΏ½__init__s

zPullDOM.__init__cCs|jd}|jd=|SοΏ½Nr
)r)rοΏ½resultrrrr!s
zPullDOM.popcCs
||_dSοΏ½N)οΏ½_locator)rZlocatorrrrοΏ½setDocumentLocator&szPullDOM.setDocumentLocatorcCsHt|dοΏ½sg|_|jοΏ½|pd|fοΏ½|jοΏ½|jοΏ½οΏ½οΏ½|p<d|j|<dS)NοΏ½_xmlns_attrsοΏ½xmlns)οΏ½hasattrr"rrrοΏ½copy)rοΏ½prefixοΏ½urirrrοΏ½startPrefixMapping)s

zPullDOM.startPrefixMappingcCs|jοΏ½οΏ½|_dSr)rrr)rr&rrrοΏ½endPrefixMapping0szPullDOM.endPrefixMappingcCsοΏ½d}t|ddοΏ½}|dk	r:|D]\}}||j||f<qg|_|\}}	|rοΏ½|dkrn|j|}
|
rj|
d|	}n|	}|jrοΏ½|jοΏ½||οΏ½}qοΏ½|οΏ½||οΏ½}n |jrοΏ½|jοΏ½|	οΏ½}n|οΏ½d|	οΏ½}|οΏ½οΏ½D]οΏ½\}}|\}}
||kοΏ½r|
dkrοΏ½|
}nd|
}|jοΏ½	||οΏ½}|οΏ½
|οΏ½nX|οΏ½rF|j|}
|
οΏ½r(|
d|
}n|
}|jοΏ½	||οΏ½}|οΏ½
|οΏ½n|jοΏ½|
οΏ½}|οΏ½|οΏ½||_
qοΏ½t|fdg|jd<|jd|_|οΏ½|οΏ½dS)Nzhttp://www.w3.org/2000/xmlns/r"οΏ½:r#zxmlns:οΏ½)οΏ½getattrοΏ½_attrsr"rοΏ½documentZcreateElementNSοΏ½
buildDocumentοΏ½
createElementοΏ½itemsZcreateAttributeNSZsetAttributeNodeNSοΏ½createAttributeοΏ½setAttributeNodeοΏ½valuerrr)rοΏ½nameοΏ½tagNameοΏ½attrsZ	xmlns_uriZxmlns_attrsοΏ½anamer4r'Z	localnamer&οΏ½nodeZa_uriZa_localnameZqnameοΏ½attrrrrοΏ½startElementNS3sP



zPullDOM.startElementNScCs&t|οΏ½οΏ½fdg|jd<|jd|_dSοΏ½Nr+οΏ½rrr)rr5r6rrrοΏ½endElementNSlszPullDOM.endElementNScCsz|jr|jοΏ½|οΏ½}n|οΏ½d|οΏ½}|οΏ½οΏ½D]$\}}|jοΏ½|οΏ½}||_|οΏ½|οΏ½q(t|fdg|jd<|jd|_|οΏ½	|οΏ½dSr<)
r.r0r/r1r2r4r3rrr)rr5r7r9r8r4r:rrrοΏ½startElementpszPullDOM.startElementcCs&t|οΏ½οΏ½fdg|jd<|jd|_dSr<r=)rr5rrrοΏ½
endElementszPullDOM.endElementcCsN|jr2|jοΏ½|οΏ½}t|fdg|jd<|jd|_nt|fdg}|jοΏ½|οΏ½dSr<)r.οΏ½
createCommentrrrr)rοΏ½sr9οΏ½eventrrrοΏ½commentοΏ½szPullDOM.commentcCsR|jr4|jοΏ½||οΏ½}t|fdg|jd<|jd|_nt||fdg}|jοΏ½|οΏ½dSr<)r.οΏ½createProcessingInstructionrrrr)rοΏ½targetοΏ½datar9rCrrrοΏ½processingInstructionοΏ½szPullDOM.processingInstructioncCs.|jοΏ½|οΏ½}t|fdg|jd<|jd|_dSr<)r.οΏ½createTextNoderrοΏ½rοΏ½charsr9rrrοΏ½ignorableWhitespaceοΏ½szPullDOM.ignorableWhitespacecCs.|jοΏ½|οΏ½}t|fdg|jd<|jd|_dSr<)r.rIr	rrJrrrοΏ½
charactersοΏ½szPullDOM.characterscCs$|jdkr ddl}|jjjj|_dS)Nr)rZxml.dom.minidomZdomZminidomZDocumentοΏ½implementation)rrrrrοΏ½
startDocumentοΏ½s
zPullDOM.startDocumentc	CsοΏ½|jοΏ½||dοΏ½}||_t|fdg|jd<|jd|_|οΏ½|οΏ½|jD]οΏ½}|ddtkrοΏ½|d\}}}|jοΏ½||οΏ½}t|f|d<nD|ddt	krοΏ½|jοΏ½
|ddοΏ½}t	|f|d<ntd|ddοΏ½οΏ½||jd<||_qDd|_|jS)Nr+rzUnknown pending event )
rZcreateDocumentr.rrrrrrErrAοΏ½AssertionErrorZ
firstChild)	rr'Ztagnamer9οΏ½eοΏ½_rFrGοΏ½nrrrr/οΏ½s$


zPullDOM.buildDocumentcCs t|jfdg|jd<|οΏ½οΏ½dSr<)rr.rrοΏ½rrrrοΏ½endDocumentοΏ½szPullDOM.endDocumentcCs
d|_dS)z.clear(): Explicitly release parsing structuresN)r.rTrrrοΏ½clearοΏ½sz
PullDOM.clear)N)οΏ½__name__οΏ½
__module__οΏ½__qualname__r r.rrr!r(r)r;r>r?r@rDrHrLrMrOr/rUrVrrrrr

s&
9		r
c@s$eZdZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½ErrorHandlercCst|οΏ½dSr)οΏ½printοΏ½rZ	exceptionrrrοΏ½warningοΏ½szErrorHandler.warningcCs|οΏ½dSrrr\rrrοΏ½errorοΏ½szErrorHandler.errorcCs|οΏ½dSrrr\rrrοΏ½
fatalErrorοΏ½szErrorHandler.fatalErrorN)rWrXrYr]r^r_rrrrrZοΏ½srZc@s\eZdZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZdS)οΏ½DOMEventStreamcCs2||_||_||_t|jdοΏ½s&|j|_|οΏ½οΏ½dS)NοΏ½feed)οΏ½streamοΏ½parserοΏ½bufsizer$οΏ½_slurpοΏ½getEventοΏ½reset)rrbrcrdrrrrοΏ½szDOMEventStream.__init__cCs.tοΏ½|_|jοΏ½tjjjdοΏ½|jοΏ½|jοΏ½dSr<)	r
οΏ½pulldomrcZ
setFeaturerοΏ½saxZhandlerZfeature_namespacesZsetContentHandlerrTrrrrgοΏ½szDOMEventStream.resetcCs0ddl}|jdtddοΏ½|οΏ½οΏ½}|r(|StοΏ½dS)Nrz[DOMEventStream's __getitem__ method ignores 'pos' parameter. Use iterator protocol instead.οΏ½)οΏ½
stacklevel)οΏ½warningsοΏ½warnοΏ½DeprecationWarningrfοΏ½
IndexError)rοΏ½posrlοΏ½rcrrrοΏ½__getitem__οΏ½sοΏ½zDOMEventStream.__getitem__cCs|οΏ½οΏ½}|r|StοΏ½dSr)rfοΏ½
StopIterationοΏ½rrqrrrοΏ½__next__οΏ½szDOMEventStream.__next__cCs|SrrrTrrrοΏ½__iter__οΏ½szDOMEventStream.__iter__cCsl|οΏ½οΏ½}|g}|rh|\}}||kr&dS|tkr<|dοΏ½|οΏ½|tkrP|οΏ½|οΏ½n|tkr^|d=|οΏ½οΏ½}qdSr)rfrοΏ½appendChildrr)rr9rCοΏ½parentsοΏ½tokenZcur_noderrrοΏ½
expandNodeοΏ½szDOMEventStream.expandNodecCs~|jjds|jj|j_|jjdsR|jοΏ½|jοΏ½}|sD|jοΏ½οΏ½dS|jοΏ½|οΏ½q|jjdd}|jjdd|jjd<|S)Nr+r)	rhrrrbοΏ½readrdrcοΏ½closera)rοΏ½bufrqrrrrfs
zDOMEventStream.getEventcCs|jοΏ½|jοΏ½|j|_|οΏ½οΏ½S)zοΏ½ Fallback replacement for getEvent() using the
            standard SAX2 interface, which means we slurp the
            SAX events into memory (no performance gain, but
            we are compatible to all SAX parsers).
        )rcοΏ½parserbοΏ½_emitrfrTrrrreszDOMEventStream._slurpcCs,|jjdd}|jjdd|jjd<|S)zn Fallback replacement for getEvent() that emits
            the events that _slurp() read previously.
        r+r)rhrrtrrrrszDOMEventStream._emitcCs|jοΏ½οΏ½|`d|_d|_dS)z+clear(): Explicitly release parsing objectsN)rhrVrcrbrTrrrrV!s
zDOMEventStream.clearN)
rWrXrYrrgrrrurvrzrfrerrVrrrrr`οΏ½s

r`c@s4eZdZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZdS)οΏ½SAX2DOMcCs2tοΏ½||||οΏ½|jd}|jd}|οΏ½|οΏ½dSοΏ½Nr
οΏ½οΏ½οΏ½)r
r;rrw)rr5r6r7οΏ½curNodeοΏ½
parentNoderrrr;*s

zSAX2DOM.startElementNScCs0tοΏ½|||οΏ½|jd}|jd}|οΏ½|οΏ½dSrοΏ½)r
r?rrw)rr5r7rοΏ½rοΏ½rrrr?0s

zSAX2DOM.startElementcCs4tοΏ½|||οΏ½|jdd}|jd}|οΏ½|οΏ½dSοΏ½Nrr+r
)r
rHrrrw)rrFrGr9rοΏ½rrrrH6s
zSAX2DOM.processingInstructioncCs2tοΏ½||οΏ½|jdd}|jd}|οΏ½|οΏ½dSrοΏ½)r
rLrrrwοΏ½rrKr9rοΏ½rrrrL<s
zSAX2DOM.ignorableWhitespacecCs2tοΏ½||οΏ½|jdd}|jd}|οΏ½|οΏ½dSrοΏ½)r
rMrrrwrοΏ½rrrrMBs
zSAX2DOM.charactersN)rWrXrYr;r?rHrLrMrrrrrοΏ½(s
rοΏ½iοΏ½?cCs@|dkrt}t|tοΏ½r"t|dοΏ½}n|}|s4tjοΏ½οΏ½}t|||οΏ½S)NοΏ½rb)οΏ½default_bufsizeοΏ½
isinstanceοΏ½strοΏ½openrriοΏ½make_parserr`)Zstream_or_stringrcrdrbrrrr~Ks

r~cCs6ddlm}t|οΏ½}||οΏ½}|s*tjοΏ½οΏ½}t|||οΏ½S)Nr)οΏ½StringIO)οΏ½iorοΏ½οΏ½lenrrirοΏ½r`)οΏ½stringrcrοΏ½rdr}rrrοΏ½parseStringVs
rοΏ½)NN)N)Zxml.saxrZxml.sax.handlerrrrrrrrr	riZContentHandlerr
rZr`rοΏ½rοΏ½r~rοΏ½rrrrοΏ½<module>s"8\!
U

e5dοΏ½οΏ½@sοΏ½dZGddοΏ½dοΏ½ZdZdZdZdZdZdZd	Zd
Z	dZ
dZd
ZdZ
dZdZdZdZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZGdd οΏ½d eοΏ½ZGd!d"οΏ½d"eοΏ½ZGd#d$οΏ½d$eοΏ½ZGd%d&οΏ½d&eοΏ½ZGd'd(οΏ½d(eοΏ½ZGd)d*οΏ½d*eοΏ½ZGd+d,οΏ½d,eοΏ½ZGd-d.οΏ½d.eοΏ½Z Gd/d0οΏ½d0eοΏ½Z!Gd1d2οΏ½d2eοΏ½Z"Gd3d4οΏ½d4eοΏ½Z#Gd5d6οΏ½d6οΏ½Z$d7Z%d8Z&d9Z'd:Z(d:Z)dd;l*m+Z+m,Z,d:S)<a
W3C Document Object Model implementation for Python.

The Python mapping of the Document Object Model is documented in the
Python Library Reference in the section on the xml.dom package.

This package contains the following modules:

minidom -- A simple implementation of the Level 1 DOM with namespace
           support added (based on the Level 2 specification) and other
           minor Level 2 functionality.

pulldom -- DOM builder supporting on-demand tree-building for selected
           subtrees of the document.

c@sDeZdZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZ
dZd
ZdZdS)οΏ½Nodez$Class giving the NodeType constants.οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½	οΏ½
οΏ½οΏ½N)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½__doc__οΏ½	__slots__ZELEMENT_NODEZATTRIBUTE_NODEZ	TEXT_NODEZCDATA_SECTION_NODEZENTITY_REFERENCE_NODEZENTITY_NODEZPROCESSING_INSTRUCTION_NODEZCOMMENT_NODEZ
DOCUMENT_NODEZDOCUMENT_TYPE_NODEZDOCUMENT_FRAGMENT_NODEZ
NOTATION_NODErrrοΏ½(/usr/lib64/python3.8/xml/dom/__init__.pyrs	rrrrrrrr	r
rrr
rοΏ½
οΏ½οΏ½οΏ½c@s eZdZdZddοΏ½ZddοΏ½ZdS)οΏ½DOMExceptionzmAbstract base class for DOM exceptions.
    Exceptions with specific codes are specializations of this class.cOs(|jtkrtdοΏ½οΏ½tj|f|οΏ½|οΏ½dS)Nz0DOMException should not be instantiated directly)οΏ½	__class__rοΏ½RuntimeErrorοΏ½	ExceptionοΏ½__init__)οΏ½selfοΏ½argsοΏ½kwrrrrBs

οΏ½zDOMException.__init__cCs|jS)N)οΏ½code)rrrrοΏ½	_get_codeHszDOMException._get_codeN)rrrrrr"rrrrr>src@seZdZeZdS)οΏ½IndexSizeErrN)rrrοΏ½INDEX_SIZE_ERRr!rrrrr#Lsr#c@seZdZeZdS)οΏ½DomstringSizeErrN)rrrοΏ½DOMSTRING_SIZE_ERRr!rrrrr%Osr%c@seZdZeZdS)οΏ½HierarchyRequestErrN)rrrοΏ½HIERARCHY_REQUEST_ERRr!rrrrr'Rsr'c@seZdZeZdS)οΏ½WrongDocumentErrN)rrrοΏ½WRONG_DOCUMENT_ERRr!rrrrr)Usr)c@seZdZeZdS)οΏ½InvalidCharacterErrN)rrrοΏ½INVALID_CHARACTER_ERRr!rrrrr+Xsr+c@seZdZeZdS)οΏ½NoDataAllowedErrN)rrrοΏ½NO_DATA_ALLOWED_ERRr!rrrrr-[sr-c@seZdZeZdS)οΏ½NoModificationAllowedErrN)rrrοΏ½NO_MODIFICATION_ALLOWED_ERRr!rrrrr/^sr/c@seZdZeZdS)οΏ½NotFoundErrN)rrrοΏ½
NOT_FOUND_ERRr!rrrrr1asr1c@seZdZeZdS)οΏ½NotSupportedErrN)rrrοΏ½NOT_SUPPORTED_ERRr!rrrrr3dsr3c@seZdZeZdS)οΏ½InuseAttributeErrN)rrrοΏ½INUSE_ATTRIBUTE_ERRr!rrrrr5gsr5c@seZdZeZdS)οΏ½InvalidStateErrN)rrrοΏ½INVALID_STATE_ERRr!rrrrr7jsr7c@seZdZeZdS)οΏ½	SyntaxErrN)rrrοΏ½
SYNTAX_ERRr!rrrrr9msr9c@seZdZeZdS)οΏ½InvalidModificationErrN)rrrοΏ½INVALID_MODIFICATION_ERRr!rrrrr;psr;c@seZdZeZdS)οΏ½NamespaceErrN)rrrοΏ½
NAMESPACE_ERRr!rrrrr=ssr=c@seZdZeZdS)οΏ½InvalidAccessErrN)rrrοΏ½INVALID_ACCESS_ERRr!rrrrr?vsr?c@seZdZeZdS)οΏ½
ValidationErrN)rrrοΏ½VALIDATION_ERRr!rrrrrAysrAc@s eZdZdZdZdZdZdZdS)οΏ½UserDataHandlerzBClass giving the operation constants for UserDataHandler.handle().rrrrN)rrrrZNODE_CLONEDZ
NODE_IMPORTEDZNODE_DELETEDZNODE_RENAMEDrrrrrC|s
rCz$http://www.w3.org/XML/1998/namespacezhttp://www.w3.org/2000/xmlns/zhttp://www.w3.org/1999/xhtmlN)οΏ½getDOMImplementationοΏ½registerDOMImplementation)-rrr$r&r(r*r,r.r0r2r4r6r8r:r<r>r@rBrrr#r%r'r)r+r-r/r1r3r5r7r9r;r=r?rArCZ
XML_NAMESPACEZXMLNS_NAMESPACEZXHTML_NAMESPACEZEMPTY_NAMESPACEZEMPTY_PREFIXZdomregrDrErrrrοΏ½<module>sR
U

e5d)οΏ½@sοΏ½dZddlZddlZddlmZmZmZmZddlTddl	m
Z
mZejj
jejj
jfZGddοΏ½dejj
οΏ½Z
ee
dd	d
οΏ½ee
ddd
οΏ½ee
d
dd
οΏ½ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZGddοΏ½de
οΏ½ZGddοΏ½de
οΏ½Zeeddd
οΏ½eed
dd
οΏ½eed d!d
οΏ½Gd"d#οΏ½d#eοΏ½Zeed$d%d
οΏ½eZGd&d'οΏ½d'eοΏ½ZeddοΏ½ZGd(d)οΏ½d)e
οΏ½Zeed*d+d
οΏ½eed
d,d
οΏ½d-d.οΏ½ZGd/d0οΏ½d0οΏ½Z Gd1d2οΏ½d2e e
οΏ½Z!Gd3d4οΏ½d4e e
οΏ½Z"ee"d$d5d
οΏ½Gd6d7οΏ½d7e"οΏ½Z#ee#d8d9d
οΏ½ee#d:d;d
οΏ½d<d=οΏ½Z$d>d?οΏ½Z%Gd@dAοΏ½dAe"οΏ½Z&GdBdCοΏ½dCe#οΏ½Z'GdDdEοΏ½dEeοΏ½Z(ee(d$dFd
οΏ½GdGdHοΏ½dHοΏ½Z)GdIdJοΏ½dJe)e e
οΏ½Z*GdKdLοΏ½dLe)e
οΏ½Z+GdMdNοΏ½dNe)e e
οΏ½Z,GdOdPοΏ½dPe
οΏ½Z-GdQdRοΏ½dReοΏ½Z.dSdTοΏ½Z/GdUdVοΏ½dVe
eοΏ½Z0ee0dWdXd
οΏ½dYdZοΏ½Z1d[d\οΏ½Z2d]d^οΏ½Z3ded_d`οΏ½Z4dfdadbοΏ½Z5dgdcddοΏ½Z6dS)hacSimple 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
οΏ½N)οΏ½EMPTY_NAMESPACEοΏ½EMPTY_PREFIXοΏ½XMLNS_NAMESPACEοΏ½domreg)οΏ½*)οΏ½DOMImplementationLSοΏ½
DocumentLSc@sοΏ½eZdZdZdZdZdZdZeZ	ddοΏ½Z
d2ddοΏ½Zd3dd	οΏ½Zd
dοΏ½Z
dd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd d!οΏ½Zd"d#οΏ½Zd$d%οΏ½Zd&d'οΏ½Zd(d)οΏ½Zd*d+οΏ½Zd,d-οΏ½Zd.d/οΏ½Zd0d1οΏ½Z dS)4οΏ½NodeNcCsdS)NTοΏ½οΏ½οΏ½selfr
r
οΏ½'/usr/lib64/python3.8/xml/dom/minidom.pyοΏ½__bool__+sz
Node.__bool__cCs|οΏ½dd|οΏ½SοΏ½NοΏ½)οΏ½toprettyxml)rοΏ½encodingr
r
r
οΏ½toxml.sz
Node.toxmlοΏ½	οΏ½
cCsx|dkrtοΏ½οΏ½}ntjtοΏ½οΏ½|dddοΏ½}|jtjkrH|οΏ½|d|||οΏ½n|οΏ½|d||οΏ½|dkrh|οΏ½οΏ½S|οΏ½	οΏ½οΏ½οΏ½SdS)NοΏ½xmlcharrefreplacer)rοΏ½errorsοΏ½newliner)
οΏ½ioοΏ½StringIOοΏ½
TextIOWrapperοΏ½BytesIOοΏ½nodeTyper	οΏ½
DOCUMENT_NODEοΏ½writexmlοΏ½getvalueοΏ½detach)rοΏ½indentοΏ½newlrοΏ½writerr
r
r
r1s

οΏ½zNode.toprettyxmlcCs
t|jοΏ½SοΏ½N)οΏ½boolοΏ½
childNodesrr
r
r
οΏ½
hasChildNodesCszNode.hasChildNodescCs|jSr%οΏ½r'rr
r
r
οΏ½_get_childNodesFszNode._get_childNodescCs|jr|jdSdSοΏ½Nrr)rr
r
r
οΏ½_get_firstChildIszNode._get_firstChildcCs|jr|jdSdSοΏ½NοΏ½οΏ½οΏ½r)rr
r
r
οΏ½_get_lastChildMszNode._get_lastChildcCs
|j|jkr,t|jοΏ½D]}|οΏ½||οΏ½q|S|j|jkrTtjοΏ½dt	|οΏ½t	|οΏ½fοΏ½οΏ½|j
dk	rj|j
οΏ½|οΏ½|dkr~|οΏ½|οΏ½nοΏ½z|jοΏ½
|οΏ½}Wntk
rοΏ½tjοΏ½οΏ½οΏ½YnX|jtkrοΏ½t|οΏ½|jοΏ½||οΏ½||_||_|rοΏ½|j|d}||_||_nd|_||_
|S)NοΏ½%s cannot be child of %sοΏ½)rοΏ½DOCUMENT_FRAGMENT_NODEοΏ½tupler'οΏ½insertBeforeοΏ½_child_node_typesοΏ½xmlοΏ½domοΏ½HierarchyRequestErrοΏ½reprοΏ½
parentNodeοΏ½removeChildοΏ½appendChildοΏ½indexοΏ½
ValueErrorοΏ½NotFoundErrοΏ½_nodeTypes_with_childrenοΏ½_clear_id_cacheοΏ½insertοΏ½nextSiblingοΏ½previousSibling)rοΏ½newChildοΏ½refChildοΏ½cr=οΏ½noder
r
r
r4Qs8οΏ½

zNode.insertBeforecCsοΏ½|j|jkr*t|jοΏ½D]}|οΏ½|οΏ½q|S|j|jkrTtjοΏ½dt	|οΏ½t	|οΏ½fοΏ½οΏ½n|jt
krft|οΏ½|jdk	r||jοΏ½
|οΏ½t||οΏ½d|_|SοΏ½Nr0)rr2r3r'r<r5r6r7r8r9r@rAr:r;οΏ½
_append_childrC)rrHrGr
r
r
r<qsοΏ½


zNode.appendChildcCs|j|jkr(|j}|οΏ½|οΏ½|οΏ½||οΏ½S|j|jkrPtjοΏ½dt	|οΏ½t	|οΏ½fοΏ½οΏ½||kr\dS|j
dk	rr|j
οΏ½|οΏ½z|jοΏ½|οΏ½}Wnt
k
rοΏ½tjοΏ½οΏ½οΏ½YnX||j|<||_
d|_
|jtksοΏ½|jtkrοΏ½t|οΏ½|j|_|j|_d|_d|_|jrοΏ½||j_|jοΏ½r||j_|SrI)rr2rCr;r4r5r6r7r8r9r:r'r=r>r?r@rArD)rrEοΏ½oldChildrFr=r
r
r
οΏ½replaceChildοΏ½s@
οΏ½


οΏ½zNode.replaceChildcCsοΏ½z|jοΏ½|οΏ½Wntk
r.tjοΏ½οΏ½οΏ½YnX|jdk	rD|j|j_|jdk	rX|j|j_d|_|_|jt	krvt
|οΏ½d|_|Sr%)r'οΏ½remover>r6r7r?rCrDrr@rAr:οΏ½rrKr
r
r
r;οΏ½s




zNode.removeChildcCsοΏ½g}|jD]οΏ½}|jtjkrοΏ½|jsJ|r0|j|d_|jr@|j|j_|οΏ½οΏ½qοΏ½|rοΏ½|dj|jkrοΏ½|d}|j|j|_|j|_|jrοΏ½||j_|οΏ½οΏ½qοΏ½|οΏ½|οΏ½q
|οΏ½|οΏ½|jtj	kr
|οΏ½
οΏ½q
||jddοΏ½<dSr-)r'rr	οΏ½	TEXT_NODEοΏ½datarCrDοΏ½unlinkοΏ½appendοΏ½ELEMENT_NODEοΏ½	normalize)rοΏ½LοΏ½childrHr
r
r
rTοΏ½s*





zNode.normalizecCst|||jp|οΏ½Sr%)οΏ½_clone_nodeοΏ½
ownerDocument)rοΏ½deepr
r
r
οΏ½	cloneNodeοΏ½szNode.cloneNodecCs|jjοΏ½||οΏ½Sr%)rXοΏ½implementationοΏ½
hasFeatureοΏ½rοΏ½featureοΏ½versionr
r
r
οΏ½isSupportedοΏ½szNode.isSupportedcCsdSr%r
rr
r
r
οΏ½_get_localNameοΏ½szNode._get_localNamecCs||kSr%r
οΏ½rοΏ½otherr
r
r
οΏ½
isSameNodeοΏ½szNode.isSameNodecCs|οΏ½|dοΏ½r|SdSdSr%)r`οΏ½rr^r
r
r
οΏ½getInterfaceοΏ½szNode.getInterfacec	Cs0z|j|dWSttfk
r*YdSXdSr+)οΏ½
_user_dataοΏ½AttributeErrorοΏ½KeyErrorοΏ½rοΏ½keyr
r
r
οΏ½getUserDataοΏ½szNode.getUserDatacCsnd}z
|j}Wntk
r,i}||_YnX||krB||d}|dkr^d}|dk	rj||=n||f||<|Sr+)rgrh)rrkrPοΏ½handlerοΏ½oldοΏ½dr
r
r
οΏ½setUserDataοΏ½s
zNode.setUserDatacCsDt|dοΏ½r@t|jοΏ½οΏ½οΏ½D]&\}\}}|dk	r|οΏ½|||||οΏ½qdS)Nrg)οΏ½hasattrοΏ½listrgοΏ½itemsZhandle)rοΏ½	operationοΏ½srcZdstrkrPrmr
r
r
οΏ½_call_user_data_handlerοΏ½s
zNode._call_user_data_handlercCs>d|_|_|jr.|jD]}|οΏ½οΏ½qtοΏ½|_d|_d|_dSr%)r:rXr'rQοΏ½NodeListrDrC)rrVr
r
r
rQs

zNode.unlinkcCs|Sr%r
rr
r
r
οΏ½	__enter__szNode.__enter__cCs|οΏ½οΏ½dSr%)rQ)rZetZevοΏ½tbr
r
r
οΏ½__exit__sz
Node.__exit__)N)rrN)!οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½namespaceURIr:rXrCrDrοΏ½prefixrrrr(r*r,r/r4r<rLr;rTrZr`rardrfrlrprvrQrxrzr
r
r
r
r	"s:

  
r	οΏ½
firstChildzFirst child node, or None.)οΏ½docοΏ½	lastChildzLast child node, or None.οΏ½	localNamez"Namespace-local name of this node.cCs2|j}|r|d}||_||_|οΏ½|οΏ½||_dSr-)r'rDrCrRr:)rrHr'Zlastr
r
r
rJs
rJcCs$|dk	r |jtjkrdS|j}qdSοΏ½NTF)rr	rr:οΏ½rHr
r
r
οΏ½_in_document&s
rοΏ½cCs6|r2|οΏ½ddοΏ½οΏ½ddοΏ½οΏ½ddοΏ½οΏ½ddοΏ½}|οΏ½|οΏ½d	S)
zWrites datachars to writer.οΏ½&z&amp;οΏ½<z&lt;οΏ½"z&quot;οΏ½>z&gt;N)οΏ½replaceοΏ½write)r$rPr
r
r
οΏ½_write_data.sοΏ½οΏ½rοΏ½cCsD|jD]8}|jtjkr2|dks(|j|kr2|οΏ½|οΏ½t|||οΏ½q|SοΏ½Nr)r'rr	rSοΏ½tagNamerRοΏ½_get_elements_by_tagName_helper)οΏ½parentοΏ½nameοΏ½rcrHr
r
r
rοΏ½5s
οΏ½οΏ½
rοΏ½cCsX|jD]L}|jtjkr|dks(|j|krD|dks:|j|krD|οΏ½|οΏ½t||||οΏ½q|SrοΏ½)r'rr	rSrοΏ½r~rRοΏ½"_get_elements_by_tagName_ns_helper)rοΏ½ZnsURIrοΏ½rοΏ½rHr
r
r
rοΏ½=s
οΏ½οΏ½
rοΏ½c@sJeZdZejZdZdZdZdZ	ej
ejejej
ejejejfZddοΏ½ZdS)οΏ½DocumentFragmentz#document-fragmentNcCstοΏ½|_dSr%)rwr'rr
r
r
οΏ½__init__TszDocumentFragment.__init__)r{r|r}r	r2rοΏ½nodeNameοΏ½	nodeValueοΏ½
attributesr:rSrOοΏ½CDATA_SECTION_NODEοΏ½ENTITY_REFERENCE_NODEοΏ½PROCESSING_INSTRUCTION_NODEοΏ½COMMENT_NODEοΏ½
NOTATION_NODEr5rοΏ½r
r
r
r
rοΏ½FsοΏ½rοΏ½c@sοΏ½eZdZdZejZdZdZdZ	ej
ejfZe
ddfddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZeeeοΏ½ZZddοΏ½ZddοΏ½ZeeeοΏ½ZZddοΏ½ZddοΏ½ZeeeοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½Attr)οΏ½_nameοΏ½_valuer~οΏ½_prefixr'οΏ½
_localNamerXοΏ½ownerElementNFcCs2d|_||_||_||_tοΏ½|_|jοΏ½tοΏ½οΏ½dSr%)rοΏ½rοΏ½r~rοΏ½rwr'rRοΏ½Text)rοΏ½qNamer~rοΏ½rr
r
r
rοΏ½bsz
Attr.__init__cCs4z|jWStk
r.|jοΏ½ddοΏ½dYSXdSοΏ½NοΏ½:r1r.)rοΏ½rhrοΏ½οΏ½splitrr
r
r
raoszAttr._get_localNamecCs|jSr%)οΏ½	specifiedrr
r
r
οΏ½_get_specifieduszAttr._get_specifiedcCs|jSr%)rοΏ½rr
r
r
οΏ½	_get_namexszAttr._get_namecCs||_|jdk	rt|jοΏ½dSr%)rοΏ½rοΏ½rAοΏ½rοΏ½valuer
r
r
οΏ½	_set_name{s
zAttr._set_namecCs|jSr%)rοΏ½rr
r
r
οΏ½
_get_valueοΏ½szAttr._get_valuecCs6||_||jd_|jdk	r&t|jοΏ½||jd_dSr+)rοΏ½r'rPrοΏ½rArοΏ½r
r
r
οΏ½
_set_valueοΏ½s


zAttr._set_valuecCs|jSr%)rοΏ½rr
r
r
οΏ½_get_prefixοΏ½szAttr._get_prefixcCsd|j}|dkr&|r&|tkr&tjοΏ½dοΏ½οΏ½||_|dkr<|j}nd||jf}|jrZt|jοΏ½||_	dS)NοΏ½xmlnsz5illegal use of 'xmlns' prefix for the wrong namespacez%s:%s)
r~rr6r7οΏ½NamespaceErrrοΏ½rοΏ½rοΏ½rArοΏ½)rrZnsuriZnewNamer
r
r
οΏ½_set_prefixοΏ½sοΏ½
zAttr._set_prefixcCsv|j}|dk	rR|j|j=|j|j|jf=|jrRd|_|jd8_|jj	d8_	|j
D]}|οΏ½οΏ½qX|j
ddοΏ½=dS)NFr1)rοΏ½οΏ½_attrsrοΏ½οΏ½_attrsNSr~rοΏ½οΏ½_is_idοΏ½_magic_id_nodesrXοΏ½_magic_id_countr'rQ)rοΏ½elemrVr
r
r
rQοΏ½s


zAttr.unlinkcCsf|jr
dS|j}|j}|dks&|dkr*dS|οΏ½|οΏ½}|dkr@dS|jrV|οΏ½|j|jοΏ½S|οΏ½|jοΏ½SdSrοΏ½)	rοΏ½rXrοΏ½οΏ½_get_elem_infor~οΏ½isIdNSrοΏ½οΏ½isIdrοΏ½οΏ½rrοΏ½rοΏ½οΏ½infor
r
r
οΏ½	_get_isIdοΏ½s
zAttr._get_isIdcCs\|j}|j}|dks|dkr tS|οΏ½|οΏ½}|dkr6tS|jrL|οΏ½|j|jοΏ½S|οΏ½|jοΏ½SdSr%)	rXrοΏ½οΏ½_no_typerοΏ½r~οΏ½getAttributeTypeNSrοΏ½οΏ½getAttributeTyperοΏ½rοΏ½r
r
r
οΏ½_get_schemaTypeοΏ½s
zAttr._get_schemaType) r{r|r}οΏ½	__slots__r	οΏ½ATTRIBUTE_NODErrοΏ½rοΏ½rοΏ½rOrοΏ½r5rrοΏ½rarοΏ½rοΏ½rοΏ½οΏ½propertyrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrQrοΏ½rοΏ½r
r
r
r
rοΏ½Xs.οΏ½


rοΏ½rοΏ½z True if this attribute is an ID.z'Namespace-local name of this attribute.οΏ½
schemaTypezSchema type for this attribute.c@sοΏ½eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Z	d
dοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
d:ddοΏ½ZeZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd d!οΏ½Zd"d#οΏ½Zd$d%οΏ½Zd&d'οΏ½Zd(d)οΏ½Zd*d+οΏ½Zd,d-οΏ½Zd.d/οΏ½Zd0d1οΏ½Zd2d3οΏ½Zd4d5οΏ½Zd6d7οΏ½Zd8d9οΏ½Z dS);οΏ½NamedNodeMapaThe 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.
    οΏ½rοΏ½rοΏ½οΏ½
_ownerElementcCs||_||_||_dSr%rοΏ½)rοΏ½attrsZattrsNSrοΏ½r
r
r
rοΏ½οΏ½szNamedNodeMap.__init__cCs
t|jοΏ½Sr%)οΏ½lenrοΏ½rr
r
r
οΏ½_get_lengthοΏ½szNamedNodeMap._get_lengthcCs4z|t|jοΏ½οΏ½οΏ½|WStk
r.YdSXdSr%)rrrοΏ½οΏ½keysοΏ½
IndexErrorοΏ½rr=r
r
r
οΏ½itemοΏ½szNamedNodeMap.itemcCs*g}|jοΏ½οΏ½D]}|οΏ½|j|jfοΏ½q|Sr%)rοΏ½οΏ½valuesrRrοΏ½rοΏ½οΏ½rrUrHr
r
r
rsοΏ½szNamedNodeMap.itemscCs0g}|jοΏ½οΏ½D]}|οΏ½|j|jf|jfοΏ½q|Sr%)rοΏ½rοΏ½rRr~rοΏ½rοΏ½rοΏ½r
r
r
οΏ½itemsNSοΏ½szNamedNodeMap.itemsNScCs"t|tοΏ½r||jkS||jkSdSr%)οΏ½
isinstanceοΏ½strrοΏ½rοΏ½rjr
r
r
οΏ½__contains__οΏ½s

zNamedNodeMap.__contains__cCs
|jοΏ½οΏ½Sr%)rοΏ½rοΏ½rr
r
r
rοΏ½szNamedNodeMap.keyscCs
|jοΏ½οΏ½Sr%)rοΏ½rοΏ½rr
r
r
οΏ½keysNSszNamedNodeMap.keysNScCs
|jοΏ½οΏ½Sr%)rοΏ½rοΏ½rr
r
r
rοΏ½szNamedNodeMap.valuesNcCs|jοΏ½||οΏ½Sr%οΏ½rοΏ½οΏ½get)rrοΏ½rοΏ½r
r
r
rοΏ½
szNamedNodeMap.getcCs:|jt|ddοΏ½krdSt|οΏ½t|οΏ½kt|οΏ½t|οΏ½kSdS)NrοΏ½r)rοΏ½οΏ½getattrοΏ½idrbr
r
r
οΏ½_cmpszNamedNodeMap._cmpcCs|οΏ½|οΏ½dkSr+οΏ½rοΏ½rbr
r
r
οΏ½__eq__szNamedNodeMap.__eq__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__ge__szNamedNodeMap.__ge__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__gt__szNamedNodeMap.__gt__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__le__szNamedNodeMap.__le__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__lt__!szNamedNodeMap.__lt__cCs"t|tοΏ½r|j|S|j|SdSr%)rοΏ½r3rοΏ½rοΏ½)rοΏ½attname_or_tupler
r
r
οΏ½__getitem__$s

zNamedNodeMap.__getitem__cCsvt|tοΏ½rRz|j|}Wn0tk
rHt|οΏ½}|jj|_|οΏ½|οΏ½YnX||_n t|tοΏ½sdt	dοΏ½οΏ½|}|οΏ½|οΏ½dS)Nz%value must be a string or Attr object)
rοΏ½rοΏ½rοΏ½rirοΏ½rοΏ½rXοΏ½setNamedItemrοΏ½οΏ½	TypeError)rοΏ½attnamerοΏ½rHr
r
r
οΏ½__setitem__+s


zNamedNodeMap.__setitem__cCs(z|j|WStk
r"YdSXdSr%)rοΏ½riοΏ½rrοΏ½r
r
r
οΏ½getNamedItem:szNamedNodeMap.getNamedItemcCs,z|j||fWStk
r&YdSXdSr%)rοΏ½riοΏ½rr~rοΏ½r
r
r
οΏ½getNamedItemNS@szNamedNodeMap.getNamedItemNScCsX|οΏ½|οΏ½}|dk	rJt|jοΏ½|j|j=|j|j|jf=t|dοΏ½rFd|_	|St
jοΏ½οΏ½οΏ½dSοΏ½NrοΏ½)
rοΏ½rArοΏ½rοΏ½rοΏ½rοΏ½r~rοΏ½rqrοΏ½r6r7r?οΏ½rrοΏ½οΏ½nr
r
r
οΏ½removeNamedItemFs



zNamedNodeMap.removeNamedItemcCsZ|οΏ½||οΏ½}|dk	rLt|jοΏ½|j|j|jf=|j|j=t|dοΏ½rHd|_	|St
jοΏ½οΏ½οΏ½dSrοΏ½)
rοΏ½rArοΏ½rοΏ½r~rοΏ½rοΏ½rοΏ½rqrοΏ½r6r7r?οΏ½rr~rοΏ½rοΏ½r
r
r
οΏ½removeNamedItemNSRs


zNamedNodeMap.removeNamedItemNScCstt|tοΏ½s&tjοΏ½dt|οΏ½t|οΏ½fοΏ½οΏ½|jοΏ½|jοΏ½}|r@|οΏ½	οΏ½||j|j<||j
|j|jf<|j
|_t|jοΏ½|SrI)rοΏ½rοΏ½r6r7r8r9rοΏ½rοΏ½rοΏ½rQrοΏ½r~rοΏ½rοΏ½rοΏ½rA)rrHrnr
r
r
rοΏ½^s
οΏ½
zNamedNodeMap.setNamedItemcCs
|οΏ½|οΏ½Sr%)rοΏ½οΏ½rrHr
r
r
οΏ½setNamedItemNSkszNamedNodeMap.setNamedItemNScCs||}t|jοΏ½|οΏ½οΏ½dSr%)rArοΏ½rQ)rrοΏ½rHr
r
r
οΏ½__delitem__ns
zNamedNodeMap.__delitem__cCs|j|j|jfSr%rοΏ½rr
r
r
οΏ½__getstate__sszNamedNodeMap.__getstate__cCs|\|_|_|_dSr%rοΏ½οΏ½rοΏ½stater
r
r
οΏ½__setstate__vszNamedNodeMap.__setstate__)N)!r{r|r}οΏ½__doc__rοΏ½rοΏ½rοΏ½rοΏ½rsrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½__len__rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
rοΏ½οΏ½s<

rοΏ½Zlengthz$Number of nodes in the NamedNodeMap.c@s0eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
S)οΏ½TypeInfoοΏ½οΏ½	namespacerοΏ½cCs||_||_dSr%r)rrrοΏ½r
r
r
rοΏ½οΏ½szTypeInfo.__init__cCs2|jrd|jj|j|jfSd|jj|jfSdS)Nz<%s %r (from %r)>z<%s %r>)rοΏ½	__class__r{rοΏ½rr
r
r
οΏ½__repr__οΏ½s
οΏ½zTypeInfo.__repr__cCs|jSr%)rοΏ½rr
r
r
rοΏ½οΏ½szTypeInfo._get_namecCs|jSr%)rrr
r
r
οΏ½_get_namespaceοΏ½szTypeInfo._get_namespaceN)r{r|r}rοΏ½rοΏ½rrοΏ½rr
r
r
r
rοΏ½s
rοΏ½c@s eZdZdZejZdZeZ	dZ
ejejejej
ejejfZeddfddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZeZddοΏ½ZddοΏ½Z d d!οΏ½Z!e!Z"d"d#οΏ½Z#d$d%οΏ½Z$d&d'οΏ½Z%d(d)οΏ½Z&d*d+οΏ½Z'd9d-d.οΏ½Z(d/d0οΏ½Z)d1d2οΏ½Z*d3d4οΏ½Z+d5d6οΏ½Z,d7d8οΏ½Z-dS):οΏ½Element)rXr:rοΏ½rοΏ½rr~rοΏ½r'rοΏ½rοΏ½rCrDNrcCsBd|_||_|_||_||_tοΏ½|_d|_|_d|_	d|_
dSr%)r:rοΏ½rοΏ½rr~rwr'rCrDrοΏ½rοΏ½)rrοΏ½r~rrοΏ½r
r
r
rοΏ½οΏ½s
zElement.__init__cCs|jdkri|_i|_dSr%)rοΏ½rοΏ½rr
r
r
οΏ½_ensure_attributesοΏ½s
zElement._ensure_attributescCs4z|jWStk
r.|jοΏ½ddοΏ½dYSXdSrοΏ½)rοΏ½rhrοΏ½rοΏ½rr
r
r
raοΏ½szElement._get_localNamecCs|jSr%οΏ½rοΏ½rr
r
r
οΏ½_get_tagNameοΏ½szElement._get_tagNamecCs@|jdk	r&t|jοΏ½οΏ½οΏ½D]}|οΏ½οΏ½qd|_d|_tοΏ½|οΏ½dSr%)rοΏ½rrrοΏ½rQrοΏ½r	)rοΏ½attrr
r
r
rQοΏ½s

zElement.unlinkcCs8|jdkrdSz|j|jWStk
r2YdSXdSr)rοΏ½rοΏ½ri)rrοΏ½r
r
r
οΏ½getAttributeοΏ½s
zElement.getAttributecCs<|jdkrdSz|j||fjWStk
r6YdSXdSr)rοΏ½rοΏ½rirοΏ½r
r
r
οΏ½getAttributeNSοΏ½s
zElement.getAttributeNScCsV|οΏ½|οΏ½}|dkr4t|οΏ½}||_|j|_|οΏ½|οΏ½n||jkrR||_|jrRt|οΏ½dSr%)οΏ½getAttributeNoderοΏ½rοΏ½rXοΏ½setAttributeNoderοΏ½rA)rrοΏ½rοΏ½r	r
r
r
οΏ½setAttributeοΏ½s

zElement.setAttributecCsοΏ½t|οΏ½\}}|οΏ½||οΏ½}|dkrHt||||οΏ½}||_|j|_|οΏ½|οΏ½n4||jkrf||_|jrft|οΏ½|j|kr|||_||_	dSr%)
οΏ½_nssplitοΏ½getAttributeNodeNSrοΏ½rοΏ½rXr
rοΏ½rArrοΏ½)rr~οΏ½
qualifiedNamerοΏ½rοΏ½	localnamer	r
r
r
οΏ½setAttributeNSοΏ½s

zElement.setAttributeNScCs|jdkrdS|jοΏ½|οΏ½Sr%rοΏ½)rοΏ½attrnamer
r
r
rοΏ½s
zElement.getAttributeNodecCs|jdkrdS|jοΏ½||fοΏ½Sr%)rοΏ½rοΏ½rοΏ½r
r
r
rs
zElement.getAttributeNodeNScCsοΏ½|jd|fkrtjοΏ½dοΏ½οΏ½|οΏ½οΏ½|jοΏ½|jdοΏ½}|dk	rD|οΏ½|οΏ½|j	οΏ½|j
|jfdοΏ½}|dk	rt||k	rt|οΏ½|οΏ½t||οΏ½||k	rοΏ½|S||k	rοΏ½|SdS)Nzattribute node already owned)
rοΏ½r6r7ZInuseAttributeErrrrοΏ½rοΏ½rοΏ½οΏ½removeAttributeNoderοΏ½r~rοΏ½οΏ½_set_attribute_node)rr	Zold1Zold2r
r
r
r
s


zElement.setAttributeNodecCsP|jdkrtjοΏ½οΏ½οΏ½z|j|}Wntk
r@tjοΏ½οΏ½οΏ½YnX|οΏ½|οΏ½dSr%)rοΏ½r6r7r?rοΏ½rir)rrοΏ½r	r
r
r
οΏ½removeAttributes

zElement.removeAttributecCsT|jdkrtjοΏ½οΏ½οΏ½z|j||f}Wntk
rDtjοΏ½οΏ½οΏ½YnX|οΏ½|οΏ½dSr%)rοΏ½r6r7r?rir)rr~rοΏ½r	r
r
r
οΏ½removeAttributeNS%s

zElement.removeAttributeNScCs^|dkrtjοΏ½οΏ½οΏ½z|j|jWntk
r@tjοΏ½οΏ½οΏ½YnXt|οΏ½|οΏ½οΏ½|j|_|Sr%)	r6r7r?rοΏ½rοΏ½rirArQrXrοΏ½r
r
r
r.s
zElement.removeAttributeNodecCs|jdkrdS||jkSοΏ½NFοΏ½rοΏ½rοΏ½r
r
r
οΏ½hasAttribute>s
zElement.hasAttributecCs|jdkrdS||f|jkSr)rοΏ½rοΏ½r
r
r
οΏ½hasAttributeNSCs
zElement.hasAttributeNScCst||tοΏ½οΏ½Sr%οΏ½rοΏ½rwrοΏ½r
r
r
οΏ½getElementsByTagNameHszElement.getElementsByTagNamecCst|||tοΏ½οΏ½Sr%οΏ½rοΏ½rwrοΏ½r
r
r
οΏ½getElementsByTagNameNSKsοΏ½zElement.getElementsByTagNameNScCsd|jt|οΏ½fS)Nz<DOM Element: %s at %#x>)rοΏ½rοΏ½rr
r
r
rOszElement.__repr__rcCsοΏ½|οΏ½|d|jοΏ½|οΏ½οΏ½}|οΏ½οΏ½D],}|οΏ½d|οΏ½t|||jοΏ½|οΏ½dοΏ½q$|jrοΏ½|οΏ½dοΏ½t|jοΏ½dkrοΏ½|jdjt	j
t	jfkrοΏ½|jdοΏ½|dddοΏ½n4|οΏ½|οΏ½|jD]}|οΏ½|||||οΏ½qοΏ½|οΏ½|οΏ½|οΏ½d|j|fοΏ½n|οΏ½d	|οΏ½dS)
NrοΏ½z %s="rοΏ½rοΏ½r1rrz</%s>%sz/>%s)
rοΏ½rοΏ½οΏ½_get_attributesrοΏ½rοΏ½rοΏ½r'rοΏ½rr	rOrοΏ½r)rr$r"οΏ½	addindentr#rοΏ½Za_namerHr
r
r
rRs*

οΏ½οΏ½


zElement.writexmlcCs|οΏ½οΏ½t|j|j|οΏ½Sr%)rrοΏ½rοΏ½rοΏ½rr
r
r
r!mszElement._get_attributescCs|jr
dSdSdSrοΏ½rrr
r
r
οΏ½
hasAttributesqszElement.hasAttributescCs|οΏ½|οΏ½}|οΏ½|οΏ½dSr%)rοΏ½setIdAttributeNode)rrοΏ½οΏ½idAttrr
r
r
οΏ½setIdAttributeys
zElement.setIdAttributecCs|οΏ½||οΏ½}|οΏ½|οΏ½dSr%)rr$)rr~rοΏ½r%r
r
r
οΏ½setIdAttributeNS}szElement.setIdAttributeNScCsj|dks|οΏ½|jοΏ½stjοΏ½οΏ½οΏ½t|οΏ½dk	r4tjοΏ½οΏ½οΏ½|jsfd|_|jd7_|j	j
d7_
t|οΏ½dS)NTr1)rdrοΏ½r6r7r?οΏ½_get_containing_entrefοΏ½NoModificationAllowedErrrοΏ½rοΏ½rXrοΏ½rA)rr%r
r
r
r$οΏ½s

zElement.setIdAttributeNode)rrr).r{r|r}rοΏ½r	rSrrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rOrοΏ½rοΏ½r5rrοΏ½rrarrQr
rrrrrr
ZsetAttributeNodeNSrrrZremoveAttributeNodeNSrrrr rrr!r#r&r'r$r
r
r
r
rοΏ½sTοΏ½οΏ½
		
rrοΏ½z*NamedNodeMap of attributes on the element.z%Namespace-local name of this element.cCs8t|οΏ½|οΏ½οΏ½||j|j<||j|j|jf<||_dSr%)rArrοΏ½rοΏ½rοΏ½r~rοΏ½rοΏ½)οΏ½elementr	r
r
r
rοΏ½s
rc@sfeZdZdZdZdZeοΏ½ZdZdZ	ddοΏ½Z
ddοΏ½Zdd	οΏ½Zd
dοΏ½Z
dd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½	ChildlesszοΏ½Mixin that makes childless-ness easy to implement and avoids
    the complexity of the Node methods that deal with children.
    r
NcCsdSr%r
rr
r
r
r,οΏ½szChildless._get_firstChildcCsdSr%r
rr
r
r
r/οΏ½szChildless._get_lastChildcCstjοΏ½|jdοΏ½οΏ½dS)Nz nodes cannot have childrenοΏ½r6r7r8rοΏ½rοΏ½r
r
r
r<οΏ½sοΏ½zChildless.appendChildcCsdSrr
rr
r
r
r(οΏ½szChildless.hasChildNodescCstjοΏ½|jdοΏ½οΏ½dSοΏ½Nz nodes do not have childrenr,οΏ½rrErFr
r
r
r4οΏ½sοΏ½zChildless.insertBeforecCstjοΏ½|jdοΏ½οΏ½dSr-)r6r7r?rοΏ½rNr
r
r
r;οΏ½sοΏ½zChildless.removeChildcCsdSr%r
rr
r
r
rTοΏ½szChildless.normalizecCstjοΏ½|jdοΏ½οΏ½dSr-r,οΏ½rrErKr
r
r
rLοΏ½sοΏ½zChildless.replaceChild)r{r|r}rοΏ½rοΏ½rοΏ½Z
EmptyNodeListr'rοΏ½rοΏ½r,r/r<r(r4r;rTrLr
r
r
r
r+οΏ½sr+c@s\eZdZejZdZddοΏ½ZddοΏ½ZddοΏ½Z	e
ee	οΏ½Zdd	οΏ½Zd
dοΏ½Z
e
ee
οΏ½Zdd
dοΏ½ZdS)οΏ½ProcessingInstructionοΏ½οΏ½targetrPcCs||_||_dSr%r1)rr2rPr
r
r
rοΏ½οΏ½szProcessingInstruction.__init__cCs|jSr%οΏ½rPrr
r
r
οΏ½_get_nodeValueοΏ½sz$ProcessingInstruction._get_nodeValuecCs
||_dSr%r3rοΏ½r
r
r
οΏ½_set_nodeValueοΏ½sz$ProcessingInstruction._set_nodeValuecCs|jSr%οΏ½r2rr
r
r
οΏ½
_get_nodeNameοΏ½sz#ProcessingInstruction._get_nodeNamecCs
||_dSr%r6rοΏ½r
r
r
οΏ½
_set_nodeNameοΏ½sz#ProcessingInstruction._set_nodeNamercCs|οΏ½d||j|j|fοΏ½dS)Nz
%s<?%s %s?>%s)rοΏ½r2rPοΏ½rr$r"r"r#r
r
r
rοΏ½szProcessingInstruction.writexmlN)rrr)r{r|r}r	rοΏ½rrοΏ½rοΏ½r4r5rοΏ½rοΏ½r7r8rοΏ½rr
r
r
r
r0οΏ½s

r0c@sreZdZdZddοΏ½ZddοΏ½ZeZddοΏ½Zdd	οΏ½Ze	eeοΏ½Z
Zd
dοΏ½Zdd
οΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½
CharacterData)οΏ½_datarXr:rDrCcCs,d|_|_d|_|_d|_tοΏ½|οΏ½dSr)rXr:rDrCr;r	rοΏ½rr
r
r
rοΏ½οΏ½szCharacterData.__init__cCs
t|jοΏ½Sr%)rοΏ½rPrr
r
r
rοΏ½οΏ½szCharacterData._get_lengthcCs|jSr%οΏ½r;rr
r
r
οΏ½	_get_dataοΏ½szCharacterData._get_datacCs
||_dSr%r<οΏ½rrPr
r
r
οΏ½	_set_dataοΏ½szCharacterData._set_datacCs6|j}t|οΏ½dkrd}nd}d|jj|ddοΏ½|fS)NοΏ½
z...rz<DOM %s node "%r%s">r)rPrοΏ½rr{)rrPZ	dotdotdotr
r
r
rοΏ½s
οΏ½zCharacterData.__repr__cCsT|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|dkrBtjοΏ½dοΏ½οΏ½|j|||οΏ½SοΏ½NrοΏ½offset cannot be negativeοΏ½#offset cannot be beyond end of dataοΏ½count cannot be negativeοΏ½r6r7οΏ½IndexSizeErrrοΏ½rPοΏ½rοΏ½offsetοΏ½countr
r
r
οΏ½
substringDataοΏ½szCharacterData.substringDatacCs|j||_dSr%r3)rοΏ½argr
r
r
οΏ½
appendDataszCharacterData.appendDatacCsZ|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|rVd|jd|οΏ½||j|dοΏ½f|_dS)NrrBrCοΏ½%s%s%srE)rrHrKr
r
r
οΏ½
insertData	sοΏ½zCharacterData.insertDatacCsl|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|dkrBtjοΏ½dοΏ½οΏ½|rh|jd|οΏ½|j||dοΏ½|_dSrArErGr
r
r
οΏ½
deleteDataszCharacterData.deleteDatacCsr|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|dkrBtjοΏ½dοΏ½οΏ½|rnd|jd|οΏ½||j||dοΏ½f|_dS)NrrBrCrDrMrE)rrHrIrKr
r
r
οΏ½replaceDatasοΏ½zCharacterData.replaceDataN)r{r|r}rοΏ½rοΏ½rοΏ½rοΏ½r=r?rοΏ½rPrοΏ½rrJrLrNrOrPr
r
r
r
r:οΏ½s			
r:zLength of the string data.c@sHeZdZdZejZdZdZddοΏ½Z	dddοΏ½Z
d	d
οΏ½ZddοΏ½Zd
dοΏ½Z
dS)rοΏ½r
z#textNcCsοΏ½|dks|t|jοΏ½kr"tjοΏ½dοΏ½οΏ½|οΏ½οΏ½}|j|dοΏ½|_|j|_|j}|jr~||jj	kr~|dkrp|jοΏ½
|οΏ½n|jοΏ½||οΏ½|jd|οΏ½|_|S)Nrzillegal offset value)rοΏ½rPr6r7rFrrXrCr:r'r<r4)rrHZnewTextοΏ½nextr
r
r
οΏ½	splitText1szText.splitTextrcCst|d||j|fοΏ½dS)NrM)rοΏ½rPr9r
r
r
r@sz
Text.writexmlcCsοΏ½|jg}|j}|dk	rB|jtjtjfkrB|οΏ½d|jοΏ½|j}qqBq|j}|dk	rz|jtjtjfkrz|οΏ½|jοΏ½|j}qHqzqHdοΏ½	|οΏ½S)Nrr)
rPrDrr	rOrοΏ½rBrCrRοΏ½join)rrUrοΏ½r
r
r
οΏ½_get_wholeTextEszText._get_wholeTextcCsοΏ½|j}|j}|dk	r@|jtjtjfkr@|j}|οΏ½|οΏ½|}qq@q|j}|sT|οΏ½|οΏ½|dk	rοΏ½|jtjtjfkrοΏ½|j}|οΏ½|οΏ½|}qTqοΏ½qT|rοΏ½||_|SdSdSr%)	r:rDrr	rOrοΏ½r;rCrP)rZcontentrοΏ½rοΏ½rQr
r
r
οΏ½replaceWholeTextWs*


zText.replaceWholeTextcCsF|jοΏ½οΏ½rdSt|οΏ½}|dkr"dS|jοΏ½|οΏ½}|dkr:dS|οΏ½οΏ½SdSr)rPοΏ½stripοΏ½_get_containing_elementrXrοΏ½οΏ½isElementContent)rrοΏ½rοΏ½r
r
r
οΏ½!_get_isWhitespaceInElementContentss
z&Text._get_isWhitespaceInElementContent)rrr)r{r|r}rοΏ½r	rOrrοΏ½rοΏ½rRrrTrUrYr
r
r
r
rοΏ½*s
rοΏ½ZisWhitespaceInElementContentzKTrue iff this text node contains only whitespace and is in element content.Z	wholeTextz.The text of all logically-adjacent text nodes.cCs*|j}|dk	r&|jtjkr|S|j}qdSr%)r:rr	rSοΏ½rHrGr
r
r
rWοΏ½srWcCs*|j}|dk	r&|jtjkr|S|j}qdSr%)r:rr	rοΏ½rZr
r
r
r(οΏ½sr(c@s(eZdZejZdZddοΏ½ZdddοΏ½ZdS)	οΏ½Commentz#commentcCstοΏ½|οΏ½||_dSr%)r:rοΏ½r;r>r
r
r
rοΏ½οΏ½s
zComment.__init__rcCs,d|jkrtdοΏ½οΏ½|οΏ½d||j|fοΏ½dS)Nz--z%'--' is not allowed in a comment nodez
%s<!--%s-->%s)rPr>rοΏ½r9r
r
r
rοΏ½s
zComment.writexmlN)rrr)	r{r|r}r	rοΏ½rrοΏ½rοΏ½rr
r
r
r
r[οΏ½sr[c@s$eZdZdZejZdZdddοΏ½ZdS)οΏ½CDATASectionr
z#cdata-sectionrcCs,|jοΏ½dοΏ½dkrtdοΏ½οΏ½|οΏ½d|jοΏ½dS)Nz]]>rz$']]>' not allowed in a CDATA sectionz<![CDATA[%s]]>)rPοΏ½findr>rοΏ½r9r
r
r
rοΏ½szCDATASection.writexmlN)rrr)	r{r|r}rοΏ½r	rοΏ½rrοΏ½rr
r
r
r
r\οΏ½sr\c@szeZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½ReadOnlySequentialNamedNodeMapοΏ½οΏ½_seqr
cCs
||_dSr%r_)rοΏ½seqr
r
r
rοΏ½οΏ½sz'ReadOnlySequentialNamedNodeMap.__init__cCs
t|jοΏ½Sr%οΏ½rοΏ½r`rr
r
r
rοΏ½οΏ½sz&ReadOnlySequentialNamedNodeMap.__len__cCs
t|jοΏ½Sr%rbrr
r
r
rοΏ½οΏ½sz*ReadOnlySequentialNamedNodeMap._get_lengthcCs"|jD]}|j|kr|SqdSr%)r`rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s

z+ReadOnlySequentialNamedNodeMap.getNamedItemcCs,|jD] }|j|kr|j|kr|SqdSr%)r`r~rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s
z-ReadOnlySequentialNamedNodeMap.getNamedItemNScCs4t|tοΏ½r|j|οΏ½}n
|οΏ½|οΏ½}|dkr0t|οΏ½οΏ½|Sr%)rοΏ½r3rοΏ½rοΏ½ri)rZ
name_or_tuplerHr
r
r
rοΏ½οΏ½s

z*ReadOnlySequentialNamedNodeMap.__getitem__cCs4|dkrdSz|j|WStk
r.YdSXdSr+)r`rοΏ½rοΏ½r
r
r
rοΏ½οΏ½sz#ReadOnlySequentialNamedNodeMap.itemcCstjοΏ½dοΏ½οΏ½dSοΏ½Nz"NamedNodeMap instance is read-onlyοΏ½r6r7r)rοΏ½r
r
r
rοΏ½οΏ½sοΏ½z.ReadOnlySequentialNamedNodeMap.removeNamedItemcCstjοΏ½dοΏ½οΏ½dSrcrdrοΏ½r
r
r
rοΏ½οΏ½sοΏ½z0ReadOnlySequentialNamedNodeMap.removeNamedItemNScCstjοΏ½dοΏ½οΏ½dSrcrdrοΏ½r
r
r
rοΏ½οΏ½sοΏ½z+ReadOnlySequentialNamedNodeMap.setNamedItemcCstjοΏ½dοΏ½οΏ½dSrcrdrοΏ½r
r
r
rοΏ½οΏ½sοΏ½z-ReadOnlySequentialNamedNodeMap.setNamedItemNScCs|jgSr%r_rr
r
r
rοΏ½οΏ½sz+ReadOnlySequentialNamedNodeMap.__getstate__cCs|d|_dSr+r_rοΏ½r
r
r
rοΏ½οΏ½sz+ReadOnlySequentialNamedNodeMap.__setstate__N)r
)r{r|r}rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
r^οΏ½s
	r^z&Number of entries in the NamedNodeMap.c@s,eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	S)
οΏ½
Identifiedz@Mix-in class that supports the publicId and systemId attributes.οΏ½οΏ½publicIdοΏ½systemIdcCs||_||_dSr%rf)rrgrhr
r
r
οΏ½_identified_mixin_initοΏ½sz!Identified._identified_mixin_initcCs|jSr%)rgrr
r
r
οΏ½
_get_publicIdοΏ½szIdentified._get_publicIdcCs|jSr%)rhrr
r
r
οΏ½
_get_systemIdοΏ½szIdentified._get_systemIdN)r{r|r}rοΏ½rοΏ½rirjrkr
r
r
r
reοΏ½s
rec@sHeZdZejZdZdZdZdZ	dZ
ddοΏ½ZddοΏ½ZddοΏ½Z
dd	d
οΏ½ZdS)οΏ½DocumentTypeNcCs2tοΏ½|_tοΏ½|_|r&t|οΏ½\}}||_|j|_dSr%)r^οΏ½entitiesοΏ½	notationsrrοΏ½rοΏ½)rrrrr
r
r
rοΏ½
szDocumentType.__init__cCs|jSr%)οΏ½internalSubsetrr
r
r
οΏ½_get_internalSubsetsz DocumentType._get_internalSubsetcCsοΏ½|jdkrοΏ½tdοΏ½}|j|_|j|_tjjj}|rοΏ½g|j_	g|j
_	|j
j	D]2}t|j|j|j
οΏ½}|j
j	οΏ½|οΏ½|οΏ½|||οΏ½qH|jj	D]N}t|j|j|j
|jοΏ½}|j|_|j|_|j|_|jj	οΏ½|οΏ½|οΏ½|||οΏ½qοΏ½|οΏ½|||οΏ½|SdSdSr%)rXrlrοΏ½rοΏ½r6r7οΏ½UserDataHandlerοΏ½NODE_CLONEDrmr`rnοΏ½NotationrgrhrRrvοΏ½EntityοΏ½notationNameοΏ½actualEncodingrr_)rrYοΏ½clonertrοΏ½οΏ½notationοΏ½eοΏ½entityr
r
r
rZs0

οΏ½zDocumentType.cloneNodercCsοΏ½|οΏ½dοΏ½|οΏ½|jοΏ½|jr8|οΏ½d||j||jfοΏ½n|jrR|οΏ½d||jfοΏ½|jdk	r||οΏ½dοΏ½|οΏ½|jοΏ½|οΏ½dοΏ½|οΏ½d|οΏ½dS)Nz
<!DOCTYPE z%s  PUBLIC '%s'%s  '%s'z%s  SYSTEM '%s'z [οΏ½]rοΏ½)rοΏ½rοΏ½rgrhror9r
r
r
r0s
οΏ½


zDocumentType.writexml)rrr)r{r|r}r	οΏ½DOCUMENT_TYPE_NODErrοΏ½rοΏ½rgrhrorοΏ½rprZrr
r
r
r
rlsrlc@sfeZdZdZejZdZdZdZ	dZ
ddοΏ½ZddοΏ½ZddοΏ½Z
dd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½ZddοΏ½ZdS)rtNcCs$||_||_tοΏ½|_|οΏ½||οΏ½dSr%)rοΏ½rurwr'ri)rrοΏ½rgrhrxr
r
r
rοΏ½GszEntity.__init__cCs|jSr%οΏ½rvrr
r
r
οΏ½_get_actualEncodingMszEntity._get_actualEncodingcCs|jSr%οΏ½rrr
r
r
οΏ½
_get_encodingPszEntity._get_encodingcCs|jSr%οΏ½r_rr
r
r
οΏ½_get_versionSszEntity._get_versioncCstjοΏ½dοΏ½οΏ½dS)Nz(cannot append children to an entity nodeοΏ½r6r7r8)rrEr
r
r
r<VsοΏ½zEntity.appendChildcCstjοΏ½dοΏ½οΏ½dS)Nz+cannot insert children below an entity noderοΏ½r.r
r
r
r4ZsοΏ½zEntity.insertBeforecCstjοΏ½dοΏ½οΏ½dS)Nz*cannot remove children from an entity noderοΏ½rNr
r
r
r;^sοΏ½zEntity.removeChildcCstjοΏ½dοΏ½οΏ½dS)Nz)cannot replace children of an entity noderοΏ½r/r
r
r
rLbsοΏ½zEntity.replaceChild)r{r|r}rοΏ½r	ZENTITY_NODErrοΏ½rvrr_rοΏ½r~rοΏ½rοΏ½r<r4r;rLr
r
r
r
rt>srtc@seZdZejZdZddοΏ½ZdS)rsNcCs||_|οΏ½||οΏ½dSr%)rοΏ½ri)rrοΏ½rgrhr
r
r
rοΏ½jszNotation.__init__)r{r|r}r	rοΏ½rrοΏ½rοΏ½r
r
r
r
rsfsrsc@sHeZdZddddddddgZd	d
οΏ½ZddοΏ½Zd
dοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½DOMImplementation)οΏ½coreοΏ½1.0)rοΏ½οΏ½2.0)rοΏ½N)r6rοΏ½)r6rοΏ½)r6N)οΏ½ls-loadz3.0)rοΏ½NcCs|dkrd}|οΏ½οΏ½|f|jkSr)οΏ½lowerοΏ½	_featuresr]r
r
r
r\zszDOMImplementation.hasFeaturec	CsοΏ½|r|jdk	rtjοΏ½dοΏ½οΏ½|οΏ½οΏ½}|dko8|dko8|dk}|sP|rPtjοΏ½dοΏ½οΏ½|rοΏ½t|οΏ½\}}|dkr||dkr|tjοΏ½dοΏ½οΏ½|rοΏ½|sοΏ½tjοΏ½dοΏ½οΏ½|οΏ½||οΏ½}|rοΏ½|οΏ½	|οΏ½|οΏ½	|οΏ½|rοΏ½||_|_
||_||_|S)Nz(doctype object owned by another DOM treezElement with no namer6z$http://www.w3.org/XML/1998/namespacezillegal use of 'xml' prefixz(illegal use of prefix without namespaces)
r:r6r7οΏ½WrongDocumentErrοΏ½_create_documentZInvalidCharacterErrrrοΏ½οΏ½createElementNSr<rXοΏ½doctyper[)	rr~rrοΏ½rοΏ½Zadd_root_elementrrr*r
r
r
οΏ½createDocuments>οΏ½οΏ½οΏ½
οΏ½οΏ½

z DOMImplementation.createDocumentcCst|οΏ½}||_||_|Sr%)rlrgrh)rrrgrhrοΏ½r
r
r
οΏ½createDocumentTypeοΏ½sz$DOMImplementation.createDocumentTypecCs|οΏ½|dοΏ½r|SdSdSr%)r\rer
r
r
rfοΏ½szDOMImplementation.getInterfacecCstοΏ½Sr%)οΏ½Documentrr
r
r
rοΏ½οΏ½sz"DOMImplementation._create_documentN)	r{r|r}rοΏ½r\rοΏ½rοΏ½rfrοΏ½r
r
r
r
rοΏ½osοΏ½
-rοΏ½c@s\eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Z	d
dοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
dS)οΏ½ElementInfozοΏ½Object that represents content-model information for an element.

    This implementation is not expected to be used in practice; DOM
    builders should provide implementations which do the right thing
    using information available to it.

    rcCs
||_dSr%rrοΏ½r
r
r
rοΏ½οΏ½szElementInfo.__init__cCstSr%οΏ½rοΏ½οΏ½rZanamer
r
r
rοΏ½οΏ½szElementInfo.getAttributeTypecCstSr%rοΏ½rοΏ½r
r
r
rοΏ½οΏ½szElementInfo.getAttributeTypeNScCsdSrr
rr
r
r
rXοΏ½szElementInfo.isElementContentcCsdS)zQReturns true iff this element is declared to have an EMPTY
        content model.Fr
rr
r
r
οΏ½isEmptyοΏ½szElementInfo.isEmptycCsdS)z7Returns true iff the named attribute is a DTD-style ID.Fr
rοΏ½r
r
r
rοΏ½οΏ½szElementInfo.isIdcCsdS)z<Returns true iff the identified attribute is a DTD-style ID.Fr
rοΏ½r
r
r
rοΏ½οΏ½szElementInfo.isIdNScCs|jSr%rrr
r
r
rοΏ½οΏ½szElementInfo.__getstate__cCs
||_dSr%rrοΏ½r
r
r
rοΏ½οΏ½szElementInfo.__setstate__N)r{r|r}rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rXrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
rοΏ½οΏ½srοΏ½cCs>|jtjkr|jοΏ½οΏ½d|_nt|οΏ½r:|jjοΏ½οΏ½d|j_dSr%)rr	rοΏ½	_id_cacheοΏ½clearοΏ½_id_search_stackrοΏ½rXrοΏ½r
r
r
rAοΏ½s
rAc@sreZdZdZejejejejfZ	e
οΏ½ZejZ
dZdZdZdZdZZdZdZdZdZdZdZdZdZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½Z ddοΏ½Z!ddοΏ½Z"ddοΏ½Z#ddοΏ½Z$ddοΏ½Z%ddοΏ½Z&ddοΏ½Z'ddοΏ½Z(d d!οΏ½Z)d"d#οΏ½Z*d$d%οΏ½Z+d&d'οΏ½Z,d(d)οΏ½Z-d*d+οΏ½Z.d,d-οΏ½Z/d.d/οΏ½Z0d0d1οΏ½Z1d2d3οΏ½Z2d4d5οΏ½Z3d6d7οΏ½Z4d8d9οΏ½Z5d:d;οΏ½Z6d<d=οΏ½Z7d>d?οΏ½Z8d@dAοΏ½Z9dBdCοΏ½Z:dIdEdFοΏ½Z;dGdHοΏ½Z<dS)JrοΏ½)οΏ½
_elem_inforοΏ½rοΏ½r'rοΏ½z	#documentNFrcCs$d|_tοΏ½|_i|_i|_d|_dSr%)rοΏ½rwr'rοΏ½rοΏ½rοΏ½rr
r
r
rοΏ½s
zDocument.__init__cCs&|jr|j|jf}n|j}|jοΏ½|οΏ½Sr%)r~rοΏ½rοΏ½rοΏ½rοΏ½)rr*rkr
r
r
rοΏ½szDocument._get_elem_infocCs|jSr%r}rr
r
r
r~szDocument._get_actualEncodingcCs|jSr%)rοΏ½rr
r
r
οΏ½_get_doctypeszDocument._get_doctypecCs|jSr%)οΏ½documentURIrr
r
r
οΏ½_get_documentURI!szDocument._get_documentURIcCs|jSr%rrr
r
r
rοΏ½$szDocument._get_encodingcCs|jSr%)οΏ½errorHandlerrr
r
r
οΏ½_get_errorHandler'szDocument._get_errorHandlercCs|jSr%)οΏ½
standalonerr
r
r
οΏ½_get_standalone*szDocument._get_standalonecCs|jSr%)οΏ½strictErrorCheckingrr
r
r
οΏ½_get_strictErrorChecking-sz!Document._get_strictErrorCheckingcCs|jSr%rοΏ½rr
r
r
rοΏ½0szDocument._get_versioncCsj|j|jkr(tjοΏ½dt|οΏ½t|οΏ½fοΏ½οΏ½|jdk	r>|jοΏ½|οΏ½|jtj	kr^|οΏ½
οΏ½r^tjοΏ½dοΏ½οΏ½tοΏ½||οΏ½S)Nr0z two document elements disallowed)rr5r6r7r8r9r:r;r	rSοΏ½_get_documentElementr<rοΏ½r
r
r
r<3sοΏ½
οΏ½οΏ½zDocument.appendChildcCsVz|jοΏ½|οΏ½Wntk
r.tjοΏ½οΏ½οΏ½YnXd|_|_d|_|j	|krRd|_	|Sr%)
r'rMr>r6r7r?rCrDr:οΏ½documentElementrNr
r
r
r;Cs
zDocument.removeChildcCs$|jD]}|jtjkr|SqdSr%)r'rr	rSrοΏ½r
r
r
rοΏ½Os
zDocument._get_documentElementcCs(|jdk	r|jοΏ½οΏ½d|_tοΏ½|οΏ½dSr%)rοΏ½rQr	rr
r
r
rQTs

zDocument.unlinkcCsοΏ½|sdS|jοΏ½dddοΏ½}|j|_|j|_|j|_|jD]n}t|||οΏ½}|jοΏ½|οΏ½sVt	οΏ½|jοΏ½
|οΏ½|jtj
kr~|jdksοΏ½t	οΏ½n |jtjkrοΏ½|jdksοΏ½t	οΏ½||_||_q6|οΏ½tjjj||οΏ½|Sr%)r[rοΏ½rrοΏ½r_r'rWrXrdοΏ½AssertionErrorrRrr	rrοΏ½r|rοΏ½r:rvr6r7rqrr)rrYrwrοΏ½Z
childcloner
r
r
rZZs*
οΏ½zDocument.cloneNodecCstοΏ½}||_|Sr%)rοΏ½rX)rror
r
r
οΏ½createDocumentFragmentoszDocument.createDocumentFragmentcCst|οΏ½}||_|Sr%)rrX)rrοΏ½ryr
r
r
οΏ½
createElementtszDocument.createElementcCs(t|tοΏ½stdοΏ½οΏ½tοΏ½}||_||_|SοΏ½Nznode contents must be a string)rοΏ½rοΏ½rοΏ½rοΏ½rPrX)rrPοΏ½tr
r
r
οΏ½createTextNodeys
zDocument.createTextNodecCs(t|tοΏ½stdοΏ½οΏ½tοΏ½}||_||_|SrοΏ½)rοΏ½rοΏ½rοΏ½r\rPrXοΏ½rrPrGr
r
r
οΏ½createCDATASectionοΏ½s
zDocument.createCDATASectioncCst|οΏ½}||_|Sr%)r[rXrοΏ½r
r
r
οΏ½
createCommentοΏ½szDocument.createCommentcCst||οΏ½}||_|Sr%)r0rX)rr2rPοΏ½pr
r
r
οΏ½createProcessingInstructionοΏ½s
z$Document.createProcessingInstructioncCst|οΏ½}||_d|_|Sr)rοΏ½rXrοΏ½)rrοΏ½οΏ½ar
r
r
οΏ½createAttributeοΏ½szDocument.createAttributecCs"t|οΏ½\}}t|||οΏ½}||_|Sr%)rrrX)rr~rrrοΏ½ryr
r
r
rοΏ½οΏ½szDocument.createElementNScCs*t|οΏ½\}}t||||οΏ½}||_d|_|Sr)rrοΏ½rXrοΏ½)rr~rrrοΏ½rοΏ½r
r
r
οΏ½createAttributeNSοΏ½s
zDocument.createAttributeNScCst||||οΏ½}||_|Sr%)rtrX)rrοΏ½rgrhruryr
r
r
οΏ½_create_entityοΏ½szDocument._create_entitycCst|||οΏ½}||_|Sr%)rsrX)rrοΏ½rgrhrοΏ½r
r
r
οΏ½_create_notationοΏ½szDocument._create_notationcCsοΏ½||jkr|j|S|js$|js$dS|j}|dkrB|jg}||_n|sJdSd}|οΏ½rοΏ½|οΏ½οΏ½}|οΏ½ddοΏ½|jDοΏ½οΏ½|οΏ½|οΏ½}|οΏ½rB|j	οΏ½
οΏ½D]οΏ½}|jrοΏ½|οΏ½|j|j
οΏ½rοΏ½||j|j<|j|krοΏ½|}n|jsοΏ½οΏ½qοΏ½qοΏ½|οΏ½|jοΏ½οΏ½r
||j|j<|j|krοΏ½|}n|jοΏ½s>οΏ½qοΏ½qοΏ½|jrοΏ½||j|j<|j|kοΏ½r.|}qοΏ½|jdkrοΏ½οΏ½qοΏ½qοΏ½n>|jοΏ½rοΏ½|j	οΏ½
οΏ½D]*}|jοΏ½rT||j|j<|j|kοΏ½rT|}οΏ½qT|dk	rNοΏ½qοΏ½qN|S)NcSsg|]}|jtkr|οΏ½qSr
)rr@)οΏ½.0rVr
r
r
οΏ½
<listcomp>οΏ½s
οΏ½z+Document.getElementById.<locals>.<listcomp>r1)rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½popοΏ½extendr'rοΏ½rοΏ½rοΏ½r~rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½)rrοΏ½οΏ½stackοΏ½resultrHrοΏ½r	r
r
r
οΏ½getElementByIdοΏ½sZ






zDocument.getElementByIdcCst||tοΏ½οΏ½Sr%rrοΏ½r
r
r
rοΏ½szDocument.getElementsByTagNamecCst|||tοΏ½οΏ½Sr%rrοΏ½r
r
r
r οΏ½sοΏ½zDocument.getElementsByTagNameNScCs|jοΏ½||οΏ½Sr%)r[r\r]r
r
r
r`οΏ½szDocument.isSupportedcCs>|jtjkrtjοΏ½dοΏ½οΏ½n|jtjkr2tjοΏ½dοΏ½οΏ½t|||οΏ½S)Nzcannot import document nodesz!cannot import document type nodes)rr	rr6r7οΏ½NotSupportedErrr|rW)rrHrYr
r
r
οΏ½
importNodeοΏ½s
zDocument.importNodercCsJ|dkr|οΏ½d|οΏ½n|οΏ½d||fοΏ½|jD]}|οΏ½||||οΏ½q0dS)Nz<?xml version="1.0" ?>z%<?xml version="1.0" encoding="%s"?>%s)rοΏ½r'r)rr$r"r"r#rrHr
r
r
rοΏ½sοΏ½
zDocument.writexmlcCsJ|j|k	r tjοΏ½d||jfοΏ½οΏ½|jtjtjfkr>tjοΏ½dοΏ½οΏ½|t	krοΏ½d|krοΏ½|οΏ½
ddοΏ½\}}|dkrοΏ½|tjjkrοΏ½tjοΏ½dοΏ½οΏ½qοΏ½|dkrοΏ½|tjjkrοΏ½|jtjkrοΏ½tjοΏ½dοΏ½οΏ½d}|}nd}d}|jtjkrοΏ½|j
}|dk	rοΏ½|j}|οΏ½|οΏ½nd}||_||_||_||_|jtjkοΏ½r||_n*||_|dk	οΏ½rF|οΏ½|οΏ½|οΏ½rF|οΏ½|οΏ½|S)Nz?cannot rename nodes from other documents;
expected %s,
found %sz8renameNode() only applies to element and attribute nodesrοΏ½r1rοΏ½zillegal use of 'xmlns' prefixz$illegal use of the 'xmlns' attribute)rXr6r7rοΏ½rr	rSrοΏ½rοΏ½rrοΏ½rrοΏ½rοΏ½rοΏ½rrrοΏ½r~rοΏ½rοΏ½rοΏ½r
r$)rrοΏ½r~rοΏ½rrοΏ½r*Zis_idr
r
r
οΏ½
renameNode	sb
οΏ½οΏ½οΏ½
οΏ½οΏ½
οΏ½
οΏ½οΏ½


zDocument.renameNode)rrrN)=r{r|r}rοΏ½r	rSrοΏ½rοΏ½r|r5rοΏ½r[rrrοΏ½rοΏ½rοΏ½r:rDrCrvrrοΏ½r_rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r~rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r<r;rοΏ½rQrZrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rr r`rοΏ½rrοΏ½r
r
r
r
rοΏ½οΏ½sjοΏ½	
:
rοΏ½rοΏ½z#Top-level element of this document.c
CsοΏ½|jοΏ½|οΏ½rtjjj}n
tjjj}|jtj	krοΏ½|οΏ½
|j|jοΏ½}|j
οΏ½οΏ½D]0}|οΏ½|j|j|jοΏ½|οΏ½|j|jοΏ½}|j|_qH|rοΏ½|jD]}t|||οΏ½}|οΏ½|οΏ½qοΏ½οΏ½n|jtjkrοΏ½|οΏ½οΏ½}|rοΏ½|jD]}t|||οΏ½}|οΏ½|οΏ½qnοΏ½|jtjkrοΏ½|οΏ½|jοΏ½}οΏ½nοΏ½|jtjkοΏ½r|οΏ½|jοΏ½}οΏ½nοΏ½|jtjkοΏ½r>|οΏ½|j |jοΏ½}οΏ½nz|jtj!kοΏ½r\|οΏ½"|jοΏ½}οΏ½n\|jtj#kοΏ½rοΏ½|οΏ½$|j|jοΏ½}d|_|j|_οΏ½n,|jtj%kοΏ½rοΏ½|j|k	οΏ½sοΏ½t&οΏ½tjjj}|j'οΏ½(|j)|j*|j+οΏ½}||_|οΏ½rοΏ½g|j,_-g|j._-|j.j-D]F}	t/|	j|	j*|	j+οΏ½}
||
_|j.j-οΏ½0|
οΏ½t1|	dοΏ½οΏ½rοΏ½|	οΏ½2||	|
οΏ½οΏ½qοΏ½|j,j-D]b}t3|j|j*|j+|j4οΏ½}|j5|_5|j6|_6|j7|_7||_|j,j-οΏ½0|οΏ½t1|dοΏ½οΏ½r>|οΏ½2|||οΏ½οΏ½q>ntjοΏ½8dt9|οΏ½οΏ½οΏ½t1|dοΏ½οΏ½rοΏ½|οΏ½2|||οΏ½|S)zo
    Clone a node and give it the new owner document.
    Called by Node.cloneNode and Document.importNode
    TrvzCannot clone node %s):rXrdr6r7rqrrZ
NODE_IMPORTEDrr	rSrοΏ½r~rοΏ½rοΏ½rοΏ½rrοΏ½rrοΏ½rοΏ½r'rWr<r2rοΏ½rOrοΏ½rPrοΏ½rοΏ½rοΏ½rοΏ½r2rοΏ½rοΏ½rοΏ½rοΏ½r|rοΏ½r[rοΏ½rοΏ½rgrhrmr`rnrsrRrqrvrtrurvrr_rοΏ½r9)
rHrYZnewOwnerDocumentrtrwr	rοΏ½rVrGrοΏ½rxryrzr
r
r
rWBsοΏ½
οΏ½


οΏ½οΏ½
οΏ½οΏ½rWcCs,|οΏ½ddοΏ½}t|οΏ½dkr|Sd|dfSdS)NrοΏ½r1οΏ½r)rοΏ½rοΏ½)rZfieldsr
r
r
rοΏ½srcCs,|||οΏ½}|οΏ½οΏ½\}}|οΏ½|οΏ½|οΏ½οΏ½|Sr%)ZgetEventZ
expandNoderοΏ½)οΏ½funcοΏ½argsοΏ½kwargsZeventsZtoktypeZrootNoder
r
r
οΏ½_do_pulldom_parseοΏ½s


rοΏ½cCsH|dkr"|s"ddlm}|οΏ½|οΏ½Sddlm}t|j|f||dοΏ½οΏ½SdS)z3Parse a file into a DOM by filename or file object.NrοΏ½οΏ½expatbuilderοΏ½οΏ½pulldom)οΏ½parserοΏ½bufsize)οΏ½xml.domrοΏ½οΏ½parserοΏ½rοΏ½)οΏ½filerοΏ½rοΏ½rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s

οΏ½rοΏ½cCsB|dkrddlm}|οΏ½|οΏ½Sddlm}t|j|fd|iοΏ½SdS)z&Parse a file into a DOM from a string.NrrοΏ½rοΏ½rοΏ½)rοΏ½rοΏ½οΏ½parseStringrοΏ½rοΏ½)οΏ½stringrοΏ½rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s

οΏ½rοΏ½cCs@|r:t|tοΏ½rtοΏ½|οΏ½}|D]\}}tjοΏ½||οΏ½sdSqtjSr%)rοΏ½rοΏ½rZ_parse_feature_stringrοΏ½r[r\)ZfeaturesοΏ½fοΏ½vr
r
r
οΏ½getDOMImplementationοΏ½s

rοΏ½)NN)N)N)7rοΏ½rrοΏ½r6rrrrZxml.dom.minicompatZxml.dom.xmlbuilderrrr7r	rSrοΏ½r@ZdefpropertyrJrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½objectrοΏ½Z
AttributeListrοΏ½rοΏ½rrr+r0r:rοΏ½rWr(r[r\r^rerlrtrsrοΏ½rοΏ½rArοΏ½rWrrοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
οΏ½<module>sοΏ½οΏ½v
	y$οΏ½
xοΏ½οΏ½)GUοΏ½οΏ½	>οΏ½<(	O*PοΏ½R



U

e5dοΏ½οΏ½@sGddοΏ½dοΏ½ZdS)c@sTeZdZdZdZdZdZdZdZdZ	dZ
dZdZd	Z
d
ZdZdZd
ZdZddοΏ½ZdS)οΏ½
NodeFilterοΏ½οΏ½οΏ½lοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½ οΏ½@οΏ½οΏ½iiicCstοΏ½dS)N)οΏ½NotImplementedError)οΏ½selfZnodeοΏ½rοΏ½*/usr/lib64/python3.8/xml/dom/NodeFilter.pyοΏ½
acceptNodeszNodeFilter.acceptNodeN)οΏ½__name__οΏ½
__module__οΏ½__qualname__Z
FILTER_ACCEPTZ
FILTER_REJECTZFILTER_SKIPZSHOW_ALLZSHOW_ELEMENTZSHOW_ATTRIBUTEZ	SHOW_TEXTZSHOW_CDATA_SECTIONZSHOW_ENTITY_REFERENCEZSHOW_ENTITYZSHOW_PROCESSING_INSTRUCTIONZSHOW_COMMENTZ
SHOW_DOCUMENTZSHOW_DOCUMENT_TYPEZSHOW_DOCUMENT_FRAGMENTZ
SHOW_NOTATIONrrrrrrs"rN)rrrrrοΏ½<module>οΏ½U

e5d'
οΏ½@sJdZddddgZddlZefZGddοΏ½deοΏ½ZGddοΏ½deοΏ½Z	d	dοΏ½Z
dS)
zοΏ½Python version compatibility support for minidom.

This module contains internal implementation details and
should not be imported; use xml.dom.minidom instead.
οΏ½NodeListοΏ½
EmptyNodeListοΏ½StringTypesοΏ½defpropertyοΏ½Nc@s>eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zeeedd	οΏ½Zd
dοΏ½Z	dS)
rοΏ½cCs(d|krt|οΏ½kr$nn||SdSοΏ½NrοΏ½οΏ½lenοΏ½οΏ½selfοΏ½indexrrοΏ½*/usr/lib64/python3.8/xml/dom/minicompat.pyοΏ½item5sz
NodeList.itemcCst|οΏ½SοΏ½NrοΏ½rrrr
οΏ½_get_length9szNodeList._get_lengthcCstjοΏ½dοΏ½οΏ½dSοΏ½Nz.attempt to modify read-only attribute 'length'οΏ½οΏ½xmlοΏ½domοΏ½NoModificationAllowedErrοΏ½rοΏ½valuerrr
οΏ½_set_length<sοΏ½zNodeList._set_lengthοΏ½$The number of nodes in the NodeList.οΏ½οΏ½doccCs|dkrg}||ddοΏ½<dSrr)rοΏ½staterrr
οΏ½__setstate__DszNodeList.__setstate__N)
οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½	__slots__rrrοΏ½propertyοΏ½lengthrrrrr
r2sοΏ½c@sFeZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Ze	eedd
οΏ½Z
dS)rrcCstοΏ½}|οΏ½|οΏ½|SrοΏ½rοΏ½extendοΏ½rοΏ½otherοΏ½NLrrr
οΏ½__add__Ms
zEmptyNodeList.__add__cCstοΏ½}|οΏ½|οΏ½|Srr%r'rrr
οΏ½__radd__Rs
zEmptyNodeList.__radd__cCsdSrrr
rrr
rWszEmptyNodeList.itemcCsdSrrrrrr
rZszEmptyNodeList._get_lengthcCstjοΏ½dοΏ½οΏ½dSrrrrrr
r]sοΏ½zEmptyNodeList._set_lengthrrN)rr r!r"r*r+rrrr#r$rrrr
rJsοΏ½cCsRt|d|οΏ½}|fddοΏ½}t|d|οΏ½r4td|οΏ½οΏ½t|||dοΏ½}t|||οΏ½dS)NZ_get_cSstjοΏ½dt|οΏ½οΏ½οΏ½dS)Nz&attempt to modify read-only attribute )rrrοΏ½repr)rrοΏ½namerrr
οΏ½setgs
οΏ½zdefproperty.<locals>.setZ_set_zexpected not to find _set_r)οΏ½getattrοΏ½hasattrοΏ½AssertionErrorr#οΏ½setattr)οΏ½klassr-rοΏ½getr.Zproprrr
resοΏ½)οΏ½__doc__οΏ½__all__Zxml.domrοΏ½strrοΏ½listrοΏ½tuplerrrrrr
οΏ½<module>s*U

e5dοΏ½οΏ½οΏ½@sddlmZmZmZddlmZmZmZddlmZddl	m
Z
mZddlm
Z
ejZejZejZejjZejjZejjZejjZeοΏ½οΏ½ZeοΏ½ddοΏ½eοΏ½ddοΏ½eοΏ½dd	οΏ½eοΏ½dd
οΏ½eοΏ½ddοΏ½eοΏ½ddοΏ½eοΏ½dd
οΏ½eοΏ½ddοΏ½eοΏ½ddοΏ½dοΏ½	ZGddοΏ½deοΏ½ZddοΏ½ZddοΏ½ZGddοΏ½dοΏ½ZeeefZGddοΏ½deοΏ½Z GddοΏ½deοΏ½Z!GddοΏ½de!οΏ½Z"Gdd οΏ½d e!οΏ½Z#d!Z$d"e$Z%Gd#d$οΏ½d$eοΏ½Z&Gd%d&οΏ½d&οΏ½Z'Gd'd(οΏ½d(e'eοΏ½Z(Gd)d*οΏ½d*e'e&οΏ½Z)Gd+d,οΏ½d,e*οΏ½Z+Gd-d.οΏ½d.eοΏ½Z,d:d0d1οΏ½Z-d;d2d3οΏ½Z.d<d4d5οΏ½Z/d=d6d7οΏ½Z0d8d9οΏ½Z1dS)>οΏ½)οΏ½
xmlbuilderοΏ½minidomοΏ½Node)οΏ½EMPTY_NAMESPACEοΏ½EMPTY_PREFIXοΏ½XMLNS_NAMESPACE)οΏ½expat)οΏ½
_append_childοΏ½_set_attribute_node)οΏ½
NodeFilterNZcdataοΏ½enumerationοΏ½entityοΏ½entitiesοΏ½idZidrefZidrefsZnmtokenZnmtokens)	ZCDATAοΏ½ENUMZENTITYZENTITIESοΏ½IDZIDREFZIDREFSZNMTOKENZNMTOKENSc@sZeZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZdS)οΏ½ElementInfoοΏ½οΏ½
_attr_infoοΏ½_modelοΏ½tagNameNcCs||_g|_||_dSοΏ½N)rrr)οΏ½selfrοΏ½modelοΏ½rοΏ½,/usr/lib64/python3.8/xml/dom/expatbuilder.pyοΏ½__init__?szElementInfo.__init__cCs|j|j|jfSrrοΏ½rrrrοΏ½__getstate__DszElementInfo.__getstate__cCs|\|_|_|_dSrr)rοΏ½staterrrοΏ½__setstate__GszElementInfo.__setstate__cCsN|jD]@}|d|kr|d}|ddkr6tdSt|dSqtjS)NοΏ½οΏ½οΏ½οΏ½rοΏ½(r)rοΏ½
_typeinfo_maprοΏ½_no_type)rοΏ½anameοΏ½infoοΏ½trrrοΏ½getAttributeTypeJs
zElementInfo.getAttributeTypecCstjSr)rr%)rZnamespaceURIZ	localNamerrrοΏ½getAttributeTypeNSTszElementInfo.getAttributeTypeNScCs,|jr$|jd}|tjjtjjfkSdSdSοΏ½NrF)rrrZ
XML_CTYPE_ANYZXML_CTYPE_MIXED)rοΏ½typerrrοΏ½isElementContentWs
οΏ½zElementInfo.isElementContentcCs |jr|jdtjjkSdSdSr+)rrrZXML_CTYPE_EMPTYrrrrοΏ½isEmpty_szElementInfo.isEmptycCs,|jD] }|d|kr|ddkSqdS)Nr!r"rF)r)rr&r'rrrοΏ½isIdes
zElementInfo.isIdcCs|οΏ½||fοΏ½Sr)r/)rZeuriZenameZaurir&rrrοΏ½isIdNSkszElementInfo.isIdNS)N)
οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½	__slots__rrr r)r*r-r.r/r0rrrrr<s

rcCs|οΏ½||οΏ½Sr)οΏ½_intern_setdefault)οΏ½builderοΏ½srrrοΏ½_internosr8cCsοΏ½|οΏ½dοΏ½}|j}t|οΏ½dkrR|\}}}|||οΏ½}d||f}|||οΏ½}|||οΏ½}n4t|οΏ½dkrz|\}}t}|||οΏ½}}ntd|οΏ½οΏ½|||οΏ½|||fS)NοΏ½ οΏ½z%s:%sοΏ½z4Unsupported syntax: spaces in URIs not supported: %r)οΏ½splitr5οΏ½lenrοΏ½
ValueError)r6οΏ½nameοΏ½partsοΏ½internοΏ½uriοΏ½	localnameοΏ½prefixοΏ½qnamerrrοΏ½_parse_ns_namers



rFc@sοΏ½eZdZd:ddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd d!οΏ½Zd"d#οΏ½Zd$d%οΏ½Zd&d'οΏ½Zd(d)οΏ½Zd*d+οΏ½Zd,d-οΏ½Zd.d/οΏ½Zd0d1οΏ½Zd2d3οΏ½Zd4d5οΏ½Zd6d7οΏ½Zd8d9οΏ½ZdS);οΏ½ExpatBuilderNcCsP|dkrtοΏ½οΏ½}||_|jjdk	r2t|jjοΏ½|_nd|_t|_d|_|οΏ½	οΏ½dSr)
rZOptionsοΏ½_optionsοΏ½filterοΏ½FilterVisibilityControllerοΏ½_filterrοΏ½_finish_start_elementοΏ½_parserοΏ½reset)rοΏ½optionsrrrrοΏ½szExpatBuilder.__init__cCstοΏ½οΏ½Sr)rοΏ½ParserCreaterrrrοΏ½createParserοΏ½szExpatBuilder.createParsercCsF|js@|οΏ½οΏ½|_|jjj|_d|j_d|j_d|j_|οΏ½|jοΏ½|jSοΏ½NT)	rMrQrAοΏ½
setdefaultr5Zbuffer_textZordered_attributesZspecified_attributesοΏ½installrrrrοΏ½	getParserοΏ½s
zExpatBuilder.getParsercCs,tοΏ½tddοΏ½|_|j|_|jj|_d|_dSοΏ½NF)οΏ½theDOMImplementationZcreateDocumentrοΏ½documentοΏ½curNodeοΏ½
_elem_infoοΏ½_cdatarrrrrNοΏ½sοΏ½
zExpatBuilder.resetcCsοΏ½|j|_|j|_|j|_|j|_|jj	r0|j
|_|j|_
|jjrH|j|_|jjrj|j|_|j|_|j|_n|j|_|j|_|j|_|j|_|j|_ dSr)!οΏ½start_doctype_decl_handlerοΏ½StartDoctypeDeclHandlerοΏ½first_element_handlerοΏ½StartElementHandlerοΏ½end_element_handlerοΏ½EndElementHandlerοΏ½
pi_handlerοΏ½ProcessingInstructionHandlerrHrοΏ½entity_decl_handlerοΏ½EntityDeclHandlerοΏ½notation_decl_handlerοΏ½NotationDeclHandlerοΏ½commentsοΏ½comment_handlerοΏ½CommentHandlerZcdata_sectionsοΏ½start_cdata_section_handlerοΏ½StartCdataSectionHandlerοΏ½end_cdata_section_handlerοΏ½EndCdataSectionHandlerοΏ½character_data_handler_cdataοΏ½CharacterDataHandlerοΏ½character_data_handlerοΏ½external_entity_ref_handlerοΏ½ExternalEntityRefHandlerοΏ½xml_decl_handlerZXmlDeclHandlerοΏ½element_decl_handlerZElementDeclHandlerοΏ½attlist_decl_handlerZAttlistDeclHandlerοΏ½rοΏ½parserrrrrTοΏ½s$
zExpatBuilder.installcCsοΏ½|οΏ½οΏ½}d}zH|οΏ½dοΏ½}|sqF|οΏ½|dοΏ½|r@|jjr@|οΏ½|οΏ½d}q|οΏ½ddοΏ½Wntk
rhYnX|j}|οΏ½οΏ½d|_|S)NTi@rFοΏ½)	rUοΏ½readοΏ½ParserXοΏ½documentElementοΏ½
_setup_subsetοΏ½ParseEscaperNrM)rοΏ½filerxZfirst_bufferοΏ½bufferοΏ½docrrrοΏ½	parseFileοΏ½s"

zExpatBuilder.parseFilecCsP|οΏ½οΏ½}z|οΏ½|dοΏ½|οΏ½|οΏ½Wntk
r6YnX|j}|οΏ½οΏ½d|_|SrR)rUr{r}r~rXrNrM)rοΏ½stringrxrοΏ½rrrοΏ½parseStringοΏ½szExpatBuilder.parseStringcCs.|jjr*tοΏ½}|οΏ½|οΏ½|οΏ½οΏ½}||jj_dSr)rXοΏ½doctypeοΏ½InternalSubsetExtractorrοΏ½οΏ½	getSubsetοΏ½internalSubset)rrοΏ½Z	extractorοΏ½subsetrrrr}οΏ½s

zExpatBuilder._setup_subsetcCsοΏ½|jjοΏ½|||οΏ½}|j|_t|j|οΏ½||j_|jrj|jοΏ½|οΏ½tkrjd|j_|jj	d=d}d|j
_d|j
_|rοΏ½|dk	rοΏ½g|j
_g|j_d|j
_d|j
_|j|j
_dSοΏ½NοΏ½οΏ½οΏ½)rXοΏ½implementationZcreateDocumentTypeοΏ½
ownerDocumentr	rοΏ½rKοΏ½
acceptNodeοΏ½
FILTER_REJECTοΏ½
childNodesrMrergrοΏ½_seqοΏ½	notationsrjrcοΏ½end_doctype_decl_handlerοΏ½EndDoctypeDeclHandler)rZdoctypeNameοΏ½systemIdοΏ½publicIdοΏ½has_internal_subsetrοΏ½rrrr\οΏ½s*οΏ½
z'ExpatBuilder.start_doctype_decl_handlercCs2|jjr|j|j_|j|j_|js.|js.t	|_
dSr)rHrhrirMrjrbrcrZrKrοΏ½_finish_end_elementrrrrrοΏ½s


z%ExpatBuilder.end_doctype_decl_handlercCs@|jοΏ½||οΏ½}t|j|οΏ½|jr<|jοΏ½|οΏ½tkr<|jοΏ½|οΏ½dSr)rXZcreateProcessingInstructionr	rYrKrοΏ½rοΏ½οΏ½removeChild)rοΏ½targetοΏ½dataοΏ½noderrrrbszExpatBuilder.pi_handlercCsοΏ½|jj}|jrH|jr4|djtkr4|dοΏ½|οΏ½dS|jοΏ½|οΏ½}d|_nD|rv|djt	krv|d}|j
|}||_
dStοΏ½οΏ½}||_
|j|_
t|j|οΏ½dS)NrοΏ½T)rYrοΏ½r[οΏ½_cdata_continueοΏ½nodeTypeοΏ½CDATA_SECTION_NODEZ
appendDatarXZcreateCDATASectionοΏ½	TEXT_NODErοΏ½rοΏ½TextrοΏ½r	)rrοΏ½rοΏ½rοΏ½οΏ½valuerrrros$οΏ½
z)ExpatBuilder.character_data_handler_cdatacCs^|jj}|r2|djtkr2|d}|j||_dStοΏ½οΏ½}|j||_|j|_t	|j|οΏ½dSrοΏ½)
rYrοΏ½rοΏ½rοΏ½rοΏ½rrοΏ½rXrοΏ½r	)rrοΏ½rοΏ½rοΏ½rrrrq&sz#ExpatBuilder.character_data_handlerc
CsοΏ½|rdS|jjsdS|jοΏ½||||οΏ½}|dk	rF|jοΏ½|οΏ½}	|jοΏ½|	οΏ½|jjjjοΏ½|οΏ½|j	r||j	οΏ½
|οΏ½tkr||jjjjd=dSrοΏ½)rHrrXZ_create_entityZcreateTextNoderοΏ½οΏ½appendrοΏ½rοΏ½rKrοΏ½rοΏ½)
rZ
entityNameZis_parameter_entityrοΏ½οΏ½baserοΏ½rοΏ½οΏ½notationNamerοΏ½οΏ½childrrrrd1s
οΏ½z ExpatBuilder.entity_decl_handlercCsJ|jοΏ½|||οΏ½}|jjjjοΏ½|οΏ½|jrF|jοΏ½|οΏ½tkrF|jjjjd=dSrοΏ½)	rXZ_create_notationrοΏ½rοΏ½rοΏ½rοΏ½rKrοΏ½οΏ½
FILTER_ACCEPT)rrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrfCsz"ExpatBuilder.notation_decl_handlercCs>|jοΏ½|οΏ½}t|j|οΏ½|jr:|jοΏ½|οΏ½tkr:|jοΏ½|οΏ½dSr)rXZ
createCommentr	rYrKrοΏ½rοΏ½rοΏ½)rrοΏ½rοΏ½rrrriIszExpatBuilder.comment_handlercCsd|_d|_dS)NTFοΏ½r[rοΏ½rrrrrkOsz(ExpatBuilder.start_cdata_section_handlercCsd|_d|_dSrVrοΏ½rrrrrmSsz&ExpatBuilder.end_cdata_section_handlercCsdSοΏ½Nr!r)rοΏ½contextrοΏ½rοΏ½rοΏ½rrrrrWsz(ExpatBuilder.external_entity_ref_handlercCs2|jdkr|jst|_|j|οΏ½οΏ½_|οΏ½||οΏ½dSr)rKrZrrοΏ½οΏ½start_element_handlerrUr_)rr?οΏ½
attributesrrrr^Zsz"ExpatBuilder.first_element_handlercCsοΏ½|jοΏ½|οΏ½}t|j|οΏ½||_|rptdt|οΏ½dοΏ½D]<}tοΏ½||tdt	οΏ½}||d}||_
|j|_t||οΏ½q2||jj
k	rοΏ½|οΏ½|οΏ½dS)Nrr;r!)rXZ
createElementr	rYοΏ½ranger=rοΏ½AttrrrrοΏ½rοΏ½r
r|rL)rr?rοΏ½rοΏ½οΏ½iοΏ½arοΏ½rrrrοΏ½`sοΏ½z"ExpatBuilder.start_element_handlercCsj|jrf||jjkrdS|jοΏ½|οΏ½}|tkr4t|οΏ½n|tkrFt|οΏ½ndS|j|_	|jοΏ½
|οΏ½|οΏ½οΏ½dSr)rKrXr|οΏ½startContainerrοΏ½οΏ½RejecterοΏ½FILTER_SKIPοΏ½SkipperοΏ½
parentNoderYrοΏ½οΏ½unlink)rrοΏ½ZfiltrrrrLqs

z"ExpatBuilder._finish_start_elementcCs|j}|j|_|οΏ½|οΏ½dSr)rYrοΏ½rοΏ½)rr?rYrrrr`οΏ½sz ExpatBuilder.end_element_handlercCs\|jοΏ½|jοΏ½}|r|οΏ½||οΏ½|jrX||jjkr4dS|jοΏ½|οΏ½tkrX|j	οΏ½
|οΏ½|οΏ½οΏ½dSr)rZοΏ½getrοΏ½_handle_white_text_nodesrKrXr|rοΏ½rοΏ½rYrοΏ½rοΏ½)rrYr'rrrrοΏ½οΏ½sz ExpatBuilder._finish_end_elementcCsZ|jjs|οΏ½οΏ½sdSg}|jD]"}|jtkr|jοΏ½οΏ½s|οΏ½|οΏ½q|D]}|οΏ½	|οΏ½qFdSr)
rHZwhitespace_in_element_contentr-rοΏ½rοΏ½rοΏ½rοΏ½οΏ½striprοΏ½rοΏ½)rrοΏ½r'οΏ½LrοΏ½rrrrοΏ½οΏ½sοΏ½
z%ExpatBuilder._handle_white_text_nodescCs0|jοΏ½|οΏ½}|dkr&t||οΏ½|j|<n||_dSr)rZrοΏ½rr)rr?rr'rrrruοΏ½sz!ExpatBuilder.element_decl_handlerc
CsF|jοΏ½|οΏ½}|dkr&t|οΏ½}||j|<|jοΏ½d|dd|d||gοΏ½dSοΏ½Nr)rZrοΏ½rrrοΏ½)rοΏ½elemr?r,οΏ½defaultZrequiredr'rrrrvοΏ½s
οΏ½z!ExpatBuilder.attlist_decl_handlercCs2||j_||j_|dkr.|r&d|j_nd|j_dS)NrTF)rXοΏ½versionοΏ½encodingοΏ½
standalone)rrοΏ½rοΏ½rοΏ½rrrrtοΏ½s
zExpatBuilder.xml_decl_handler)N)r1r2r3rrQrUrNrTrοΏ½rοΏ½r}r\rοΏ½rbrorqrdrfrirkrmrrr^rοΏ½rLr`rοΏ½rοΏ½rurvrtrrrrrGοΏ½s8

rGc@sοΏ½eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zeje	j
eje	jej
e	jeje	jeje	jeje	jeje	jeje	jeje	jeje	jeje	jeje	j iZ!dS)	rJοΏ½rIcCs
||_dSrrοΏ½)rrIrrrrοΏ½sz#FilterVisibilityController.__init__cCsT|j|j}|jj|@rL|jοΏ½|οΏ½}|tkr0tοΏ½|tkrHtdt	|οΏ½οΏ½οΏ½|St
SdS)Nz)startContainer() returned illegal value: )οΏ½_nodetype_maskrοΏ½rIοΏ½
whatToShowrοΏ½οΏ½FILTER_INTERRUPTr~οΏ½_ALLOWED_FILTER_RETURNSr>οΏ½reprrοΏ½)rrοΏ½οΏ½maskοΏ½valrrrrοΏ½οΏ½s
οΏ½z)FilterVisibilityController.startContainercCsοΏ½|j|j}|jj|@r||jοΏ½|οΏ½}|tkr0tοΏ½|tkr`|j}|j	ddοΏ½D]}|οΏ½
|οΏ½qLtS|tkrxt
dt|οΏ½οΏ½οΏ½|StSdS)Nz%acceptNode() returned illegal value: )rοΏ½rοΏ½rIrοΏ½rοΏ½rοΏ½r~rοΏ½rοΏ½rοΏ½ZappendChildrοΏ½rοΏ½r>rοΏ½rοΏ½)rrοΏ½rοΏ½rοΏ½οΏ½parentrοΏ½rrrrοΏ½οΏ½s 
οΏ½z%FilterVisibilityController.acceptNodeN)"r1r2r3r4rrοΏ½rοΏ½rZELEMENT_NODErZSHOW_ELEMENTZATTRIBUTE_NODEZSHOW_ATTRIBUTErοΏ½Z	SHOW_TEXTrοΏ½ZSHOW_CDATA_SECTIONZENTITY_REFERENCE_NODEZSHOW_ENTITY_REFERENCEZENTITY_NODEZSHOW_ENTITYZPROCESSING_INSTRUCTION_NODEZSHOW_PROCESSING_INSTRUCTIONZCOMMENT_NODEZSHOW_COMMENTοΏ½
DOCUMENT_NODEZ
SHOW_DOCUMENTZDOCUMENT_TYPE_NODEZSHOW_DOCUMENT_TYPEZDOCUMENT_FRAGMENT_NODEZSHOW_DOCUMENT_FRAGMENTZ
NOTATION_NODEZ
SHOW_NOTATIONrοΏ½rrrrrJοΏ½s:
οΏ½rJc@seZdZdZddοΏ½ZdS)οΏ½FilterCrutch)οΏ½_builderοΏ½_levelοΏ½
_old_startοΏ½_old_endcCs6d|_||_|j}|j|_|j|_|j|_|j|_dSrοΏ½)	rοΏ½rοΏ½rMr_rοΏ½rarοΏ½rοΏ½r`)rr6rxrrrrszFilterCrutch.__init__N)r1r2r3r4rrrrrrοΏ½srοΏ½c@s(eZdZdZddοΏ½ZddοΏ½ZddοΏ½ZdS)	rοΏ½rcCs,tοΏ½||οΏ½|j}dD]}t||dοΏ½qdS)N)rcrjrprlrnrs)rοΏ½rrMοΏ½setattr)rr6rxr?rrrrszRejecter.__init__cGs|jd|_dSrοΏ½)rοΏ½οΏ½rοΏ½argsrrrrοΏ½szRejecter.start_element_handlercGs@|jdkr0|jj}|jοΏ½|οΏ½|j|_|j|_n|jd|_dSοΏ½Nrr!)rοΏ½rοΏ½rMrTrοΏ½r_rοΏ½ra)rrοΏ½rxrrrr` s

zRejecter.end_element_handlerN)r1r2r3r4rrοΏ½r`rrrrrοΏ½srοΏ½c@s eZdZdZddοΏ½ZddοΏ½ZdS)rοΏ½rcGs.|jj}|j|οΏ½|jj|k	r*|jd|_dSrοΏ½)rοΏ½rYrοΏ½rοΏ½)rrοΏ½rοΏ½rrrrοΏ½-s
zSkipper.start_element_handlercGsD|jdkr*|j|jj_|j|jj_d|_n|jd|_|j|οΏ½dSrοΏ½)rοΏ½rοΏ½rοΏ½rMr_rοΏ½rarοΏ½rrrr`3s
zSkipper.end_element_handlerN)r1r2r3r4rοΏ½r`rrrrrοΏ½*srοΏ½z8http://xml.python.org/entities/fragment-builder/internalzοΏ½<!DOCTYPE wrapper
  %%s [
  <!ENTITY fragment-builder-internal
    SYSTEM "%s">
%%s
]>
<wrapper %%s
>&fragment-builder-internal;</wrapper>c@sFeZdZdddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½Z	dS)οΏ½FragmentBuilderNcCs6|jtkr||_||_n|j|_||_tοΏ½||οΏ½dSr)rοΏ½rοΏ½οΏ½originalDocumentrοΏ½rοΏ½rGr)rrοΏ½rOrrrr[s
zFragmentBuilder.__init__cCstοΏ½|οΏ½d|_dSr)rGrNοΏ½fragmentrrrrrNds
zFragmentBuilder.resetcCs|οΏ½|οΏ½οΏ½οΏ½Sr)rοΏ½rzοΏ½rrrrrrοΏ½hszFragmentBuilder.parseFilec	CsοΏ½||_|οΏ½οΏ½}|jj}d}|rV|jp*|οΏ½οΏ½}|jrDd|j|jf}qZ|jrZd|j}nd}|οΏ½οΏ½}t	|||f}z|οΏ½
|dοΏ½Wn|οΏ½οΏ½οΏ½YnX|j}|οΏ½οΏ½|S)NryzPUBLIC "%s" "%s"zSYSTEM "%s"r!)
οΏ½_sourcerUrοΏ½rοΏ½rοΏ½οΏ½_getDeclarationsrοΏ½rοΏ½οΏ½_getNSattrsοΏ½_FRAGMENT_BUILDER_TEMPLATEr{rNrοΏ½)	rrοΏ½rxrοΏ½ZidentrοΏ½ZnsattrsrXrοΏ½rrrrοΏ½ms.
οΏ½zFragmentBuilder.parseStringcCs|jjj}d}|οΏ½rt|jjοΏ½D]R}|jοΏ½|οΏ½}|r<|d}d||jf}|jrdd||j|j	f}q d||j	f}q t|j
jοΏ½D]οΏ½}|j
οΏ½|οΏ½}|rοΏ½|d}d||jf}|jrοΏ½d||j|j	f}n&|j	rοΏ½d||j	f}nd	||jjf}|j
rοΏ½d
||j
f}|d}qοΏ½|S)Nryz
  z%s<!NOTATION %sz!%s PUBLIC "%s"
             "%s">z%s SYSTEM "%s">z
%s<!ENTITY %sz %s PUBLIC "%s"
             "%s"z%s SYSTEM "%s"z%s "%s"z%s NOTATION %sοΏ½>)rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½ZlengthοΏ½itemZnodeNamerοΏ½rοΏ½rZ
firstChildrοΏ½rοΏ½)rrοΏ½r7rοΏ½Znotationr
rrrrοΏ½οΏ½s:
οΏ½οΏ½
z FragmentBuilder._getDeclarationscCsdS)NryrrrrrrοΏ½οΏ½szFragmentBuilder._getNSattrscCs~|tkrh|j}|j}|jοΏ½|οΏ½}|j|_|jοΏ½οΏ½|_|j|_z|οΏ½	|jdοΏ½W5||_||_d|_XdSt
οΏ½|||||οΏ½SdS)Nr!rοΏ½)οΏ½$_FRAGMENT_BUILDER_INTERNAL_SYSTEM_IDrXrYrMZExternalEntityParserCreaterοΏ½ZcreateDocumentFragmentrοΏ½rοΏ½r{rGrr)rrοΏ½rοΏ½rοΏ½rοΏ½Zold_documentZold_cur_noderxrrrrrοΏ½s(οΏ½z+FragmentBuilder.external_entity_ref_handler)N)
r1r2r3rrNrοΏ½rοΏ½rοΏ½rοΏ½rrrrrrrοΏ½Rs	
	$rοΏ½c@s4eZdZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZdS)οΏ½
NamespacescCs
g|_dSr)οΏ½_ns_ordered_prefixesrrrrοΏ½_initNamespacesοΏ½szNamespaces._initNamespacescCstjddοΏ½}d|_|S)Nr9)Znamespace_separatorT)rrPZnamespace_prefixesrwrrrrQοΏ½szNamespaces.createParsercCs tοΏ½||οΏ½|jjr|j|_dSr)rGrTrHZnamespace_declarationsοΏ½start_namespace_decl_handlerZStartNamespaceDeclHandlerrwrrrrTοΏ½sοΏ½zNamespaces.installcCs|jοΏ½||fοΏ½dSr)rοΏ½rοΏ½)rrDrBrrrrοΏ½οΏ½sz'Namespaces.start_namespace_decl_handlercCsοΏ½d|krt||οΏ½\}}}}nt}|}d}t}tοΏ½||||οΏ½}|j|_t|j|οΏ½||_|j	rοΏ½|j	D]P\}}|rοΏ½tοΏ½
t|d|οΏ½t|dοΏ½}ntοΏ½
dtdtοΏ½}||_
|j|_t||οΏ½qb|j	ddοΏ½=|οΏ½r~|οΏ½οΏ½|j}	|j}
tdt|οΏ½dοΏ½D]οΏ½}||}||d}
d|kοΏ½rDt||οΏ½\}}}}tοΏ½
||||οΏ½}||	|<||
||f<n$tοΏ½
|t|tοΏ½}||	|<||
t|f<|j|_|
|_
||_qοΏ½dS)Nr9οΏ½xmlns:οΏ½xmlnsrr;r!)rFrrrZElementrXrοΏ½r	rYrοΏ½rοΏ½r8rrοΏ½r
Z_ensure_attributesοΏ½_attrsοΏ½_attrsNSrοΏ½r=ZownerElement)rr?rοΏ½rBrCrDrErοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r&rοΏ½rrrrοΏ½οΏ½s^οΏ½οΏ½
οΏ½z Namespaces.start_element_handlerN)	r1r2r3rοΏ½rQrTrοΏ½rοΏ½r`rrrrrοΏ½οΏ½s5rοΏ½c@seZdZddοΏ½ZdS)οΏ½ExpatBuilderNScCstοΏ½|οΏ½|οΏ½οΏ½dSr)rGrNrοΏ½rrrrrN)s
zExpatBuilderNS.resetN)r1r2r3rNrrrrrοΏ½&srοΏ½c@seZdZddοΏ½ZddοΏ½ZdS)οΏ½FragmentBuilderNScCstοΏ½|οΏ½|οΏ½οΏ½dSr)rοΏ½rNrοΏ½rrrrrN1s
zFragmentBuilderNS.resetcCsοΏ½d}|j}g}|r~t|dοΏ½rv|jοΏ½οΏ½D]N\}}||kr8q&|οΏ½|οΏ½|rPd|}nd}|rhd|||f}q&d||f}q&|j}q|S)NryοΏ½_ns_prefix_urirοΏ½rοΏ½z%s
    %s='%s'z %s='%s')rοΏ½οΏ½hasattrrοΏ½οΏ½itemsrοΏ½rοΏ½)rοΏ½attrsrοΏ½rοΏ½rDrBZdeclnamerrrrοΏ½5s"


zFragmentBuilderNS._getNSattrsN)r1r2r3rNrοΏ½rrrrrοΏ½.srοΏ½c@seZdZdS)r~N)r1r2r3rrrrr~Ssr~c@sHeZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½Z	ddοΏ½Z
dS)rοΏ½NcCs|jSr)rοΏ½rrrrrοΏ½\sz!InternalSubsetExtractor.getSubsetcCs*ztοΏ½||οΏ½Wntk
r$YnXdSr)rGrοΏ½r~rοΏ½rrrrοΏ½`sz!InternalSubsetExtractor.parseFilecCs*ztοΏ½||οΏ½Wntk
r$YnXdSr)rGrοΏ½r~)rrοΏ½rrrrοΏ½fsz#InternalSubsetExtractor.parseStringcCs|j|_|j|_dSr)r\r]rοΏ½r_rwrrrrTlszInternalSubsetExtractor.installcCs0|r&|οΏ½οΏ½}g|_|jj|_|j|_ntοΏ½οΏ½dSr)rUrοΏ½rοΏ½ZDefaultHandlerrοΏ½rοΏ½r~)rr?rοΏ½rοΏ½rοΏ½rxrrrr\ps

z2InternalSubsetExtractor.start_doctype_decl_handlercCs,dοΏ½|jοΏ½οΏ½ddοΏ½οΏ½ddοΏ½}||_tοΏ½οΏ½dS)Nryz
οΏ½
οΏ½
)οΏ½joinrοΏ½οΏ½replacer~)rr7rrrrοΏ½zsz0InternalSubsetExtractor.end_doctype_decl_handlercCs
tοΏ½οΏ½dSr)r~)rr?rοΏ½rrrrοΏ½sz-InternalSubsetExtractor.start_element_handler)r1r2r3rοΏ½rοΏ½rοΏ½rοΏ½rTr\rοΏ½rοΏ½rrrrrοΏ½Ws
rοΏ½Tc	CsL|rtοΏ½}ntοΏ½}t|tοΏ½r>t|dοΏ½οΏ½}|οΏ½|οΏ½}W5QRXn
|οΏ½|οΏ½}|SοΏ½NοΏ½rb)rοΏ½rGοΏ½
isinstanceοΏ½strοΏ½openrοΏ½)rοΏ½
namespacesr6οΏ½fpοΏ½resultrrrοΏ½parseοΏ½s

rοΏ½cCs|rtοΏ½}ntοΏ½}|οΏ½|οΏ½Sr)rοΏ½rGrοΏ½)rοΏ½rοΏ½r6rrrrοΏ½οΏ½srοΏ½c	CsP|rt|οΏ½}nt|οΏ½}t|tοΏ½rBt|dοΏ½οΏ½}|οΏ½|οΏ½}W5QRXn
|οΏ½|οΏ½}|SrοΏ½)rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½)rrοΏ½rοΏ½r6rοΏ½rοΏ½rrrοΏ½
parseFragmentοΏ½s


rοΏ½cCs |rt|οΏ½}nt|οΏ½}|οΏ½|οΏ½Sr)rοΏ½rοΏ½rοΏ½)rοΏ½rοΏ½rοΏ½r6rrrοΏ½parseFragmentStringοΏ½s
rοΏ½cCs|jrt|οΏ½St|οΏ½SdSr)rοΏ½rοΏ½rG)rOrrrοΏ½makeBuilderοΏ½srοΏ½)T)T)T)T)2Zxml.domrrrrrrZxml.parsersrZxml.dom.minidomr	r
Zxml.dom.NodeFilterrrοΏ½rοΏ½rοΏ½ZDOMBuilderFilterrοΏ½rοΏ½rοΏ½rοΏ½ZgetDOMImplementationrWZTypeInfor$οΏ½objectrr8rFrGrοΏ½rJrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½	Exceptionr~rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrοΏ½<module>sd








οΏ½3C
:οΏ½	οΏ½οΏ½
u_%,



U

e5dοΏ½οΏ½οΏ½@sdZddlmZmZmZddlmZmZmZddlm	Z	ddl
mZmZddl
mZejZejZejZejjZejjZejjZejjZeοΏ½οΏ½ZeοΏ½ddοΏ½eοΏ½dd	οΏ½eοΏ½dd
οΏ½eοΏ½ddοΏ½eοΏ½ddοΏ½eοΏ½dd
οΏ½eοΏ½ddοΏ½eοΏ½ddοΏ½eοΏ½ddοΏ½dοΏ½	ZGddοΏ½deοΏ½ZddοΏ½ZddοΏ½ZGddοΏ½dοΏ½ZeeefZ GddοΏ½deοΏ½Z!GddοΏ½deοΏ½Z"GddοΏ½de"οΏ½Z#Gd d!οΏ½d!e"οΏ½Z$d"Z%d#e%Z&Gd$d%οΏ½d%eοΏ½Z'Gd&d'οΏ½d'οΏ½Z(Gd(d)οΏ½d)e(eοΏ½Z)Gd*d+οΏ½d+e(e'οΏ½Z*Gd,d-οΏ½d-e+οΏ½Z,Gd.d/οΏ½d/eοΏ½Z-d;d1d2οΏ½Z.d<d3d4οΏ½Z/d=d5d6οΏ½Z0d>d7d8οΏ½Z1d9d:οΏ½Z2dS)?zοΏ½Facility to use the Expat parser to load a minidom instance
from a string or file.

This avoids all the overhead of SAX and pulldom to gain performance.
οΏ½)οΏ½
xmlbuilderοΏ½minidomοΏ½Node)οΏ½EMPTY_NAMESPACEοΏ½EMPTY_PREFIXοΏ½XMLNS_NAMESPACE)οΏ½expat)οΏ½
_append_childοΏ½_set_attribute_node)οΏ½
NodeFilterNZcdataοΏ½enumerationοΏ½entityοΏ½entitiesοΏ½idZidrefZidrefsZnmtokenZnmtokens)	ZCDATAοΏ½ENUMZENTITYZENTITIESοΏ½IDZIDREFZIDREFSZNMTOKENZNMTOKENSc@sZeZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZdS)οΏ½ElementInfoοΏ½οΏ½
_attr_infoοΏ½_modelοΏ½tagNameNcCs||_g|_||_dSοΏ½N)rrr)οΏ½selfrοΏ½modelοΏ½rοΏ½,/usr/lib64/python3.8/xml/dom/expatbuilder.pyοΏ½__init__?szElementInfo.__init__cCs|j|j|jfSrrοΏ½rrrrοΏ½__getstate__DszElementInfo.__getstate__cCs|\|_|_|_dSrr)rοΏ½staterrrοΏ½__setstate__GszElementInfo.__setstate__cCsN|jD]@}|d|kr|d}|ddkr6tdSt|dSqtjS)NοΏ½οΏ½οΏ½οΏ½rοΏ½(r)rοΏ½
_typeinfo_maprοΏ½_no_type)rοΏ½anameοΏ½infoοΏ½trrrοΏ½getAttributeTypeJs
zElementInfo.getAttributeTypecCstjSr)rr%)rοΏ½namespaceURIοΏ½	localNamerrrοΏ½getAttributeTypeNSTszElementInfo.getAttributeTypeNScCs,|jr$|jd}|tjjtjjfkSdSdSοΏ½NrF)rrrZ
XML_CTYPE_ANYZXML_CTYPE_MIXED)rοΏ½typerrrοΏ½isElementContentWs
οΏ½zElementInfo.isElementContentcCs |jr|jdtjjkSdSdSr-)rrrZXML_CTYPE_EMPTYrrrrοΏ½isEmpty_szElementInfo.isEmptycCs,|jD] }|d|kr|ddkSqdS)Nr!r"rF)r)rr&r'rrrοΏ½isIdes
zElementInfo.isIdcCs|οΏ½||fοΏ½Sr)r1)rZeuriZenameZaurir&rrrοΏ½isIdNSkszElementInfo.isIdNS)N)
οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½	__slots__rrr r)r,r/r0r1r2rrrrr<s

rcCs|οΏ½||οΏ½Sr)οΏ½_intern_setdefault)οΏ½builderοΏ½srrrοΏ½_internosr:cCsοΏ½d|kstοΏ½|οΏ½dοΏ½}|j}t|οΏ½dkr^|\}}}|||οΏ½}d||f}|||οΏ½}|||οΏ½}n4t|οΏ½dkrοΏ½|\}}t}|||οΏ½}}ntd|οΏ½οΏ½|||οΏ½|||fS)NοΏ½ οΏ½z%s:%sοΏ½z4Unsupported syntax: spaces in URIs not supported: %r)οΏ½AssertionErrorοΏ½splitr7οΏ½lenrοΏ½
ValueError)r8οΏ½nameοΏ½partsοΏ½internοΏ½uriοΏ½	localnameοΏ½prefixοΏ½qnamerrrοΏ½_parse_ns_namers



rIc@sοΏ½eZdZdZd;ddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zdd οΏ½Zd!d"οΏ½Zd#d$οΏ½Zd%d&οΏ½Zd'd(οΏ½Zd)d*οΏ½Zd+d,οΏ½Zd-d.οΏ½Zd/d0οΏ½Zd1d2οΏ½Zd3d4οΏ½Zd5d6οΏ½Zd7d8οΏ½Zd9d:οΏ½ZdS)<οΏ½ExpatBuilderzPDocument builder that uses Expat to build a ParsedXML.DOM document
    instance.NcCsP|dkrtοΏ½οΏ½}||_|jjdk	r2t|jjοΏ½|_nd|_t|_d|_|οΏ½	οΏ½dSr)
rZOptionsοΏ½_optionsοΏ½filterοΏ½FilterVisibilityControllerοΏ½_filterrοΏ½_finish_start_elementοΏ½_parserοΏ½reset)rοΏ½optionsrrrrοΏ½szExpatBuilder.__init__cCstοΏ½οΏ½S)zCreate a new parser object.)rοΏ½ParserCreaterrrrοΏ½createParserοΏ½szExpatBuilder.createParsercCsF|js@|οΏ½οΏ½|_|jjj|_d|j_d|j_d|j_|οΏ½|jοΏ½|jS)z7Return the parser object, creating a new one if needed.T)	rPrTrDοΏ½
setdefaultr7Zbuffer_textZordered_attributesZspecified_attributesοΏ½installrrrrοΏ½	getParserοΏ½s
zExpatBuilder.getParsercCs,tοΏ½tddοΏ½|_|j|_|jj|_d|_dS)z6Free all data structures used during DOM construction.NF)οΏ½theDOMImplementationZcreateDocumentrοΏ½documentοΏ½curNodeοΏ½
_elem_infoοΏ½_cdatarrrrrQοΏ½sοΏ½
zExpatBuilder.resetcCsοΏ½|j|_|j|_|j|_|j|_|jj	r0|j
|_|j|_
|jjrH|j|_|jjrj|j|_|j|_|j|_n|j|_|j|_|j|_|j|_|j|_ dS)z>Install the callbacks needed to build the DOM into the parser.N)!οΏ½start_doctype_decl_handlerοΏ½StartDoctypeDeclHandlerοΏ½first_element_handlerοΏ½StartElementHandlerοΏ½end_element_handlerοΏ½EndElementHandlerοΏ½
pi_handlerοΏ½ProcessingInstructionHandlerrKrοΏ½entity_decl_handlerοΏ½EntityDeclHandlerοΏ½notation_decl_handlerοΏ½NotationDeclHandlerοΏ½commentsοΏ½comment_handlerοΏ½CommentHandlerZcdata_sectionsοΏ½start_cdata_section_handlerοΏ½StartCdataSectionHandlerοΏ½end_cdata_section_handlerοΏ½EndCdataSectionHandlerοΏ½character_data_handler_cdataοΏ½CharacterDataHandlerοΏ½character_data_handlerοΏ½external_entity_ref_handlerοΏ½ExternalEntityRefHandlerοΏ½xml_decl_handlerZXmlDeclHandlerοΏ½element_decl_handlerZElementDeclHandlerοΏ½attlist_decl_handlerZAttlistDeclHandlerοΏ½rοΏ½parserrrrrVοΏ½s$
zExpatBuilder.installcCsοΏ½|οΏ½οΏ½}d}zH|οΏ½dοΏ½}|sqF|οΏ½|dοΏ½|r@|jjr@|οΏ½|οΏ½d}q|οΏ½ddοΏ½Wntk
rhYnX|j}|οΏ½οΏ½d|_|S)zIParse a document from a file object, returning the document
        node.Ti@rFοΏ½N)	rWοΏ½readοΏ½ParserYοΏ½documentElementοΏ½
_setup_subsetοΏ½ParseEscaperQrP)rοΏ½fileryZfirst_bufferοΏ½bufferοΏ½docrrrοΏ½	parseFileοΏ½s"

zExpatBuilder.parseFilecCsP|οΏ½οΏ½}z|οΏ½|dοΏ½|οΏ½|οΏ½Wntk
r6YnX|j}|οΏ½οΏ½d|_|S)z<Parse a document from a string, returning the document node.TN)rWr|r~rrYrQrP)rοΏ½stringryrοΏ½rrrοΏ½parseStringοΏ½szExpatBuilder.parseStringcCs.|jjr*tοΏ½}|οΏ½|οΏ½|οΏ½οΏ½}||jj_dS)z/Load the internal subset if there might be one.N)rYοΏ½doctypeοΏ½InternalSubsetExtractorrοΏ½οΏ½	getSubsetοΏ½internalSubset)rrοΏ½Z	extractorοΏ½subsetrrrr~οΏ½s

zExpatBuilder._setup_subsetcCsοΏ½|jjοΏ½|||οΏ½}|j|_t|j|οΏ½||j_|jrj|jοΏ½|οΏ½tkrjd|j_|jj	d=d}d|j
_d|j
_|rοΏ½|dk	rοΏ½g|j
_g|j_d|j
_d|j
_|j|j
_dSοΏ½NοΏ½οΏ½οΏ½)rYοΏ½implementationZcreateDocumentTypeοΏ½
ownerDocumentr	rοΏ½rNοΏ½
acceptNodeοΏ½
FILTER_REJECTοΏ½
childNodesrPrfrhrοΏ½_seqοΏ½	notationsrkrdοΏ½end_doctype_decl_handlerοΏ½EndDoctypeDeclHandler)rZdoctypeNameοΏ½systemIdοΏ½publicIdοΏ½has_internal_subsetrοΏ½rrrr]οΏ½s*οΏ½
z'ExpatBuilder.start_doctype_decl_handlercCs2|jjr|j|j_|j|j_|js.|js.t	|_
dSr)rKrirjrPrkrcrdr[rNrοΏ½_finish_end_elementrrrrrοΏ½s


z%ExpatBuilder.end_doctype_decl_handlercCs@|jοΏ½||οΏ½}t|j|οΏ½|jr<|jοΏ½|οΏ½tkr<|jοΏ½|οΏ½dSr)rYZcreateProcessingInstructionr	rZrNrοΏ½rοΏ½οΏ½removeChild)rοΏ½targetοΏ½dataοΏ½noderrrrcszExpatBuilder.pi_handlercCsοΏ½|jj}|jrH|jr4|djtkr4|dοΏ½|οΏ½dS|jοΏ½|οΏ½}d|_nD|rv|djt	krv|d}|j
|}||_
dStοΏ½οΏ½}||_
|j|_
t|j|οΏ½dS)NrοΏ½T)rZrοΏ½r\οΏ½_cdata_continueοΏ½nodeTypeοΏ½CDATA_SECTION_NODEZ
appendDatarYZcreateCDATASectionοΏ½	TEXT_NODErοΏ½rοΏ½TextrοΏ½r	)rrοΏ½rοΏ½rοΏ½οΏ½valuerrrrps$οΏ½
z)ExpatBuilder.character_data_handler_cdatacCs^|jj}|r2|djtkr2|d}|j||_dStοΏ½οΏ½}|j||_|j|_t	|j|οΏ½dSrοΏ½)
rZrοΏ½rοΏ½rοΏ½rοΏ½rrοΏ½rYrοΏ½r	)rrοΏ½rοΏ½rοΏ½rrrrr&sz#ExpatBuilder.character_data_handlerc
CsοΏ½|rdS|jjsdS|jοΏ½||||οΏ½}|dk	rF|jοΏ½|οΏ½}	|jοΏ½|	οΏ½|jjjjοΏ½|οΏ½|j	r||j	οΏ½
|οΏ½tkr||jjjjd=dSrοΏ½)rKrrYZ_create_entityZcreateTextNoderοΏ½οΏ½appendrοΏ½rοΏ½rNrοΏ½rοΏ½)
rZ
entityNameZis_parameter_entityrοΏ½οΏ½baserοΏ½rοΏ½οΏ½notationNamerοΏ½οΏ½childrrrre1s
οΏ½z ExpatBuilder.entity_decl_handlercCsJ|jοΏ½|||οΏ½}|jjjjοΏ½|οΏ½|jrF|jοΏ½|οΏ½tkrF|jjjjd=dSrοΏ½)	rYZ_create_notationrοΏ½rοΏ½rοΏ½rοΏ½rNrοΏ½οΏ½
FILTER_ACCEPT)rrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrgCsz"ExpatBuilder.notation_decl_handlercCs>|jοΏ½|οΏ½}t|j|οΏ½|jr:|jοΏ½|οΏ½tkr:|jοΏ½|οΏ½dSr)rYZ
createCommentr	rZrNrοΏ½rοΏ½rοΏ½)rrοΏ½rοΏ½rrrrjIszExpatBuilder.comment_handlercCsd|_d|_dS)NTFοΏ½r\rοΏ½rrrrrlOsz(ExpatBuilder.start_cdata_section_handlercCsd|_d|_dS)NFrοΏ½rrrrrnSsz&ExpatBuilder.end_cdata_section_handlercCsdSοΏ½Nr!r)rοΏ½contextrοΏ½rοΏ½rοΏ½rrrrsWsz(ExpatBuilder.external_entity_ref_handlercCs2|jdkr|jst|_|j|οΏ½οΏ½_|οΏ½||οΏ½dSr)rNr[rrοΏ½οΏ½start_element_handlerrWr`)rrBοΏ½
attributesrrrr_Zsz"ExpatBuilder.first_element_handlercCsοΏ½|jοΏ½|οΏ½}t|j|οΏ½||_|rptdt|οΏ½dοΏ½D]<}tοΏ½||tdt	οΏ½}||d}||_
|j|_t||οΏ½q2||jj
k	rοΏ½|οΏ½|οΏ½dS)Nrr=r!)rYZ
createElementr	rZοΏ½ranger@rοΏ½AttrrrrοΏ½rοΏ½r
r}rO)rrBrοΏ½rοΏ½οΏ½iοΏ½arοΏ½rrrrοΏ½`sοΏ½z"ExpatBuilder.start_element_handlercCsj|jrf||jjkrdS|jοΏ½|οΏ½}|tkr4t|οΏ½n|tkrFt|οΏ½ndS|j|_	|jοΏ½
|οΏ½|οΏ½οΏ½dSr)rNrYr}οΏ½startContainerrοΏ½οΏ½RejecterοΏ½FILTER_SKIPοΏ½SkipperοΏ½
parentNoderZrοΏ½οΏ½unlink)rrοΏ½ZfiltrrrrOqs

z"ExpatBuilder._finish_start_elementcCs|j}|j|_|οΏ½|οΏ½dSr)rZrοΏ½rοΏ½)rrBrZrrrraοΏ½sz ExpatBuilder.end_element_handlercCs\|jοΏ½|jοΏ½}|r|οΏ½||οΏ½|jrX||jjkr4dS|jοΏ½|οΏ½tkrX|j	οΏ½
|οΏ½|οΏ½οΏ½dSr)r[οΏ½getrοΏ½_handle_white_text_nodesrNrYr}rοΏ½rοΏ½rZrοΏ½rοΏ½)rrZr'rrrrοΏ½οΏ½sz ExpatBuilder._finish_end_elementcCsZ|jjs|οΏ½οΏ½sdSg}|jD]"}|jtkr|jοΏ½οΏ½s|οΏ½|οΏ½q|D]}|οΏ½	|οΏ½qFdSr)
rKZwhitespace_in_element_contentr/rοΏ½rοΏ½rοΏ½rοΏ½οΏ½striprοΏ½rοΏ½)rrοΏ½r'οΏ½LrοΏ½rrrrοΏ½οΏ½sοΏ½
z%ExpatBuilder._handle_white_text_nodescCs>|jοΏ½|οΏ½}|dkr&t||οΏ½|j|<n|jdks4tοΏ½||_dSr)r[rοΏ½rrr>)rrBrr'rrrrvοΏ½s
z!ExpatBuilder.element_decl_handlerc
CsF|jοΏ½|οΏ½}|dkr&t|οΏ½}||j|<|jοΏ½d|dd|d||gοΏ½dSοΏ½Nr)r[rοΏ½rrrοΏ½)rοΏ½elemrBr.οΏ½defaultZrequiredr'rrrrwοΏ½s
οΏ½z!ExpatBuilder.attlist_decl_handlercCs2||j_||j_|dkr.|r&d|j_nd|j_dS)NrTF)rYοΏ½versionοΏ½encodingοΏ½
standalone)rrοΏ½rοΏ½rοΏ½rrrruοΏ½s
zExpatBuilder.xml_decl_handler)N) r3r4r5οΏ½__doc__rrTrWrQrVrοΏ½rοΏ½r~r]rοΏ½rcrprrrergrjrlrnrsr_rοΏ½rOrarοΏ½rοΏ½rvrwrurrrrrJοΏ½s:

rJc@sοΏ½eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zej	e
jeje
j
eje
jeje
jeje
jeje
jeje
jeje
jeje
jeje
jeje
jej e
j!iZ"d	S)
rMzoWrapper around a DOMBuilderFilter which implements the checks
    to make the whatToShow filter attribute work.οΏ½rLcCs
||_dSrrοΏ½)rrLrrrrοΏ½sz#FilterVisibilityController.__init__cCsT|j|j}|jj|@rL|jοΏ½|οΏ½}|tkr0tοΏ½|tkrHtdt	|οΏ½οΏ½οΏ½|St
SdS)Nz)startContainer() returned illegal value: )οΏ½_nodetype_maskrοΏ½rLοΏ½
whatToShowrοΏ½οΏ½FILTER_INTERRUPTrοΏ½_ALLOWED_FILTER_RETURNSrAοΏ½reprrοΏ½)rrοΏ½οΏ½maskοΏ½valrrrrοΏ½οΏ½s
οΏ½z)FilterVisibilityController.startContainercCsοΏ½|j|j}|jj|@r||jοΏ½|οΏ½}|tkr0tοΏ½|tkr`|j}|j	ddοΏ½D]}|οΏ½
|οΏ½qLtS|tkrxt
dt|οΏ½οΏ½οΏ½|StSdS)Nz%acceptNode() returned illegal value: )rοΏ½rοΏ½rLrοΏ½rοΏ½rοΏ½rrοΏ½rοΏ½rοΏ½ZappendChildrοΏ½rοΏ½rArοΏ½rοΏ½)rrοΏ½rοΏ½rοΏ½οΏ½parentrοΏ½rrrrοΏ½οΏ½s 
οΏ½z%FilterVisibilityController.acceptNodeN)#r3r4r5rοΏ½r6rrοΏ½rοΏ½rZELEMENT_NODErZSHOW_ELEMENTZATTRIBUTE_NODEZSHOW_ATTRIBUTErοΏ½Z	SHOW_TEXTrοΏ½ZSHOW_CDATA_SECTIONZENTITY_REFERENCE_NODEZSHOW_ENTITY_REFERENCEZENTITY_NODEZSHOW_ENTITYZPROCESSING_INSTRUCTION_NODEZSHOW_PROCESSING_INSTRUCTIONZCOMMENT_NODEZSHOW_COMMENTοΏ½
DOCUMENT_NODEZ
SHOW_DOCUMENTZDOCUMENT_TYPE_NODEZSHOW_DOCUMENT_TYPEZDOCUMENT_FRAGMENT_NODEZSHOW_DOCUMENT_FRAGMENTZ
NOTATION_NODEZ
SHOW_NOTATIONrοΏ½rrrrrMοΏ½s<
οΏ½rMc@seZdZdZddοΏ½ZdS)οΏ½FilterCrutch)οΏ½_builderοΏ½_levelοΏ½
_old_startοΏ½_old_endcCs6d|_||_|j}|j|_|j|_|j|_|j|_dSrοΏ½)	rοΏ½rοΏ½rPr`rοΏ½rbrοΏ½rοΏ½ra)rr8ryrrrrszFilterCrutch.__init__N)r3r4r5r6rrrrrrοΏ½srοΏ½c@s(eZdZdZddοΏ½ZddοΏ½ZddοΏ½ZdS)	rοΏ½rcCs,tοΏ½||οΏ½|j}dD]}t||dοΏ½qdS)N)rdrkrqrmrort)rοΏ½rrPοΏ½setattr)rr8ryrBrrrrszRejecter.__init__cGs|jd|_dSrοΏ½)rοΏ½οΏ½rοΏ½argsrrrrοΏ½szRejecter.start_element_handlercGs@|jdkr0|jj}|jοΏ½|οΏ½|j|_|j|_n|jd|_dSοΏ½Nrr!)rοΏ½rοΏ½rPrVrοΏ½r`rοΏ½rb)rrοΏ½ryrrrra s

zRejecter.end_element_handlerN)r3r4r5r6rrοΏ½rarrrrrοΏ½srοΏ½c@s eZdZdZddοΏ½ZddοΏ½ZdS)rοΏ½rcGs.|jj}|j|οΏ½|jj|k	r*|jd|_dSrοΏ½)rοΏ½rZrοΏ½rοΏ½)rrοΏ½rοΏ½rrrrοΏ½-s
zSkipper.start_element_handlercGsD|jdkr*|j|jj_|j|jj_d|_n|jd|_|j|οΏ½dSrοΏ½)rοΏ½rοΏ½rοΏ½rPr`rοΏ½rbrοΏ½rrrra3s
zSkipper.end_element_handlerN)r3r4r5r6rοΏ½rarrrrrοΏ½*srοΏ½z8http://xml.python.org/entities/fragment-builder/internalzοΏ½<!DOCTYPE wrapper
  %%s [
  <!ENTITY fragment-builder-internal
    SYSTEM "%s">
%%s
]>
<wrapper %%s
>&fragment-builder-internal;</wrapper>c@sJeZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
dS)οΏ½FragmentBuilderzοΏ½Builder which constructs document fragments given XML source
    text and a context node.

    The context node is expected to provide information about the
    namespace declarations which are in scope at the start of the
    fragment.
    NcCs6|jtkr||_||_n|j|_||_tοΏ½||οΏ½dSr)rοΏ½rοΏ½οΏ½originalDocumentrοΏ½rοΏ½rJr)rrοΏ½rRrrrr[s
zFragmentBuilder.__init__cCstοΏ½|οΏ½d|_dSr)rJrQοΏ½fragmentrrrrrQds
zFragmentBuilder.resetcCs|οΏ½|οΏ½οΏ½οΏ½S)zRParse a document fragment from a file object, returning the
        fragment node.)rοΏ½r{οΏ½rrοΏ½rrrrοΏ½hszFragmentBuilder.parseFilec	CsοΏ½||_|οΏ½οΏ½}|jj}d}|rV|jp*|οΏ½οΏ½}|jrDd|j|jf}qZ|jrZd|j}nd}|οΏ½οΏ½}t	|||f}z|οΏ½
|dοΏ½Wn|οΏ½οΏ½οΏ½YnX|j}|οΏ½οΏ½|S)zMParse a document fragment from a string, returning the
        fragment node.rzzPUBLIC "%s" "%s"zSYSTEM "%s"r!)
οΏ½_sourcerWrοΏ½rοΏ½rοΏ½οΏ½_getDeclarationsrοΏ½rοΏ½οΏ½_getNSattrsοΏ½_FRAGMENT_BUILDER_TEMPLATEr|rQrοΏ½)	rrοΏ½ryrοΏ½ZidentrοΏ½ZnsattrsrYrοΏ½rrrrοΏ½ms.
οΏ½zFragmentBuilder.parseStringcCs|jjj}d}|οΏ½rt|jjοΏ½D]R}|jοΏ½|οΏ½}|r<|d}d||jf}|jrdd||j|j	f}q d||j	f}q t|j
jοΏ½D]οΏ½}|j
οΏ½|οΏ½}|rοΏ½|d}d||jf}|jrοΏ½d||j|j	f}n&|j	rοΏ½d||j	f}nd	||jjf}|j
rοΏ½d
||j
f}|d}qοΏ½|S)zοΏ½Re-create the internal subset from the DocumentType node.

        This is only needed if we don't already have the
        internalSubset as a string.
        rzz
  z%s<!NOTATION %sz!%s PUBLIC "%s"
             "%s">z%s SYSTEM "%s">z
%s<!ENTITY %sz %s PUBLIC "%s"
             "%s"z%s SYSTEM "%s"z%s "%s"z%s NOTATION %sοΏ½>)rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½ZlengthοΏ½itemοΏ½nodeNamerοΏ½rοΏ½rZ
firstChildrοΏ½rοΏ½)rrοΏ½r9rοΏ½Znotationr
rrrrοΏ½οΏ½s:
οΏ½οΏ½
z FragmentBuilder._getDeclarationscCsdS)NrzrrrrrrοΏ½οΏ½szFragmentBuilder._getNSattrscCs~|tkrh|j}|j}|jοΏ½|οΏ½}|j|_|jοΏ½οΏ½|_|j|_z|οΏ½	|jdοΏ½W5||_||_d|_XdSt
οΏ½|||||οΏ½SdS)Nr!rοΏ½)οΏ½$_FRAGMENT_BUILDER_INTERNAL_SYSTEM_IDrYrZrPZExternalEntityParserCreaterοΏ½ZcreateDocumentFragmentrοΏ½rοΏ½r|rJrs)rrοΏ½rοΏ½rοΏ½rοΏ½Zold_documentZold_cur_noderyrrrrsοΏ½s(οΏ½z+FragmentBuilder.external_entity_ref_handler)N)r3r4r5rοΏ½rrQrοΏ½rοΏ½rοΏ½rοΏ½rsrrrrrοΏ½Rs
	$rοΏ½c@s@eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½Z	dS)οΏ½
Namespacesz7Mix-in class for builders; adds support for namespaces.cCs
g|_dSr)οΏ½_ns_ordered_prefixesrrrrοΏ½_initNamespacesοΏ½szNamespaces._initNamespacescCstjddοΏ½}d|_|S)z'Create a new namespace-handling parser.r;)Znamespace_separatorT)rrSZnamespace_prefixesrxrrrrTοΏ½szNamespaces.createParsercCs tοΏ½||οΏ½|jjr|j|_dS)z.Insert the namespace-handlers onto the parser.N)rJrVrKZnamespace_declarationsοΏ½start_namespace_decl_handlerZStartNamespaceDeclHandlerrxrrrrVοΏ½sοΏ½zNamespaces.installcCs|jοΏ½||fοΏ½dS)z/Push this namespace declaration on our storage.N)rοΏ½rοΏ½)rrGrErrrrοΏ½οΏ½sz'Namespaces.start_namespace_decl_handlercCsοΏ½d|krt||οΏ½\}}}}nt}|}d}t}tοΏ½||||οΏ½}|j|_t|j|οΏ½||_|j	rοΏ½|j	D]P\}}|rοΏ½tοΏ½
t|d|οΏ½t|dοΏ½}ntοΏ½
dtdtοΏ½}||_
|j|_t||οΏ½qb|j	ddοΏ½=|οΏ½r~|οΏ½οΏ½|j}	|j}
tdt|οΏ½dοΏ½D]οΏ½}||}||d}
d|kοΏ½rDt||οΏ½\}}}}tοΏ½
||||οΏ½}||	|<||
||f<n$tοΏ½
|t|tοΏ½}||	|<||
t|f<|j|_|
|_
||_qοΏ½dS)Nr;οΏ½xmlns:οΏ½xmlnsrr=r!)rIrrrZElementrYrοΏ½r	rZrοΏ½rοΏ½r:rrοΏ½r
Z_ensure_attributesοΏ½_attrsοΏ½_attrsNSrοΏ½r@ZownerElement)rrBrοΏ½rErFrGrHrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r&rοΏ½rrrrοΏ½οΏ½s^οΏ½οΏ½
οΏ½z Namespaces.start_element_handlercCsοΏ½|j}d|krHt||οΏ½\}}}}|j|kr>|j|kr>|j|ksltdοΏ½οΏ½n$|j|ksZtdοΏ½οΏ½|jtksltdοΏ½οΏ½|j|_|οΏ½	|οΏ½dS)Nr;z$element stack messed up! (namespace)z&element stack messed up - bad nodeNamez*element stack messed up - bad namespaceURI)
rZrIr*r+rGr>rοΏ½rrοΏ½rοΏ½)rrBrZrErFrGrHrrrras$
οΏ½οΏ½οΏ½οΏ½οΏ½zNamespaces.end_element_handlerN)
r3r4r5rοΏ½rοΏ½rTrVrοΏ½rοΏ½rarrrrrοΏ½οΏ½s5rοΏ½c@seZdZdZddοΏ½ZdS)οΏ½ExpatBuilderNSz*Document builder that supports namespaces.cCstοΏ½|οΏ½|οΏ½οΏ½dSr)rJrQrοΏ½rrrrrQ)s
zExpatBuilderNS.resetN)r3r4r5rοΏ½rQrrrrrοΏ½&srοΏ½c@s eZdZdZddοΏ½ZddοΏ½ZdS)οΏ½FragmentBuilderNSz*Fragment builder that supports namespaces.cCstοΏ½|οΏ½|οΏ½οΏ½dSr)rοΏ½rQrοΏ½rrrrrQ1s
zFragmentBuilderNS.resetcCsοΏ½d}|j}g}|r~t|dοΏ½rv|jοΏ½οΏ½D]N\}}||kr8q&|οΏ½|οΏ½|rPd|}nd}|rhd|||f}q&d||f}q&|j}q|S)zNReturn string of namespace attributes from this element and
        ancestors.rzοΏ½_ns_prefix_urirοΏ½rοΏ½z%s
    %s='%s'z %s='%s')rοΏ½οΏ½hasattrrοΏ½οΏ½itemsrοΏ½rοΏ½)rοΏ½attrsrοΏ½rοΏ½rGrEZdeclnamerrrrοΏ½5s"


zFragmentBuilderNS._getNSattrsN)r3r4r5rοΏ½rQrοΏ½rrrrrοΏ½.srοΏ½c@seZdZdZdS)rzEException raised to short-circuit parsing in InternalSubsetExtractor.N)r3r4r5rοΏ½rrrrrSsrc@sLeZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Z	d
dοΏ½Z
ddοΏ½ZdS)rοΏ½zBXML processor which can rip out the internal document type subset.NcCs|jS)z'Return the internal subset as a string.)rοΏ½rrrrrοΏ½\sz!InternalSubsetExtractor.getSubsetcCs*ztοΏ½||οΏ½Wntk
r$YnXdSr)rJrοΏ½rrοΏ½rrrrοΏ½`sz!InternalSubsetExtractor.parseFilecCs*ztοΏ½||οΏ½Wntk
r$YnXdSr)rJrοΏ½r)rrοΏ½rrrrοΏ½fsz#InternalSubsetExtractor.parseStringcCs|j|_|j|_dSr)r]r^rοΏ½r`rxrrrrVlszInternalSubsetExtractor.installcCs0|r&|οΏ½οΏ½}g|_|jj|_|j|_ntοΏ½οΏ½dSr)rWrοΏ½rοΏ½ZDefaultHandlerrοΏ½rοΏ½r)rrBrοΏ½rοΏ½rοΏ½ryrrrr]ps

z2InternalSubsetExtractor.start_doctype_decl_handlercCs,dοΏ½|jοΏ½οΏ½ddοΏ½οΏ½ddοΏ½}||_tοΏ½οΏ½dS)Nrzz
οΏ½
οΏ½
)οΏ½joinrοΏ½οΏ½replacer)rr9rrrrοΏ½zsz0InternalSubsetExtractor.end_doctype_decl_handlercCs
tοΏ½οΏ½dSr)r)rrBrοΏ½rrrrοΏ½sz-InternalSubsetExtractor.start_element_handler)r3r4r5rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rVr]rοΏ½rοΏ½rrrrrοΏ½Ws
rοΏ½Tc	CsL|rtοΏ½}ntοΏ½}t|tοΏ½r>t|dοΏ½οΏ½}|οΏ½|οΏ½}W5QRXn
|οΏ½|οΏ½}|S)z{Parse a document, returning the resulting Document node.

    'file' may be either a file name or an open file object.
    οΏ½rb)rοΏ½rJοΏ½
isinstanceοΏ½strοΏ½openrοΏ½)rοΏ½οΏ½
namespacesr8οΏ½fpοΏ½resultrrrοΏ½parseοΏ½s

rοΏ½cCs|rtοΏ½}ntοΏ½}|οΏ½|οΏ½S)zOParse a document from a string, returning the resulting
    Document node.
    )rοΏ½rJrοΏ½)rοΏ½rοΏ½r8rrrrοΏ½οΏ½srοΏ½c	CsP|rt|οΏ½}nt|οΏ½}t|tοΏ½rBt|dοΏ½οΏ½}|οΏ½|οΏ½}W5QRXn
|οΏ½|οΏ½}|S)zοΏ½Parse a fragment of a document, given the context from which it
    was originally extracted.  context should be the parent of the
    node(s) which are in the fragment.

    'file' may be either a file name or an open file object.
    rοΏ½)rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½)rοΏ½rοΏ½rοΏ½r8rοΏ½rοΏ½rrrοΏ½
parseFragmentοΏ½s


rοΏ½cCs |rt|οΏ½}nt|οΏ½}|οΏ½|οΏ½S)zοΏ½Parse a fragment of a document from a string, given the context
    from which it was originally extracted.  context should be the
    parent of the node(s) which are in the fragment.
    )rοΏ½rοΏ½rοΏ½)rοΏ½rοΏ½rοΏ½r8rrrοΏ½parseFragmentStringοΏ½s
rοΏ½cCs|jrt|οΏ½St|οΏ½SdS)z,Create a builder based on an Options object.N)rοΏ½rοΏ½rJ)rRrrrοΏ½makeBuilderοΏ½srοΏ½)T)T)T)T)3rοΏ½Zxml.domrrrrrrZxml.parsersrZxml.dom.minidomr	r
Zxml.dom.NodeFilterrrοΏ½rοΏ½rοΏ½ZDOMBuilderFilterrοΏ½rοΏ½rοΏ½rοΏ½ZgetDOMImplementationrXZTypeInfor$οΏ½objectrr:rIrJrοΏ½rMrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½	ExceptionrrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrοΏ½<module>sf








οΏ½3C
:οΏ½	οΏ½οΏ½
u_%,



U

e5d'
οΏ½@sFddddgZddlZefZGddοΏ½deοΏ½ZGddοΏ½deοΏ½ZddοΏ½Z	dS)	οΏ½NodeListοΏ½
EmptyNodeListοΏ½StringTypesοΏ½defpropertyοΏ½Nc@s>eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zeeedd	οΏ½Zd
dοΏ½Z	dS)
rοΏ½cCs(d|krt|οΏ½kr$nn||SdSοΏ½NrοΏ½οΏ½lenοΏ½οΏ½selfοΏ½indexrrοΏ½*/usr/lib64/python3.8/xml/dom/minicompat.pyοΏ½item5sz
NodeList.itemcCst|οΏ½SοΏ½NrοΏ½rrrr
οΏ½_get_length9szNodeList._get_lengthcCstjοΏ½dοΏ½οΏ½dSοΏ½Nz.attempt to modify read-only attribute 'length'οΏ½οΏ½xmlοΏ½domοΏ½NoModificationAllowedErrοΏ½rοΏ½valuerrr
οΏ½_set_length<sοΏ½zNodeList._set_lengthοΏ½$The number of nodes in the NodeList.οΏ½οΏ½doccCs|dkrg}||ddοΏ½<dSrr)rοΏ½staterrr
οΏ½__setstate__DszNodeList.__setstate__N)
οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½	__slots__rrrοΏ½propertyοΏ½lengthrrrrr
r2sοΏ½c@sFeZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Ze	eedd
οΏ½Z
dS)rrcCstοΏ½}|οΏ½|οΏ½|SrοΏ½rοΏ½extendοΏ½rοΏ½otherοΏ½NLrrr
οΏ½__add__Ms
zEmptyNodeList.__add__cCstοΏ½}|οΏ½|οΏ½|Srr%r'rrr
οΏ½__radd__Rs
zEmptyNodeList.__radd__cCsdSrrr
rrr
rWszEmptyNodeList.itemcCsdSrrrrrr
rZszEmptyNodeList._get_lengthcCstjοΏ½dοΏ½οΏ½dSrrrrrr
r]sοΏ½zEmptyNodeList._set_lengthrrN)rr r!r"r*r+rrrr#r$rrrr
rJsοΏ½cCs8t|d|οΏ½}|fddοΏ½}t|||dοΏ½}t|||οΏ½dS)NZ_get_cSstjοΏ½dt|οΏ½οΏ½οΏ½dS)Nz&attempt to modify read-only attribute )rrrοΏ½repr)rrοΏ½namerrr
οΏ½setgs
οΏ½zdefproperty.<locals>.setr)οΏ½getattrr#οΏ½setattr)οΏ½klassr-rοΏ½getr.Zproprrr
res)
οΏ½__all__Zxml.domrοΏ½strrοΏ½listrοΏ½tuplerrrrrr
οΏ½<module>+s
U

e5ds0οΏ½@sοΏ½ddlZddlZddlZddlmZdddgZGddοΏ½dοΏ½ZGddοΏ½dοΏ½Zd	d
οΏ½Z	GddοΏ½de
οΏ½ZGddοΏ½de
οΏ½ZGd
dοΏ½dοΏ½Z
[GddοΏ½dοΏ½ZGddοΏ½dοΏ½ZdS)οΏ½N)οΏ½
NodeFilterοΏ½
DOMBuilderοΏ½DOMEntityResolverοΏ½DOMInputSourcec@sXeZdZdZdZdZdZdZdZdZ	dZ
dZdZdZ
dZdZdZdZdZdZdZdZdS)οΏ½OptionsοΏ½TFN)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½
namespacesοΏ½namespace_declarationsοΏ½
validationοΏ½external_parameter_entitiesοΏ½external_general_entitiesZexternal_dtd_subsetοΏ½validate_if_schemaZvalidateοΏ½datatype_normalizationοΏ½create_entity_ref_nodesοΏ½entitiesοΏ½whitespace_in_element_contentοΏ½cdata_sectionsοΏ½commentsοΏ½charset_overrides_xml_encodingοΏ½infosetοΏ½supported_mediatypes_onlyοΏ½errorHandlerοΏ½filterοΏ½rrοΏ½*/usr/lib64/python3.8/xml/dom/xmlbuilder.pyr
s&
rc@s&eZdZdZdZdZdZdZdZdZ	eeee	fZ
ddοΏ½Zdd	οΏ½Zd
dοΏ½Z
dd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zdgdgdgdgdgdgd gd!gd"gd#gd"d$gd%gd&gd'gd(gd)gd*gd+gd,gd-ggdd!d"d$d(d.d'd+d-g	d/gd0gd1gd2οΏ½Zd3d4οΏ½Zd5d6οΏ½Zd7d8οΏ½Zd9d:οΏ½Zd;d<οΏ½ZdS)=rNrοΏ½οΏ½οΏ½cCstοΏ½|_dSοΏ½N)rοΏ½_optionsοΏ½οΏ½selfrrrοΏ½__init__:szDOMBuilder.__init__cCs|jSr!οΏ½οΏ½entityResolverr#rrrοΏ½_get_entityResolver=szDOMBuilder._get_entityResolvercCs
||_dSr!r&)r$r'rrrοΏ½_set_entityResolver?szDOMBuilder._set_entityResolvercCs|jSr!οΏ½rr#rrrοΏ½_get_errorHandlerBszDOMBuilder._get_errorHandlercCs
||_dSr!r*)r$rrrrοΏ½_set_errorHandlerDszDOMBuilder._set_errorHandlercCs|jSr!οΏ½rr#rrrοΏ½_get_filterGszDOMBuilder._get_filtercCs
||_dSr!r-)r$rrrrοΏ½_set_filterIszDOMBuilder._set_filtercCsοΏ½|οΏ½|οΏ½rt|rdpd}z|jt|οΏ½|f}Wn(tk
rTtjοΏ½d|fοΏ½dοΏ½YqοΏ½X|D]\}}t|j||οΏ½qZntjοΏ½	dt
|οΏ½οΏ½οΏ½dS)Nrrzunsupported feature: %rzunknown feature: )οΏ½supportsFeatureοΏ½	_settingsοΏ½_name_xformοΏ½KeyErrorοΏ½xmlοΏ½domοΏ½NotSupportedErrοΏ½setattrr"οΏ½NotFoundErrοΏ½repr)r$οΏ½nameοΏ½stateZsettingsοΏ½valuerrrοΏ½
setFeatureLs
οΏ½οΏ½zDOMBuilder.setFeaturecCst|jt|οΏ½οΏ½Sr!)οΏ½hasattrr"r2)r$r:rrrr0ZszDOMBuilder.supportsFeaturecCst|οΏ½|rdpdf}||jkS)Nrr)r2r1)r$r:r;οΏ½keyrrrοΏ½
canSetFeature]szDOMBuilder.canSetFeatureοΏ½rrοΏ½rrοΏ½r
rοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rr)rrοΏ½rrοΏ½rrοΏ½rr)rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrT)rr)rrrUrVrWcCsοΏ½t|οΏ½}zt|j|οΏ½WStk
rοΏ½|dkrp|j}|joj|joj|joj|joj|jph|j	ph|j
ph|jph|jYSt
jοΏ½dt|οΏ½οΏ½οΏ½YnXdS)Nrzfeature %s not known)r2οΏ½getattrr"οΏ½AttributeErrorrrrrrrrrrr4r5r8r9)r$r:ZxnameοΏ½optionsrrrοΏ½
getFeatureοΏ½s0οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½	zDOMBuilder.getFeaturecCs.|jr|jοΏ½d|οΏ½}ntοΏ½οΏ½d|οΏ½}|οΏ½|οΏ½Sr!)r'οΏ½
resolveEntityrοΏ½parse)r$οΏ½uriοΏ½inputrrrοΏ½parseURIοΏ½szDOMBuilder.parseURIcCsRtοΏ½|jοΏ½}|j|_|j|_|j}|dkrF|jrFddl}|jοΏ½|jοΏ½}|οΏ½	||οΏ½SοΏ½Nr)
οΏ½copyr"rrοΏ½
byteStreamοΏ½systemIdοΏ½urllib.requestοΏ½requestZurlopenοΏ½_parse_bytestream)r$r_rZοΏ½fpοΏ½urllibrrrr]οΏ½szDOMBuilder.parsecCs||jkrtdοΏ½οΏ½tdοΏ½οΏ½dS)Nznot a legal actionzHaven't written this yet...)οΏ½_legal_actionsοΏ½
ValueErrorοΏ½NotImplementedError)r$r_ZcnodeοΏ½actionrrrοΏ½parseWithContextοΏ½s
zDOMBuilder.parseWithContextcCs ddl}|jjοΏ½|οΏ½}|οΏ½|οΏ½Sra)Zxml.dom.expatbuilderr5ZexpatbuilderZmakeBuilderZ	parseFile)r$οΏ½streamrZr4ZbuilderrrrrgοΏ½szDOMBuilder._parse_bytestream)rr	r
r'rrZACTION_REPLACEZACTION_APPEND_AS_CHILDRENZACTION_INSERT_AFTERZACTION_INSERT_BEFORErjr%r(r)r+r,r.r/r=r0r@r1r[r`r]rnrgrrrrr-sοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½=
cCs|οΏ½οΏ½οΏ½ddοΏ½S)NοΏ½-οΏ½_)οΏ½lowerοΏ½replace)r:rrrr2οΏ½sr2c@s0eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
S)r)οΏ½_openerc
CsοΏ½tοΏ½}||_||_|οΏ½οΏ½οΏ½|οΏ½|_|οΏ½|οΏ½|_ddl}ddl	}|j
οΏ½|οΏ½}|\}}}	}
}}|	rοΏ½|	οΏ½dοΏ½sοΏ½|οΏ½
|	οΏ½d}	|||	|
||f}|j
οΏ½|οΏ½|_|S)NrοΏ½/)rοΏ½publicIdrdοΏ½_get_openerοΏ½openrcοΏ½_guess_media_encodingοΏ½encodingοΏ½	posixpathZurllib.parser]ZurlparseοΏ½endswithοΏ½dirnameZ
urlunparseοΏ½baseURI)
r$rvrdοΏ½sourcer{riοΏ½partsZschemeZnetlocοΏ½pathZparamsZqueryZfragmentrrrr\οΏ½szDOMEntityResolver.resolveEntitycCs2z|jWStk
r,|οΏ½οΏ½|_|jYSXdSr!)rtrYοΏ½_create_openerr#rrrrwοΏ½s

zDOMEntityResolver._get_openercCsddl}|jοΏ½οΏ½Sra)rerfZbuild_opener)r$rirrrrοΏ½οΏ½sz DOMEntityResolver._create_openercCsF|jοΏ½οΏ½}d|krB|οΏ½οΏ½D]&}|οΏ½dοΏ½r|οΏ½ddοΏ½dοΏ½οΏ½SqdS)NzContent-Typezcharset=οΏ½=r)rcοΏ½infoZgetplistοΏ½
startswithοΏ½splitrr)r$rrοΏ½ZparamrrrryοΏ½s


z'DOMEntityResolver._guess_media_encodingN)rr	r
οΏ½	__slots__r\rwrοΏ½ryrrrrrοΏ½s
c@sοΏ½eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd S)!rοΏ½rcοΏ½characterStreamοΏ½
stringDatarzrvrdr~cCs.d|_d|_d|_d|_d|_d|_d|_dSr!rοΏ½r#rrrr%szDOMInputSource.__init__cCs|jSr!οΏ½rcr#rrrοΏ½_get_byteStreamszDOMInputSource._get_byteStreamcCs
||_dSr!rοΏ½)r$rcrrrοΏ½_set_byteStreamszDOMInputSource._set_byteStreamcCs|jSr!οΏ½rοΏ½r#rrrοΏ½_get_characterStreamsz#DOMInputSource._get_characterStreamcCs
||_dSr!rοΏ½)r$rοΏ½rrrοΏ½_set_characterStreamsz#DOMInputSource._set_characterStreamcCs|jSr!οΏ½rοΏ½r#rrrοΏ½_get_stringDataszDOMInputSource._get_stringDatacCs
||_dSr!rοΏ½)r$οΏ½datarrrοΏ½_set_stringDataszDOMInputSource._set_stringDatacCs|jSr!οΏ½rzr#rrrοΏ½
_get_encodingszDOMInputSource._get_encodingcCs
||_dSr!rοΏ½)r$rzrrrοΏ½
_set_encodingszDOMInputSource._set_encodingcCs|jSr!οΏ½rvr#rrrοΏ½
_get_publicId"szDOMInputSource._get_publicIdcCs
||_dSr!rοΏ½)r$rvrrrοΏ½
_set_publicId$szDOMInputSource._set_publicIdcCs|jSr!οΏ½rdr#rrrοΏ½
_get_systemId'szDOMInputSource._get_systemIdcCs
||_dSr!rοΏ½)r$rdrrrοΏ½
_set_systemId)szDOMInputSource._set_systemIdcCs|jSr!οΏ½r~r#rrrοΏ½_get_baseURI,szDOMInputSource._get_baseURIcCs
||_dSr!rοΏ½οΏ½r$r^rrrοΏ½_set_baseURI.szDOMInputSource._set_baseURIN)rr	r
rοΏ½r%rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrrs 	c@s:eZdZdZdZdZdZejZ	ddοΏ½Z
ddοΏ½Zd	d
οΏ½ZdS)οΏ½DOMBuilderFilterrrrr cCs|jSr!)οΏ½
whatToShowr#rrrοΏ½_get_whatToShowCsz DOMBuilderFilter._get_whatToShowcCs|jSr!οΏ½οΏ½
FILTER_ACCEPTοΏ½r$ZelementrrrοΏ½
acceptNodeFszDOMBuilderFilter.acceptNodecCs|jSr!rοΏ½rοΏ½rrrοΏ½startContainerIszDOMBuilderFilter.startContainerN)
rr	r
rοΏ½Z
FILTER_REJECTZFILTER_SKIPZFILTER_INTERRUPTrZSHOW_ALLrοΏ½rοΏ½rοΏ½rοΏ½rrrrrοΏ½2s
rοΏ½c@s@eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½Z	dS)οΏ½
DocumentLSFcCsdS)NFrr#rrrοΏ½
_get_asyncTszDocumentLS._get_asynccCs|rtjοΏ½dοΏ½οΏ½dS)Nz.asynchronous document loading is not supported)r4r5r6)r$οΏ½flagrrrοΏ½
_set_asyncWsοΏ½zDocumentLS._set_asynccCstdοΏ½οΏ½dS)Nz'haven't figured out what this means yetοΏ½rlr#rrrοΏ½abort\sοΏ½zDocumentLS.abortcCstdοΏ½οΏ½dSοΏ½Nzhaven't written this yetrοΏ½rοΏ½rrrοΏ½loadbszDocumentLS.loadcCstdοΏ½οΏ½dSrοΏ½rοΏ½)r$rrrrοΏ½loadXMLeszDocumentLS.loadXMLcCs*|dkr|}n|j|k	r"tjοΏ½οΏ½οΏ½|οΏ½οΏ½Sr!)Z
ownerDocumentr4r5ZWrongDocumentErrZtoxml)r$ZsnoderrrοΏ½saveXMLhs


zDocumentLS.saveXMLN)
rr	r
Zasync_rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrrοΏ½OsrοΏ½c@s,eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	S)
οΏ½DOMImplementationLSrrcCsF|dk	rtjοΏ½dοΏ½οΏ½||jkr$tοΏ½S||jkr:tjοΏ½dοΏ½οΏ½tdοΏ½οΏ½dS)NzschemaType not yet supportedz'asynchronous builders are not supportedzunknown value for mode)r4r5r6οΏ½MODE_SYNCHRONOUSrοΏ½MODE_ASYNCHRONOUSrk)r$οΏ½modeZ
schemaTyperrrοΏ½createDOMBuildertsοΏ½

οΏ½z$DOMImplementationLS.createDOMBuildercCstdοΏ½οΏ½dS)Nz-the writer interface hasn't been written yet!rοΏ½r#rrrοΏ½createDOMWritersοΏ½z#DOMImplementationLS.createDOMWritercCstοΏ½Sr!)rr#rrrοΏ½createDOMInputSourceοΏ½sz(DOMImplementationLS.createDOMInputSourceN)rr	r
rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrrοΏ½ps
rοΏ½)rbοΏ½warningsZxml.domr4Zxml.dom.NodeFilterrοΏ½__all__rrr2οΏ½objectrrrοΏ½rοΏ½rοΏ½rrrrοΏ½<module>s
 %,1!U

e5ds0οΏ½@sοΏ½dZddlZddlZddlZddlmZdddgZGddοΏ½dοΏ½ZGd	dοΏ½dοΏ½Z	d
dοΏ½Z
GddοΏ½deοΏ½ZGd
dοΏ½deοΏ½Z
GddοΏ½dοΏ½Z[GddοΏ½dοΏ½ZGddοΏ½dοΏ½ZdS)z4Implementation of the DOM Level 3 'LS-Load' feature.οΏ½N)οΏ½
NodeFilterοΏ½
DOMBuilderοΏ½DOMEntityResolverοΏ½DOMInputSourcec@s\eZdZdZdZdZdZdZdZdZ	dZ
dZdZdZ
dZdZdZdZdZdZdZdZdZdS)οΏ½OptionszοΏ½Features object that has variables set for each DOMBuilder feature.

    The DOMBuilder class uses an instance of this class to pass settings to
    the ExpatBuilder class.
    οΏ½TFN)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½__doc__οΏ½
namespacesοΏ½namespace_declarationsοΏ½
validationοΏ½external_parameter_entitiesοΏ½external_general_entitiesZexternal_dtd_subsetοΏ½validate_if_schemaZvalidateοΏ½datatype_normalizationοΏ½create_entity_ref_nodesοΏ½entitiesοΏ½whitespace_in_element_contentοΏ½cdata_sectionsοΏ½commentsοΏ½charset_overrides_xml_encodingοΏ½infosetοΏ½supported_mediatypes_onlyοΏ½errorHandlerοΏ½filterοΏ½rrοΏ½*/usr/lib64/python3.8/xml/dom/xmlbuilder.pyr
s(	rc@s&eZdZdZdZdZdZdZdZdZ	eeee	fZ
ddοΏ½Zdd	οΏ½Zd
dοΏ½Z
dd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zdgdgdgdgdgdgd gd!gd"gd#gd"d$gd%gd&gd'gd(gd)gd*gd+gd,gd-ggdd!d"d$d(d.d'd+d-g	d/gd0gd1gd2οΏ½Zd3d4οΏ½Zd5d6οΏ½Zd7d8οΏ½Zd9d:οΏ½Zd;d<οΏ½ZdS)=rNrοΏ½οΏ½οΏ½cCstοΏ½|_dSοΏ½N)rοΏ½_optionsοΏ½οΏ½selfrrrοΏ½__init__:szDOMBuilder.__init__cCs|jSr"οΏ½οΏ½entityResolverr$rrrοΏ½_get_entityResolver=szDOMBuilder._get_entityResolvercCs
||_dSr"r')r%r(rrrοΏ½_set_entityResolver?szDOMBuilder._set_entityResolvercCs|jSr"οΏ½rr$rrrοΏ½_get_errorHandlerBszDOMBuilder._get_errorHandlercCs
||_dSr"r+)r%rrrrοΏ½_set_errorHandlerDszDOMBuilder._set_errorHandlercCs|jSr"οΏ½rr$rrrοΏ½_get_filterGszDOMBuilder._get_filtercCs
||_dSr"r.)r%rrrrοΏ½_set_filterIszDOMBuilder._set_filtercCsοΏ½|οΏ½|οΏ½rt|rdpd}z|jt|οΏ½|f}Wn(tk
rTtjοΏ½d|fοΏ½dοΏ½YqοΏ½X|D]\}}t|j||οΏ½qZntjοΏ½	dt
|οΏ½οΏ½οΏ½dS)Nrrzunsupported feature: %rzunknown feature: )οΏ½supportsFeatureοΏ½	_settingsοΏ½_name_xformοΏ½KeyErrorοΏ½xmlοΏ½domοΏ½NotSupportedErrοΏ½setattrr#οΏ½NotFoundErrοΏ½repr)r%οΏ½nameοΏ½stateZsettingsοΏ½valuerrrοΏ½
setFeatureLs
οΏ½οΏ½zDOMBuilder.setFeaturecCst|jt|οΏ½οΏ½Sr")οΏ½hasattrr#r3)r%r;rrrr1ZszDOMBuilder.supportsFeaturecCst|οΏ½|rdpdf}||jkS)Nrr)r3r2)r%r;r<οΏ½keyrrrοΏ½
canSetFeature]szDOMBuilder.canSetFeatureοΏ½r
rοΏ½r
rοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rrοΏ½rr)rrοΏ½rrοΏ½rrοΏ½rr)rBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrU)rr)rrrVrWrXcCsοΏ½t|οΏ½}zt|j|οΏ½WStk
rοΏ½|dkrp|j}|joj|joj|joj|joj|jph|j	ph|j
ph|jph|jYSt
jοΏ½dt|οΏ½οΏ½οΏ½YnXdS)Nrzfeature %s not known)r3οΏ½getattrr#οΏ½AttributeErrorrrrrr
rrrrr5r6r9r:)r%r;ZxnameοΏ½optionsrrrοΏ½
getFeatureοΏ½s0οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½	zDOMBuilder.getFeaturecCs.|jr|jοΏ½d|οΏ½}ntοΏ½οΏ½d|οΏ½}|οΏ½|οΏ½Sr")r(οΏ½
resolveEntityrοΏ½parse)r%οΏ½uriοΏ½inputrrrοΏ½parseURIοΏ½szDOMBuilder.parseURIcCsRtοΏ½|jοΏ½}|j|_|j|_|j}|dkrF|jrFddl}|jοΏ½|jοΏ½}|οΏ½	||οΏ½SοΏ½Nr)
οΏ½copyr#rrοΏ½
byteStreamοΏ½systemIdοΏ½urllib.requestοΏ½requestZurlopenοΏ½_parse_bytestream)r%r`r[οΏ½fpοΏ½urllibrrrr^οΏ½szDOMBuilder.parsecCs||jkrtdοΏ½οΏ½tdοΏ½οΏ½dS)Nznot a legal actionzHaven't written this yet...)οΏ½_legal_actionsοΏ½
ValueErrorοΏ½NotImplementedError)r%r`ZcnodeοΏ½actionrrrοΏ½parseWithContextοΏ½s
zDOMBuilder.parseWithContextcCs ddl}|jjοΏ½|οΏ½}|οΏ½|οΏ½Srb)Zxml.dom.expatbuilderr6ZexpatbuilderZmakeBuilderZ	parseFile)r%οΏ½streamr[r5ZbuilderrrrrhοΏ½szDOMBuilder._parse_bytestream)rr	r
r(rrZACTION_REPLACEZACTION_APPEND_AS_CHILDRENZACTION_INSERT_AFTERZACTION_INSERT_BEFORErkr&r)r*r,r-r/r0r>r1rAr2r\rar^rorhrrrrr-sοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½=
cCs|οΏ½οΏ½οΏ½ddοΏ½S)NοΏ½-οΏ½_)οΏ½lowerοΏ½replace)r;rrrr3οΏ½sr3c@s0eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
S)r)οΏ½_openerc
CsοΏ½|dk	stοΏ½tοΏ½}||_||_|οΏ½οΏ½οΏ½|οΏ½|_|οΏ½|οΏ½|_ddl	}ddl
}|jοΏ½|οΏ½}|\}}}	}
}}|	rοΏ½|	οΏ½
dοΏ½sοΏ½|οΏ½|	οΏ½d}	|||	|
||f}|jοΏ½|οΏ½|_|S)NrοΏ½/)οΏ½AssertionErrorrοΏ½publicIdreοΏ½_get_openerοΏ½openrdοΏ½_guess_media_encodingοΏ½encodingοΏ½	posixpathZurllib.parser^ZurlparseοΏ½endswithοΏ½dirnameZ
urlunparseοΏ½baseURI)
r%rxreοΏ½sourcer}rjοΏ½partsZschemeZnetlocοΏ½pathZparamsZqueryZfragmentrrrr]οΏ½szDOMEntityResolver.resolveEntitycCs2z|jWStk
r,|οΏ½οΏ½|_|jYSXdSr")rurZοΏ½_create_openerr$rrrryοΏ½s

zDOMEntityResolver._get_openercCsddl}|jοΏ½οΏ½Srb)rfrgZbuild_opener)r%rjrrrrοΏ½οΏ½sz DOMEntityResolver._create_openercCsF|jοΏ½οΏ½}d|krB|οΏ½οΏ½D]&}|οΏ½dοΏ½r|οΏ½ddοΏ½dοΏ½οΏ½SqdS)NzContent-Typezcharset=οΏ½=r)rdοΏ½infoZgetplistοΏ½
startswithοΏ½splitrs)r%rοΏ½rοΏ½Zparamrrrr{οΏ½s


z'DOMEntityResolver._guess_media_encodingN)rr	r
οΏ½	__slots__r]ryrοΏ½r{rrrrrοΏ½s
c@sοΏ½eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd S)!rοΏ½rdοΏ½characterStreamοΏ½
stringDatar|rxrerοΏ½cCs.d|_d|_d|_d|_d|_d|_d|_dSr"rοΏ½r$rrrr&szDOMInputSource.__init__cCs|jSr"οΏ½rdr$rrrοΏ½_get_byteStreamszDOMInputSource._get_byteStreamcCs
||_dSr"rοΏ½)r%rdrrrοΏ½_set_byteStreamszDOMInputSource._set_byteStreamcCs|jSr"οΏ½rοΏ½r$rrrοΏ½_get_characterStreamsz#DOMInputSource._get_characterStreamcCs
||_dSr"rοΏ½)r%rοΏ½rrrοΏ½_set_characterStreamsz#DOMInputSource._set_characterStreamcCs|jSr"οΏ½rοΏ½r$rrrοΏ½_get_stringDataszDOMInputSource._get_stringDatacCs
||_dSr"rοΏ½)r%οΏ½datarrrοΏ½_set_stringDataszDOMInputSource._set_stringDatacCs|jSr"οΏ½r|r$rrrοΏ½
_get_encodingszDOMInputSource._get_encodingcCs
||_dSr"rοΏ½)r%r|rrrοΏ½
_set_encodingszDOMInputSource._set_encodingcCs|jSr"οΏ½rxr$rrrοΏ½
_get_publicId"szDOMInputSource._get_publicIdcCs
||_dSr"rοΏ½)r%rxrrrοΏ½
_set_publicId$szDOMInputSource._set_publicIdcCs|jSr"οΏ½rer$rrrοΏ½
_get_systemId'szDOMInputSource._get_systemIdcCs
||_dSr"rοΏ½)r%rerrrοΏ½
_set_systemId)szDOMInputSource._set_systemIdcCs|jSr"οΏ½rοΏ½r$rrrοΏ½_get_baseURI,szDOMInputSource._get_baseURIcCs
||_dSr"rοΏ½οΏ½r%r_rrrοΏ½_set_baseURI.szDOMInputSource._set_baseURIN)rr	r
rοΏ½r&rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrrs 	c@s>eZdZdZdZdZdZdZej	Z
ddοΏ½Zdd	οΏ½Zd
dοΏ½Z
dS)
οΏ½DOMBuilderFilterzSElement filter which can be used to tailor construction of
    a DOM instance.
    rrr r!cCs|jSr")οΏ½
whatToShowr$rrrοΏ½_get_whatToShowCsz DOMBuilderFilter._get_whatToShowcCs|jSr"οΏ½οΏ½
FILTER_ACCEPTοΏ½r%ZelementrrrοΏ½
acceptNodeFszDOMBuilderFilter.acceptNodecCs|jSr"rοΏ½rοΏ½rrrοΏ½startContainerIszDOMBuilderFilter.startContainerN)rr	r
rrοΏ½Z
FILTER_REJECTZFILTER_SKIPZFILTER_INTERRUPTrZSHOW_ALLrοΏ½rοΏ½rοΏ½rοΏ½rrrrrοΏ½2s	rοΏ½c@sDeZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Z	d
dοΏ½Z
dS)οΏ½
DocumentLSz=Mixin to create documents that conform to the load/save spec.FcCsdS)NFrr$rrrοΏ½
_get_asyncTszDocumentLS._get_asynccCs|rtjοΏ½dοΏ½οΏ½dS)Nz.asynchronous document loading is not supported)r5r6r7)r%οΏ½flagrrrοΏ½
_set_asyncWsοΏ½zDocumentLS._set_asynccCstdοΏ½οΏ½dS)Nz'haven't figured out what this means yetοΏ½rmr$rrrοΏ½abort\sοΏ½zDocumentLS.abortcCstdοΏ½οΏ½dSοΏ½Nzhaven't written this yetrοΏ½rοΏ½rrrοΏ½loadbszDocumentLS.loadcCstdοΏ½οΏ½dSrοΏ½rοΏ½)r%rοΏ½rrrοΏ½loadXMLeszDocumentLS.loadXMLcCs*|dkr|}n|j|k	r"tjοΏ½οΏ½οΏ½|οΏ½οΏ½Sr")Z
ownerDocumentr5r6ZWrongDocumentErrZtoxml)r%ZsnoderrrοΏ½saveXMLhs


zDocumentLS.saveXMLN)rr	r
rZasync_rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrrοΏ½OsrοΏ½c@s,eZdZdZdZddοΏ½ZddοΏ½ZddοΏ½Zd	S)
οΏ½DOMImplementationLSrrcCsF|dk	rtjοΏ½dοΏ½οΏ½||jkr$tοΏ½S||jkr:tjοΏ½dοΏ½οΏ½tdοΏ½οΏ½dS)NzschemaType not yet supportedz'asynchronous builders are not supportedzunknown value for mode)r5r6r7οΏ½MODE_SYNCHRONOUSrοΏ½MODE_ASYNCHRONOUSrl)r%οΏ½modeZ
schemaTyperrrοΏ½createDOMBuildertsοΏ½

οΏ½z$DOMImplementationLS.createDOMBuildercCstdοΏ½οΏ½dS)Nz-the writer interface hasn't been written yet!rοΏ½r$rrrοΏ½createDOMWritersοΏ½z#DOMImplementationLS.createDOMWritercCstοΏ½Sr")rr$rrrοΏ½createDOMInputSourceοΏ½sz(DOMImplementationLS.createDOMInputSourceN)rr	r
rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrrοΏ½ps
rοΏ½)rrcοΏ½warningsZxml.domr5Zxml.dom.NodeFilterrοΏ½__all__rrr3οΏ½objectrrrοΏ½rοΏ½rοΏ½rrrrοΏ½<module>s
 %,1!U

e5dοΏ½.οΏ½@sοΏ½ddlZddlZdZdZdZdZdZdZdZ	d	Z
Gd
dοΏ½dejjοΏ½Z
Gdd
οΏ½d
οΏ½ZGddοΏ½dοΏ½ZGddοΏ½de
οΏ½ZdZdddοΏ½ZdddοΏ½ZdS)οΏ½NοΏ½
START_ELEMENTοΏ½END_ELEMENTοΏ½COMMENTοΏ½START_DOCUMENTοΏ½END_DOCUMENTοΏ½PROCESSING_INSTRUCTIONοΏ½IGNORABLE_WHITESPACEοΏ½
CHARACTERSc@sοΏ½eZdZdZdZd$ddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Z	dd
οΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd d!οΏ½Zd"d#οΏ½ZdS)%οΏ½PullDOMNcCszddlm}||_ddg|_|j|_g|_|jj|_z|jj|_Wnt	k
rVYnX|dig|_
|j
d|_g|_dS)Nr)οΏ½
XML_NAMESPACEοΏ½xmlοΏ½οΏ½οΏ½)
Zxml.domrοΏ½documentFactoryοΏ½
firstEventοΏ½	lastEventοΏ½elementStackοΏ½appendοΏ½pushοΏ½popοΏ½AttributeErrorοΏ½_ns_contextsοΏ½_current_contextοΏ½pending_events)οΏ½selfrrοΏ½rοΏ½'/usr/lib64/python3.8/xml/dom/pulldom.pyοΏ½__init__s

zPullDOM.__init__cCs|jd}|jd=|SοΏ½Nr
)r)rοΏ½resultrrrr!s
zPullDOM.popcCs
||_dSοΏ½N)οΏ½_locator)rZlocatorrrrοΏ½setDocumentLocator&szPullDOM.setDocumentLocatorcCsHt|dοΏ½sg|_|jοΏ½|pd|fοΏ½|jοΏ½|jοΏ½οΏ½οΏ½|p<d|j|<dS)NοΏ½_xmlns_attrsοΏ½xmlns)οΏ½hasattrr"rrrοΏ½copy)rοΏ½prefixοΏ½urirrrοΏ½startPrefixMapping)s

zPullDOM.startPrefixMappingcCs|jοΏ½οΏ½|_dSr)rrr)rr&rrrοΏ½endPrefixMapping0szPullDOM.endPrefixMappingcCsοΏ½d}t|ddοΏ½}|dk	r:|D]\}}||j||f<qg|_|\}}	|rοΏ½|dkrn|j|}
|
rj|
d|	}n|	}|jrοΏ½|jοΏ½||οΏ½}qοΏ½|οΏ½||οΏ½}n |jrοΏ½|jοΏ½|	οΏ½}n|οΏ½d|	οΏ½}|οΏ½οΏ½D]οΏ½\}}|\}}
||kοΏ½r|
dkrοΏ½|
}nd|
}|jοΏ½	||οΏ½}|οΏ½
|οΏ½nX|οΏ½rF|j|}
|
οΏ½r(|
d|
}n|
}|jοΏ½	||οΏ½}|οΏ½
|οΏ½n|jοΏ½|
οΏ½}|οΏ½|οΏ½||_
qοΏ½t|fdg|jd<|jd|_|οΏ½|οΏ½dS)Nzhttp://www.w3.org/2000/xmlns/r"οΏ½:r#zxmlns:οΏ½)οΏ½getattrοΏ½_attrsr"rοΏ½documentZcreateElementNSοΏ½
buildDocumentοΏ½
createElementοΏ½itemsZcreateAttributeNSZsetAttributeNodeNSοΏ½createAttributeοΏ½setAttributeNodeοΏ½valuerrr)rοΏ½nameοΏ½tagNameοΏ½attrsZ	xmlns_uriZxmlns_attrsοΏ½anamer4r'Z	localnamer&οΏ½nodeZa_uriZa_localnameZqnameοΏ½attrrrrοΏ½startElementNS3sP



zPullDOM.startElementNScCs&t|οΏ½οΏ½fdg|jd<|jd|_dSοΏ½Nr+οΏ½rrr)rr5r6rrrοΏ½endElementNSlszPullDOM.endElementNScCsz|jr|jοΏ½|οΏ½}n|οΏ½d|οΏ½}|οΏ½οΏ½D]$\}}|jοΏ½|οΏ½}||_|οΏ½|οΏ½q(t|fdg|jd<|jd|_|οΏ½	|οΏ½dSr<)
r.r0r/r1r2r4r3rrr)rr5r7r9r8r4r:rrrοΏ½startElementpszPullDOM.startElementcCs&t|οΏ½οΏ½fdg|jd<|jd|_dSr<r=)rr5rrrοΏ½
endElementszPullDOM.endElementcCsN|jr2|jοΏ½|οΏ½}t|fdg|jd<|jd|_nt|fdg}|jοΏ½|οΏ½dSr<)r.οΏ½
createCommentrrrr)rοΏ½sr9οΏ½eventrrrοΏ½commentοΏ½szPullDOM.commentcCsR|jr4|jοΏ½||οΏ½}t|fdg|jd<|jd|_nt||fdg}|jοΏ½|οΏ½dSr<)r.οΏ½createProcessingInstructionrrrr)rοΏ½targetοΏ½datar9rCrrrοΏ½processingInstructionοΏ½szPullDOM.processingInstructioncCs.|jοΏ½|οΏ½}t|fdg|jd<|jd|_dSr<)r.οΏ½createTextNoderrοΏ½rοΏ½charsr9rrrοΏ½ignorableWhitespaceοΏ½szPullDOM.ignorableWhitespacecCs.|jοΏ½|οΏ½}t|fdg|jd<|jd|_dSr<)r.rIr	rrJrrrοΏ½
charactersοΏ½szPullDOM.characterscCs$|jdkr ddl}|jjjj|_dS)Nr)rZxml.dom.minidomZdomZminidomZDocumentοΏ½implementation)rrrrrοΏ½
startDocumentοΏ½s
zPullDOM.startDocumentc	CsοΏ½|jοΏ½||dοΏ½}||_t|fdg|jd<|jd|_|οΏ½|οΏ½|jD]οΏ½}|ddtkrοΏ½|d\}}}|jοΏ½||οΏ½}t|f|d<nD|ddt	krοΏ½|jοΏ½
|ddοΏ½}t	|f|d<ntd|ddοΏ½οΏ½||jd<||_qDd|_|jS)Nr+rzUnknown pending event )
rZcreateDocumentr.rrrrrrErrAοΏ½AssertionErrorZ
firstChild)	rr'Ztagnamer9οΏ½eοΏ½_rFrGοΏ½nrrrr/οΏ½s$


zPullDOM.buildDocumentcCs t|jfdg|jd<|οΏ½οΏ½dSr<)rr.rrοΏ½rrrrοΏ½endDocumentοΏ½szPullDOM.endDocumentcCs
d|_dS)z.clear(): Explicitly release parsing structuresN)r.rTrrrοΏ½clearοΏ½sz
PullDOM.clear)N)οΏ½__name__οΏ½
__module__οΏ½__qualname__r r.rrr!r(r)r;r>r?r@rDrHrLrMrOr/rUrVrrrrr

s&
9		r
c@s$eZdZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½ErrorHandlercCst|οΏ½dSr)οΏ½printοΏ½rZ	exceptionrrrοΏ½warningοΏ½szErrorHandler.warningcCs|οΏ½dSrrr\rrrοΏ½errorοΏ½szErrorHandler.errorcCs|οΏ½dSrrr\rrrοΏ½
fatalErrorοΏ½szErrorHandler.fatalErrorN)rWrXrYr]r^r_rrrrrZοΏ½srZc@s\eZdZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZdS)οΏ½DOMEventStreamcCs2||_||_||_t|jdοΏ½s&|j|_|οΏ½οΏ½dS)NοΏ½feed)οΏ½streamοΏ½parserοΏ½bufsizer$οΏ½_slurpοΏ½getEventοΏ½reset)rrbrcrdrrrrοΏ½szDOMEventStream.__init__cCs.tοΏ½|_|jοΏ½tjjjdοΏ½|jοΏ½|jοΏ½dSr<)	r
οΏ½pulldomrcZ
setFeaturerοΏ½saxZhandlerZfeature_namespacesZsetContentHandlerrTrrrrgοΏ½szDOMEventStream.resetcCs0ddl}|jdtddοΏ½|οΏ½οΏ½}|r(|StοΏ½dS)Nrz[DOMEventStream's __getitem__ method ignores 'pos' parameter. Use iterator protocol instead.οΏ½)οΏ½
stacklevel)οΏ½warningsοΏ½warnοΏ½DeprecationWarningrfοΏ½
IndexError)rοΏ½posrlοΏ½rcrrrοΏ½__getitem__οΏ½sοΏ½zDOMEventStream.__getitem__cCs|οΏ½οΏ½}|r|StοΏ½dSr)rfοΏ½
StopIterationοΏ½rrqrrrοΏ½__next__οΏ½szDOMEventStream.__next__cCs|SrrrTrrrοΏ½__iter__οΏ½szDOMEventStream.__iter__cCsl|οΏ½οΏ½}|g}|rh|\}}||kr&dS|tkr<|dοΏ½|οΏ½|tkrP|οΏ½|οΏ½n|tkr^|d=|οΏ½οΏ½}qdSr)rfrοΏ½appendChildrr)rr9rCοΏ½parentsοΏ½tokenZcur_noderrrοΏ½
expandNodeοΏ½szDOMEventStream.expandNodecCs~|jjds|jj|j_|jjdsR|jοΏ½|jοΏ½}|sD|jοΏ½οΏ½dS|jοΏ½|οΏ½q|jjdd}|jjdd|jjd<|S)Nr+r)	rhrrrbοΏ½readrdrcοΏ½closera)rοΏ½bufrqrrrrfs
zDOMEventStream.getEventcCs|jοΏ½|jοΏ½|j|_|οΏ½οΏ½S)zοΏ½ Fallback replacement for getEvent() using the
            standard SAX2 interface, which means we slurp the
            SAX events into memory (no performance gain, but
            we are compatible to all SAX parsers).
        )rcοΏ½parserbοΏ½_emitrfrTrrrreszDOMEventStream._slurpcCs,|jjdd}|jjdd|jjd<|S)zn Fallback replacement for getEvent() that emits
            the events that _slurp() read previously.
        r+r)rhrrtrrrrszDOMEventStream._emitcCs|jοΏ½οΏ½|`d|_d|_dS)z+clear(): Explicitly release parsing objectsN)rhrVrcrbrTrrrrV!s
zDOMEventStream.clearN)
rWrXrYrrgrrrurvrzrfrerrVrrrrr`οΏ½s

r`c@s4eZdZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZdS)οΏ½SAX2DOMcCs2tοΏ½||||οΏ½|jd}|jd}|οΏ½|οΏ½dSοΏ½Nr
οΏ½οΏ½οΏ½)r
r;rrw)rr5r6r7οΏ½curNodeοΏ½
parentNoderrrr;*s

zSAX2DOM.startElementNScCs0tοΏ½|||οΏ½|jd}|jd}|οΏ½|οΏ½dSrοΏ½)r
r?rrw)rr5r7rοΏ½rοΏ½rrrr?0s

zSAX2DOM.startElementcCs4tοΏ½|||οΏ½|jdd}|jd}|οΏ½|οΏ½dSοΏ½Nrr+r
)r
rHrrrw)rrFrGr9rοΏ½rrrrH6s
zSAX2DOM.processingInstructioncCs2tοΏ½||οΏ½|jdd}|jd}|οΏ½|οΏ½dSrοΏ½)r
rLrrrwοΏ½rrKr9rοΏ½rrrrL<s
zSAX2DOM.ignorableWhitespacecCs2tοΏ½||οΏ½|jdd}|jd}|οΏ½|οΏ½dSrοΏ½)r
rMrrrwrοΏ½rrrrMBs
zSAX2DOM.charactersN)rWrXrYr;r?rHrLrMrrrrrοΏ½(s
rοΏ½iοΏ½?cCs@|dkrt}t|tοΏ½r"t|dοΏ½}n|}|s4tjοΏ½οΏ½}t|||οΏ½S)NοΏ½rb)οΏ½default_bufsizeοΏ½
isinstanceοΏ½strοΏ½openrriοΏ½make_parserr`)Zstream_or_stringrcrdrbrrrr~Ks

r~cCs6ddlm}t|οΏ½}||οΏ½}|s*tjοΏ½οΏ½}t|||οΏ½S)Nr)οΏ½StringIO)οΏ½iorοΏ½οΏ½lenrrirοΏ½r`)οΏ½stringrcrοΏ½rdr}rrrοΏ½parseStringVs
rοΏ½)NN)N)Zxml.saxrZxml.sax.handlerrrrrrrrr	riZContentHandlerr
rZr`rοΏ½rοΏ½r~rοΏ½rrrrοΏ½<module>s"8\!
U

e5dοΏ½οΏ½@sGddοΏ½dοΏ½ZdS)c@sXeZdZdZdZdZdZdZdZdZ	dZ
dZdZd	Z
d
ZdZdZd
ZdZdZddοΏ½ZdS)οΏ½
NodeFilterzL
    This is the DOM2 NodeFilter interface. It contains only constants.
    οΏ½οΏ½οΏ½lοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½ οΏ½@οΏ½οΏ½iiicCstοΏ½dS)N)οΏ½NotImplementedError)οΏ½selfZnodeοΏ½rοΏ½*/usr/lib64/python3.8/xml/dom/NodeFilter.pyοΏ½
acceptNodeszNodeFilter.acceptNodeN)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½__doc__Z
FILTER_ACCEPTZ
FILTER_REJECTZFILTER_SKIPZSHOW_ALLZSHOW_ELEMENTZSHOW_ATTRIBUTEZ	SHOW_TEXTZSHOW_CDATA_SECTIONZSHOW_ENTITY_REFERENCEZSHOW_ENTITYZSHOW_PROCESSING_INSTRUCTIONZSHOW_COMMENTZ
SHOW_DOCUMENTZSHOW_DOCUMENT_TYPEZSHOW_DOCUMENT_FRAGMENTZ
SHOW_NOTATIONrrrrrrs$rN)rrrrrοΏ½<module>οΏ½U

e5d)οΏ½@sοΏ½ddlZddlZddlmZmZmZmZddlTddlm	Z	m
Z
ejjj
ejjjfZGddοΏ½dejjοΏ½Zeeddd	οΏ½eed
dd	οΏ½eedd
d	οΏ½ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZGddοΏ½deοΏ½ZGddοΏ½deοΏ½Zeeddd	οΏ½eeddd	οΏ½eedd d	οΏ½Gd!d"οΏ½d"eοΏ½Zeed#d$d	οΏ½eZGd%d&οΏ½d&eοΏ½ZeddοΏ½ZGd'd(οΏ½d(eοΏ½Zeed)d*d	οΏ½eedd+d	οΏ½d,d-οΏ½ZGd.d/οΏ½d/οΏ½ZGd0d1οΏ½d1eeοΏ½Z Gd2d3οΏ½d3eeοΏ½Z!ee!d#d4d	οΏ½Gd5d6οΏ½d6e!οΏ½Z"ee"d7d8d	οΏ½ee"d9d:d	οΏ½d;d<οΏ½Z#d=d>οΏ½Z$Gd?d@οΏ½d@e!οΏ½Z%GdAdBοΏ½dBe"οΏ½Z&GdCdDοΏ½dDeοΏ½Z'ee'd#dEd	οΏ½GdFdGοΏ½dGοΏ½Z(GdHdIοΏ½dIe(eeοΏ½Z)GdJdKοΏ½dKe(eοΏ½Z*GdLdMοΏ½dMe(eeοΏ½Z+GdNdOοΏ½dOe	οΏ½Z,GdPdQοΏ½dQeοΏ½Z-dRdSοΏ½Z.GdTdUοΏ½dUee
οΏ½Z/ee/dVdWd	οΏ½dXdYοΏ½Z0dZd[οΏ½Z1d\d]οΏ½Z2ddd^d_οΏ½Z3ded`daοΏ½Z4dfdbdcοΏ½Z5dS)gοΏ½N)οΏ½EMPTY_NAMESPACEοΏ½EMPTY_PREFIXοΏ½XMLNS_NAMESPACEοΏ½domreg)οΏ½*)οΏ½DOMImplementationLSοΏ½
DocumentLSc@sοΏ½eZdZdZdZdZdZdZeZ	ddοΏ½Z
d2ddοΏ½Zd3dd	οΏ½Zd
dοΏ½Z
dd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd d!οΏ½Zd"d#οΏ½Zd$d%οΏ½Zd&d'οΏ½Zd(d)οΏ½Zd*d+οΏ½Zd,d-οΏ½Zd.d/οΏ½Zd0d1οΏ½Z dS)4οΏ½NodeNcCsdS)NTοΏ½οΏ½οΏ½selfr
r
οΏ½'/usr/lib64/python3.8/xml/dom/minidom.pyοΏ½__bool__+sz
Node.__bool__cCs|οΏ½dd|οΏ½SοΏ½NοΏ½)οΏ½toprettyxml)rοΏ½encodingr
r
r
οΏ½toxml.sz
Node.toxmlοΏ½	οΏ½
cCsx|dkrtοΏ½οΏ½}ntjtοΏ½οΏ½|dddοΏ½}|jtjkrH|οΏ½|d|||οΏ½n|οΏ½|d||οΏ½|dkrh|οΏ½οΏ½S|οΏ½	οΏ½οΏ½οΏ½SdS)NοΏ½xmlcharrefreplacer)rοΏ½errorsοΏ½newliner)
οΏ½ioοΏ½StringIOοΏ½
TextIOWrapperοΏ½BytesIOοΏ½nodeTyper	οΏ½
DOCUMENT_NODEοΏ½writexmlοΏ½getvalueοΏ½detach)rοΏ½indentοΏ½newlrοΏ½writerr
r
r
r1s

οΏ½zNode.toprettyxmlcCs
t|jοΏ½SοΏ½N)οΏ½boolοΏ½
childNodesrr
r
r
οΏ½
hasChildNodesCszNode.hasChildNodescCs|jSr%οΏ½r'rr
r
r
οΏ½_get_childNodesFszNode._get_childNodescCs|jr|jdSdSοΏ½Nrr)rr
r
r
οΏ½_get_firstChildIszNode._get_firstChildcCs|jr|jdSdSοΏ½NοΏ½οΏ½οΏ½r)rr
r
r
οΏ½_get_lastChildMszNode._get_lastChildcCs
|j|jkr,t|jοΏ½D]}|οΏ½||οΏ½q|S|j|jkrTtjοΏ½dt	|οΏ½t	|οΏ½fοΏ½οΏ½|j
dk	rj|j
οΏ½|οΏ½|dkr~|οΏ½|οΏ½nοΏ½z|jοΏ½
|οΏ½}Wntk
rοΏ½tjοΏ½οΏ½οΏ½YnX|jtkrοΏ½t|οΏ½|jοΏ½||οΏ½||_||_|rοΏ½|j|d}||_||_nd|_||_
|S)NοΏ½%s cannot be child of %sοΏ½)rοΏ½DOCUMENT_FRAGMENT_NODEοΏ½tupler'οΏ½insertBeforeοΏ½_child_node_typesοΏ½xmlοΏ½domοΏ½HierarchyRequestErrοΏ½reprοΏ½
parentNodeοΏ½removeChildοΏ½appendChildοΏ½indexοΏ½
ValueErrorοΏ½NotFoundErrοΏ½_nodeTypes_with_childrenοΏ½_clear_id_cacheοΏ½insertοΏ½nextSiblingοΏ½previousSibling)rοΏ½newChildοΏ½refChildοΏ½cr=οΏ½noder
r
r
r4Qs8οΏ½

zNode.insertBeforecCsοΏ½|j|jkr*t|jοΏ½D]}|οΏ½|οΏ½q|S|j|jkrTtjοΏ½dt	|οΏ½t	|οΏ½fοΏ½οΏ½n|jt
krft|οΏ½|jdk	r||jοΏ½
|οΏ½t||οΏ½d|_|SοΏ½Nr0)rr2r3r'r<r5r6r7r8r9r@rAr:r;οΏ½
_append_childrC)rrHrGr
r
r
r<qsοΏ½


zNode.appendChildcCs|j|jkr(|j}|οΏ½|οΏ½|οΏ½||οΏ½S|j|jkrPtjοΏ½dt	|οΏ½t	|οΏ½fοΏ½οΏ½||kr\dS|j
dk	rr|j
οΏ½|οΏ½z|jοΏ½|οΏ½}Wnt
k
rοΏ½tjοΏ½οΏ½οΏ½YnX||j|<||_
d|_
|jtksοΏ½|jtkrοΏ½t|οΏ½|j|_|j|_d|_d|_|jrοΏ½||j_|jοΏ½r||j_|SrI)rr2rCr;r4r5r6r7r8r9r:r'r=r>r?r@rArD)rrEοΏ½oldChildrFr=r
r
r
οΏ½replaceChildοΏ½s@
οΏ½


οΏ½zNode.replaceChildcCsοΏ½z|jοΏ½|οΏ½Wntk
r.tjοΏ½οΏ½οΏ½YnX|jdk	rD|j|j_|jdk	rX|j|j_d|_|_|jt	krvt
|οΏ½d|_|Sr%)r'οΏ½remover>r6r7r?rCrDrr@rAr:οΏ½rrKr
r
r
r;οΏ½s




zNode.removeChildcCsοΏ½g}|jD]οΏ½}|jtjkrοΏ½|jsJ|r0|j|d_|jr@|j|j_|οΏ½οΏ½qοΏ½|rοΏ½|dj|jkrοΏ½|d}|j|j|_|j|_|jrοΏ½||j_|οΏ½οΏ½qοΏ½|οΏ½|οΏ½q
|οΏ½|οΏ½|jtj	kr
|οΏ½
οΏ½q
||jddοΏ½<dSr-)r'rr	οΏ½	TEXT_NODEοΏ½datarCrDοΏ½unlinkοΏ½appendοΏ½ELEMENT_NODEοΏ½	normalize)rοΏ½LοΏ½childrHr
r
r
rTοΏ½s*





zNode.normalizecCst|||jp|οΏ½Sr%)οΏ½_clone_nodeοΏ½
ownerDocument)rοΏ½deepr
r
r
οΏ½	cloneNodeοΏ½szNode.cloneNodecCs|jjοΏ½||οΏ½Sr%)rXοΏ½implementationοΏ½
hasFeatureοΏ½rοΏ½featureοΏ½versionr
r
r
οΏ½isSupportedοΏ½szNode.isSupportedcCsdSr%r
rr
r
r
οΏ½_get_localNameοΏ½szNode._get_localNamecCs||kSr%r
οΏ½rοΏ½otherr
r
r
οΏ½
isSameNodeοΏ½szNode.isSameNodecCs|οΏ½|dοΏ½r|SdSdSr%)r`οΏ½rr^r
r
r
οΏ½getInterfaceοΏ½szNode.getInterfacec	Cs0z|j|dWSttfk
r*YdSXdSr+)οΏ½
_user_dataοΏ½AttributeErrorοΏ½KeyErrorοΏ½rοΏ½keyr
r
r
οΏ½getUserDataοΏ½szNode.getUserDatacCsnd}z
|j}Wntk
r,i}||_YnX||krB||d}|dkr^d}|dk	rj||=n||f||<|Sr+)rgrh)rrkrPοΏ½handlerοΏ½oldοΏ½dr
r
r
οΏ½setUserDataοΏ½s
zNode.setUserDatacCsDt|dοΏ½r@t|jοΏ½οΏ½οΏ½D]&\}\}}|dk	r|οΏ½|||||οΏ½qdS)Nrg)οΏ½hasattrοΏ½listrgοΏ½itemsZhandle)rοΏ½	operationοΏ½srcZdstrkrPrmr
r
r
οΏ½_call_user_data_handlerοΏ½s
zNode._call_user_data_handlercCs>d|_|_|jr.|jD]}|οΏ½οΏ½qtοΏ½|_d|_d|_dSr%)r:rXr'rQοΏ½NodeListrDrC)rrVr
r
r
rQs

zNode.unlinkcCs|Sr%r
rr
r
r
οΏ½	__enter__szNode.__enter__cCs|οΏ½οΏ½dSr%)rQ)rZetZevοΏ½tbr
r
r
οΏ½__exit__sz
Node.__exit__)N)rrN)!οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½namespaceURIr:rXrCrDrοΏ½prefixrrrr(r*r,r/r4r<rLr;rTrZr`rardrfrlrprvrQrxrzr
r
r
r
r	"s:

  
r	οΏ½
firstChildzFirst child node, or None.)οΏ½docοΏ½	lastChildzLast child node, or None.οΏ½	localNamez"Namespace-local name of this node.cCs2|j}|r|d}||_||_|οΏ½|οΏ½||_dSr-)r'rDrCrRr:)rrHr'Zlastr
r
r
rJs
rJcCs$|dk	r |jtjkrdS|j}qdSοΏ½NTF)rr	rr:οΏ½rHr
r
r
οΏ½_in_document&s
rοΏ½cCs6|r2|οΏ½ddοΏ½οΏ½ddοΏ½οΏ½ddοΏ½οΏ½ddοΏ½}|οΏ½|οΏ½dS)	NοΏ½&z&amp;οΏ½<z&lt;οΏ½"z&quot;οΏ½>z&gt;)οΏ½replaceοΏ½write)r$rPr
r
r
οΏ½_write_data.sοΏ½οΏ½rοΏ½cCsD|jD]8}|jtjkr2|dks(|j|kr2|οΏ½|οΏ½t|||οΏ½q|SοΏ½Nr)r'rr	rSοΏ½tagNamerRοΏ½_get_elements_by_tagName_helper)οΏ½parentοΏ½nameοΏ½rcrHr
r
r
rοΏ½5s
οΏ½οΏ½
rοΏ½cCsX|jD]L}|jtjkr|dks(|j|krD|dks:|j|krD|οΏ½|οΏ½t||||οΏ½q|SrοΏ½)r'rr	rSrοΏ½r~rRοΏ½"_get_elements_by_tagName_ns_helper)rοΏ½ZnsURIrοΏ½rοΏ½rHr
r
r
rοΏ½=s
οΏ½οΏ½
rοΏ½c@sJeZdZejZdZdZdZdZ	ej
ejejej
ejejejfZddοΏ½ZdS)οΏ½DocumentFragmentz#document-fragmentNcCstοΏ½|_dSr%)rwr'rr
r
r
οΏ½__init__TszDocumentFragment.__init__)r{r|r}r	r2rοΏ½nodeNameοΏ½	nodeValueοΏ½
attributesr:rSrOοΏ½CDATA_SECTION_NODEοΏ½ENTITY_REFERENCE_NODEοΏ½PROCESSING_INSTRUCTION_NODEοΏ½COMMENT_NODEοΏ½
NOTATION_NODEr5rοΏ½r
r
r
r
rοΏ½FsοΏ½rοΏ½c@sοΏ½eZdZdZejZdZdZdZ	ej
ejfZe
ddfddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZeeeοΏ½ZZddοΏ½ZddοΏ½ZeeeοΏ½ZZddοΏ½ZddοΏ½ZeeeοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½Attr)οΏ½_nameοΏ½_valuer~οΏ½_prefixr'οΏ½
_localNamerXοΏ½ownerElementNFcCs2d|_||_||_||_tοΏ½|_|jοΏ½tοΏ½οΏ½dSr%)rοΏ½rοΏ½r~rοΏ½rwr'rRοΏ½Text)rοΏ½qNamer~rοΏ½rr
r
r
rοΏ½bsz
Attr.__init__cCs4z|jWStk
r.|jοΏ½ddοΏ½dYSXdSοΏ½NοΏ½:r1r.)rοΏ½rhrοΏ½οΏ½splitrr
r
r
raoszAttr._get_localNamecCs|jSr%)οΏ½	specifiedrr
r
r
οΏ½_get_specifieduszAttr._get_specifiedcCs|jSr%)rοΏ½rr
r
r
οΏ½	_get_namexszAttr._get_namecCs||_|jdk	rt|jοΏ½dSr%)rοΏ½rοΏ½rAοΏ½rοΏ½valuer
r
r
οΏ½	_set_name{s
zAttr._set_namecCs|jSr%)rοΏ½rr
r
r
οΏ½
_get_valueοΏ½szAttr._get_valuecCs6||_||jd_|jdk	r&t|jοΏ½||jd_dSr+)rοΏ½r'rPrοΏ½rArοΏ½r
r
r
οΏ½
_set_valueοΏ½s


zAttr._set_valuecCs|jSr%)rοΏ½rr
r
r
οΏ½_get_prefixοΏ½szAttr._get_prefixcCsd|j}|dkr&|r&|tkr&tjοΏ½dοΏ½οΏ½||_|dkr<|j}nd||jf}|jrZt|jοΏ½||_	dS)NοΏ½xmlnsz5illegal use of 'xmlns' prefix for the wrong namespacez%s:%s)
r~rr6r7οΏ½NamespaceErrrοΏ½rοΏ½rοΏ½rArοΏ½)rrZnsuriZnewNamer
r
r
οΏ½_set_prefixοΏ½sοΏ½
zAttr._set_prefixcCsv|j}|dk	rR|j|j=|j|j|jf=|jrRd|_|jd8_|jj	d8_	|j
D]}|οΏ½οΏ½qX|j
ddοΏ½=dS)NFr1)rοΏ½οΏ½_attrsrοΏ½οΏ½_attrsNSr~rοΏ½οΏ½_is_idοΏ½_magic_id_nodesrXοΏ½_magic_id_countr'rQ)rοΏ½elemrVr
r
r
rQοΏ½s


zAttr.unlinkcCsf|jr
dS|j}|j}|dks&|dkr*dS|οΏ½|οΏ½}|dkr@dS|jrV|οΏ½|j|jοΏ½S|οΏ½|jοΏ½SdSrοΏ½)	rοΏ½rXrοΏ½οΏ½_get_elem_infor~οΏ½isIdNSrοΏ½οΏ½isIdrοΏ½οΏ½rrοΏ½rοΏ½οΏ½infor
r
r
οΏ½	_get_isIdοΏ½s
zAttr._get_isIdcCs\|j}|j}|dks|dkr tS|οΏ½|οΏ½}|dkr6tS|jrL|οΏ½|j|jοΏ½S|οΏ½|jοΏ½SdSr%)	rXrοΏ½οΏ½_no_typerοΏ½r~οΏ½getAttributeTypeNSrοΏ½οΏ½getAttributeTyperοΏ½rοΏ½r
r
r
οΏ½_get_schemaTypeοΏ½s
zAttr._get_schemaType) r{r|r}οΏ½	__slots__r	οΏ½ATTRIBUTE_NODErrοΏ½rοΏ½rοΏ½rOrοΏ½r5rrοΏ½rarοΏ½rοΏ½rοΏ½οΏ½propertyrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrQrοΏ½rοΏ½r
r
r
r
rοΏ½Xs.οΏ½


rοΏ½rοΏ½z True if this attribute is an ID.z'Namespace-local name of this attribute.οΏ½
schemaTypezSchema type for this attribute.c@sοΏ½eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½Zd9ddοΏ½Z
eZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zdd οΏ½Zd!d"οΏ½Zd#d$οΏ½Zd%d&οΏ½Zd'd(οΏ½Zd)d*οΏ½Zd+d,οΏ½Zd-d.οΏ½Zd/d0οΏ½Zd1d2οΏ½Zd3d4οΏ½Zd5d6οΏ½Zd7d8οΏ½ZdS):οΏ½NamedNodeMapοΏ½rοΏ½rοΏ½οΏ½
_ownerElementcCs||_||_||_dSr%rοΏ½)rοΏ½attrsZattrsNSrοΏ½r
r
r
rοΏ½οΏ½szNamedNodeMap.__init__cCs
t|jοΏ½Sr%)οΏ½lenrοΏ½rr
r
r
οΏ½_get_lengthοΏ½szNamedNodeMap._get_lengthcCs4z|t|jοΏ½οΏ½οΏ½|WStk
r.YdSXdSr%)rrrοΏ½οΏ½keysοΏ½
IndexErrorοΏ½rr=r
r
r
οΏ½itemοΏ½szNamedNodeMap.itemcCs*g}|jοΏ½οΏ½D]}|οΏ½|j|jfοΏ½q|Sr%)rοΏ½οΏ½valuesrRrοΏ½rοΏ½οΏ½rrUrHr
r
r
rsοΏ½szNamedNodeMap.itemscCs0g}|jοΏ½οΏ½D]}|οΏ½|j|jf|jfοΏ½q|Sr%)rοΏ½rοΏ½rRr~rοΏ½rοΏ½rοΏ½r
r
r
οΏ½itemsNSοΏ½szNamedNodeMap.itemsNScCs"t|tοΏ½r||jkS||jkSdSr%)οΏ½
isinstanceοΏ½strrοΏ½rοΏ½rjr
r
r
οΏ½__contains__οΏ½s

zNamedNodeMap.__contains__cCs
|jοΏ½οΏ½Sr%)rοΏ½rοΏ½rr
r
r
rοΏ½szNamedNodeMap.keyscCs
|jοΏ½οΏ½Sr%)rοΏ½rοΏ½rr
r
r
οΏ½keysNSszNamedNodeMap.keysNScCs
|jοΏ½οΏ½Sr%)rοΏ½rοΏ½rr
r
r
rοΏ½szNamedNodeMap.valuesNcCs|jοΏ½||οΏ½Sr%οΏ½rοΏ½οΏ½get)rrοΏ½rοΏ½r
r
r
rοΏ½
szNamedNodeMap.getcCs:|jt|ddοΏ½krdSt|οΏ½t|οΏ½kt|οΏ½t|οΏ½kSdS)NrοΏ½r)rοΏ½οΏ½getattrοΏ½idrbr
r
r
οΏ½_cmpszNamedNodeMap._cmpcCs|οΏ½|οΏ½dkSr+οΏ½rοΏ½rbr
r
r
οΏ½__eq__szNamedNodeMap.__eq__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__ge__szNamedNodeMap.__ge__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__gt__szNamedNodeMap.__gt__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__le__szNamedNodeMap.__le__cCs|οΏ½|οΏ½dkSr+rοΏ½rbr
r
r
οΏ½__lt__!szNamedNodeMap.__lt__cCs"t|tοΏ½r|j|S|j|SdSr%)rοΏ½r3rοΏ½rοΏ½)rοΏ½attname_or_tupler
r
r
οΏ½__getitem__$s

zNamedNodeMap.__getitem__cCsvt|tοΏ½rRz|j|}Wn0tk
rHt|οΏ½}|jj|_|οΏ½|οΏ½YnX||_n t|tοΏ½sdt	dοΏ½οΏ½|}|οΏ½|οΏ½dS)Nz%value must be a string or Attr object)
rοΏ½rοΏ½rοΏ½rirοΏ½rοΏ½rXοΏ½setNamedItemrοΏ½οΏ½	TypeError)rοΏ½attnamerοΏ½rHr
r
r
οΏ½__setitem__+s


zNamedNodeMap.__setitem__cCs(z|j|WStk
r"YdSXdSr%)rοΏ½riοΏ½rrοΏ½r
r
r
οΏ½getNamedItem:szNamedNodeMap.getNamedItemcCs,z|j||fWStk
r&YdSXdSr%)rοΏ½riοΏ½rr~rοΏ½r
r
r
οΏ½getNamedItemNS@szNamedNodeMap.getNamedItemNScCsX|οΏ½|οΏ½}|dk	rJt|jοΏ½|j|j=|j|j|jf=t|dοΏ½rFd|_	|St
jοΏ½οΏ½οΏ½dSοΏ½NrοΏ½)
rοΏ½rArοΏ½rοΏ½rοΏ½rοΏ½r~rοΏ½rqrοΏ½r6r7r?οΏ½rrοΏ½οΏ½nr
r
r
οΏ½removeNamedItemFs



zNamedNodeMap.removeNamedItemcCsZ|οΏ½||οΏ½}|dk	rLt|jοΏ½|j|j|jf=|j|j=t|dοΏ½rHd|_	|St
jοΏ½οΏ½οΏ½dSrοΏ½)
rοΏ½rArοΏ½rοΏ½r~rοΏ½rοΏ½rοΏ½rqrοΏ½r6r7r?οΏ½rr~rοΏ½rοΏ½r
r
r
οΏ½removeNamedItemNSRs


zNamedNodeMap.removeNamedItemNScCstt|tοΏ½s&tjοΏ½dt|οΏ½t|οΏ½fοΏ½οΏ½|jοΏ½|jοΏ½}|r@|οΏ½	οΏ½||j|j<||j
|j|jf<|j
|_t|jοΏ½|SrI)rοΏ½rοΏ½r6r7r8r9rοΏ½rοΏ½rοΏ½rQrοΏ½r~rοΏ½rοΏ½rοΏ½rA)rrHrnr
r
r
rοΏ½^s
οΏ½
zNamedNodeMap.setNamedItemcCs
|οΏ½|οΏ½Sr%)rοΏ½οΏ½rrHr
r
r
οΏ½setNamedItemNSkszNamedNodeMap.setNamedItemNScCs||}t|jοΏ½|οΏ½οΏ½dSr%)rArοΏ½rQ)rrοΏ½rHr
r
r
οΏ½__delitem__ns
zNamedNodeMap.__delitem__cCs|j|j|jfSr%rοΏ½rr
r
r
οΏ½__getstate__sszNamedNodeMap.__getstate__cCs|\|_|_|_dSr%rοΏ½οΏ½rοΏ½stater
r
r
οΏ½__setstate__vszNamedNodeMap.__setstate__)N) r{r|r}rοΏ½rοΏ½rοΏ½rοΏ½rsrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½__len__rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
rοΏ½οΏ½s:	

rοΏ½Zlengthz$Number of nodes in the NamedNodeMap.c@s0eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
S)οΏ½TypeInfoοΏ½οΏ½	namespacerοΏ½cCs||_||_dSr%rοΏ½)rrrοΏ½r
r
r
rοΏ½οΏ½szTypeInfo.__init__cCs2|jrd|jj|j|jfSd|jj|jfSdS)Nz<%s %r (from %r)>z<%s %r>)rοΏ½	__class__r{rοΏ½rr
r
r
οΏ½__repr__οΏ½s
οΏ½zTypeInfo.__repr__cCs|jSr%)rοΏ½rr
r
r
rοΏ½οΏ½szTypeInfo._get_namecCs|jSr%)rrr
r
r
οΏ½_get_namespaceοΏ½szTypeInfo._get_namespaceN)r{r|r}rοΏ½rοΏ½rrοΏ½rr
r
r
r
rοΏ½s
rοΏ½c@s eZdZdZejZdZeZ	dZ
ejejejej
ejejfZeddfddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZeZddοΏ½ZddοΏ½Z d d!οΏ½Z!e!Z"d"d#οΏ½Z#d$d%οΏ½Z$d&d'οΏ½Z%d(d)οΏ½Z&d*d+οΏ½Z'd9d-d.οΏ½Z(d/d0οΏ½Z)d1d2οΏ½Z*d3d4οΏ½Z+d5d6οΏ½Z,d7d8οΏ½Z-dS):οΏ½Element)rXr:rοΏ½rοΏ½rr~rοΏ½r'rοΏ½rοΏ½rCrDNrcCsBd|_||_|_||_||_tοΏ½|_d|_|_d|_	d|_
dSr%)r:rοΏ½rοΏ½rr~rwr'rCrDrοΏ½rοΏ½)rrοΏ½r~rrοΏ½r
r
r
rοΏ½οΏ½s
zElement.__init__cCs|jdkri|_i|_dSr%)rοΏ½rοΏ½rr
r
r
οΏ½_ensure_attributesοΏ½s
zElement._ensure_attributescCs4z|jWStk
r.|jοΏ½ddοΏ½dYSXdSrοΏ½)rοΏ½rhrοΏ½rοΏ½rr
r
r
raοΏ½szElement._get_localNamecCs|jSr%οΏ½rοΏ½rr
r
r
οΏ½_get_tagNameοΏ½szElement._get_tagNamecCs@|jdk	r&t|jοΏ½οΏ½οΏ½D]}|οΏ½οΏ½qd|_d|_tοΏ½|οΏ½dSr%)rοΏ½rrrοΏ½rQrοΏ½r	)rοΏ½attrr
r
r
rQοΏ½s

zElement.unlinkcCs8|jdkrdSz|j|jWStk
r2YdSXdSr)rοΏ½rοΏ½ri)rrοΏ½r
r
r
οΏ½getAttributeοΏ½s
zElement.getAttributecCs<|jdkrdSz|j||fjWStk
r6YdSXdSr)rοΏ½rοΏ½rirοΏ½r
r
r
οΏ½getAttributeNSοΏ½s
zElement.getAttributeNScCsV|οΏ½|οΏ½}|dkr4t|οΏ½}||_|j|_|οΏ½|οΏ½n||jkrR||_|jrRt|οΏ½dSr%)οΏ½getAttributeNoderοΏ½rοΏ½rXοΏ½setAttributeNoderοΏ½rA)rrοΏ½rοΏ½rr
r
r
οΏ½setAttributeοΏ½s

zElement.setAttributecCsοΏ½t|οΏ½\}}|οΏ½||οΏ½}|dkrHt||||οΏ½}||_|j|_|οΏ½|οΏ½n4||jkrf||_|jrft|οΏ½|j|kr|||_||_	dSr%)
οΏ½_nssplitοΏ½getAttributeNodeNSrοΏ½rοΏ½rXrrοΏ½rArrοΏ½)rr~οΏ½
qualifiedNamerοΏ½rοΏ½	localnamerr
r
r
οΏ½setAttributeNSοΏ½s

zElement.setAttributeNScCs|jdkrdS|jοΏ½|οΏ½Sr%rοΏ½)rοΏ½attrnamer
r
r
rοΏ½s
zElement.getAttributeNodecCs|jdkrdS|jοΏ½||fοΏ½Sr%)rοΏ½rοΏ½rοΏ½r
r
r
rs
zElement.getAttributeNodeNScCsοΏ½|jd|fkrtjοΏ½dοΏ½οΏ½|οΏ½οΏ½|jοΏ½|jdοΏ½}|dk	rD|οΏ½|οΏ½|j	οΏ½|j
|jfdοΏ½}|dk	rt||k	rt|οΏ½|οΏ½t||οΏ½||k	rοΏ½|S||k	rοΏ½|SdS)Nzattribute node already owned)
rοΏ½r6r7ZInuseAttributeErrrrοΏ½rοΏ½rοΏ½οΏ½removeAttributeNoderοΏ½r~rοΏ½οΏ½_set_attribute_node)rrZold1Zold2r
r
r
rs


zElement.setAttributeNodecCsP|jdkrtjοΏ½οΏ½οΏ½z|j|}Wntk
r@tjοΏ½οΏ½οΏ½YnX|οΏ½|οΏ½dSr%)rοΏ½r6r7r?rοΏ½rir)rrοΏ½rr
r
r
οΏ½removeAttributes

zElement.removeAttributecCsT|jdkrtjοΏ½οΏ½οΏ½z|j||f}Wntk
rDtjοΏ½οΏ½οΏ½YnX|οΏ½|οΏ½dSr%)rοΏ½r6r7r?rir)rr~rοΏ½rr
r
r
οΏ½removeAttributeNS%s

zElement.removeAttributeNScCs^|dkrtjοΏ½οΏ½οΏ½z|j|jWntk
r@tjοΏ½οΏ½οΏ½YnXt|οΏ½|οΏ½οΏ½|j|_|Sr%)	r6r7r?rοΏ½rοΏ½rirArQrXrοΏ½r
r
r
r.s
zElement.removeAttributeNodecCs|jdkrdS||jkSοΏ½NFοΏ½rοΏ½rοΏ½r
r
r
οΏ½hasAttribute>s
zElement.hasAttributecCs|jdkrdS||f|jkSr)rοΏ½rοΏ½r
r
r
οΏ½hasAttributeNSCs
zElement.hasAttributeNScCst||tοΏ½οΏ½Sr%οΏ½rοΏ½rwrοΏ½r
r
r
οΏ½getElementsByTagNameHszElement.getElementsByTagNamecCst|||tοΏ½οΏ½Sr%οΏ½rοΏ½rwrοΏ½r
r
r
οΏ½getElementsByTagNameNSKsοΏ½zElement.getElementsByTagNameNScCsd|jt|οΏ½fS)Nz<DOM Element: %s at %#x>)rοΏ½rοΏ½rr
r
r
rOszElement.__repr__rcCsοΏ½|οΏ½|d|jοΏ½|οΏ½οΏ½}|οΏ½οΏ½D],}|οΏ½d|οΏ½t|||jοΏ½|οΏ½dοΏ½q$|jrοΏ½|οΏ½dοΏ½t|jοΏ½dkrοΏ½|jdjt	j
t	jfkrοΏ½|jdοΏ½|dddοΏ½n4|οΏ½|οΏ½|jD]}|οΏ½|||||οΏ½qοΏ½|οΏ½|οΏ½|οΏ½d|j|fοΏ½n|οΏ½d	|οΏ½dS)
NrοΏ½z %s="rοΏ½rοΏ½r1rrz</%s>%sz/>%s)
rοΏ½rοΏ½οΏ½_get_attributesrοΏ½rοΏ½rοΏ½r'rοΏ½rr	rOrοΏ½r)rr$r"οΏ½	addindentr#rοΏ½Za_namerHr
r
r
rRs*

οΏ½οΏ½


zElement.writexmlcCs|οΏ½οΏ½t|j|j|οΏ½Sr%)rrοΏ½rοΏ½rοΏ½rr
r
r
r mszElement._get_attributescCs|jr
dSdSdSrοΏ½rrr
r
r
οΏ½
hasAttributesqszElement.hasAttributescCs|οΏ½|οΏ½}|οΏ½|οΏ½dSr%)rοΏ½setIdAttributeNode)rrοΏ½οΏ½idAttrr
r
r
οΏ½setIdAttributeys
zElement.setIdAttributecCs|οΏ½||οΏ½}|οΏ½|οΏ½dSr%)rr#)rr~rοΏ½r$r
r
r
οΏ½setIdAttributeNS}szElement.setIdAttributeNScCsj|dks|οΏ½|jοΏ½stjοΏ½οΏ½οΏ½t|οΏ½dk	r4tjοΏ½οΏ½οΏ½|jsfd|_|jd7_|j	j
d7_
t|οΏ½dS)NTr1)rdrοΏ½r6r7r?οΏ½_get_containing_entrefοΏ½NoModificationAllowedErrrοΏ½rοΏ½rXrοΏ½rA)rr$r
r
r
r#οΏ½s

zElement.setIdAttributeNode)rrr).r{r|r}rοΏ½r	rSrrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rOrοΏ½rοΏ½r5rrοΏ½rrarrQr	r
r
rrrrZsetAttributeNodeNSrrrZremoveAttributeNodeNSrrrrrrr r"r%r&r#r
r
r
r
rοΏ½sTοΏ½οΏ½
		
rrοΏ½z*NamedNodeMap of attributes on the element.z%Namespace-local name of this element.cCs8t|οΏ½|οΏ½οΏ½||j|j<||j|j|jf<||_dSr%)rArrοΏ½rοΏ½rοΏ½r~rοΏ½rοΏ½)οΏ½elementrr
r
r
rοΏ½s
rc@sbeZdZdZdZeοΏ½ZdZdZddοΏ½Z	ddοΏ½Z
ddοΏ½Zd	d
οΏ½ZddοΏ½Z
d
dοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½	Childlessr
NcCsdSr%r
rr
r
r
r,οΏ½szChildless._get_firstChildcCsdSr%r
rr
r
r
r/οΏ½szChildless._get_lastChildcCstjοΏ½|jdοΏ½οΏ½dS)Nz nodes cannot have childrenοΏ½r6r7r8rοΏ½rοΏ½r
r
r
r<οΏ½sοΏ½zChildless.appendChildcCsdSrr
rr
r
r
r(οΏ½szChildless.hasChildNodescCstjοΏ½|jdοΏ½οΏ½dSοΏ½Nz nodes do not have childrenr+οΏ½rrErFr
r
r
r4οΏ½sοΏ½zChildless.insertBeforecCstjοΏ½|jdοΏ½οΏ½dSr,)r6r7r?rοΏ½rNr
r
r
r;οΏ½sοΏ½zChildless.removeChildcCsdSr%r
rr
r
r
rTοΏ½szChildless.normalizecCstjοΏ½|jdοΏ½οΏ½dSr,r+οΏ½rrErKr
r
r
rLοΏ½sοΏ½zChildless.replaceChild)r{r|r}rοΏ½rοΏ½Z
EmptyNodeListr'rοΏ½rοΏ½r,r/r<r(r4r;rTrLr
r
r
r
r*οΏ½sr*c@s\eZdZejZdZddοΏ½ZddοΏ½ZddοΏ½Z	e
ee	οΏ½Zdd	οΏ½Zd
dοΏ½Z
e
ee
οΏ½Zdd
dοΏ½ZdS)οΏ½ProcessingInstructionοΏ½οΏ½targetrPcCs||_||_dSr%r0)rr1rPr
r
r
rοΏ½οΏ½szProcessingInstruction.__init__cCs|jSr%οΏ½rPrr
r
r
οΏ½_get_nodeValueοΏ½sz$ProcessingInstruction._get_nodeValuecCs
||_dSr%r2rοΏ½r
r
r
οΏ½_set_nodeValueοΏ½sz$ProcessingInstruction._set_nodeValuecCs|jSr%οΏ½r1rr
r
r
οΏ½
_get_nodeNameοΏ½sz#ProcessingInstruction._get_nodeNamecCs
||_dSr%r5rοΏ½r
r
r
οΏ½
_set_nodeNameοΏ½sz#ProcessingInstruction._set_nodeNamercCs|οΏ½d||j|j|fοΏ½dS)Nz
%s<?%s %s?>%s)rοΏ½r1rPοΏ½rr$r"r!r#r
r
r
rοΏ½szProcessingInstruction.writexmlN)rrr)r{r|r}r	rοΏ½rrοΏ½rοΏ½r3r4rοΏ½rοΏ½r6r7rοΏ½rr
r
r
r
r/οΏ½s

r/c@sreZdZdZddοΏ½ZddοΏ½ZeZddοΏ½Zdd	οΏ½Ze	eeοΏ½Z
Zd
dοΏ½Zdd
οΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½
CharacterData)οΏ½_datarXr:rDrCcCs,d|_|_d|_|_d|_tοΏ½|οΏ½dSr)rXr:rDrCr:r	rοΏ½rr
r
r
rοΏ½οΏ½szCharacterData.__init__cCs
t|jοΏ½Sr%)rοΏ½rPrr
r
r
rοΏ½οΏ½szCharacterData._get_lengthcCs|jSr%οΏ½r:rr
r
r
οΏ½	_get_dataοΏ½szCharacterData._get_datacCs
||_dSr%r;οΏ½rrPr
r
r
οΏ½	_set_dataοΏ½szCharacterData._set_datacCs6|j}t|οΏ½dkrd}nd}d|jj|ddοΏ½|fS)NοΏ½
z...rz<DOM %s node "%r%s">r)rPrοΏ½rr{)rrPZ	dotdotdotr
r
r
rοΏ½s
οΏ½zCharacterData.__repr__cCsT|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|dkrBtjοΏ½dοΏ½οΏ½|j|||οΏ½SοΏ½NrοΏ½offset cannot be negativeοΏ½#offset cannot be beyond end of dataοΏ½count cannot be negativeοΏ½r6r7οΏ½IndexSizeErrrοΏ½rPοΏ½rοΏ½offsetοΏ½countr
r
r
οΏ½
substringDataοΏ½szCharacterData.substringDatacCs|j||_dSr%r2)rοΏ½argr
r
r
οΏ½
appendDataszCharacterData.appendDatacCsZ|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|rVd|jd|οΏ½||j|dοΏ½f|_dS)NrrArBοΏ½%s%s%srD)rrGrJr
r
r
οΏ½
insertData	sοΏ½zCharacterData.insertDatacCsl|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|dkrBtjοΏ½dοΏ½οΏ½|rh|jd|οΏ½|j||dοΏ½|_dSr@rDrFr
r
r
οΏ½
deleteDataszCharacterData.deleteDatacCsr|dkrtjοΏ½dοΏ½οΏ½|t|jοΏ½kr.tjοΏ½dοΏ½οΏ½|dkrBtjοΏ½dοΏ½οΏ½|rnd|jd|οΏ½||j||dοΏ½f|_dS)NrrArBrCrLrD)rrGrHrJr
r
r
οΏ½replaceDatasοΏ½zCharacterData.replaceDataN)r{r|r}rοΏ½rοΏ½rοΏ½rοΏ½r<r>rοΏ½rPrοΏ½rrIrKrMrNrOr
r
r
r
r9οΏ½s			
r9zLength of the string data.c@sHeZdZdZejZdZdZddοΏ½Z	dddοΏ½Z
d	d
οΏ½ZddοΏ½Zd
dοΏ½Z
dS)rοΏ½r
z#textNcCsοΏ½|dks|t|jοΏ½kr"tjοΏ½dοΏ½οΏ½|οΏ½οΏ½}|j|dοΏ½|_|j|_|j}|jr~||jj	kr~|dkrp|jοΏ½
|οΏ½n|jοΏ½||οΏ½|jd|οΏ½|_|S)Nrzillegal offset value)rοΏ½rPr6r7rErrXrCr:r'r<r4)rrGZnewTextοΏ½nextr
r
r
οΏ½	splitText1szText.splitTextrcCst|d||j|fοΏ½dS)NrL)rοΏ½rPr8r
r
r
r@sz
Text.writexmlcCsοΏ½|jg}|j}|dk	rB|jtjtjfkrB|οΏ½d|jοΏ½|j}qqBq|j}|dk	rz|jtjtjfkrz|οΏ½|jοΏ½|j}qHqzqHdοΏ½	|οΏ½S)Nrr)
rPrDrr	rOrοΏ½rBrCrRοΏ½join)rrUrοΏ½r
r
r
οΏ½_get_wholeTextEszText._get_wholeTextcCsοΏ½|j}|j}|dk	r@|jtjtjfkr@|j}|οΏ½|οΏ½|}qq@q|j}|sT|οΏ½|οΏ½|dk	rοΏ½|jtjtjfkrοΏ½|j}|οΏ½|οΏ½|}qTqοΏ½qT|rοΏ½||_|SdSdSr%)	r:rDrr	rOrοΏ½r;rCrP)rZcontentrοΏ½rοΏ½rPr
r
r
οΏ½replaceWholeTextWs*


zText.replaceWholeTextcCsF|jοΏ½οΏ½rdSt|οΏ½}|dkr"dS|jοΏ½|οΏ½}|dkr:dS|οΏ½οΏ½SdSr)rPοΏ½stripοΏ½_get_containing_elementrXrοΏ½οΏ½isElementContent)rrοΏ½rοΏ½r
r
r
οΏ½!_get_isWhitespaceInElementContentss
z&Text._get_isWhitespaceInElementContent)rrr)r{r|r}rοΏ½r	rOrrοΏ½rοΏ½rQrrSrTrXr
r
r
r
rοΏ½*s
rοΏ½ZisWhitespaceInElementContentzKTrue iff this text node contains only whitespace and is in element content.Z	wholeTextz.The text of all logically-adjacent text nodes.cCs*|j}|dk	r&|jtjkr|S|j}qdSr%)r:rr	rSοΏ½rHrGr
r
r
rVοΏ½srVcCs*|j}|dk	r&|jtjkr|S|j}qdSr%)r:rr	rοΏ½rYr
r
r
r'οΏ½sr'c@s(eZdZejZdZddοΏ½ZdddοΏ½ZdS)	οΏ½Commentz#commentcCstοΏ½|οΏ½||_dSr%)r9rοΏ½r:r=r
r
r
rοΏ½οΏ½s
zComment.__init__rcCs,d|jkrtdοΏ½οΏ½|οΏ½d||j|fοΏ½dS)Nz--z%'--' is not allowed in a comment nodez
%s<!--%s-->%s)rPr>rοΏ½r8r
r
r
rοΏ½s
zComment.writexmlN)rrr)	r{r|r}r	rοΏ½rrοΏ½rοΏ½rr
r
r
r
rZοΏ½srZc@s$eZdZdZejZdZdddοΏ½ZdS)οΏ½CDATASectionr
z#cdata-sectionrcCs,|jοΏ½dοΏ½dkrtdοΏ½οΏ½|οΏ½d|jοΏ½dS)Nz]]>rz$']]>' not allowed in a CDATA sectionz<![CDATA[%s]]>)rPοΏ½findr>rοΏ½r8r
r
r
rοΏ½szCDATASection.writexmlN)rrr)	r{r|r}rοΏ½r	rοΏ½rrοΏ½rr
r
r
r
r[οΏ½sr[c@szeZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½ReadOnlySequentialNamedNodeMapοΏ½οΏ½_seqr
cCs
||_dSr%r^)rοΏ½seqr
r
r
rοΏ½οΏ½sz'ReadOnlySequentialNamedNodeMap.__init__cCs
t|jοΏ½Sr%οΏ½rοΏ½r_rr
r
r
rοΏ½οΏ½sz&ReadOnlySequentialNamedNodeMap.__len__cCs
t|jοΏ½Sr%rarr
r
r
rοΏ½οΏ½sz*ReadOnlySequentialNamedNodeMap._get_lengthcCs"|jD]}|j|kr|SqdSr%)r_rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s

z+ReadOnlySequentialNamedNodeMap.getNamedItemcCs,|jD] }|j|kr|j|kr|SqdSr%)r_r~rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s
z-ReadOnlySequentialNamedNodeMap.getNamedItemNScCs4t|tοΏ½r|j|οΏ½}n
|οΏ½|οΏ½}|dkr0t|οΏ½οΏ½|Sr%)rοΏ½r3rοΏ½rοΏ½ri)rZ
name_or_tuplerHr
r
r
rοΏ½οΏ½s

z*ReadOnlySequentialNamedNodeMap.__getitem__cCs4|dkrdSz|j|WStk
r.YdSXdSr+)r_rοΏ½rοΏ½r
r
r
rοΏ½οΏ½sz#ReadOnlySequentialNamedNodeMap.itemcCstjοΏ½dοΏ½οΏ½dSοΏ½Nz"NamedNodeMap instance is read-onlyοΏ½r6r7r(rοΏ½r
r
r
rοΏ½οΏ½sοΏ½z.ReadOnlySequentialNamedNodeMap.removeNamedItemcCstjοΏ½dοΏ½οΏ½dSrbrcrοΏ½r
r
r
rοΏ½οΏ½sοΏ½z0ReadOnlySequentialNamedNodeMap.removeNamedItemNScCstjοΏ½dοΏ½οΏ½dSrbrcrοΏ½r
r
r
rοΏ½οΏ½sοΏ½z+ReadOnlySequentialNamedNodeMap.setNamedItemcCstjοΏ½dοΏ½οΏ½dSrbrcrοΏ½r
r
r
rοΏ½οΏ½sοΏ½z-ReadOnlySequentialNamedNodeMap.setNamedItemNScCs|jgSr%r^rr
r
r
rοΏ½οΏ½sz+ReadOnlySequentialNamedNodeMap.__getstate__cCs|d|_dSr+r^rοΏ½r
r
r
rοΏ½οΏ½sz+ReadOnlySequentialNamedNodeMap.__setstate__N)r
)r{r|r}rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
r]οΏ½s
	r]z&Number of entries in the NamedNodeMap.c@s(eZdZdZddοΏ½ZddοΏ½ZddοΏ½ZdS)	οΏ½
IdentifiedοΏ½οΏ½publicIdοΏ½systemIdcCs||_||_dSr%re)rrfrgr
r
r
οΏ½_identified_mixin_initοΏ½sz!Identified._identified_mixin_initcCs|jSr%)rfrr
r
r
οΏ½
_get_publicIdοΏ½szIdentified._get_publicIdcCs|jSr%)rgrr
r
r
οΏ½
_get_systemIdοΏ½szIdentified._get_systemIdN)r{r|r}rοΏ½rhrirjr
r
r
r
rdοΏ½srdc@sHeZdZejZdZdZdZdZ	dZ
ddοΏ½ZddοΏ½ZddοΏ½Z
dd	d
οΏ½ZdS)οΏ½DocumentTypeNcCs2tοΏ½|_tοΏ½|_|r&t|οΏ½\}}||_|j|_dSr%)r]οΏ½entitiesοΏ½	notationsrrοΏ½rοΏ½)rrrrr
r
r
rοΏ½
szDocumentType.__init__cCs|jSr%)οΏ½internalSubsetrr
r
r
οΏ½_get_internalSubsetsz DocumentType._get_internalSubsetcCsοΏ½|jdkrοΏ½tdοΏ½}|j|_|j|_tjjj}|rοΏ½g|j_	g|j
_	|j
j	D]2}t|j|j|j
οΏ½}|j
j	οΏ½|οΏ½|οΏ½|||οΏ½qH|jj	D]N}t|j|j|j
|jοΏ½}|j|_|j|_|j|_|jj	οΏ½|οΏ½|οΏ½|||οΏ½qοΏ½|οΏ½|||οΏ½|SdSdSr%)rXrkrοΏ½rοΏ½r6r7οΏ½UserDataHandlerοΏ½NODE_CLONEDrlr_rmοΏ½NotationrfrgrRrvοΏ½EntityοΏ½notationNameοΏ½actualEncodingrr_)rrYοΏ½clonertrοΏ½οΏ½notationοΏ½eοΏ½entityr
r
r
rZs0

οΏ½zDocumentType.cloneNodercCsοΏ½|οΏ½dοΏ½|οΏ½|jοΏ½|jr8|οΏ½d||j||jfοΏ½n|jrR|οΏ½d||jfοΏ½|jdk	r||οΏ½dοΏ½|οΏ½|jοΏ½|οΏ½dοΏ½|οΏ½d|οΏ½dS)Nz
<!DOCTYPE z%s  PUBLIC '%s'%s  '%s'z%s  SYSTEM '%s'z [οΏ½]rοΏ½)rοΏ½rοΏ½rfrgrnr8r
r
r
r0s
οΏ½


zDocumentType.writexml)rrr)r{r|r}r	οΏ½DOCUMENT_TYPE_NODErrοΏ½rοΏ½rfrgrnrοΏ½rorZrr
r
r
r
rksrkc@sfeZdZdZejZdZdZdZ	dZ
ddοΏ½ZddοΏ½ZddοΏ½Z
dd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½ZddοΏ½ZdS)rsNcCs$||_||_tοΏ½|_|οΏ½||οΏ½dSr%)rοΏ½rtrwr'rh)rrοΏ½rfrgrwr
r
r
rοΏ½GszEntity.__init__cCs|jSr%οΏ½rurr
r
r
οΏ½_get_actualEncodingMszEntity._get_actualEncodingcCs|jSr%οΏ½rrr
r
r
οΏ½
_get_encodingPszEntity._get_encodingcCs|jSr%οΏ½r_rr
r
r
οΏ½_get_versionSszEntity._get_versioncCstjοΏ½dοΏ½οΏ½dS)Nz(cannot append children to an entity nodeοΏ½r6r7r8)rrEr
r
r
r<VsοΏ½zEntity.appendChildcCstjοΏ½dοΏ½οΏ½dS)Nz+cannot insert children below an entity noderοΏ½r-r
r
r
r4ZsοΏ½zEntity.insertBeforecCstjοΏ½dοΏ½οΏ½dS)Nz*cannot remove children from an entity noderοΏ½rNr
r
r
r;^sοΏ½zEntity.removeChildcCstjοΏ½dοΏ½οΏ½dS)Nz)cannot replace children of an entity noderοΏ½r.r
r
r
rLbsοΏ½zEntity.replaceChild)r{r|r}rοΏ½r	ZENTITY_NODErrοΏ½rurr_rοΏ½r}rrοΏ½r<r4r;rLr
r
r
r
rs>srsc@seZdZejZdZddοΏ½ZdS)rrNcCs||_|οΏ½||οΏ½dSr%)rοΏ½rh)rrοΏ½rfrgr
r
r
rοΏ½jszNotation.__init__)r{r|r}r	rοΏ½rrοΏ½rοΏ½r
r
r
r
rrfsrrc@sHeZdZddddddddgZd	d
οΏ½ZddοΏ½Zd
dοΏ½ZddοΏ½ZddοΏ½ZdS)οΏ½DOMImplementation)οΏ½coreοΏ½1.0)rοΏ½οΏ½2.0)rοΏ½N)r6rοΏ½)r6rοΏ½)r6N)οΏ½ls-loadz3.0)rοΏ½NcCs|dkrd}|οΏ½οΏ½|f|jkSr)οΏ½lowerοΏ½	_featuresr]r
r
r
r\zszDOMImplementation.hasFeaturec	CsοΏ½|r|jdk	rtjοΏ½dοΏ½οΏ½|οΏ½οΏ½}|dko8|dko8|dk}|sP|rPtjοΏ½dοΏ½οΏ½|rοΏ½t|οΏ½\}}|dkr||dkr|tjοΏ½dοΏ½οΏ½|rοΏ½|sοΏ½tjοΏ½dοΏ½οΏ½|οΏ½||οΏ½}|rοΏ½|οΏ½	|οΏ½|οΏ½	|οΏ½|rοΏ½||_|_
||_||_|S)Nz(doctype object owned by another DOM treezElement with no namer6z$http://www.w3.org/XML/1998/namespacezillegal use of 'xml' prefixz(illegal use of prefix without namespaces)
r:r6r7οΏ½WrongDocumentErrοΏ½_create_documentZInvalidCharacterErrrrοΏ½οΏ½createElementNSr<rXοΏ½doctyper[)	rr~rrοΏ½rοΏ½Zadd_root_elementrrr)r
r
r
οΏ½createDocuments>οΏ½οΏ½οΏ½
οΏ½οΏ½

z DOMImplementation.createDocumentcCst|οΏ½}||_||_|Sr%)rkrfrg)rrrfrgrοΏ½r
r
r
οΏ½createDocumentTypeοΏ½sz$DOMImplementation.createDocumentTypecCs|οΏ½|dοΏ½r|SdSdSr%)r\rer
r
r
rfοΏ½szDOMImplementation.getInterfacecCstοΏ½Sr%)οΏ½Documentrr
r
r
rοΏ½οΏ½sz"DOMImplementation._create_documentN)	r{r|r}rοΏ½r\rοΏ½rοΏ½rfrοΏ½r
r
r
r
rοΏ½osοΏ½
-rοΏ½c@sXeZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZdS)οΏ½ElementInforcCs
||_dSr%rrοΏ½r
r
r
rοΏ½οΏ½szElementInfo.__init__cCstSr%οΏ½rοΏ½οΏ½rZanamer
r
r
rοΏ½οΏ½szElementInfo.getAttributeTypecCstSr%rοΏ½rοΏ½r
r
r
rοΏ½οΏ½szElementInfo.getAttributeTypeNScCsdSrr
rr
r
r
rWοΏ½szElementInfo.isElementContentcCsdSrr
rr
r
r
οΏ½isEmptyοΏ½szElementInfo.isEmptycCsdSrr
rοΏ½r
r
r
rοΏ½οΏ½szElementInfo.isIdcCsdSrr
rοΏ½r
r
r
rοΏ½οΏ½szElementInfo.isIdNScCs|jSr%rrr
r
r
rοΏ½οΏ½szElementInfo.__getstate__cCs
||_dSr%rrοΏ½r
r
r
rοΏ½οΏ½szElementInfo.__setstate__N)
r{r|r}rοΏ½rοΏ½rοΏ½rοΏ½rWrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
rοΏ½οΏ½s	rοΏ½cCs>|jtjkr|jοΏ½οΏ½d|_nt|οΏ½r:|jjοΏ½οΏ½d|j_dSr%)rr	rοΏ½	_id_cacheοΏ½clearοΏ½_id_search_stackrοΏ½rXrοΏ½r
r
r
rAοΏ½s
rAc@sreZdZdZejejejejfZ	e
οΏ½ZejZ
dZdZdZdZdZZdZdZdZdZdZdZdZdZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½Z ddοΏ½Z!ddοΏ½Z"ddοΏ½Z#ddοΏ½Z$ddοΏ½Z%ddοΏ½Z&ddοΏ½Z'ddοΏ½Z(d d!οΏ½Z)d"d#οΏ½Z*d$d%οΏ½Z+d&d'οΏ½Z,d(d)οΏ½Z-d*d+οΏ½Z.d,d-οΏ½Z/d.d/οΏ½Z0d0d1οΏ½Z1d2d3οΏ½Z2d4d5οΏ½Z3d6d7οΏ½Z4d8d9οΏ½Z5d:d;οΏ½Z6d<d=οΏ½Z7d>d?οΏ½Z8d@dAοΏ½Z9dBdCοΏ½Z:dIdEdFοΏ½Z;dGdHοΏ½Z<dS)JrοΏ½)οΏ½
_elem_inforοΏ½rοΏ½r'rοΏ½z	#documentNFrcCs$d|_tοΏ½|_i|_i|_d|_dSr%)rοΏ½rwr'rοΏ½rοΏ½rοΏ½rr
r
r
rοΏ½s
zDocument.__init__cCs&|jr|j|jf}n|j}|jοΏ½|οΏ½Sr%)r~rοΏ½rοΏ½rοΏ½rοΏ½)rr)rkr
r
r
rοΏ½szDocument._get_elem_infocCs|jSr%r|rr
r
r
r}szDocument._get_actualEncodingcCs|jSr%)rοΏ½rr
r
r
οΏ½_get_doctypeszDocument._get_doctypecCs|jSr%)οΏ½documentURIrr
r
r
οΏ½_get_documentURI!szDocument._get_documentURIcCs|jSr%r~rr
r
r
r$szDocument._get_encodingcCs|jSr%)οΏ½errorHandlerrr
r
r
οΏ½_get_errorHandler'szDocument._get_errorHandlercCs|jSr%)οΏ½
standalonerr
r
r
οΏ½_get_standalone*szDocument._get_standalonecCs|jSr%)οΏ½strictErrorCheckingrr
r
r
οΏ½_get_strictErrorChecking-sz!Document._get_strictErrorCheckingcCs|jSr%rοΏ½rr
r
r
rοΏ½0szDocument._get_versioncCsj|j|jkr(tjοΏ½dt|οΏ½t|οΏ½fοΏ½οΏ½|jdk	r>|jοΏ½|οΏ½|jtj	kr^|οΏ½
οΏ½r^tjοΏ½dοΏ½οΏ½tοΏ½||οΏ½S)Nr0z two document elements disallowed)rr5r6r7r8r9r:r;r	rSοΏ½_get_documentElementr<rοΏ½r
r
r
r<3sοΏ½
οΏ½οΏ½zDocument.appendChildcCsVz|jοΏ½|οΏ½Wntk
r.tjοΏ½οΏ½οΏ½YnXd|_|_d|_|j	|krRd|_	|Sr%)
r'rMr>r6r7r?rCrDr:οΏ½documentElementrNr
r
r
r;Cs
zDocument.removeChildcCs$|jD]}|jtjkr|SqdSr%)r'rr	rSrοΏ½r
r
r
rοΏ½Os
zDocument._get_documentElementcCs(|jdk	r|jοΏ½οΏ½d|_tοΏ½|οΏ½dSr%)rοΏ½rQr	rr
r
r
rQTs

zDocument.unlinkcCsοΏ½|sdS|jοΏ½dddοΏ½}|j|_|j|_|j|_|jD]B}t|||οΏ½}|jοΏ½|οΏ½|jt	j
kr`n|jt	jkrr||_||_
q6|οΏ½tjjj||οΏ½|Sr%)r[rοΏ½rrοΏ½r_r'rWrRrr	rr{rοΏ½r:rvr6r7rprq)rrYrvrοΏ½Z
childcloner
r
r
rZZs&
οΏ½zDocument.cloneNodecCstοΏ½}||_|Sr%)rοΏ½rX)rror
r
r
οΏ½createDocumentFragmentoszDocument.createDocumentFragmentcCst|οΏ½}||_|Sr%)rrX)rrοΏ½rxr
r
r
οΏ½
createElementtszDocument.createElementcCs(t|tοΏ½stdοΏ½οΏ½tοΏ½}||_||_|SοΏ½Nznode contents must be a string)rοΏ½rοΏ½rοΏ½rοΏ½rPrX)rrPοΏ½tr
r
r
οΏ½createTextNodeys
zDocument.createTextNodecCs(t|tοΏ½stdοΏ½οΏ½tοΏ½}||_||_|SrοΏ½)rοΏ½rοΏ½rοΏ½r[rPrXοΏ½rrPrGr
r
r
οΏ½createCDATASectionοΏ½s
zDocument.createCDATASectioncCst|οΏ½}||_|Sr%)rZrXrοΏ½r
r
r
οΏ½
createCommentοΏ½szDocument.createCommentcCst||οΏ½}||_|Sr%)r/rX)rr1rPοΏ½pr
r
r
οΏ½createProcessingInstructionοΏ½s
z$Document.createProcessingInstructioncCst|οΏ½}||_d|_|Sr)rοΏ½rXrοΏ½)rrοΏ½οΏ½ar
r
r
οΏ½createAttributeοΏ½szDocument.createAttributecCs"t|οΏ½\}}t|||οΏ½}||_|Sr%)rrrX)rr~rrrοΏ½rxr
r
r
rοΏ½οΏ½szDocument.createElementNScCs*t|οΏ½\}}t||||οΏ½}||_d|_|Sr)rrοΏ½rXrοΏ½)rr~rrrοΏ½rοΏ½r
r
r
οΏ½createAttributeNSοΏ½s
zDocument.createAttributeNScCst||||οΏ½}||_|Sr%)rsrX)rrοΏ½rfrgrtrxr
r
r
οΏ½_create_entityοΏ½szDocument._create_entitycCst|||οΏ½}||_|Sr%)rrrX)rrοΏ½rfrgrοΏ½r
r
r
οΏ½_create_notationοΏ½szDocument._create_notationcCsοΏ½||jkr|j|S|js$|js$dS|j}|dkrB|jg}||_n|sJdSd}|οΏ½rοΏ½|οΏ½οΏ½}|οΏ½ddοΏ½|jDοΏ½οΏ½|οΏ½|οΏ½}|οΏ½rB|j	οΏ½
οΏ½D]οΏ½}|jrοΏ½|οΏ½|j|j
οΏ½rοΏ½||j|j<|j|krοΏ½|}n|jsοΏ½οΏ½qοΏ½qοΏ½|οΏ½|jοΏ½οΏ½r
||j|j<|j|krοΏ½|}n|jοΏ½s>οΏ½qοΏ½qοΏ½|jrοΏ½||j|j<|j|kοΏ½r.|}qοΏ½|jdkrοΏ½οΏ½qοΏ½qοΏ½n>|jοΏ½rοΏ½|j	οΏ½
οΏ½D]*}|jοΏ½rT||j|j<|j|kοΏ½rT|}οΏ½qT|dk	rNοΏ½qοΏ½qN|S)NcSsg|]}|jtkr|οΏ½qSr
)rr@)οΏ½.0rVr
r
r
οΏ½
<listcomp>οΏ½s
οΏ½z+Document.getElementById.<locals>.<listcomp>r1)rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½popοΏ½extendr'rοΏ½rοΏ½rοΏ½r~rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½)rrοΏ½οΏ½stackοΏ½resultrHrοΏ½rr
r
r
οΏ½getElementByIdοΏ½sZ






zDocument.getElementByIdcCst||tοΏ½οΏ½Sr%rrοΏ½r
r
r
rοΏ½szDocument.getElementsByTagNamecCst|||tοΏ½οΏ½Sr%rrοΏ½r
r
r
rοΏ½sοΏ½zDocument.getElementsByTagNameNScCs|jοΏ½||οΏ½Sr%)r[r\r]r
r
r
r`οΏ½szDocument.isSupportedcCs>|jtjkrtjοΏ½dοΏ½οΏ½n|jtjkr2tjοΏ½dοΏ½οΏ½t|||οΏ½S)Nzcannot import document nodesz!cannot import document type nodes)rr	rr6r7οΏ½NotSupportedErrr{rW)rrHrYr
r
r
οΏ½
importNodeοΏ½s
zDocument.importNodercCsJ|dkr|οΏ½d|οΏ½n|οΏ½d||fοΏ½|jD]}|οΏ½||||οΏ½q0dS)Nz<?xml version="1.0" ?>z%<?xml version="1.0" encoding="%s"?>%s)rοΏ½r'r)rr$r"r!r#rrHr
r
r
rοΏ½sοΏ½
zDocument.writexmlcCsJ|j|k	r tjοΏ½d||jfοΏ½οΏ½|jtjtjfkr>tjοΏ½dοΏ½οΏ½|t	krοΏ½d|krοΏ½|οΏ½
ddοΏ½\}}|dkrοΏ½|tjjkrοΏ½tjοΏ½dοΏ½οΏ½qοΏ½|dkrοΏ½|tjjkrοΏ½|jtjkrοΏ½tjοΏ½dοΏ½οΏ½d}|}nd}d}|jtjkrοΏ½|j
}|dk	rοΏ½|j}|οΏ½|οΏ½nd}||_||_||_||_|jtjkοΏ½r||_n*||_|dk	οΏ½rF|οΏ½|οΏ½|οΏ½rF|οΏ½|οΏ½|S)Nz?cannot rename nodes from other documents;
expected %s,
found %sz8renameNode() only applies to element and attribute nodesrοΏ½r1rοΏ½zillegal use of 'xmlns' prefixz$illegal use of the 'xmlns' attribute)rXr6r7rοΏ½rr	rSrοΏ½rοΏ½rrοΏ½rrοΏ½rοΏ½rοΏ½rrrοΏ½r~rοΏ½rοΏ½rοΏ½rr#)rrοΏ½r~rοΏ½rrοΏ½r)Zis_idr
r
r
οΏ½
renameNode	sb
οΏ½οΏ½οΏ½
οΏ½οΏ½
οΏ½
οΏ½οΏ½


zDocument.renameNode)rrrN)=r{r|r}rοΏ½r	rSrοΏ½rοΏ½r{r5rοΏ½r[rrrοΏ½rοΏ½rοΏ½r:rDrCrurrοΏ½r_rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r}rοΏ½rοΏ½rrοΏ½rοΏ½rοΏ½rοΏ½r<r;rοΏ½rQrZrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrr`rοΏ½rrοΏ½r
r
r
r
rοΏ½οΏ½sjοΏ½	
:
rοΏ½rοΏ½z#Top-level element of this document.c
CsοΏ½|jοΏ½|οΏ½rtjjj}n
tjjj}|jtj	krοΏ½|οΏ½
|j|jοΏ½}|j
οΏ½οΏ½D]0}|οΏ½|j|j|jοΏ½|οΏ½|j|jοΏ½}|j|_qH|rοΏ½|jD]}t|||οΏ½}|οΏ½|οΏ½qοΏ½οΏ½n|jtjkrοΏ½|οΏ½οΏ½}|rοΏ½|jD]}t|||οΏ½}|οΏ½|οΏ½qnοΏ½|jtjkrοΏ½|οΏ½|jοΏ½}οΏ½nοΏ½|jtjkοΏ½r|οΏ½|jοΏ½}οΏ½nοΏ½|jtjkοΏ½r>|οΏ½|j |jοΏ½}οΏ½nj|jtj!kοΏ½r\|οΏ½"|jοΏ½}οΏ½nL|jtj#kοΏ½rοΏ½|οΏ½$|j|jοΏ½}d|_|j|_οΏ½n|jtj%kοΏ½rοΏ½tjjj}|j&οΏ½'|j(|j)|j*οΏ½}||_|οΏ½rοΏ½g|j+_,g|j-_,|j-j,D]F}	t.|	j|	j)|	j*οΏ½}
||
_|j-j,οΏ½/|
οΏ½t0|	dοΏ½οΏ½rοΏ½|	οΏ½1||	|
οΏ½οΏ½qοΏ½|j+j,D]b}t2|j|j)|j*|j3οΏ½}|j4|_4|j5|_5|j6|_6||_|j+j,οΏ½/|οΏ½t0|dοΏ½οΏ½r.|οΏ½1|||οΏ½οΏ½q.ntjοΏ½7dt8|οΏ½οΏ½οΏ½t0|dοΏ½οΏ½rοΏ½|οΏ½1|||οΏ½|S)NTrvzCannot clone node %s)9rXrdr6r7rprqZ
NODE_IMPORTEDrr	rSrοΏ½r~rοΏ½rοΏ½rοΏ½rrοΏ½rrοΏ½rοΏ½r'rWr<r2rοΏ½rOrοΏ½rPrοΏ½rοΏ½rοΏ½rοΏ½r1rοΏ½rοΏ½rοΏ½rοΏ½r{r[rοΏ½rοΏ½rfrgrlr_rmrrrRrqrvrsrtrurr_rοΏ½r9)
rHrYZnewOwnerDocumentrtrvrrοΏ½rVrGrοΏ½rwrxryr
r
r
rWBsοΏ½
οΏ½


οΏ½οΏ½
οΏ½οΏ½rWcCs,|οΏ½ddοΏ½}t|οΏ½dkr|Sd|dfSdS)NrοΏ½r1οΏ½r)rοΏ½rοΏ½)rZfieldsr
r
r
rοΏ½srcCs,|||οΏ½}|οΏ½οΏ½\}}|οΏ½|οΏ½|οΏ½οΏ½|Sr%)ZgetEventZ
expandNoderοΏ½)οΏ½funcοΏ½argsοΏ½kwargsZeventsZtoktypeZrootNoder
r
r
οΏ½_do_pulldom_parseοΏ½s


rοΏ½cCsH|dkr"|s"ddlm}|οΏ½|οΏ½Sddlm}t|j|f||dοΏ½οΏ½SdS)NrοΏ½οΏ½expatbuilderοΏ½οΏ½pulldom)οΏ½parserοΏ½bufsize)οΏ½xml.domrοΏ½οΏ½parserοΏ½rοΏ½)οΏ½filerοΏ½rοΏ½rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s

οΏ½rοΏ½cCsB|dkrddlm}|οΏ½|οΏ½Sddlm}t|j|fd|iοΏ½SdS)NrrοΏ½rοΏ½rοΏ½)rοΏ½rοΏ½οΏ½parseStringrοΏ½rοΏ½)οΏ½stringrοΏ½rοΏ½rοΏ½r
r
r
rοΏ½οΏ½s

οΏ½rοΏ½cCs@|r:t|tοΏ½rtοΏ½|οΏ½}|D]\}}tjοΏ½||οΏ½sdSqtjSr%)rοΏ½rοΏ½rZ_parse_feature_stringrοΏ½r[r\)ZfeaturesοΏ½fοΏ½vr
r
r
οΏ½getDOMImplementationοΏ½s

rοΏ½)NN)N)N)6rrοΏ½r6rrrrZxml.dom.minicompatZxml.dom.xmlbuilderrrr7r	rSrοΏ½r@ZdefpropertyrJrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½objectrοΏ½Z
AttributeListrοΏ½rοΏ½rrr*r/r9rοΏ½rVr'rZr[r]rdrkrsrrrοΏ½rοΏ½rArοΏ½rWrrοΏ½rοΏ½rοΏ½rοΏ½r
r
r
r
οΏ½<module>sοΏ½οΏ½v
	y$οΏ½
xοΏ½οΏ½)GUοΏ½οΏ½	>οΏ½<(	O*PοΏ½R



U

e5dοΏ½οΏ½@sGddοΏ½dοΏ½ZdS)c@sXeZdZdZdZdZdZdZdZdZ	dZ
dZdZd	Z
d
ZdZdZd
ZdZdZddοΏ½ZdS)οΏ½
NodeFilterzL
    This is the DOM2 NodeFilter interface. It contains only constants.
    οΏ½οΏ½οΏ½lοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½ οΏ½@οΏ½οΏ½iiicCstοΏ½dS)N)οΏ½NotImplementedError)οΏ½selfZnodeοΏ½rοΏ½*/usr/lib64/python3.8/xml/dom/NodeFilter.pyοΏ½
acceptNodeszNodeFilter.acceptNodeN)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½__doc__Z
FILTER_ACCEPTZ
FILTER_REJECTZFILTER_SKIPZSHOW_ALLZSHOW_ELEMENTZSHOW_ATTRIBUTEZ	SHOW_TEXTZSHOW_CDATA_SECTIONZSHOW_ENTITY_REFERENCEZSHOW_ENTITYZSHOW_PROCESSING_INSTRUCTIONZSHOW_COMMENTZ
SHOW_DOCUMENTZSHOW_DOCUMENT_TYPEZSHOW_DOCUMENT_FRAGMENTZ
SHOW_NOTATIONrrrrrrs$rN)rrrrrοΏ½<module>οΏ½"""W3C Document Object Model implementation for Python.

The Python mapping of the Document Object Model is documented in the
Python Library Reference in the section on the xml.dom package.

This package contains the following modules:

minidom -- A simple implementation of the Level 1 DOM with namespace
           support added (based on the Level 2 specification) and other
           minor Level 2 functionality.

pulldom -- DOM builder supporting on-demand tree-building for selected
           subtrees of the document.

"""


class Node:
    """Class giving the NodeType constants."""
    __slots__ = ()

    # DOM implementations may use this as a base class for their own
    # Node implementations.  If they don't, the constants defined here
    # should still be used as the canonical definitions as they match
    # the values given in the W3C recommendation.  Client code can
    # safely refer to these values in all tests of Node.nodeType
    # values.

    ELEMENT_NODE                = 1
    ATTRIBUTE_NODE              = 2
    TEXT_NODE                   = 3
    CDATA_SECTION_NODE          = 4
    ENTITY_REFERENCE_NODE       = 5
    ENTITY_NODE                 = 6
    PROCESSING_INSTRUCTION_NODE = 7
    COMMENT_NODE                = 8
    DOCUMENT_NODE               = 9
    DOCUMENT_TYPE_NODE          = 10
    DOCUMENT_FRAGMENT_NODE      = 11
    NOTATION_NODE               = 12


#ExceptionCode
INDEX_SIZE_ERR                 = 1
DOMSTRING_SIZE_ERR             = 2
HIERARCHY_REQUEST_ERR          = 3
WRONG_DOCUMENT_ERR             = 4
INVALID_CHARACTER_ERR          = 5
NO_DATA_ALLOWED_ERR            = 6
NO_MODIFICATION_ALLOWED_ERR    = 7
NOT_FOUND_ERR                  = 8
NOT_SUPPORTED_ERR              = 9
INUSE_ATTRIBUTE_ERR            = 10
INVALID_STATE_ERR              = 11
SYNTAX_ERR                     = 12
INVALID_MODIFICATION_ERR       = 13
NAMESPACE_ERR                  = 14
INVALID_ACCESS_ERR             = 15
VALIDATION_ERR                 = 16


class DOMException(Exception):
    """Abstract base class for DOM exceptions.
    Exceptions with specific codes are specializations of this class."""

    def __init__(self, *args, **kw):
        if self.__class__ is DOMException:
            raise RuntimeError(
                "DOMException should not be instantiated directly")
        Exception.__init__(self, *args, **kw)

    def _get_code(self):
        return self.code


class IndexSizeErr(DOMException):
    code = INDEX_SIZE_ERR

class DomstringSizeErr(DOMException):
    code = DOMSTRING_SIZE_ERR

class HierarchyRequestErr(DOMException):
    code = HIERARCHY_REQUEST_ERR

class WrongDocumentErr(DOMException):
    code = WRONG_DOCUMENT_ERR

class InvalidCharacterErr(DOMException):
    code = INVALID_CHARACTER_ERR

class NoDataAllowedErr(DOMException):
    code = NO_DATA_ALLOWED_ERR

class NoModificationAllowedErr(DOMException):
    code = NO_MODIFICATION_ALLOWED_ERR

class NotFoundErr(DOMException):
    code = NOT_FOUND_ERR

class NotSupportedErr(DOMException):
    code = NOT_SUPPORTED_ERR

class InuseAttributeErr(DOMException):
    code = INUSE_ATTRIBUTE_ERR

class InvalidStateErr(DOMException):
    code = INVALID_STATE_ERR

class SyntaxErr(DOMException):
    code = SYNTAX_ERR

class InvalidModificationErr(DOMException):
    code = INVALID_MODIFICATION_ERR

class NamespaceErr(DOMException):
    code = NAMESPACE_ERR

class InvalidAccessErr(DOMException):
    code = INVALID_ACCESS_ERR

class ValidationErr(DOMException):
    code = VALIDATION_ERR

class UserDataHandler:
    """Class giving the operation constants for UserDataHandler.handle()."""

    # Based on DOM Level 3 (WD 9 April 2002)

    NODE_CLONED   = 1
    NODE_IMPORTED = 2
    NODE_DELETED  = 3
    NODE_RENAMED  = 4

XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace"
XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/"
XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml"
EMPTY_NAMESPACE = None
EMPTY_PREFIX = None

from .domreg import getDOMImplementation, registerDOMImplementation
# This is the Python mapping for interface NodeFilter from
# DOM2-Traversal-Range. It contains only constants.

class NodeFilter:
    """
    This is the DOM2 NodeFilter interface. It contains only constants.
    """
    FILTER_ACCEPT = 1
    FILTER_REJECT = 2
    FILTER_SKIP   = 3

    SHOW_ALL                    = 0xFFFFFFFF
    SHOW_ELEMENT                = 0x00000001
    SHOW_ATTRIBUTE              = 0x00000002
    SHOW_TEXT                   = 0x00000004
    SHOW_CDATA_SECTION          = 0x00000008
    SHOW_ENTITY_REFERENCE       = 0x00000010
    SHOW_ENTITY                 = 0x00000020
    SHOW_PROCESSING_INSTRUCTION = 0x00000040
    SHOW_COMMENT                = 0x00000080
    SHOW_DOCUMENT               = 0x00000100
    SHOW_DOCUMENT_TYPE          = 0x00000200
    SHOW_DOCUMENT_FRAGMENT      = 0x00000400
    SHOW_NOTATION               = 0x00000800

    def acceptNode(self, node):
        raise NotImplementedError
#
# ElementTree
# $Id: ElementPath.py 3375 2008-02-13 08:05:08Z fredrik $
#
# limited xpath support for element trees
#
# history:
# 2003-05-23 fl   created
# 2003-05-28 fl   added support for // etc
# 2003-08-27 fl   fixed parsing of periods in element names
# 2007-09-10 fl   new selection engine
# 2007-09-12 fl   fixed parent selector
# 2007-09-13 fl   added iterfind; changed findall to return a list
# 2007-11-30 fl   added namespaces support
# 2009-10-30 fl   added child element value filter
#
# Copyright (c) 2003-2009 by Fredrik Lundh.  All rights reserved.
#
# fredrik@pythonware.com
# http://www.pythonware.com
#
# --------------------------------------------------------------------
# The ElementTree toolkit is
#
# Copyright (c) 1999-2009 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------

# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/psf/license for licensing details.

##
# Implementation module for XPath support.  There's usually no reason
# to import this module directly; the <b>ElementTree</b> does this for
# you, if needed.
##

import re

xpath_tokenizer_re = re.compile(
    r"("
    r"'[^']*'|\"[^\"]*\"|"
    r"::|"
    r"//?|"
    r"\.\.|"
    r"\(\)|"
    r"[/.*:\[\]\(\)@=])|"
    r"((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|"
    r"\s+"
    )

def xpath_tokenizer(pattern, namespaces=None):
    default_namespace = namespaces.get('') if namespaces else None
    parsing_attribute = False
    for token in xpath_tokenizer_re.findall(pattern):
        ttype, tag = token
        if tag and tag[0] != "{":
            if ":" in tag:
                prefix, uri = tag.split(":", 1)
                try:
                    if not namespaces:
                        raise KeyError
                    yield ttype, "{%s}%s" % (namespaces[prefix], uri)
                except KeyError:
                    raise SyntaxError("prefix %r not found in prefix map" % prefix) from None
            elif default_namespace and not parsing_attribute:
                yield ttype, "{%s}%s" % (default_namespace, tag)
            else:
                yield token
            parsing_attribute = False
        else:
            yield token
            parsing_attribute = ttype == '@'


def get_parent_map(context):
    parent_map = context.parent_map
    if parent_map is None:
        context.parent_map = parent_map = {}
        for p in context.root.iter():
            for e in p:
                parent_map[e] = p
    return parent_map


def _is_wildcard_tag(tag):
    return tag[:3] == '{*}' or tag[-2:] == '}*'


def _prepare_tag(tag):
    _isinstance, _str = isinstance, str
    if tag == '{*}*':
        # Same as '*', but no comments or processing instructions.
        # It can be a surprise that '*' includes those, but there is no
        # justification for '{*}*' doing the same.
        def select(context, result):
            for elem in result:
                if _isinstance(elem.tag, _str):
                    yield elem
    elif tag == '{}*':
        # Any tag that is not in a namespace.
        def select(context, result):
            for elem in result:
                el_tag = elem.tag
                if _isinstance(el_tag, _str) and el_tag[0] != '{':
                    yield elem
    elif tag[:3] == '{*}':
        # The tag in any (or no) namespace.
        suffix = tag[2:]  # '}name'
        no_ns = slice(-len(suffix), None)
        tag = tag[3:]
        def select(context, result):
            for elem in result:
                el_tag = elem.tag
                if el_tag == tag or _isinstance(el_tag, _str) and el_tag[no_ns] == suffix:
                    yield elem
    elif tag[-2:] == '}*':
        # Any tag in the given namespace.
        ns = tag[:-1]
        ns_only = slice(None, len(ns))
        def select(context, result):
            for elem in result:
                el_tag = elem.tag
                if _isinstance(el_tag, _str) and el_tag[ns_only] == ns:
                    yield elem
    else:
        raise RuntimeError(f"internal parser error, got {tag}")
    return select


def prepare_child(next, token):
    tag = token[1]
    if _is_wildcard_tag(tag):
        select_tag = _prepare_tag(tag)
        def select(context, result):
            def select_child(result):
                for elem in result:
                    yield from elem
            return select_tag(context, select_child(result))
    else:
        if tag[:2] == '{}':
            tag = tag[2:]  # '{}tag' == 'tag'
        def select(context, result):
            for elem in result:
                for e in elem:
                    if e.tag == tag:
                        yield e
    return select

def prepare_star(next, token):
    def select(context, result):
        for elem in result:
            yield from elem
    return select

def prepare_self(next, token):
    def select(context, result):
        yield from result
    return select

def prepare_descendant(next, token):
    try:
        token = next()
    except StopIteration:
        return
    if token[0] == "*":
        tag = "*"
    elif not token[0]:
        tag = token[1]
    else:
        raise SyntaxError("invalid descendant")

    if _is_wildcard_tag(tag):
        select_tag = _prepare_tag(tag)
        def select(context, result):
            def select_child(result):
                for elem in result:
                    for e in elem.iter():
                        if e is not elem:
                            yield e
            return select_tag(context, select_child(result))
    else:
        if tag[:2] == '{}':
            tag = tag[2:]  # '{}tag' == 'tag'
        def select(context, result):
            for elem in result:
                for e in elem.iter(tag):
                    if e is not elem:
                        yield e
    return select

def prepare_parent(next, token):
    def select(context, result):
        # FIXME: raise error if .. is applied at toplevel?
        parent_map = get_parent_map(context)
        result_map = {}
        for elem in result:
            if elem in parent_map:
                parent = parent_map[elem]
                if parent not in result_map:
                    result_map[parent] = None
                    yield parent
    return select

def prepare_predicate(next, token):
    # FIXME: replace with real parser!!! refs:
    # http://effbot.org/zone/simple-iterator-parser.htm
    # http://javascript.crockford.com/tdop/tdop.html
    signature = []
    predicate = []
    while 1:
        try:
            token = next()
        except StopIteration:
            return
        if token[0] == "]":
            break
        if token == ('', ''):
            # ignore whitespace
            continue
        if token[0] and token[0][:1] in "'\"":
            token = "'", token[0][1:-1]
        signature.append(token[0] or "-")
        predicate.append(token[1])
    signature = "".join(signature)
    # use signature to determine predicate type
    if signature == "@-":
        # [@attribute] predicate
        key = predicate[1]
        def select(context, result):
            for elem in result:
                if elem.get(key) is not None:
                    yield elem
        return select
    if signature == "@-='":
        # [@attribute='value']
        key = predicate[1]
        value = predicate[-1]
        def select(context, result):
            for elem in result:
                if elem.get(key) == value:
                    yield elem
        return select
    if signature == "-" and not re.match(r"\-?\d+$", predicate[0]):
        # [tag]
        tag = predicate[0]
        def select(context, result):
            for elem in result:
                if elem.find(tag) is not None:
                    yield elem
        return select
    if signature == ".='" or (signature == "-='" and not re.match(r"\-?\d+$", predicate[0])):
        # [.='value'] or [tag='value']
        tag = predicate[0]
        value = predicate[-1]
        if tag:
            def select(context, result):
                for elem in result:
                    for e in elem.findall(tag):
                        if "".join(e.itertext()) == value:
                            yield elem
                            break
        else:
            def select(context, result):
                for elem in result:
                    if "".join(elem.itertext()) == value:
                        yield elem
        return select
    if signature == "-" or signature == "-()" or signature == "-()-":
        # [index] or [last()] or [last()-index]
        if signature == "-":
            # [index]
            index = int(predicate[0]) - 1
            if index < 0:
                raise SyntaxError("XPath position >= 1 expected")
        else:
            if predicate[0] != "last":
                raise SyntaxError("unsupported function")
            if signature == "-()-":
                try:
                    index = int(predicate[2]) - 1
                except ValueError:
                    raise SyntaxError("unsupported expression")
                if index > -2:
                    raise SyntaxError("XPath offset from last() must be negative")
            else:
                index = -1
        def select(context, result):
            parent_map = get_parent_map(context)
            for elem in result:
                try:
                    parent = parent_map[elem]
                    # FIXME: what if the selector is "*" ?
                    elems = list(parent.findall(elem.tag))
                    if elems[index] is elem:
                        yield elem
                except (IndexError, KeyError):
                    pass
        return select
    raise SyntaxError("invalid predicate")

ops = {
    "": prepare_child,
    "*": prepare_star,
    ".": prepare_self,
    "..": prepare_parent,
    "//": prepare_descendant,
    "[": prepare_predicate,
    }

_cache = {}

class _SelectorContext:
    parent_map = None
    def __init__(self, root):
        self.root = root

# --------------------------------------------------------------------

##
# Generate all matching objects.

def iterfind(elem, path, namespaces=None):
    # compile selector pattern
    if path[-1:] == "/":
        path = path + "*" # implicit all (FIXME: keep this?)

    cache_key = (path,)
    if namespaces:
        cache_key += tuple(sorted(namespaces.items()))

    try:
        selector = _cache[cache_key]
    except KeyError:
        if len(_cache) > 100:
            _cache.clear()
        if path[:1] == "/":
            raise SyntaxError("cannot use absolute path on element")
        next = iter(xpath_tokenizer(path, namespaces)).__next__
        try:
            token = next()
        except StopIteration:
            return
        selector = []
        while 1:
            try:
                selector.append(ops[token[0]](next, token))
            except StopIteration:
                raise SyntaxError("invalid path") from None
            try:
                token = next()
                if token[0] == "/":
                    token = next()
            except StopIteration:
                break
        _cache[cache_key] = selector
    # execute selector pattern
    result = [elem]
    context = _SelectorContext(elem)
    for select in selector:
        result = select(context, result)
    return result

##
# Find first matching object.

def find(elem, path, namespaces=None):
    return next(iterfind(elem, path, namespaces), None)

##
# Find all matching objects.

def findall(elem, path, namespaces=None):
    return list(iterfind(elem, path, namespaces))

##
# Find text for first matching object.

def findtext(elem, path, default=None, namespaces=None):
    try:
        elem = next(iterfind(elem, path, namespaces))
        return elem.text or ""
    except StopIteration:
        return default
#
# ElementTree
# $Id: ElementInclude.py 3375 2008-02-13 08:05:08Z fredrik $
#
# limited xinclude support for element trees
#
# history:
# 2003-08-15 fl   created
# 2003-11-14 fl   fixed default loader
#
# Copyright (c) 2003-2004 by Fredrik Lundh.  All rights reserved.
#
# fredrik@pythonware.com
# http://www.pythonware.com
#
# --------------------------------------------------------------------
# The ElementTree toolkit is
#
# Copyright (c) 1999-2008 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------

# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/psf/license for licensing details.

##
# Limited XInclude support for the ElementTree package.
##

import copy
from . import ElementTree

XINCLUDE = "{http://www.w3.org/2001/XInclude}"

XINCLUDE_INCLUDE = XINCLUDE + "include"
XINCLUDE_FALLBACK = XINCLUDE + "fallback"

##
# Fatal include error.

class FatalIncludeError(SyntaxError):
    pass

##
# Default loader.  This loader reads an included resource from disk.
#
# @param href Resource reference.
# @param parse Parse mode.  Either "xml" or "text".
# @param encoding Optional text encoding (UTF-8 by default for "text").
# @return The expanded resource.  If the parse mode is "xml", this
#    is an ElementTree instance.  If the parse mode is "text", this
#    is a Unicode string.  If the loader fails, it can return None
#    or raise an OSError exception.
# @throws OSError If the loader fails to load the resource.

def default_loader(href, parse, encoding=None):
    if parse == "xml":
        with open(href, 'rb') as file:
            data = ElementTree.parse(file).getroot()
    else:
        if not encoding:
            encoding = 'UTF-8'
        with open(href, 'r', encoding=encoding) as file:
            data = file.read()
    return data

##
# Expand XInclude directives.
#
# @param elem Root element.
# @param loader Optional resource loader.  If omitted, it defaults
#     to {@link default_loader}.  If given, it should be a callable
#     that implements the same interface as <b>default_loader</b>.
# @throws FatalIncludeError If the function fails to include a given
#     resource, or if the tree contains malformed XInclude elements.
# @throws OSError If the function fails to load a given resource.

def include(elem, loader=None):
    if loader is None:
        loader = default_loader
    # look for xinclude elements
    i = 0
    while i < len(elem):
        e = elem[i]
        if e.tag == XINCLUDE_INCLUDE:
            # process xinclude directive
            href = e.get("href")
            parse = e.get("parse", "xml")
            if parse == "xml":
                node = loader(href, parse)
                if node is None:
                    raise FatalIncludeError(
                        "cannot load %r as %r" % (href, parse)
                        )
                node = copy.copy(node)
                if e.tail:
                    node.tail = (node.tail or "") + e.tail
                elem[i] = node
            elif parse == "text":
                text = loader(href, parse, e.get("encoding"))
                if text is None:
                    raise FatalIncludeError(
                        "cannot load %r as %r" % (href, parse)
                        )
                if i:
                    node = elem[i-1]
                    node.tail = (node.tail or "") + text + (e.tail or "")
                else:
                    elem.text = (elem.text or "") + text + (e.tail or "")
                del elem[i]
                continue
            else:
                raise FatalIncludeError(
                    "unknown parse type in xi:include tag (%r)" % parse
                )
        elif e.tag == XINCLUDE_FALLBACK:
            raise FatalIncludeError(
                "xi:fallback tag must be child of xi:include (%r)" % e.tag
                )
        else:
            include(e, loader)
        i = i + 1
U

e5dDοΏ½@sdS)NοΏ½rrrοΏ½*/usr/lib64/python3.8/xml/etree/__init__.pyοΏ½<module>οΏ½U

e5dRοΏ½@sddlTdS)οΏ½)οΏ½*N)Zxml.etree.ElementTreeοΏ½rrοΏ½./usr/lib64/python3.8/xml/etree/cElementTree.pyοΏ½<module>οΏ½U

e5dοΏ½@sPddlZddlmZdZedZedZGddοΏ½deοΏ½Zdd	d
οΏ½Zd
ddοΏ½Z	dS)οΏ½NοΏ½)οΏ½ElementTreez!{http://www.w3.org/2001/XInclude}οΏ½includeZfallbackc@seZdZdS)οΏ½FatalIncludeErrorN)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½r	r	οΏ½0/usr/lib64/python3.8/xml/etree/ElementInclude.pyr>src	Cs\|dkr.t|dοΏ½οΏ½}tοΏ½|οΏ½οΏ½οΏ½}W5QRXn*|s6d}t|d|dοΏ½οΏ½}|οΏ½οΏ½}W5QRX|S)NοΏ½xmlοΏ½rbzUTF-8οΏ½r)οΏ½encoding)οΏ½openrοΏ½parseZgetrootοΏ½read)οΏ½hrefrrοΏ½fileοΏ½datar	r	r
οΏ½default_loaderMsrcCsh|dkrt}d}|t|οΏ½kοΏ½rd||}|jtkοΏ½r4|οΏ½dοΏ½}|οΏ½ddοΏ½}|dkrοΏ½|||οΏ½}|dkrrtd||fοΏ½οΏ½tοΏ½|οΏ½}|jrοΏ½|jpοΏ½d|j|_|||<nοΏ½|dkοΏ½r&||||οΏ½dοΏ½οΏ½}|dkrοΏ½td||fοΏ½οΏ½|rοΏ½||d	}|jpοΏ½d||jpοΏ½d|_n|jοΏ½pd||jοΏ½pd|_||=qntd
|οΏ½οΏ½n&|jt	kοΏ½rPtd|jοΏ½οΏ½n
t
||οΏ½|d	}qdS)Nrrrrzcannot load %r as %rοΏ½οΏ½textrrz)unknown parse type in xi:include tag (%r)z0xi:fallback tag must be child of xi:include (%r))rοΏ½lenοΏ½tagοΏ½XINCLUDE_INCLUDEοΏ½getrοΏ½copyοΏ½tailrοΏ½XINCLUDE_FALLBACKr)οΏ½elemοΏ½loaderοΏ½iοΏ½errZnoderr	r	r
rcsN


οΏ½



οΏ½οΏ½οΏ½
)N)N)
rrrZXINCLUDErrοΏ½SyntaxErrorrrrr	r	r	r
οΏ½<module>3s
U

e5d>3οΏ½@sοΏ½ddlZeοΏ½dοΏ½Zd"ddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½ZddοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½Zeee	ee
edοΏ½Z
iZGddοΏ½dοΏ½Zd#ddοΏ½Zd$ddοΏ½Zd%ddοΏ½Zd&d d!οΏ½ZdS)'οΏ½Nz\('[^']*'|\"[^\"]*\"|::|//?|\.\.|\(\)|[/.*:\[\]\(\)@=])|((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|\s+c		csοΏ½|r|οΏ½dοΏ½nd}d}tοΏ½|οΏ½D]οΏ½}|\}}|rοΏ½|ddkrοΏ½d|krοΏ½|οΏ½ddοΏ½\}}z"|s^tοΏ½|d|||ffVWqοΏ½tk
rοΏ½td|οΏ½dοΏ½YqοΏ½Xn"|rοΏ½|sοΏ½|d||ffVn|Vd}q |V|d	k}q dS)
NοΏ½FrοΏ½{οΏ½:οΏ½z{%s}%sz!prefix %r not found in prefix mapοΏ½@)οΏ½getοΏ½xpath_tokenizer_reοΏ½findallοΏ½splitοΏ½KeyErrorοΏ½SyntaxError)	οΏ½patternοΏ½
namespacesZdefault_namespaceZparsing_attributeοΏ½tokenZttypeοΏ½tagοΏ½prefixZuriοΏ½rοΏ½-/usr/lib64/python3.8/xml/etree/ElementPath.pyοΏ½xpath_tokenizerIs&rcCs>|j}|dkr:i|_}|jοΏ½οΏ½D]}|D]}|||<q*q"|SοΏ½N)οΏ½
parent_mapοΏ½rootοΏ½iter)οΏ½contextrοΏ½pοΏ½errrοΏ½get_parent_mapas
rcCs |ddοΏ½dkp|ddοΏ½dkS)NοΏ½οΏ½{*}οΏ½οΏ½οΏ½οΏ½}*rοΏ½rrrrοΏ½_is_wildcard_tagksr"csοΏ½ttοΏ½οΏ½οΏ½dkr"οΏ½οΏ½fddοΏ½}nοΏ½οΏ½dkr:οΏ½οΏ½fddοΏ½}nοΏ½οΏ½ddοΏ½dkrοΏ½οΏ½ddοΏ½οΏ½ttοΏ½οΏ½dοΏ½οΏ½οΏ½ddοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½fd	dοΏ½}nLοΏ½d
d�dkrƈdd��tdt��������fd
dοΏ½}ntdοΏ½οΏ½οΏ½οΏ½οΏ½|S)Nz{*}*c3s |D]}οΏ½|jοΏ½οΏ½r|VqdSrr!οΏ½rοΏ½resultοΏ½elemοΏ½οΏ½_isinstanceοΏ½_strrrοΏ½selectusz_prepare_tag.<locals>.selectz{}*c3s0|D]&}|j}οΏ½|οΏ½οΏ½r|ddkr|VqdS)Nrrr!οΏ½rr$r%Zel_tagr&rrr){srrοΏ½c3s8|D].}|j}|οΏ½ks,οΏ½|οΏ½οΏ½r|οΏ½οΏ½kr|VqdSrr!r*)r'r(οΏ½no_nsοΏ½suffixrrrr)οΏ½srr οΏ½οΏ½οΏ½c3s0|D]&}|j}οΏ½|οΏ½οΏ½r|οΏ½οΏ½kr|VqdSrr!r*)r'r(οΏ½nsοΏ½ns_onlyrrr)οΏ½szinternal parser error, got )οΏ½
isinstanceοΏ½strοΏ½sliceοΏ½lenοΏ½RuntimeError)rr)r)r'r(r,r/r0r-rrοΏ½_prepare_tagos 
r6csR|dοΏ½tοΏ½οΏ½r&tοΏ½οΏ½οΏ½οΏ½fddοΏ½}n(οΏ½ddοΏ½dkrBοΏ½ddοΏ½οΏ½οΏ½fddοΏ½}|S)NrcsddοΏ½}οΏ½|||οΏ½οΏ½S)Ncss|D]}|EdHqdSrr)r$r%rrrοΏ½select_childοΏ½sz3prepare_child.<locals>.select.<locals>.select_childrοΏ½rr$r7οΏ½οΏ½
select_tagrrr)οΏ½szprepare_child.<locals>.selectr+οΏ½{}c3s(|D]}|D]}|jοΏ½kr|VqqdSrr!οΏ½rr$r%rr!rrr)οΏ½s
)r"r6οΏ½οΏ½nextrr)rοΏ½r:rrοΏ½
prepare_childοΏ½sr@cCsddοΏ½}|S)Ncss|D]}|EdHqdSrrr#rrrr)οΏ½szprepare_star.<locals>.selectrr=rrrοΏ½prepare_starοΏ½srAcCsddοΏ½}|S)Ncss|EdHdSrr)rr$rrrr)οΏ½szprepare_self.<locals>.selectrr=rrrοΏ½prepare_selfοΏ½srBcsοΏ½z
|οΏ½}Wntk
r YdSX|ddkr4dοΏ½n|dsF|dοΏ½ntdοΏ½οΏ½tοΏ½οΏ½rltοΏ½οΏ½οΏ½οΏ½fddοΏ½}n(οΏ½ddοΏ½dkrοΏ½οΏ½ddοΏ½οΏ½οΏ½fd	dοΏ½}|S)
NrοΏ½*rzinvalid descendantcsddοΏ½}οΏ½|||οΏ½οΏ½S)Ncss*|D] }|οΏ½οΏ½D]}||k	r|VqqdSrοΏ½r)r$r%rrrrr7οΏ½sz8prepare_descendant.<locals>.select.<locals>.select_childrr8r9rrr)οΏ½sz"prepare_descendant.<locals>.selectr+r;c3s,|D]"}|οΏ½οΏ½οΏ½D]}||k	r|VqqdSrrDr<r!rrr)οΏ½s)οΏ½
StopIterationrr"r6r=rr?rοΏ½prepare_descendantοΏ½s 

rFcCsddοΏ½}|S)Ncss@t|οΏ½}i}|D]*}||kr||}||krd||<|VqdSr)r)rr$rZ
result_mapr%οΏ½parentrrrr)οΏ½szprepare_parent.<locals>.selectrr=rrrοΏ½prepare_parentοΏ½s
rHcsLg}g}z
|οΏ½}Wntk
r(YdSX|ddkr8qοΏ½|dkrBq|drr|dddοΏ½dkrrd|dddοΏ½f}|οΏ½|dpοΏ½dοΏ½|οΏ½|dοΏ½qd	οΏ½|οΏ½}|d
krοΏ½|dοΏ½οΏ½fddοΏ½}|S|d
krοΏ½|dοΏ½|dοΏ½οΏ½οΏ½fddοΏ½}|S|dkοΏ½rtοΏ½d|dοΏ½οΏ½s|dοΏ½οΏ½fddοΏ½}|S|dkοΏ½sB|dkοΏ½rxtοΏ½d|dοΏ½οΏ½sx|dοΏ½|dοΏ½οΏ½οΏ½rhοΏ½οΏ½fddοΏ½}nοΏ½fddοΏ½}|S|dkοΏ½sοΏ½|dkοΏ½sοΏ½|dkοΏ½r@|dkοΏ½rοΏ½t|dοΏ½dοΏ½οΏ½dkοΏ½r0tdοΏ½οΏ½nl|ddkοΏ½rοΏ½tdοΏ½οΏ½|dkοΏ½r,zt|dοΏ½dοΏ½Wntk
οΏ½rtdοΏ½οΏ½YnXοΏ½dkοΏ½r0tdοΏ½οΏ½ndοΏ½οΏ½fddοΏ½}|StdοΏ½οΏ½dS) NrοΏ½])rrrz'"οΏ½'r.οΏ½-rz@-c3s"|D]}|οΏ½οΏ½οΏ½dk	r|VqdSrοΏ½rr#)οΏ½keyrrr)οΏ½sz!prepare_predicate.<locals>.selectz@-='c3s"|D]}|οΏ½οΏ½οΏ½οΏ½kr|VqdSrrLr#)rMοΏ½valuerrr)sz\-?\d+$c3s"|D]}|οΏ½οΏ½οΏ½dk	r|VqdSr)οΏ½findr#r!rrr)sz.='z-='c3s:|D]0}|οΏ½οΏ½οΏ½D] }dοΏ½|οΏ½οΏ½οΏ½οΏ½kr|VqqqdSοΏ½Nr)r	οΏ½joinοΏ½itertextr<)rrNrrr)s
c3s&|D]}dοΏ½|οΏ½οΏ½οΏ½οΏ½kr|VqdSrP)rQrRr#)rNrrr)sz-()z-()-zXPath position >= 1 expectedZlastzunsupported functionr+zunsupported expressionrz)XPath offset from last() must be negativec
3s^t|οΏ½}|D]L}z.||}t|οΏ½|jοΏ½οΏ½}|οΏ½|kr<|VWqttfk
rVYqXqdSr)rοΏ½listr	rοΏ½
IndexErrorr)rr$rr%rGZelems)οΏ½indexrrr)5s
zinvalid predicate)rEοΏ½appendrQοΏ½reοΏ½matchοΏ½intrοΏ½
ValueError)r>rZ	signatureZ	predicater)r)rUrMrrNrοΏ½prepare_predicateοΏ½sj

&





r[)rrCοΏ½.z..z//οΏ½[c@seZdZdZddοΏ½ZdS)οΏ½_SelectorContextNcCs
||_dSr)r)οΏ½selfrrrrοΏ½__init__Psz_SelectorContext.__init__)οΏ½__name__οΏ½
__module__οΏ½__qualname__rr`rrrrr^Nsr^c
Csj|ddοΏ½dkr|d}|f}|r6|tt|οΏ½οΏ½οΏ½οΏ½7}zt|}WοΏ½nοΏ½tk
οΏ½r@ttοΏ½dkrjtοΏ½οΏ½|ddοΏ½dkrοΏ½tdοΏ½οΏ½tt	||οΏ½οΏ½j
}z
|οΏ½}Wntk
rοΏ½YYdSXg}z|οΏ½t
|d||οΏ½οΏ½Wntk
rοΏ½tdοΏ½dοΏ½YnXz|οΏ½}|ddkοΏ½r|οΏ½}WqοΏ½tk
οΏ½r0YοΏ½q4YqοΏ½XqοΏ½|t|<YnX|g}t|οΏ½}|D]}	|	||οΏ½}οΏ½qT|S)	Nr.οΏ½/rCοΏ½drz#cannot use absolute path on elementrzinvalid path)οΏ½tupleοΏ½sortedοΏ½itemsοΏ½_cacherr4οΏ½clearrrrοΏ½__next__rErVοΏ½opsr^)
r%οΏ½pathrZ	cache_keyZselectorr>rr$rr)rrrοΏ½iterfindXsD


rncCstt|||οΏ½dοΏ½Sr)r>rnοΏ½r%rmrrrrrOοΏ½srOcCstt|||οΏ½οΏ½Sr)rSrnrorrrr	οΏ½sr	cCs:ztt|||οΏ½οΏ½}|jpdWStk
r4|YSXdSrP)r>rnοΏ½textrE)r%rmοΏ½defaultrrrrοΏ½findtextοΏ½s
rr)N)N)N)N)NN)rWοΏ½compilerrrr"r6r@rArBrFrHr[rlrir^rnrOr	rrrrrrοΏ½<module>;s4οΏ½

)
bοΏ½	

,

U

e5dRοΏ½@sddlTdS)οΏ½)οΏ½*N)Zxml.etree.ElementTreeοΏ½rrοΏ½./usr/lib64/python3.8/xml/etree/cElementTree.pyοΏ½<module>οΏ½U

e5dDοΏ½@sdS)NοΏ½rrrοΏ½*/usr/lib64/python3.8/xml/etree/__init__.pyοΏ½<module>οΏ½U

e5dDοΏ½@sdS)NοΏ½rrrοΏ½*/usr/lib64/python3.8/xml/etree/__init__.pyοΏ½<module>οΏ½U

e5d>3οΏ½@sοΏ½ddlZeοΏ½dοΏ½Zd"ddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½ZddοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½Zeee	ee
edοΏ½Z
iZGddοΏ½dοΏ½Zd#ddοΏ½Zd$ddοΏ½Zd%ddοΏ½Zd&d d!οΏ½ZdS)'οΏ½Nz\('[^']*'|\"[^\"]*\"|::|//?|\.\.|\(\)|[/.*:\[\]\(\)@=])|((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|\s+c		csοΏ½|r|οΏ½dοΏ½nd}d}tοΏ½|οΏ½D]οΏ½}|\}}|rοΏ½|ddkrοΏ½d|krοΏ½|οΏ½ddοΏ½\}}z"|s^tοΏ½|d|||ffVWqοΏ½tk
rοΏ½td|οΏ½dοΏ½YqοΏ½Xn"|rοΏ½|sοΏ½|d||ffVn|Vd}q |V|d	k}q dS)
NοΏ½FrοΏ½{οΏ½:οΏ½z{%s}%sz!prefix %r not found in prefix mapοΏ½@)οΏ½getοΏ½xpath_tokenizer_reοΏ½findallοΏ½splitοΏ½KeyErrorοΏ½SyntaxError)	οΏ½patternοΏ½
namespacesZdefault_namespaceZparsing_attributeοΏ½tokenZttypeοΏ½tagοΏ½prefixZuriοΏ½rοΏ½-/usr/lib64/python3.8/xml/etree/ElementPath.pyοΏ½xpath_tokenizerIs&rcCs>|j}|dkr:i|_}|jοΏ½οΏ½D]}|D]}|||<q*q"|SοΏ½N)οΏ½
parent_mapοΏ½rootοΏ½iter)οΏ½contextrοΏ½pοΏ½errrοΏ½get_parent_mapas
rcCs |ddοΏ½dkp|ddοΏ½dkS)NοΏ½οΏ½{*}οΏ½οΏ½οΏ½οΏ½}*rοΏ½rrrrοΏ½_is_wildcard_tagksr"csοΏ½ttοΏ½οΏ½οΏ½dkr"οΏ½οΏ½fddοΏ½}nοΏ½οΏ½dkr:οΏ½οΏ½fddοΏ½}nοΏ½οΏ½ddοΏ½dkrοΏ½οΏ½ddοΏ½οΏ½ttοΏ½οΏ½dοΏ½οΏ½οΏ½ddοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½fd	dοΏ½}nLοΏ½d
d�dkrƈdd��tdt��������fd
dοΏ½}ntdοΏ½οΏ½οΏ½οΏ½οΏ½|S)Nz{*}*c3s |D]}οΏ½|jοΏ½οΏ½r|VqdSrr!οΏ½rοΏ½resultοΏ½elemοΏ½οΏ½_isinstanceοΏ½_strrrοΏ½selectusz_prepare_tag.<locals>.selectz{}*c3s0|D]&}|j}οΏ½|οΏ½οΏ½r|ddkr|VqdS)Nrrr!οΏ½rr$r%Zel_tagr&rrr){srrοΏ½c3s8|D].}|j}|οΏ½ks,οΏ½|οΏ½οΏ½r|οΏ½οΏ½kr|VqdSrr!r*)r'r(οΏ½no_nsοΏ½suffixrrrr)οΏ½srr οΏ½οΏ½οΏ½c3s0|D]&}|j}οΏ½|οΏ½οΏ½r|οΏ½οΏ½kr|VqdSrr!r*)r'r(οΏ½nsοΏ½ns_onlyrrr)οΏ½szinternal parser error, got )οΏ½
isinstanceοΏ½strοΏ½sliceοΏ½lenοΏ½RuntimeError)rr)r)r'r(r,r/r0r-rrοΏ½_prepare_tagos 
r6csR|dοΏ½tοΏ½οΏ½r&tοΏ½οΏ½οΏ½οΏ½fddοΏ½}n(οΏ½ddοΏ½dkrBοΏ½ddοΏ½οΏ½οΏ½fddοΏ½}|S)NrcsddοΏ½}οΏ½|||οΏ½οΏ½S)Ncss|D]}|EdHqdSrr)r$r%rrrοΏ½select_childοΏ½sz3prepare_child.<locals>.select.<locals>.select_childrοΏ½rr$r7οΏ½οΏ½
select_tagrrr)οΏ½szprepare_child.<locals>.selectr+οΏ½{}c3s(|D]}|D]}|jοΏ½kr|VqqdSrr!οΏ½rr$r%rr!rrr)οΏ½s
)r"r6οΏ½οΏ½nextrr)rοΏ½r:rrοΏ½
prepare_childοΏ½sr@cCsddοΏ½}|S)Ncss|D]}|EdHqdSrrr#rrrr)οΏ½szprepare_star.<locals>.selectrr=rrrοΏ½prepare_starοΏ½srAcCsddοΏ½}|S)Ncss|EdHdSrr)rr$rrrr)οΏ½szprepare_self.<locals>.selectrr=rrrοΏ½prepare_selfοΏ½srBcsοΏ½z
|οΏ½}Wntk
r YdSX|ddkr4dοΏ½n|dsF|dοΏ½ntdοΏ½οΏ½tοΏ½οΏ½rltοΏ½οΏ½οΏ½οΏ½fddοΏ½}n(οΏ½ddοΏ½dkrοΏ½οΏ½ddοΏ½οΏ½οΏ½fd	dοΏ½}|S)
NrοΏ½*rzinvalid descendantcsddοΏ½}οΏ½|||οΏ½οΏ½S)Ncss*|D] }|οΏ½οΏ½D]}||k	r|VqqdSrοΏ½r)r$r%rrrrr7οΏ½sz8prepare_descendant.<locals>.select.<locals>.select_childrr8r9rrr)οΏ½sz"prepare_descendant.<locals>.selectr+r;c3s,|D]"}|οΏ½οΏ½οΏ½D]}||k	r|VqqdSrrDr<r!rrr)οΏ½s)οΏ½
StopIterationrr"r6r=rr?rοΏ½prepare_descendantοΏ½s 

rFcCsddοΏ½}|S)Ncss@t|οΏ½}i}|D]*}||kr||}||krd||<|VqdSr)r)rr$rZ
result_mapr%οΏ½parentrrrr)οΏ½szprepare_parent.<locals>.selectrr=rrrοΏ½prepare_parentοΏ½s
rHcsLg}g}z
|οΏ½}Wntk
r(YdSX|ddkr8qοΏ½|dkrBq|drr|dddοΏ½dkrrd|dddοΏ½f}|οΏ½|dpοΏ½dοΏ½|οΏ½|dοΏ½qd	οΏ½|οΏ½}|d
krοΏ½|dοΏ½οΏ½fddοΏ½}|S|d
krοΏ½|dοΏ½|dοΏ½οΏ½οΏ½fddοΏ½}|S|dkοΏ½rtοΏ½d|dοΏ½οΏ½s|dοΏ½οΏ½fddοΏ½}|S|dkοΏ½sB|dkοΏ½rxtοΏ½d|dοΏ½οΏ½sx|dοΏ½|dοΏ½οΏ½οΏ½rhοΏ½οΏ½fddοΏ½}nοΏ½fddοΏ½}|S|dkοΏ½sοΏ½|dkοΏ½sοΏ½|dkοΏ½r@|dkοΏ½rοΏ½t|dοΏ½dοΏ½οΏ½dkοΏ½r0tdοΏ½οΏ½nl|ddkοΏ½rοΏ½tdοΏ½οΏ½|dkοΏ½r,zt|dοΏ½dοΏ½Wntk
οΏ½rtdοΏ½οΏ½YnXοΏ½dkοΏ½r0tdοΏ½οΏ½ndοΏ½οΏ½fddοΏ½}|StdοΏ½οΏ½dS) NrοΏ½])rrrz'"οΏ½'r.οΏ½-rz@-c3s"|D]}|οΏ½οΏ½οΏ½dk	r|VqdSrοΏ½rr#)οΏ½keyrrr)οΏ½sz!prepare_predicate.<locals>.selectz@-='c3s"|D]}|οΏ½οΏ½οΏ½οΏ½kr|VqdSrrLr#)rMοΏ½valuerrr)sz\-?\d+$c3s"|D]}|οΏ½οΏ½οΏ½dk	r|VqdSr)οΏ½findr#r!rrr)sz.='z-='c3s:|D]0}|οΏ½οΏ½οΏ½D] }dοΏ½|οΏ½οΏ½οΏ½οΏ½kr|VqqqdSοΏ½Nr)r	οΏ½joinοΏ½itertextr<)rrNrrr)s
c3s&|D]}dοΏ½|οΏ½οΏ½οΏ½οΏ½kr|VqdSrP)rQrRr#)rNrrr)sz-()z-()-zXPath position >= 1 expectedZlastzunsupported functionr+zunsupported expressionrz)XPath offset from last() must be negativec
3s^t|οΏ½}|D]L}z.||}t|οΏ½|jοΏ½οΏ½}|οΏ½|kr<|VWqttfk
rVYqXqdSr)rοΏ½listr	rοΏ½
IndexErrorr)rr$rr%rGZelems)οΏ½indexrrr)5s
zinvalid predicate)rEοΏ½appendrQοΏ½reοΏ½matchοΏ½intrοΏ½
ValueError)r>rZ	signatureZ	predicater)r)rUrMrrNrοΏ½prepare_predicateοΏ½sj

&





r[)rrCοΏ½.z..z//οΏ½[c@seZdZdZddοΏ½ZdS)οΏ½_SelectorContextNcCs
||_dSr)r)οΏ½selfrrrrοΏ½__init__Psz_SelectorContext.__init__)οΏ½__name__οΏ½
__module__οΏ½__qualname__rr`rrrrr^Nsr^c
Csj|ddοΏ½dkr|d}|f}|r6|tt|οΏ½οΏ½οΏ½οΏ½7}zt|}WοΏ½nοΏ½tk
οΏ½r@ttοΏ½dkrjtοΏ½οΏ½|ddοΏ½dkrοΏ½tdοΏ½οΏ½tt	||οΏ½οΏ½j
}z
|οΏ½}Wntk
rοΏ½YYdSXg}z|οΏ½t
|d||οΏ½οΏ½Wntk
rοΏ½tdοΏ½dοΏ½YnXz|οΏ½}|ddkοΏ½r|οΏ½}WqοΏ½tk
οΏ½r0YοΏ½q4YqοΏ½XqοΏ½|t|<YnX|g}t|οΏ½}|D]}	|	||οΏ½}οΏ½qT|S)	Nr.οΏ½/rCοΏ½drz#cannot use absolute path on elementrzinvalid path)οΏ½tupleοΏ½sortedοΏ½itemsοΏ½_cacherr4οΏ½clearrrrοΏ½__next__rErVοΏ½opsr^)
r%οΏ½pathrZ	cache_keyZselectorr>rr$rr)rrrοΏ½iterfindXsD


rncCstt|||οΏ½dοΏ½Sr)r>rnοΏ½r%rmrrrrrOοΏ½srOcCstt|||οΏ½οΏ½Sr)rSrnrorrrr	οΏ½sr	cCs:ztt|||οΏ½οΏ½}|jpdWStk
r4|YSXdSrP)r>rnοΏ½textrE)r%rmοΏ½defaultrrrrοΏ½findtextοΏ½s
rr)N)N)N)N)NN)rWοΏ½compilerrrr"r6r@rArBrFrHr[rlrir^rnrOr	rrrrrrοΏ½<module>;s4οΏ½

)
bοΏ½	

,

U

e5dοΏ½οΏ½@sοΏ½dZddddddddd	d
ddd
ddddddddddddgZdZddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZGdd
οΏ½d
eοΏ½Z
d dοΏ½ZGd!dοΏ½dοΏ½Zifd"dοΏ½Zd]d#dοΏ½Zd^d$dοΏ½ZeZGd%d
οΏ½d
οΏ½ZGd&dοΏ½dοΏ½Ze	jd'd(οΏ½οΏ½Zd_d)d*οΏ½Zd+d,οΏ½Zd-ZzeeοΏ½ZWnek
οΏ½r.YnXd.d/οΏ½Zd0d1οΏ½Zeeed2οΏ½Zd3dοΏ½Z d4d5d6d7d8d9d:d;οΏ½Z!e!e _!d<d=οΏ½Z"d>d?οΏ½Z#d@dAοΏ½Z$dBdCοΏ½Z%d`dddDdEοΏ½dFdοΏ½Z&GdGdHοΏ½dHej'οΏ½Z(dadddDdEοΏ½dIdοΏ½Z)dJdοΏ½Z*dbdKd	οΏ½Z+dcdLdοΏ½Z,GdMdοΏ½dοΏ½Z-dddNdοΏ½Z.dedOdοΏ½Z/e.Z0dfdPdοΏ½Z1GdQdοΏ½dοΏ½Z2GdRdοΏ½dοΏ½Z3dgdddSοΏ½dTdοΏ½Z4eοΏ½5dUej6οΏ½j7Z8GdVdοΏ½dοΏ½Z9dWdXοΏ½Z:dYdZοΏ½Z;zeZ<dd[l=Tdd\l=m>Z>Wne?k
οΏ½rοΏ½YnXe>eeοΏ½dS)haLightweight XML support for Python.

 XML is an inherently hierarchical data format, and the most natural way to
 represent it is with a tree.  This module has two classes for this purpose:

    1. ElementTree represents the whole XML document as a tree and

    2. Element represents a single node in this tree.

 Interactions with the whole document (reading and writing to/from files) are
 usually done on the ElementTree level.  Interactions with a single XML element
 and its sub-elements are done on the Element level.

 Element is a flexible container object designed to store hierarchical data
 structures in memory. It can be described as a cross between a list and a
 dictionary.  Each Element has a number of properties associated with it:

    'tag' - a string containing the element's name.

    'attributes' - a Python dictionary storing the element's attributes.

    'text' - a string containing the element's text content.

    'tail' - an optional string containing text after the element's end tag.

    And a number of child elements stored in a Python sequence.

 To create an element instance, use the Element constructor,
 or the SubElement factory function.

 You can also use the ElementTree class to wrap an element structure
 and convert it to and from XML.

οΏ½CommentοΏ½dumpοΏ½ElementοΏ½ElementTreeοΏ½
fromstringοΏ½fromstringlistοΏ½	iselementοΏ½	iterparseοΏ½parseοΏ½
ParseErrorοΏ½PIοΏ½ProcessingInstructionοΏ½QNameοΏ½
SubElementοΏ½tostringοΏ½tostringlistοΏ½TreeBuilderοΏ½VERSIONοΏ½XMLοΏ½XMLIDοΏ½	XMLParserοΏ½
XMLPullParserοΏ½register_namespaceοΏ½canonicalizeοΏ½C14NWriterTargetz1.3.0οΏ½NοΏ½)οΏ½ElementPathc@seZdZdZdS)r
zοΏ½An error when parsing an XML document.

    In addition to its exception value, a ParseError contains
    two extra attributes:
        'code'     - the specific exception code
        'position' - the line and column of the error

    N)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½__doc__οΏ½r!r!οΏ½-/usr/lib64/python3.8/xml/etree/ElementTree.pyr
jscCs
t|dοΏ½S)z2Return True if *element* appears to be an Element.οΏ½tag)οΏ½hasattr)οΏ½elementr!r!r"rxsc@s
eZdZdZdZdZdZdZifddοΏ½ZddοΏ½Z	ddοΏ½Z
d	d
οΏ½ZddοΏ½Zd
dοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zdd οΏ½Zd9d!d"οΏ½Zd:d#d$οΏ½Zd;d%d&οΏ½Zd<d'd(οΏ½Zd)d*οΏ½Zd=d+d,οΏ½Zd-d.οΏ½Zd/d0οΏ½Zd1d2οΏ½Zd>d3d4οΏ½Z d?d5d6οΏ½Z!d7d8οΏ½Z"dS)@rahAn XML element.

    This class is the reference implementation of the Element interface.

    An element's length is its number of subelements.  That means if you
    want to check if an element is truly empty, you should check BOTH
    its length AND its text attribute.

    The element tag, attribute names, and attribute values can be either
    bytes or strings.

    *tag* is the element name.  *attrib* is an optional dictionary containing
    element attributes. *extra* are additional element attributes given as
    keyword arguments.

    Example form:
        <tag attrib>text<child/>...</tag>tail

    NcKs6t|tοΏ½std|jjfοΏ½οΏ½||_||οΏ½|_g|_dS)Nzattrib must be dict, not %s)οΏ½
isinstanceοΏ½dictοΏ½	TypeErrorοΏ½	__class__rr#οΏ½attribοΏ½	_children)οΏ½selfr#r*οΏ½extrar!r!r"οΏ½__init__οΏ½s
οΏ½
zElement.__init__cCsd|jj|jt|οΏ½fS)Nz<%s %r at %#x>)r)rr#οΏ½idοΏ½r,r!r!r"οΏ½__repr__οΏ½szElement.__repr__cCs|οΏ½||οΏ½S)zοΏ½Create a new element with the same type.

        *tag* is a string containing the element name.
        *attrib* is a dictionary containing the element attributes.

        Do not call this method, use the SubElement factory function instead.

        )r))r,r#r*r!r!r"οΏ½makeelementοΏ½s	zElement.makeelementcCs0|οΏ½|j|jοΏ½}|j|_|j|_||ddοΏ½<|S)zοΏ½Return copy of current element.

        This creates a shallow copy. Subelements will be shared with the
        original tree.

        N)r2r#r*οΏ½textοΏ½tail)r,οΏ½elemr!r!r"οΏ½copyοΏ½s
zElement.copycCs
t|jοΏ½SοΏ½N)οΏ½lenr+r0r!r!r"οΏ½__len__οΏ½szElement.__len__cCstjdtddοΏ½t|jοΏ½dkS)NzyThe behavior of this method will change in future versions.  Use specific 'len(elem)' or 'elem is not None' test instead.οΏ½οΏ½οΏ½
stacklevelr)οΏ½warningsοΏ½warnοΏ½
FutureWarningr8r+r0r!r!r"οΏ½__bool__οΏ½sοΏ½zElement.__bool__cCs
|j|Sr7οΏ½r+οΏ½r,οΏ½indexr!r!r"οΏ½__getitem__οΏ½szElement.__getitem__cCs8t|tοΏ½r |D]}|οΏ½|οΏ½qn
|οΏ½|οΏ½||j|<dSr7)r&οΏ½sliceοΏ½_assert_is_elementr+)r,rCr%Zeltr!r!r"οΏ½__setitem__οΏ½s


zElement.__setitem__cCs|j|=dSr7rArBr!r!r"οΏ½__delitem__οΏ½szElement.__delitem__cCs|οΏ½|οΏ½|jοΏ½|οΏ½dS)aAdd *subelement* to the end of this element.

        The new element will appear in document order after the last existing
        subelement (or directly after the text, if it's the first subelement),
        but before the end tag for this element.

        NοΏ½rFr+οΏ½appendοΏ½r,οΏ½
subelementr!r!r"rJοΏ½s
zElement.appendcCs$|D]}|οΏ½|οΏ½|jοΏ½|οΏ½qdS)zkAppend subelements from a sequence.

        *elements* is a sequence with zero or more elements.

        NrI)r,οΏ½elementsr%r!r!r"οΏ½extendοΏ½s
zElement.extendcCs|οΏ½|οΏ½|jοΏ½||οΏ½dS)z(Insert *subelement* at position *index*.N)rFr+οΏ½insert)r,rCrLr!r!r"rOοΏ½s
zElement.insertcCs t|tοΏ½stdt|οΏ½jοΏ½οΏ½dS)Nzexpected an Element, not %s)r&οΏ½_Element_Pyr(οΏ½typer)r,οΏ½er!r!r"rFοΏ½s
zElement._assert_is_elementcCs|jοΏ½|οΏ½dS)aοΏ½Remove matching subelement.

        Unlike the find methods, this method compares elements based on
        identity, NOT ON tag value or contents.  To remove subelements by
        other means, the easiest way is to use a list comprehension to
        select what elements to keep, and then use slice assignment to update
        the parent element.

        ValueError is raised if a matching element could not be found.

        N)r+οΏ½removerKr!r!r"rSs
zElement.removecCstjdtddοΏ½|jS)z`(Deprecated) Return all subelements.

        Elements are returned in document order.

        zaThis method will be removed in future versions.  Use 'list(elem)' or iteration over elem instead.r:r;)r=r>οΏ½DeprecationWarningr+r0r!r!r"οΏ½getchildrensοΏ½zElement.getchildrencCstοΏ½|||οΏ½S)aFind first matching element by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        )rοΏ½findοΏ½r,οΏ½pathοΏ½
namespacesr!r!r"rV!s	zElement.findcCstοΏ½||||οΏ½S)aοΏ½Find text for first matching element by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *default* is the value to return if the element was not found,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return text content of first matching element, or default value if
        none was found.  Note that if an element is found having no text
        content, the empty string is returned.

        )rοΏ½findtextοΏ½r,rXοΏ½defaultrYr!r!r"rZ,szElement.findtextcCstοΏ½|||οΏ½S)aFind all matching subelements by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Returns list containing all matching elements in document order.

        )rοΏ½findallrWr!r!r"r]:s	zElement.findallcCstοΏ½|||οΏ½S)a Find all matching subelements by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return an iterable yielding all matching elements in document order.

        )rοΏ½iterfindrWr!r!r"r^Es	zElement.iterfindcCs |jοΏ½οΏ½g|_d|_|_dS)zοΏ½Reset element.

        This function removes all subelements, clears all attributes, and sets
        the text and tail attributes to None.

        N)r*οΏ½clearr+r3r4r0r!r!r"r_Ps
z
Element.clearcCs|jοΏ½||οΏ½S)agGet element attribute.

        Equivalent to attrib.get, but some implementations may handle this a
        bit more efficiently.  *key* is what attribute to look for, and
        *default* is what to return if the attribute was not found.

        Returns a string containing the attribute value, or the default if
        attribute was not found.

        )r*οΏ½get)r,οΏ½keyr\r!r!r"r`[szElement.getcCs||j|<dS)zοΏ½Set element attribute.

        Equivalent to attrib[key] = value, but some implementations may handle
        this a bit more efficiently.  *key* is what attribute to set, and
        *value* is the attribute value to set it to.

        N)r*)r,raοΏ½valuer!r!r"οΏ½sethszElement.setcCs
|jοΏ½οΏ½S)zοΏ½Get list of attribute names.

        Names are returned in an arbitrary order, just like an ordinary
        Python dict.  Equivalent to attrib.keys()

        )r*οΏ½keysr0r!r!r"rdrszElement.keyscCs
|jοΏ½οΏ½S)zοΏ½Get element attributes as a sequence.

        The attributes are returned in arbitrary order.  Equivalent to
        attrib.items().

        Return a list of (name, value) tuples.

        )r*οΏ½itemsr0r!r!r"re{s	z
Element.itemsccsD|dkrd}|dks|j|kr$|V|jD]}|οΏ½|οΏ½EdHq*dS)aCreate tree iterator.

        The iterator loops over the element and all subelements in document
        order, returning all elements with a matching tag.

        If the tree structure is modified during iteration, new or removed
        elements may or may not be included.  To get a stable set, use the
        list() function on the iterator, and loop over the resulting list.

        *tag* is what tags to look for (default is to return all elements)

        Return an iterator containing all the matching elements.

        οΏ½*N)r#r+οΏ½iter)r,r#rRr!r!r"rgοΏ½s
zElement.itercCstjdtddοΏ½t|οΏ½|οΏ½οΏ½S)NzbThis method will be removed in future versions.  Use 'elem.iter()' or 'list(elem.iter())' instead.r:r;οΏ½r=r>rTοΏ½listrgοΏ½r,r#r!r!r"οΏ½getiteratorοΏ½sοΏ½zElement.getiteratorccsX|j}t|tοΏ½s|dk	rdS|j}|r,|V|D]"}|οΏ½οΏ½EdH|j}|r0|Vq0dS)zοΏ½Create text iterator.

        The iterator loops over the element and all subelements in document
        order, returning all inner text.

        N)r#r&οΏ½strr3οΏ½itertextr4)r,r#οΏ½trRr!r!r"rmοΏ½szElement.itertext)N)NN)N)N)N)N)N)#rrrr r#r*r3r4r.r1r2r6r9r@rDrGrHrJrNrOrFrSrUrVrZr]r^r_r`rcrdrergrkrmr!r!r!r"r}s@	








	

cKs"||οΏ½}|οΏ½||οΏ½}|οΏ½|οΏ½|S)aοΏ½Subelement factory which creates an element instance, and appends it
    to an existing parent.

    The element tag, attribute names, and attribute values can be either
    bytes or Unicode strings.

    *parent* is the parent element, *tag* is the subelements name, *attrib* is
    an optional directory containing element attributes, *extra* are
    additional attributes given as keyword arguments.

    )r2rJ)οΏ½parentr#r*r-r%r!r!r"rοΏ½s
cCsttοΏ½}||_|S)zοΏ½Comment element factory.

    This function creates a special element which the standard serializer
    serializes as an XML comment.

    *text* is a string containing the comment string.

    )rrr3)r3r%r!r!r"rοΏ½s	cCs&ttοΏ½}||_|r"|jd||_|S)a*Processing Instruction element factory.

    This function creates a special element which the standard serializer
    serializes as an XML comment.

    *target* is a string containing the processing instruction, *text* is a
    string containing the processing instruction contents, if any.

    οΏ½ )rrr3)οΏ½targetr3r%r!r!r"rοΏ½s

c@sZeZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZdS)r
aοΏ½Qualified name wrapper.

    This class can be used to wrap a QName attribute value in order to get
    proper namespace handing on output.

    *text_or_uri* is a string containing the QName value either in the form
    {uri}local, or if the tag argument is given, the URI part of a QName.

    *tag* is an optional argument which if given, will make the first
    argument (text_or_uri) be interpreted as a URI, and this argument (tag)
    be interpreted as a local name.

    NcCs|rd||f}||_dS)Nz{%s}%sοΏ½r3)r,Ztext_or_urir#r!r!r"r.οΏ½szQName.__init__cCs|jSr7rrr0r!r!r"οΏ½__str__οΏ½sz
QName.__str__cCsd|jj|jfS)Nz<%s %r>)r)rr3r0r!r!r"r1szQName.__repr__cCs
t|jοΏ½Sr7)οΏ½hashr3r0r!r!r"οΏ½__hash__szQName.__hash__cCs t|tοΏ½r|j|jkS|j|kSr7οΏ½r&r
r3οΏ½r,οΏ½otherr!r!r"οΏ½__le__s
zQName.__le__cCs t|tοΏ½r|j|jkS|j|kSr7rvrwr!r!r"οΏ½__lt__s
zQName.__lt__cCs t|tοΏ½r|j|jkS|j|kSr7rvrwr!r!r"οΏ½__ge__s
zQName.__ge__cCs t|tοΏ½r|j|jkS|j|kSr7rvrwr!r!r"οΏ½__gt__s
zQName.__gt__cCs t|tοΏ½r|j|jkS|j|kSr7rvrwr!r!r"οΏ½__eq__s
zQName.__eq__)N)
rrrr r.rsr1ruryrzr{r|r}r!r!r!r"r
οΏ½s
c@sοΏ½eZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zdd	d
οΏ½ZdddοΏ½Zd d
dοΏ½Z	d!ddοΏ½Z
d"ddοΏ½Zd#ddοΏ½Zd$ddοΏ½Z
d%ddοΏ½ddοΏ½ZddοΏ½ZdS)&ra%An XML element hierarchy.

    This class also provides support for serialization to and from
    standard XML.

    *element* is an optional root element node,
    *file* is an optional file handle or file name of an XML file whose
    contents will be used to initialize the tree with.

    NcCs||_|r|οΏ½|οΏ½dSr7)οΏ½_rootr	)r,r%οΏ½filer!r!r"r.'szElementTree.__init__cCs|jS)z!Return root element of this tree.οΏ½r~r0r!r!r"οΏ½getroot-szElementTree.getrootcCs
||_dS)zοΏ½Replace root element of this tree.

        This will discard the current contents of the tree and replace it
        with the given element.  Use with care!

        NrοΏ½)r,r%r!r!r"οΏ½_setroot1szElementTree._setrootcCsοΏ½d}t|dοΏ½st|dοΏ½}d}z^|dkrLtοΏ½}t|dοΏ½rL|οΏ½|οΏ½|_|jWοΏ½2S|οΏ½dοΏ½}|s\qh|οΏ½|οΏ½qL|οΏ½οΏ½|_|jWοΏ½S|rοΏ½|οΏ½οΏ½XdS)a=Load external XML document into element tree.

        *source* is a file name or file object, *parser* is an optional parser
        instance that defaults to XMLParser.

        ParseError is raised if the parser fails to parse the document.

        Returns the root element of the given source document.

        FοΏ½readοΏ½rbTNοΏ½_parse_wholei)r$οΏ½openοΏ½closerrοΏ½r~rοΏ½οΏ½feed)r,οΏ½sourceοΏ½parserοΏ½close_sourceοΏ½datar!r!r"r	;s$






zElementTree.parsecCs|jοΏ½|οΏ½S)zοΏ½Create and return tree iterator for the root element.

        The iterator loops over all elements in this tree, in document order.

        *tag* is a string with the tag name to iterate over
        (default is to return all elements).

        )r~rgrjr!r!r"rg`s
zElementTree.itercCstjdtddοΏ½t|οΏ½|οΏ½οΏ½S)NzbThis method will be removed in future versions.  Use 'tree.iter()' or 'list(tree.iter())' instead.r:r;rhrjr!r!r"rkmsοΏ½zElementTree.getiteratorcCs:|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½||οΏ½S)a\Find first matching element by tag name or path.

        Same as getroot().find(path), which is Element.find()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        NrοΏ½/οΏ½.οΏ½οΏ½This search is broken in 1.3 and earlier, and will be fixed in a future version.  If you rely on the current behaviour, change it to %rr:r;)r=r>r?r~rVrWr!r!r"rVusοΏ½οΏ½zElementTree.findcCs<|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½|||οΏ½S)aeFind first matching element by tag name or path.

        Same as getroot().findtext(path),  which is Element.findtext()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        NrrοΏ½rοΏ½rοΏ½r:r;)r=r>r?r~rZr[r!r!r"rZοΏ½sοΏ½οΏ½zElementTree.findtextcCs:|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½||οΏ½S)aaFind all matching subelements by tag name or path.

        Same as getroot().findall(path), which is Element.findall().

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return list containing all matching elements in document order.

        NrrοΏ½rοΏ½rοΏ½r:r;)r=r>r?r~r]rWr!r!r"r]οΏ½sοΏ½οΏ½zElementTree.findallcCs:|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½||οΏ½S)agFind all matching subelements by tag name or path.

        Same as getroot().iterfind(path), which is element.iterfind()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return an iterable yielding all matching elements in document order.

        NrrοΏ½rοΏ½rοΏ½r:r;)r=r>r?r~r^rWr!r!r"r^οΏ½sοΏ½οΏ½zElementTree.iterfindTοΏ½οΏ½short_empty_elementsc	CsοΏ½|s
d}n|tkrtd|οΏ½οΏ½|s4|dkr0d}nd}|οΏ½οΏ½}t||οΏ½οΏ½οΏ½}|dkrοΏ½|sd|dkrοΏ½|dkrοΏ½|}	|dkrοΏ½d	dl}
|
οΏ½οΏ½}	|d
|	fοΏ½|dkrοΏ½t||jοΏ½n,t|j|οΏ½\}}t|}
|
||j|||dοΏ½W5QRXdS)
aοΏ½Write element tree to a file as XML.

        Arguments:
          *file_or_filename* -- file name or a file object opened for writing

          *encoding* -- the output encoding (default: US-ASCII)

          *xml_declaration* -- bool indicating if an XML declaration should be
                               added to the output. If None, an XML declaration
                               is added if encoding IS NOT either of:
                               US-ASCII, UTF-8, or Unicode

          *default_namespace* -- sets the default XML namespace (for "xmlns")

          *method* -- either "xml" (default), "html, "text", or "c14n"

          *short_empty_elements* -- controls the formatting of elements
                                    that contain no content. If True (default)
                                    they are emitted as a single self-closed
                                    tag, otherwise they are emitted as a pair
                                    of start/end tags

        οΏ½xmlzunknown method %rοΏ½c14nοΏ½utf-8οΏ½us-asciiN)rοΏ½rοΏ½οΏ½unicoderοΏ½rz$<?xml version='1.0' encoding='%s'?>
r3rοΏ½)	οΏ½
_serializeοΏ½
ValueErrorοΏ½lowerοΏ½_get_writerοΏ½localeZgetpreferredencodingοΏ½_serialize_textr~οΏ½_namespaces)r,οΏ½file_or_filenameοΏ½encodingοΏ½xml_declarationοΏ½default_namespaceοΏ½methodrοΏ½Z	enc_lowerοΏ½writeZdeclared_encodingrοΏ½οΏ½qnamesrYZ	serializer!r!r"rοΏ½οΏ½s:οΏ½οΏ½οΏ½οΏ½zElementTree.writecCs|j|ddοΏ½S)NrοΏ½)rοΏ½)rοΏ½)r,rr!r!r"οΏ½
write_c14nszElementTree.write_c14n)NN)N)N)N)N)NN)N)N)NNNN)rrrr r.rοΏ½rοΏ½r	rgrkrVrZr]r^rοΏ½rοΏ½r!r!r!r"rs&



%





οΏ½οΏ½:ccs"z
|j}WnPtk
rZ|dkr.t|dοΏ½}nt|d|ddοΏ½}|οΏ½|jVW5QRXYnοΏ½X|dkrl|VnοΏ½tοΏ½οΏ½οΏ½οΏ½}t|tjοΏ½rοΏ½|}nft|tjοΏ½rοΏ½tοΏ½	|οΏ½}|οΏ½
|jοΏ½nBtοΏ½οΏ½}ddοΏ½|_||_z|j
|_
|j|_Wntk
rοΏ½YnXtj||dddοΏ½}|οΏ½
|jοΏ½|jVW5QRXdS)	NrοΏ½οΏ½wοΏ½xmlcharrefreplace)rοΏ½οΏ½errorscSsdSοΏ½NTr!r!r!r!r"οΏ½<lambda>0οΏ½z_get_writer.<locals>.<lambda>οΏ½
)rοΏ½rοΏ½οΏ½newline)rοΏ½οΏ½AttributeErrorrοΏ½οΏ½
contextlibοΏ½	ExitStackr&οΏ½ioοΏ½BufferedIOBaseοΏ½	RawIOBaseοΏ½BufferedWriterοΏ½callbackοΏ½detachοΏ½writableοΏ½seekableοΏ½tellοΏ½
TextIOWrapper)rοΏ½rοΏ½rοΏ½rοΏ½stackr!r!r"rοΏ½sB
οΏ½


οΏ½rοΏ½csddiοΏ½iοΏ½οΏ½rdοΏ½οΏ½<οΏ½οΏ½οΏ½fddοΏ½}|οΏ½οΏ½D]οΏ½}|j}t|tοΏ½rZ|jοΏ½krοΏ½||jοΏ½n<t|tοΏ½rv|οΏ½krοΏ½||οΏ½n |dk	rοΏ½|tk	rοΏ½|tk	rοΏ½t|οΏ½|οΏ½	οΏ½D]F\}}t|tοΏ½rοΏ½|j}|οΏ½krοΏ½||οΏ½t|tοΏ½rοΏ½|jοΏ½krοΏ½||jοΏ½qοΏ½|j}t|tοΏ½r0|jοΏ½kr0||jοΏ½q0οΏ½οΏ½fS)NοΏ½csοΏ½zοΏ½|ddοΏ½dkrοΏ½|ddοΏ½οΏ½ddοΏ½\}}οΏ½οΏ½|οΏ½}|dkrjtοΏ½|οΏ½}|dkrZdtοΏ½οΏ½}|dkrj|οΏ½|<|rοΏ½d||fοΏ½|<qοΏ½|οΏ½|<nοΏ½rοΏ½tdοΏ½οΏ½|οΏ½|<Wntk
rοΏ½t|οΏ½YnXdS)NrοΏ½{οΏ½}zns%drοΏ½z%s:%sz<cannot use non-qualified names with default_namespace option)οΏ½rsplitr`οΏ½_namespace_mapr8rοΏ½r(οΏ½_raise_serialization_error)οΏ½qnameοΏ½urir#οΏ½prefixοΏ½rοΏ½rYrοΏ½r!r"οΏ½	add_qnameMs(


οΏ½z_namespaces.<locals>.add_qname)
rgr#r&r
r3rlrrrοΏ½re)r5rοΏ½rοΏ½r#rarbr3r!rοΏ½r"rοΏ½Bs4




rοΏ½cKsοΏ½|j}|j}|tkr$|d|οΏ½οΏ½nv|tkr<|d|οΏ½οΏ½n^||}|dkr||r\|t|οΏ½οΏ½|D]}t|||d|dοΏ½q`οΏ½n|d|οΏ½t|οΏ½οΏ½οΏ½}	|	sοΏ½|οΏ½r2|rοΏ½t|οΏ½οΏ½ddοΏ½dοΏ½D](\}
}|rοΏ½d|}|d	|t	|
οΏ½fοΏ½qοΏ½|	D]L\}}
t
|tοΏ½rοΏ½|j}t
|
tοΏ½οΏ½r||
j}
nt	|
οΏ½}
|d
|||
fοΏ½qοΏ½|οΏ½sHt|οΏ½οΏ½sH|οΏ½sοΏ½|dοΏ½|οΏ½rb|t|οΏ½οΏ½|D]}t|||d|dοΏ½οΏ½qf|d|dοΏ½n|d
οΏ½|j
οΏ½rοΏ½|t|j
οΏ½οΏ½dS)NοΏ½	<!--%s-->οΏ½<?%s?>rοΏ½οΏ½<cSs|dSοΏ½Nrr!οΏ½οΏ½xr!r!r"rοΏ½οΏ½rοΏ½z _serialize_xml.<locals>.<lambda>οΏ½raοΏ½:οΏ½
 xmlns%s="%s"οΏ½ %s="%s"οΏ½>οΏ½</z />)r#r3rrοΏ½
_escape_cdataοΏ½_serialize_xmlrireοΏ½sortedοΏ½_escape_attribr&r
r8r4)rοΏ½r5rοΏ½rYrοΏ½οΏ½kwargsr#r3rRreοΏ½vοΏ½kr!r!r"rοΏ½s\
οΏ½
οΏ½οΏ½


οΏ½
rοΏ½)
ZareaοΏ½baseZbasefontοΏ½brοΏ½colοΏ½frameZhrZimgοΏ½inputZisindexοΏ½linkοΏ½metaZparamcKsοΏ½|j}|j}|tkr(|dt|οΏ½οΏ½οΏ½nοΏ½|tkrD|dt|οΏ½οΏ½οΏ½nh||}|dkrοΏ½|rd|t|οΏ½οΏ½|D]}t|||dοΏ½qhοΏ½n,|d|οΏ½t|οΏ½οΏ½οΏ½}|sοΏ½|οΏ½r8|rοΏ½t|οΏ½οΏ½ddοΏ½dοΏ½D](\}	}
|
rοΏ½d|
}
|d|
t	|	οΏ½fοΏ½qοΏ½|D]N\}
}	t
|
tοΏ½οΏ½r|
j}
t
|	tοΏ½οΏ½r||	j}	nt|	οΏ½}	|d	||
|	fοΏ½qοΏ½|d
οΏ½|οΏ½
οΏ½}|οΏ½rx|dkοΏ½sb|dkοΏ½rl||οΏ½n|t|οΏ½οΏ½|D]}t|||dοΏ½οΏ½q||tkοΏ½rοΏ½|d
|d
οΏ½|jοΏ½rοΏ½|t|jοΏ½οΏ½dS)NrοΏ½rοΏ½rοΏ½cSs|dSrοΏ½r!rοΏ½r!r!r"rοΏ½οΏ½rοΏ½z!_serialize_html.<locals>.<lambda>rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½ZscriptZstylerοΏ½)r#r3rrοΏ½rοΏ½_serialize_htmlrirerοΏ½rοΏ½r&r
οΏ½_escape_attrib_htmlrοΏ½οΏ½
HTML_EMPTYr4)rοΏ½r5rοΏ½rYrοΏ½r#r3rRrerοΏ½rοΏ½Zltagr!r!r"rοΏ½οΏ½sX
οΏ½οΏ½


rοΏ½cCs*|οΏ½οΏ½D]}||οΏ½q|jr&||jοΏ½dSr7)rmr4)rοΏ½r5οΏ½partr!r!r"rοΏ½οΏ½s
rοΏ½)rοΏ½οΏ½htmlr3cCsLtοΏ½d|οΏ½rtdοΏ½οΏ½ttοΏ½οΏ½οΏ½D]\}}||ks8||kr t|=q |t|<dS)atRegister a namespace prefix.

    The registry is global, and any existing mapping for either the
    given prefix or the namespace URI will be removed.

    *prefix* is the namespace prefix, *uri* is a namespace uri. Tags and
    attributes in this namespace will be serialized with prefix if possible.

    ValueError is raised if prefix is reserved or is invalid.

    zns\d+$z'Prefix format reserved for internal useN)οΏ½reοΏ½matchrοΏ½rirοΏ½re)rοΏ½rοΏ½rοΏ½rοΏ½r!r!r"rοΏ½srοΏ½rοΏ½ZrdfZwsdlZxsZxsiZdc)οΏ½$http://www.w3.org/XML/1998/namespacezhttp://www.w3.org/1999/xhtmlz+http://www.w3.org/1999/02/22-rdf-syntax-ns#z http://schemas.xmlsoap.org/wsdl/z http://www.w3.org/2001/XMLSchemaz)http://www.w3.org/2001/XMLSchema-instancez http://purl.org/dc/elements/1.1/cCstd|t|οΏ½jfοΏ½οΏ½dS)Nzcannot serialize %r (type %s))r(rQrrrr!r!r"rοΏ½sοΏ½rοΏ½c	CshzBd|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}|WSttfk
rbt|οΏ½YnXdS)NοΏ½&οΏ½&amp;rοΏ½οΏ½&lt;rοΏ½οΏ½&gt;οΏ½οΏ½replacer(rοΏ½rοΏ½rrr!r!r"rοΏ½!srοΏ½c	CsοΏ½zοΏ½d|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}d|krR|οΏ½ddοΏ½}d	|krf|οΏ½d	d
οΏ½}d|krz|οΏ½dd
οΏ½}d
|krοΏ½|οΏ½d
dοΏ½}d
|krοΏ½|οΏ½d
dοΏ½}|WSttfk
rοΏ½t|οΏ½YnXdS)NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½"οΏ½&quot;z
rοΏ½οΏ½
z&#10;οΏ½	z&#09;rοΏ½rrr!r!r"rοΏ½1s(rοΏ½c	CshzBd|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}|WSttfk
rbt|οΏ½YnXdS)NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrr!r!r"rοΏ½MsrοΏ½T)rοΏ½rοΏ½rοΏ½cCs:|dkrtοΏ½οΏ½ntοΏ½οΏ½}t|οΏ½j||||||dοΏ½|οΏ½οΏ½S)a
Generate string representation of XML element.

    All subelements are included.  If encoding is "unicode", a string
    is returned. Otherwise a bytestring is returned.

    *element* is an Element instance, *encoding* is an optional output
    encoding defaulting to US-ASCII, *method* is an optional output which can
    be one of "xml" (default), "html", "text" or "c14n", *default_namespace*
    sets the default XML namespace (for "xmlns").

    Returns an (optionally) encoded string containing the XML data.

    rοΏ½οΏ½rοΏ½rοΏ½rοΏ½rοΏ½)rοΏ½οΏ½StringIOοΏ½BytesIOrrοΏ½οΏ½getvalue)r%rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½streamr!r!r"r\sοΏ½c@s8eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½ZdS)
οΏ½_ListDataStreamz7An auxiliary stream accumulating into a list reference.cCs
||_dSr7)οΏ½lst)r,rοΏ½r!r!r"r.vsz_ListDataStream.__init__cCsdSrοΏ½r!r0r!r!r"rοΏ½ysz_ListDataStream.writablecCsdSrοΏ½r!r0r!r!r"rοΏ½|sz_ListDataStream.seekablecCs|jοΏ½|οΏ½dSr7)rοΏ½rJ)r,οΏ½br!r!r"rοΏ½sz_ListDataStream.writecCs
t|jοΏ½Sr7)r8rοΏ½r0r!r!r"rοΏ½οΏ½sz_ListDataStream.tellN)	rrrr r.rοΏ½rοΏ½rοΏ½rοΏ½r!r!r!r"rοΏ½tsrοΏ½cCs*g}t|οΏ½}t|οΏ½j||||||dοΏ½|S)NrοΏ½)rοΏ½rrοΏ½)r%rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r!r!r"rοΏ½sοΏ½cCsLt|tοΏ½st|οΏ½}|jtjddοΏ½|οΏ½οΏ½j}|r<|ddkrHtjοΏ½dοΏ½dS)a#Write element tree or element structure to sys.stdout.

    This function should be used for debugging only.

    *elem* is either an ElementTree, or a single Element.  The exact output
    format is implementation dependent.  In this version, it's written as an
    ordinary XML file.

    rοΏ½)rοΏ½οΏ½οΏ½οΏ½rοΏ½N)r&rrοΏ½οΏ½sysοΏ½stdoutrοΏ½r4)r5r4r!r!r"rοΏ½s

cCstοΏ½}|οΏ½||οΏ½|S)zοΏ½Parse XML document into element tree.

    *source* is a filename or file object containing XML data,
    *parser* is an optional parser instance defaulting to XMLParser.

    Return an ElementTree instance.

    )rr	)rοΏ½rοΏ½οΏ½treer!r!r"r	οΏ½s	csft||dοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½fddοΏ½οΏ½GοΏ½fddοΏ½dtjjοΏ½}|οΏ½οΏ½dοΏ½_οΏ½~dοΏ½tοΏ½dοΏ½sbtοΏ½d	οΏ½οΏ½d
οΏ½οΏ½S)aJIncrementally parse XML document into ElementTree.

    This class also reports what's going on to the user based on the
    *events* it is initialized with.  The supported events are the strings
    "start", "end", "start-ns" and "end-ns" (the "ns" events are used to get
    detailed namespace information).  If *events* is omitted, only
    "end" events are reported.

    *source* is a filename or file object containing XML data, *events* is
    a list of events to report back, *parser* is an optional parser instance.

    Returns an iterator providing (event, elem) pairs.

    )οΏ½eventsοΏ½_parserc3s^zJοΏ½οΏ½οΏ½EdHοΏ½οΏ½dοΏ½}|s q,οΏ½οΏ½|οΏ½qοΏ½οΏ½οΏ½}οΏ½οΏ½οΏ½EdH|οΏ½_W5οΏ½rXοΏ½οΏ½οΏ½XdS)Ni@)rοΏ½οΏ½read_eventsrοΏ½rοΏ½οΏ½_close_and_return_rootοΏ½root)rοΏ½r)rοΏ½οΏ½itοΏ½
pullparserrοΏ½r!r"οΏ½iteratorοΏ½s

ziterparse.<locals>.iteratorcseZdZοΏ½οΏ½jZdS)z$iterparse.<locals>.IterParseIteratorN)rrrοΏ½__next__r!)rr!r"οΏ½IterParseIteratorοΏ½srNFrοΏ½rοΏ½T)rοΏ½collectionsοΏ½abcοΏ½Iteratorrr$rοΏ½)rοΏ½rοΏ½rοΏ½rr!)rοΏ½rrrrοΏ½r"rοΏ½s

c@s<eZdZd
ddοΏ½ddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½ZdS)rN)rcCs<tοΏ½οΏ½|_|pttοΏ½dοΏ½|_|dkr(d}|jοΏ½|j|οΏ½dS)NοΏ½rq)οΏ½end)r	οΏ½dequeοΏ½
_events_queuerrrοΏ½
_setevents)r,rοΏ½rr!r!r"r.οΏ½s

zXMLPullParser.__init__c
CsZ|jdkrtdοΏ½οΏ½|rVz|jοΏ½|οΏ½Wn.tk
rT}z|jοΏ½|οΏ½W5d}~XYnXdS)οΏ½Feed encoded data to parser.Nz!feed() called after end of stream)rrοΏ½rοΏ½οΏ½SyntaxErrorrrJ)r,rοΏ½οΏ½excr!r!r"rοΏ½οΏ½s
zXMLPullParser.feedcCs|jοΏ½οΏ½}d|_|Sr7)rrοΏ½)r,rr!r!r"rοΏ½s
z$XMLPullParser._close_and_return_rootcCs|οΏ½οΏ½dS)zοΏ½Finish feeding data to parser.

        Unlike XMLParser, does not return the root element. Use
        read_events() to consume elements from XMLPullParser.
        N)rr0r!r!r"rοΏ½szXMLPullParser.closeccs.|j}|r*|οΏ½οΏ½}t|tοΏ½r"|οΏ½q|VqdS)zοΏ½Return an iterator over currently available (event, elem) pairs.

        Events are consumed from the internal event queue as they are
        retrieved from the iterator.
        N)rοΏ½popleftr&οΏ½	Exception)r,rοΏ½οΏ½eventr!r!r"rs
zXMLPullParser.read_events)N)rrrr.rοΏ½rrοΏ½rr!r!r!r"rοΏ½s

cCs"|sttοΏ½dοΏ½}|οΏ½|οΏ½|οΏ½οΏ½S)aParse XML document from string constant.

    This function can be used to embed "XML Literals" in Python code.

    *text* is a string containing XML data, *parser* is an
    optional parser instance, defaulting to the standard XMLParser.

    Returns an Element instance.

    rοΏ½rrrοΏ½rοΏ½)r3rοΏ½r!r!r"rs
cCsR|sttοΏ½dοΏ½}|οΏ½|οΏ½|οΏ½οΏ½}i}|οΏ½οΏ½D]}|οΏ½dοΏ½}|r.|||<q.||fS)aParse XML document from string constant for its IDs.

    *text* is a string containing XML data, *parser* is an
    optional parser instance, defaulting to the standard XMLParser.

    Returns an (Element, dict) tuple, in which the
    dict maps element id:s to elements.

    rr/)rrrοΏ½rοΏ½rgr`)r3rοΏ½rοΏ½Zidsr5r/r!r!r"r,s



cCs,|sttοΏ½dοΏ½}|D]}|οΏ½|οΏ½q|οΏ½οΏ½S)zοΏ½Parse XML document from sequence of string fragments.

    *sequence* is a list of other sequence, *parser* is an optional parser
    instance, defaulting to the standard XMLParser.

    Returns an Element instance.

    rr)ZsequencerοΏ½r3r!r!r"rDs
	c@sheZdZdZddddddοΏ½ddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½ZddοΏ½Z	ddοΏ½Z
dddοΏ½ZddοΏ½ZdS)ra8Generic element structure builder.

    This builder converts a sequence of start, data, and end method
    calls to a well-formed element structure.

    You can use this class to build an element structure using a custom XML
    parser, or a parser for some other XML-like format.

    *element_factory* is an optional element factory which is called
    to create new Element instances, as necessary.

    *comment_factory* is a factory to create comments to be used instead of
    the standard factory.  If *insert_comments* is false (the default),
    comments will not be inserted into the tree.

    *pi_factory* is a factory to create processing instructions to be used
    instead of the standard factory.  If *insert_pis* is false (the default),
    processing instructions will not be inserted into the tree.
    NF)οΏ½comment_factoryοΏ½
pi_factoryοΏ½insert_commentsοΏ½
insert_piscCsdg|_g|_d|_d|_d|_|dkr*t}||_||_|dkrBt}||_	||_
|dkrZt}||_dSr7)
οΏ½_dataοΏ½_elemοΏ½_lastr~οΏ½_tailrοΏ½_comment_factoryrrοΏ½_pi_factoryrrοΏ½_factory)r,Zelement_factoryrrrrr!r!r"r.js zTreeBuilder.__init__cCs|jS)z;Flush builder buffers and return toplevel document Element.rοΏ½r0r!r!r"rοΏ½~szTreeBuilder.closecCs>|jr:|jdk	r4dοΏ½|jοΏ½}|jr,||j_n||j_g|_dSοΏ½NrοΏ½)rrοΏ½joinrr4r3οΏ½r,r3r!r!r"οΏ½_flushοΏ½s

zTreeBuilder._flushcCs|jοΏ½|οΏ½dS)zAdd text to current element.N)rrJοΏ½r,rοΏ½r!r!r"rοΏ½οΏ½szTreeBuilder.datacCsX|οΏ½οΏ½|οΏ½||οΏ½|_}|jr2|jdοΏ½|οΏ½n|jdkrB||_|jοΏ½|οΏ½d|_|S)zοΏ½Open new element and return it.

        *tag* is the element name, *attrs* is a dict containing element
        attributes.

        rοΏ½Nr)r&r"rrrJr~r)r,r#οΏ½attrsr5r!r!r"οΏ½startοΏ½s
zTreeBuilder.startcCs |οΏ½οΏ½|jοΏ½οΏ½|_d|_|jS)zOClose and return current Element.

        *tag* is the element name.

        r)r&rοΏ½poprrrjr!r!r"r
οΏ½szTreeBuilder.endcCs|οΏ½|j|j|οΏ½S)z`Create a comment using the comment_factory.

        *text* is the text of the comment.
        )οΏ½_handle_singler rr%r!r!r"οΏ½commentοΏ½s
οΏ½zTreeBuilder.commentcCs|οΏ½|j|j||οΏ½S)zοΏ½Create a processing instruction using the pi_factory.

        *target* is the target name of the processing instruction.
        *text* is the data of the processing instruction, or ''.
        )r+r!r)r,rqr3r!r!r"οΏ½piοΏ½sοΏ½zTreeBuilder.picGs:||οΏ½}|r6|οΏ½οΏ½||_|jr0|jdοΏ½|οΏ½d|_|S)NrοΏ½r)r&rrrJr)r,οΏ½factoryrOοΏ½argsr5r!r!r"r+οΏ½szTreeBuilder._handle_single)N)N)
rrrr r.rοΏ½r&rοΏ½r)r
r,r-r+r!r!r!r"rVsοΏ½
	c@speZdZdZdddοΏ½ddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZdS)raaElement structure builder for XML source data based on the expat parser.

    *target* is an optional target object which defaults to an instance of the
    standard TreeBuilder class, *encoding* is an optional encoding string
    which if given, overrides the encoding specified in the XML file:
    http://www.iana.org/assignments/character-sets

    N)rqrοΏ½cCsdzddlm}Wn>tk
rNzddl}Wntk
rHtdοΏ½οΏ½YnXYnX|οΏ½|dοΏ½}|dkrjtοΏ½}||_|_||_|_	|j
|_i|_|j
|_t|dοΏ½rοΏ½|j|_t|dοΏ½rοΏ½|j|_t|dοΏ½rοΏ½|j|_t|dοΏ½rοΏ½|j|_t|d	οΏ½rοΏ½|j|_t|d
οΏ½οΏ½r|j|_t|dοΏ½οΏ½r|j|_d|_d|_d|_ d|_!i|_"zd
|j#|_$Wnt%k
οΏ½r^YnXdS)NrοΏ½οΏ½expatz7No module named expat; use SimpleXMLTreeBuilder insteadrοΏ½r)r
οΏ½start_nsοΏ½end_nsrοΏ½r,r-rzExpat %d.%d.%d)&οΏ½xml.parsersr1οΏ½ImportErrorZpyexpatZParserCreaterrοΏ½rrqοΏ½_targetοΏ½errorοΏ½_errorοΏ½_namesοΏ½_defaultZDefaultHandlerExpandr$οΏ½_startοΏ½StartElementHandlerοΏ½_endοΏ½EndElementHandlerοΏ½	_start_nsοΏ½StartNamespaceDeclHandlerοΏ½_end_nsοΏ½EndNamespaceDeclHandlerrοΏ½ZCharacterDataHandlerr,οΏ½CommentHandlerr-οΏ½ProcessingInstructionHandlerZbuffer_textοΏ½ordered_attributesοΏ½specified_attributesοΏ½_doctypeοΏ½entityοΏ½version_infoοΏ½versionrοΏ½)r,rqrοΏ½r1rοΏ½r!r!r"r.οΏ½sPοΏ½




zXMLParser.__init__cCs8|j}|j}|DοΏ½] }|dkrDd|_d|_|||jfddοΏ½}||_q|dkrf|||jfddοΏ½}||_q|dkrοΏ½t|j	dοΏ½rοΏ½|||j
fd	dοΏ½}n||fd
dοΏ½}||_q|dkrοΏ½t|j	dοΏ½rοΏ½|||jfd
dοΏ½}n||fddοΏ½}||_
q|dkοΏ½r|||fddοΏ½}||_q|dkοΏ½r&|||fddοΏ½}||_qtd|οΏ½οΏ½qdS)Nr)rcSs|||||οΏ½fοΏ½dSr7r!)r#Z	attrib_inrrJr)r!r!r"οΏ½handlersz%XMLParser._setevents.<locals>.handlerr
cSs||||οΏ½fοΏ½dSr7r!)r#rrJr
r!r!r"rKszstart-nsr2cSs|||||οΏ½fοΏ½dSr7r!)rοΏ½rοΏ½rrJr2r!r!r"rK!scSs|||p
d|pdffοΏ½dSr#r!)rοΏ½rοΏ½rrJr!r!r"rK%szend-nsr3cSs||||οΏ½fοΏ½dSr7r!)rοΏ½rrJr3r!r!r"rK+scSs||dfοΏ½dSr7r!)rοΏ½rrJr!r!r"rK/sr,cSs|||jοΏ½|οΏ½fοΏ½dSr7)rqr,)r3rrJr,r!r!r"rK3sr-cSs|||jοΏ½||οΏ½fοΏ½dSr7)rqr-)Z	pi_targetrοΏ½rrJr,r!r!r"rK7szunknown event %r)rrJrErFr;r<r=r>r$rqr?r@rArBrCrDrοΏ½)r,Zevents_queueZevents_to_reportrοΏ½rJZ
event_namerKr!r!r"rsL
οΏ½
οΏ½
οΏ½οΏ½

οΏ½
zXMLParser._seteventscCs&t|οΏ½}|j|_|j|jf|_|οΏ½dSr7)r
οΏ½codeοΏ½linenoοΏ½offsetZposition)r,rbοΏ½errr!r!r"οΏ½_raiseerror>szXMLParser._raiseerrorcCsFz|j|}Wn2tk
r@|}d|kr2d|}||j|<YnX|S)NrοΏ½rοΏ½)r9οΏ½KeyError)r,raοΏ½namer!r!r"οΏ½_fixnameDszXMLParser._fixnamecCs|jοΏ½|pd|pdοΏ½Sr#)rqr2οΏ½r,rοΏ½rοΏ½r!r!r"r?OszXMLParser._start_nscCs|jοΏ½|pdοΏ½Sr#)rqr3)r,rοΏ½r!r!r"rARszXMLParser._end_nscCsR|j}||οΏ½}i}|rDtdt|οΏ½dοΏ½D]}||d||||οΏ½<q&|jοΏ½||οΏ½S)Nrr:r)rSοΏ½ranger8rqr))r,r#οΏ½	attr_listZfixnamer*οΏ½ir!r!r"r;UszXMLParser._startcCs|jοΏ½|οΏ½|οΏ½οΏ½Sr7)rqr
rSrjr!r!r"r=aszXMLParser._endc	CsοΏ½|ddοΏ½}|dkrοΏ½z|jj}Wntk
r6YdSXz||j|ddοΏ½οΏ½WnZtk
rοΏ½ddlm}|οΏ½d||jj	|jj
fοΏ½}d|_|jj	|_|jj
|_
|οΏ½YnXοΏ½n"|dkrοΏ½|dd	οΏ½d
krοΏ½g|_οΏ½n|jdk	οΏ½rοΏ½|dkrοΏ½d|_dS|οΏ½οΏ½}|οΏ½sdS|jοΏ½|οΏ½t|jοΏ½}|dkοΏ½rοΏ½|jd}|d
kοΏ½rd|dkοΏ½rd|j\}}}	}
|	οΏ½rοΏ½|	ddοΏ½}	n*|dkοΏ½rοΏ½|dkοΏ½rοΏ½|j\}}}
d}	ndSt|jdοΏ½οΏ½rοΏ½|jοΏ½||	|
ddοΏ½οΏ½nt|dοΏ½οΏ½rοΏ½tοΏ½dtοΏ½d|_dS)NrrοΏ½rοΏ½rr0z'undefined entity %s: line %d, column %dοΏ½rοΏ½οΏ½	z	<!DOCTYPErοΏ½r:ZPUBLICοΏ½ZSYSTEMοΏ½οΏ½doctypezaThe doctype() method of XMLParser is ignored.  Define doctype() method on the TreeBuilder target.)rqrοΏ½rοΏ½rHrQr4r1r7rοΏ½ZErrorLineNumberZErrorColumnNumberrLrMrNrGοΏ½striprJr8r$r\r=r>οΏ½RuntimeWarning)r,r3rοΏ½Zdata_handlerr1rOοΏ½nrQrRZpubidοΏ½systemr!r!r"r:dsdοΏ½οΏ½οΏ½





οΏ½zXMLParser._defaultc
CsFz|jοΏ½|dοΏ½Wn.|jk
r@}z|οΏ½|οΏ½W5d}~XYnXdS)rrN)rοΏ½οΏ½Parser8rP)r,rοΏ½rοΏ½r!r!r"rοΏ½οΏ½szXMLParser.feedc
CsοΏ½z|jοΏ½ddοΏ½Wn.|jk
r@}z|οΏ½|οΏ½W5d}~XYnXz0z|jj}Wntk
rdYnX|οΏ½WοΏ½SW5|`|`|`|`XdS)z;Finish feeding data to parser and return element structure.rοΏ½rN)	rοΏ½rar8rPrrqr6rοΏ½rοΏ½)r,rοΏ½Z
close_handlerr!r!r"rοΏ½οΏ½szXMLParser.close)rrrr r.rrPrSr?rAr;r=r:rοΏ½rοΏ½r!r!r!r"rοΏ½s	.66)οΏ½outοΏ½	from_filecKsοΏ½|dkr|dkrtdοΏ½οΏ½d}|dkr0tοΏ½οΏ½}}tt|jf|οΏ½dοΏ½}|dk	r`|οΏ½|οΏ½|οΏ½οΏ½n|dk	rtt||dοΏ½|dk	rοΏ½|οΏ½	οΏ½SdS)a3Convert XML to its C14N 2.0 serialised form.

    If *out* is provided, it must be a file or file-like object that receives
    the serialised canonical XML output (text, not bytes) through its ``.write()``
    method.  To write to a file, open it in text mode with encoding "utf-8".
    If *out* is not provided, this function returns the output as text string.

    Either *xml_data* (an XML string) or *from_file* (a file path or
    file-like object) must be provided as input.

    The configuration options are the same as for the ``C14NWriterTarget``.
    Nz:Either 'xml_data' or 'from_file' must be provided as inputr)rοΏ½)
rοΏ½rοΏ½rοΏ½rrrοΏ½rοΏ½rοΏ½r	rοΏ½)Zxml_datarbrcZoptionsZsiorοΏ½r!r!r"rοΏ½s


z	^\w+:\w+$c@sοΏ½eZdZdZddddddddοΏ½ddοΏ½ZefddοΏ½Zd	d
οΏ½ZdddοΏ½Zd
dοΏ½Z	dj
fddοΏ½ZddοΏ½ZddοΏ½Z
dddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZdS) raοΏ½
    Canonicalization writer target for the XMLParser.

    Serialises parse events to XML C14N 2.0.

    The *write* function is used for writing out the resulting data stream
    as text (not bytes).  To write to a file, open it in text mode with encoding
    "utf-8" and pass its ``.write`` method.

    Configuration options:

    - *with_comments*: set to true to include comments
    - *strip_text*: set to true to strip whitespace before and after text content
    - *rewrite_prefixes*: set to true to replace namespace prefixes by "n{number}"
    - *qname_aware_tags*: a set of qname aware tag names in which prefixes
                          should be replaced in text content
    - *qname_aware_attrs*: a set of qname aware attribute names in which prefixes
                           should be replaced in text content
    - *exclude_attrs*: a set of attribute names that should not be serialised
    - *exclude_tags*: a set of tag names that should not be serialised
    FN)οΏ½
with_commentsοΏ½
strip_textοΏ½rewrite_prefixesοΏ½qname_aware_tagsοΏ½qname_aware_attrsοΏ½
exclude_attrsοΏ½exclude_tagsc	CsοΏ½||_g|_||_||_|r$t|οΏ½nd|_|r6t|οΏ½nd|_||_|rRt|οΏ½|_nd|_|rjt|οΏ½j	|_
nd|_
dgg|_g|_|sοΏ½|jοΏ½
ttοΏ½οΏ½οΏ½οΏ½|jοΏ½
gοΏ½i|_dg|_d|_d|_d|_d|_dS)N)rοΏ½rοΏ½Fr)οΏ½_writerοΏ½_with_commentsοΏ½_strip_textrcοΏ½_exclude_attrsοΏ½
_exclude_tagsοΏ½_rewrite_prefixesοΏ½_qname_aware_tagsοΏ½intersectionοΏ½_find_qname_aware_attrsοΏ½_declared_ns_stackοΏ½	_ns_stackrJrirοΏ½reοΏ½_prefix_mapοΏ½_preserve_spaceοΏ½_pending_startοΏ½
_root_seenοΏ½
_root_doneοΏ½_ignored_depth)	r,rοΏ½rdrerfrgrhrirjr!r!r"r.οΏ½s2οΏ½zC14NWriterTarget.__init__ccs ||οΏ½D]}|r|EdHqdSr7r!)r,Zns_stackZ	_reversedrYr!r!r"οΏ½_iter_namespacessz!C14NWriterTarget._iter_namespacescCs\|οΏ½ddοΏ½\}}|οΏ½|jοΏ½D]$\}}||krd|οΏ½d|οΏ½οΏ½Sqtd|οΏ½d|οΏ½dοΏ½οΏ½οΏ½dS)NrοΏ½rrοΏ½rοΏ½zPrefix z of QName "οΏ½" is not declared in scope)οΏ½splitr|rurοΏ½)r,Z
prefixed_namerοΏ½rRrοΏ½οΏ½pr!r!r"οΏ½_resolve_prefix_names
z%C14NWriterTarget._resolve_prefix_namecCsοΏ½|dkr:|ddοΏ½dkr,|ddοΏ½οΏ½ddοΏ½nd|f\}}n|}tοΏ½}|οΏ½|jοΏ½D]B\}}||krοΏ½||krοΏ½|rz|οΏ½d|οΏ½οΏ½n|||fS|οΏ½|οΏ½qP|jrοΏ½||jkrοΏ½|j|}ndt|jοΏ½οΏ½οΏ½}|j|<|jdοΏ½||fοΏ½|οΏ½d|οΏ½οΏ½||fS|οΏ½sd|kοΏ½r|||fS|οΏ½|j	οΏ½D]J\}}||kοΏ½r|jdοΏ½||fοΏ½|οΏ½rR|οΏ½d|οΏ½οΏ½n|||fSοΏ½q|οΏ½st|||fSt
d|οΏ½d	οΏ½οΏ½οΏ½dS)
NrrοΏ½rοΏ½rοΏ½rοΏ½r_rοΏ½zNamespace "r})rοΏ½rcr|rtοΏ½addrprvr8rJrurοΏ½)r,rοΏ½rοΏ½r#Z
prefixes_seenοΏ½urοΏ½r!r!r"οΏ½_qnames.2 


&
zC14NWriterTarget._qnamecCs|js|jοΏ½|οΏ½dSr7)r{rrJr'r!r!r"rοΏ½CszC14NWriterTarget.datarοΏ½cCsοΏ½||jοΏ½}|jddοΏ½=|jr.|jds.|οΏ½οΏ½}|jdk	rv|jd}|_|rVt|οΏ½rV|nd}|j||fοΏ½οΏ½|dk	rvdS|rοΏ½|jrοΏ½|οΏ½t	|οΏ½οΏ½dSοΏ½NrοΏ½)
rrmrwr]rxοΏ½_looks_like_prefix_namer;ryrkοΏ½_escape_cdata_c14n)r,Z
_join_textrοΏ½r/οΏ½
qname_textr!r!r"r&Gs


zC14NWriterTarget._flushcCs0|jr
dS|jr|οΏ½οΏ½|jdοΏ½||fοΏ½dSrοΏ½)r{rr&rurJrTr!r!r"r2Us
zC14NWriterTarget.start_nscCsοΏ½|jdk	r,|js||jkr,|jd7_dS|jr:|οΏ½οΏ½g}|jοΏ½|οΏ½|jdk	rn||jkrn|||f|_dS|οΏ½|||οΏ½dSrοΏ½)	ror{rr&rtrJrqrxr;)r,r#r(οΏ½new_namespacesr!r!r"r)]s
οΏ½οΏ½zC14NWriterTarget.startcsοΏ½jdk	r$|r$οΏ½fddοΏ½|οΏ½οΏ½DοΏ½}|h|οΏ½}i}|dk	rVοΏ½οΏ½|οΏ½}||<|οΏ½|οΏ½οΏ½jdk	rοΏ½|rοΏ½οΏ½οΏ½|οΏ½}|rοΏ½|D]0}	||	}
t|
οΏ½rvοΏ½οΏ½|
οΏ½}||
<|οΏ½|οΏ½qvqοΏ½d}nd}οΏ½jοΏ½οΏ½fddοΏ½t|ddοΏ½dοΏ½DοΏ½}|rοΏ½ddοΏ½|DοΏ½}|οΏ½οΏ½ng}|οΏ½rjt|οΏ½οΏ½οΏ½D]^\}
}|dk	οΏ½r@|
|kοΏ½r@||kοΏ½r@|||d	}||
\}}	}|οΏ½	|οΏ½r\|n|	|fοΏ½οΏ½q
|οΏ½
d
οΏ½}οΏ½jοΏ½	|οΏ½rοΏ½|dknοΏ½jdοΏ½οΏ½j}|d
||d	οΏ½|οΏ½rοΏ½|dοΏ½
ddοΏ½|DοΏ½οΏ½οΏ½|dοΏ½|dk	οΏ½rοΏ½|t|||d	οΏ½οΏ½dοΏ½_οΏ½jοΏ½	gοΏ½dS)Ncs i|]\}}|οΏ½jkr||οΏ½qSr!)rnοΏ½οΏ½.0rοΏ½rοΏ½r0r!r"οΏ½
<dictcomp>ps
z+C14NWriterTarget._start.<locals>.<dictcomp>csi|]}|οΏ½|οΏ½οΏ½qSr!r!)rοΏ½r_)οΏ½parse_qnamer!r"rοΏ½οΏ½scSs|οΏ½ddοΏ½S)NrοΏ½r)r~)r_r!r!r"rοΏ½οΏ½rοΏ½z)C14NWriterTarget._start.<locals>.<lambda>rοΏ½cSs$g|]\}}|rd|nd|fοΏ½qS)zxmlns:Zxmlnsr!)rοΏ½rοΏ½rοΏ½r!r!r"οΏ½
<listcomp>οΏ½sοΏ½z+C14NWriterTarget._start.<locals>.<listcomp>rz+{http://www.w3.org/XML/1998/namespace}spaceZpreserverοΏ½rοΏ½rοΏ½cSs&g|]\}}d|οΏ½dt|οΏ½οΏ½dοΏ½οΏ½qS)rpz="rοΏ½)οΏ½_escape_attrib_c14nrοΏ½r!r!r"rοΏ½οΏ½srοΏ½T)rnrerοΏ½rοΏ½rsrοΏ½rοΏ½rοΏ½οΏ½sortrJr`rwrkr$rοΏ½ryru)r,r#r(rοΏ½rοΏ½rοΏ½Zresolved_namesrοΏ½ZqattrsZ	attr_namerbZ
parsed_qnamesrVrοΏ½rοΏ½Z
attr_qnamerοΏ½Zspace_behaviourrοΏ½r!)rοΏ½r,r"r;ns`


οΏ½
οΏ½

οΏ½
zC14NWriterTarget._startcCst|jr|jd8_dS|jr&|οΏ½οΏ½|οΏ½d|οΏ½|οΏ½dοΏ½dοΏ½οΏ½|jοΏ½οΏ½t|jοΏ½dk|_|j	οΏ½οΏ½|j
οΏ½οΏ½dS)NrrοΏ½rrοΏ½)r{rr&rkrοΏ½rwr*r8rzrtrurjr!r!r"r
οΏ½s

zC14NWriterTarget.endcCsd|js
dS|jrdS|jr&|οΏ½dοΏ½n|jr:|jr:|οΏ½οΏ½|οΏ½dt|οΏ½οΏ½dοΏ½οΏ½|js`|οΏ½dοΏ½dS)NrοΏ½z<!--z-->)rlr{rzrkryrr&rοΏ½r%r!r!r"r,οΏ½szC14NWriterTarget.commentcCsp|jr
dS|jr|οΏ½dοΏ½n|jr0|jr0|οΏ½οΏ½|οΏ½|rNd|οΏ½dt|οΏ½οΏ½dοΏ½n
d|οΏ½dοΏ½οΏ½|jsl|οΏ½dοΏ½dS)NrοΏ½z<?rpz?>)r{rzrkryrr&rοΏ½)r,rqrοΏ½r!r!r"r-οΏ½s$οΏ½zC14NWriterTarget.pi)N)N)rrrr r.οΏ½reversedr|rοΏ½rοΏ½rοΏ½r$r&r2r)r;r
r,r-r!r!r!r"rοΏ½s(οΏ½%
%
E
c	Cs|zVd|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}d|krR|οΏ½ddοΏ½}|WSttfk
rvt|οΏ½YnXdS)	NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½&#xD;rοΏ½rrr!r!r"rοΏ½οΏ½srοΏ½c	CsοΏ½z~d|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}d|krR|οΏ½ddοΏ½}d	|krf|οΏ½d	d
οΏ½}d|krz|οΏ½ddοΏ½}|WSttfk
rοΏ½t|οΏ½YnXdS)
NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½z&#x9;rοΏ½z&#xA;rοΏ½rοΏ½rοΏ½rrr!r!r"rοΏ½οΏ½s rοΏ½)rf)οΏ½_set_factories)N)N)N)NN)NN)N)NN)N)N)N)N)@r οΏ½__all__rrοΏ½rοΏ½r=rοΏ½r	Zcollections.abcrοΏ½rοΏ½rrr
rrrrrrr
rοΏ½contextmanagerrοΏ½rοΏ½rοΏ½rοΏ½rcοΏ½	NameErrorrοΏ½rοΏ½rοΏ½rrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrοΏ½rοΏ½rrr	rrrrrrrrrοΏ½compileοΏ½UNICODErοΏ½rοΏ½rrοΏ½rοΏ½rPZ_elementtreerοΏ½r5r!r!r!r"οΏ½<module>sοΏ½JοΏ½>

0s
3
=22οΏ½	οΏ½
οΏ½οΏ½


05


zgU

e5dοΏ½οΏ½@sοΏ½dddddddddd	d
ddd
dddddddddddgZdZddlZddlZddlZddlZddlZddlZddlZddl	m
Z
Gdd	οΏ½d	eοΏ½ZddοΏ½Z
Gd dοΏ½dοΏ½Zifd!d
οΏ½Zd\d"dοΏ½Zd]d#dοΏ½ZeZGd$dοΏ½dοΏ½ZGd%dοΏ½dοΏ½Zejd&d'οΏ½οΏ½Zd^d(d)οΏ½Zd*d+οΏ½Zd,ZzeeοΏ½ZWnek
οΏ½r*YnXd-d.οΏ½Zd/d0οΏ½Zeeed1οΏ½Zd2dοΏ½Zd3d4d5d6d7d8d9d:οΏ½Z e e_ d;d<οΏ½Z!d=d>οΏ½Z"d?d@οΏ½Z#dAdBοΏ½Z$d_dddCdDοΏ½dEdοΏ½Z%GdFdGοΏ½dGej&οΏ½Z'd`dddCdDοΏ½dHdοΏ½Z(dIdοΏ½Z)dadJdοΏ½Z*dbdKdοΏ½Z+GdLdοΏ½dοΏ½Z,dcdMdοΏ½Z-dddNdοΏ½Z.e-Z/dedOdοΏ½Z0GdPdοΏ½dοΏ½Z1GdQdοΏ½dοΏ½Z2dfdddRοΏ½dSdοΏ½Z3eοΏ½4dTej5οΏ½j6Z7GdUdοΏ½dοΏ½Z8dVdWοΏ½Z9dXdYοΏ½Z:zeZ;ddZl<Tdd[l<m=Z=Wne>k
οΏ½rοΏ½YnXe=eeοΏ½dS)gοΏ½CommentοΏ½dumpοΏ½ElementοΏ½ElementTreeοΏ½
fromstringοΏ½fromstringlistοΏ½	iselementοΏ½	iterparseοΏ½parseοΏ½
ParseErrorοΏ½PIοΏ½ProcessingInstructionοΏ½QNameοΏ½
SubElementοΏ½tostringοΏ½tostringlistοΏ½TreeBuilderοΏ½VERSIONοΏ½XMLοΏ½XMLIDοΏ½	XMLParserοΏ½
XMLPullParserοΏ½register_namespaceοΏ½canonicalizeοΏ½C14NWriterTargetz1.3.0οΏ½NοΏ½)οΏ½ElementPathc@seZdZdS)r
N)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½r r οΏ½-/usr/lib64/python3.8/xml/etree/ElementTree.pyr
js	cCs
t|dοΏ½S)NοΏ½tag)οΏ½hasattr)οΏ½elementr r r!rxsc@seZdZdZdZdZdZifddοΏ½ZddοΏ½ZddοΏ½Z	dd	οΏ½Z
d
dοΏ½Zdd
οΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd8d d!οΏ½Zd9d"d#οΏ½Zd:d$d%οΏ½Zd;d&d'οΏ½Zd(d)οΏ½Zd<d*d+οΏ½Zd,d-οΏ½Zd.d/οΏ½Zd0d1οΏ½Zd=d2d3οΏ½Zd>d4d5οΏ½Z d6d7οΏ½Z!dS)?rNcKs6t|tοΏ½std|jjfοΏ½οΏ½||_||οΏ½|_g|_dS)Nzattrib must be dict, not %s)οΏ½
isinstanceοΏ½dictοΏ½	TypeErrorοΏ½	__class__rr"οΏ½attribοΏ½	_children)οΏ½selfr"r)οΏ½extrar r r!οΏ½__init__οΏ½s
οΏ½
zElement.__init__cCsd|jj|jt|οΏ½fS)Nz<%s %r at %#x>)r(rr"οΏ½idοΏ½r+r r r!οΏ½__repr__οΏ½szElement.__repr__cCs|οΏ½||οΏ½SοΏ½N)r()r+r"r)r r r!οΏ½makeelementοΏ½s	zElement.makeelementcCs0|οΏ½|j|jοΏ½}|j|_|j|_||ddοΏ½<|Sr1)r2r"r)οΏ½textοΏ½tail)r+οΏ½elemr r r!οΏ½copyοΏ½s
zElement.copycCs
t|jοΏ½Sr1)οΏ½lenr*r/r r r!οΏ½__len__οΏ½szElement.__len__cCstjdtddοΏ½t|jοΏ½dkS)NzyThe behavior of this method will change in future versions.  Use specific 'len(elem)' or 'elem is not None' test instead.οΏ½οΏ½οΏ½
stacklevelr)οΏ½warningsοΏ½warnοΏ½
FutureWarningr7r*r/r r r!οΏ½__bool__οΏ½sοΏ½zElement.__bool__cCs
|j|Sr1οΏ½r*οΏ½r+οΏ½indexr r r!οΏ½__getitem__οΏ½szElement.__getitem__cCs8t|tοΏ½r |D]}|οΏ½|οΏ½qn
|οΏ½|οΏ½||j|<dSr1)r%οΏ½sliceοΏ½_assert_is_elementr*)r+rBr$Zeltr r r!οΏ½__setitem__οΏ½s


zElement.__setitem__cCs|j|=dSr1r@rAr r r!οΏ½__delitem__οΏ½szElement.__delitem__cCs|οΏ½|οΏ½|jοΏ½|οΏ½dSr1οΏ½rEr*οΏ½appendοΏ½r+οΏ½
subelementr r r!rIοΏ½s
zElement.appendcCs$|D]}|οΏ½|οΏ½|jοΏ½|οΏ½qdSr1rH)r+οΏ½elementsr$r r r!οΏ½extendοΏ½s
zElement.extendcCs|οΏ½|οΏ½|jοΏ½||οΏ½dSr1)rEr*οΏ½insert)r+rBrKr r r!rNοΏ½s
zElement.insertcCs t|tοΏ½stdt|οΏ½jοΏ½οΏ½dS)Nzexpected an Element, not %s)r%οΏ½_Element_Pyr'οΏ½typer)r+οΏ½er r r!rEοΏ½s
zElement._assert_is_elementcCs|jοΏ½|οΏ½dSr1)r*οΏ½removerJr r r!rRs
zElement.removecCstjdtddοΏ½|jS)NzaThis method will be removed in future versions.  Use 'list(elem)' or iteration over elem instead.r9r:)r<r=οΏ½DeprecationWarningr*r/r r r!οΏ½getchildrensοΏ½zElement.getchildrencCstοΏ½|||οΏ½Sr1)rοΏ½findοΏ½r+οΏ½pathοΏ½
namespacesr r r!rU!s	zElement.findcCstοΏ½||||οΏ½Sr1)rοΏ½findtextοΏ½r+rWοΏ½defaultrXr r r!rY,szElement.findtextcCstοΏ½|||οΏ½Sr1)rοΏ½findallrVr r r!r\:s	zElement.findallcCstοΏ½|||οΏ½Sr1)rοΏ½iterfindrVr r r!r]Es	zElement.iterfindcCs |jοΏ½οΏ½g|_d|_|_dSr1)r)οΏ½clearr*r3r4r/r r r!r^Ps
z
Element.clearcCs|jοΏ½||οΏ½Sr1)r)οΏ½get)r+οΏ½keyr[r r r!r_[szElement.getcCs||j|<dSr1)r))r+r`οΏ½valuer r r!οΏ½sethszElement.setcCs
|jοΏ½οΏ½Sr1)r)οΏ½keysr/r r r!rcrszElement.keyscCs
|jοΏ½οΏ½Sr1)r)οΏ½itemsr/r r r!rd{s	z
Element.itemsccsD|dkrd}|dks|j|kr$|V|jD]}|οΏ½|οΏ½EdHq*dS)NοΏ½*)r"r*οΏ½iter)r+r"rQr r r!rfοΏ½s
zElement.itercCstjdtddοΏ½t|οΏ½|οΏ½οΏ½S)NzbThis method will be removed in future versions.  Use 'elem.iter()' or 'list(elem.iter())' instead.r9r:οΏ½r<r=rSοΏ½listrfοΏ½r+r"r r r!οΏ½getiteratorοΏ½sοΏ½zElement.getiteratorccsX|j}t|tοΏ½s|dk	rdS|j}|r,|V|D]"}|οΏ½οΏ½EdH|j}|r0|Vq0dSr1)r"r%οΏ½strr3οΏ½itertextr4)r+r"οΏ½trQr r r!rlοΏ½szElement.itertext)N)NN)N)N)N)N)N)"rrrr"r)r3r4r-r0r2r6r8r?rCrFrGrIrMrNrErRrTrUrYr\r]r^r_rbrcrdrfrjrlr r r r!r}s>	








	

cKs"||οΏ½}|οΏ½||οΏ½}|οΏ½|οΏ½|Sr1)r2rI)οΏ½parentr"r)r,r$r r r!rοΏ½s
cCsttοΏ½}||_|Sr1)rrr3)r3r$r r r!rοΏ½s	cCs&ttοΏ½}||_|r"|jd||_|S)NοΏ½ )rrr3)οΏ½targetr3r$r r r!rοΏ½s

c@sVeZdZdddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½Z	ddοΏ½Z
ddοΏ½ZdS)r
NcCs|rd||f}||_dS)Nz{%s}%sοΏ½r3)r+Ztext_or_urir"r r r!r-οΏ½szQName.__init__cCs|jSr1rqr/r r r!οΏ½__str__οΏ½sz
QName.__str__cCsd|jj|jfS)Nz<%s %r>)r(rr3r/r r r!r0szQName.__repr__cCs
t|jοΏ½Sr1)οΏ½hashr3r/r r r!οΏ½__hash__szQName.__hash__cCs t|tοΏ½r|j|jkS|j|kSr1οΏ½r%r
r3οΏ½r+οΏ½otherr r r!οΏ½__le__s
zQName.__le__cCs t|tοΏ½r|j|jkS|j|kSr1rurvr r r!οΏ½__lt__s
zQName.__lt__cCs t|tοΏ½r|j|jkS|j|kSr1rurvr r r!οΏ½__ge__s
zQName.__ge__cCs t|tοΏ½r|j|jkS|j|kSr1rurvr r r!οΏ½__gt__s
zQName.__gt__cCs t|tοΏ½r|j|jkS|j|kSr1rurvr r r!οΏ½__eq__s
zQName.__eq__)N)rrrr-rrr0rtrxryrzr{r|r r r r!r
οΏ½s
c@sοΏ½eZdZdddοΏ½ZddοΏ½ZddοΏ½Zddd	οΏ½Zdd
dοΏ½Zddd
οΏ½Zd ddοΏ½Z	d!ddοΏ½Z
d"ddοΏ½Zd#ddοΏ½Zd$ddοΏ½ddοΏ½Z
ddοΏ½ZdS)%rNcCs||_|r|οΏ½|οΏ½dSr1)οΏ½_rootr	)r+r$οΏ½filer r r!r-'szElementTree.__init__cCs|jSr1οΏ½r}r/r r r!οΏ½getroot-szElementTree.getrootcCs
||_dSr1r)r+r$r r r!οΏ½_setroot1szElementTree._setrootcCsοΏ½d}t|dοΏ½st|dοΏ½}d}z^|dkrLtοΏ½}t|dοΏ½rL|οΏ½|οΏ½|_|jWοΏ½2S|οΏ½dοΏ½}|s\qh|οΏ½|οΏ½qL|οΏ½οΏ½|_|jWοΏ½S|rοΏ½|οΏ½οΏ½XdS)NFοΏ½readοΏ½rbTοΏ½_parse_wholei)r#οΏ½openοΏ½closerrοΏ½r}rοΏ½οΏ½feed)r+οΏ½sourceοΏ½parserοΏ½close_sourceοΏ½datar r r!r	;s$






zElementTree.parsecCs|jοΏ½|οΏ½Sr1)r}rfrir r r!rf`s
zElementTree.itercCstjdtddοΏ½t|οΏ½|οΏ½οΏ½S)NzbThis method will be removed in future versions.  Use 'tree.iter()' or 'list(tree.iter())' instead.r9r:rgrir r r!rjmsοΏ½zElementTree.getiteratorcCs:|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½||οΏ½SοΏ½NrοΏ½/οΏ½.zοΏ½This search is broken in 1.3 and earlier, and will be fixed in a future version.  If you rely on the current behaviour, change it to %rr9r:)r<r=r>r}rUrVr r r!rUusοΏ½οΏ½zElementTree.findcCs<|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½|||οΏ½SrοΏ½)r<r=r>r}rYrZr r r!rYοΏ½sοΏ½οΏ½zElementTree.findtextcCs:|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½||οΏ½SrοΏ½)r<r=r>r}r\rVr r r!r\οΏ½sοΏ½οΏ½zElementTree.findallcCs:|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½||οΏ½SrοΏ½)r<r=r>r}r]rVr r r!r]οΏ½sοΏ½οΏ½zElementTree.iterfindTοΏ½οΏ½short_empty_elementsc	CsοΏ½|s
d}n|tkrtd|οΏ½οΏ½|s4|dkr0d}nd}|οΏ½οΏ½}t||οΏ½οΏ½οΏ½}|dkrοΏ½|sd|dkrοΏ½|dkrοΏ½|}	|dkrοΏ½ddl}
|
οΏ½οΏ½}	|d	|	fοΏ½|d
krοΏ½t||jοΏ½n,t|j|οΏ½\}}t|}
|
||j|||dοΏ½W5QRXdS)NοΏ½xmlzunknown method %rοΏ½c14nοΏ½utf-8οΏ½us-ascii)rοΏ½rοΏ½οΏ½unicoderοΏ½rz$<?xml version='1.0' encoding='%s'?>
r3rοΏ½)	οΏ½
_serializeοΏ½
ValueErrorοΏ½lowerοΏ½_get_writerοΏ½localeZgetpreferredencodingοΏ½_serialize_textr}οΏ½_namespaces)r+οΏ½file_or_filenameοΏ½encodingοΏ½xml_declarationοΏ½default_namespaceοΏ½methodrοΏ½Z	enc_lowerοΏ½writeZdeclared_encodingrοΏ½οΏ½qnamesrXZ	serializer r r!rοΏ½οΏ½s:οΏ½οΏ½οΏ½οΏ½zElementTree.writecCs|j|ddοΏ½S)NrοΏ½)rοΏ½)rοΏ½)r+r~r r r!οΏ½
write_c14nszElementTree.write_c14n)NN)N)N)N)N)NN)N)N)NNNN)rrrr-rοΏ½rοΏ½r	rfrjrUrYr\r]rοΏ½rοΏ½r r r r!rs$


%





οΏ½οΏ½:ccs"z
|j}WnPtk
rZ|dkr.t|dοΏ½}nt|d|ddοΏ½}|οΏ½|jVW5QRXYnοΏ½X|dkrl|VnοΏ½tοΏ½οΏ½οΏ½οΏ½}t|tjοΏ½rοΏ½|}nft|tjοΏ½rοΏ½tοΏ½	|οΏ½}|οΏ½
|jοΏ½nBtοΏ½οΏ½}ddοΏ½|_||_z|j
|_
|j|_Wntk
rοΏ½YnXtj||dddοΏ½}|οΏ½
|jοΏ½|jVW5QRXdS)	NrοΏ½οΏ½wοΏ½xmlcharrefreplace)rοΏ½οΏ½errorscSsdSοΏ½NTr r r r r!οΏ½<lambda>0οΏ½z_get_writer.<locals>.<lambda>οΏ½
)rοΏ½rοΏ½οΏ½newline)rοΏ½οΏ½AttributeErrorrοΏ½οΏ½
contextlibοΏ½	ExitStackr%οΏ½ioοΏ½BufferedIOBaseοΏ½	RawIOBaseοΏ½BufferedWriterοΏ½callbackοΏ½detachοΏ½writableοΏ½seekableοΏ½tellοΏ½
TextIOWrapper)rοΏ½rοΏ½rοΏ½r~οΏ½stackr r r!rοΏ½sB
οΏ½


οΏ½rοΏ½csddiοΏ½iοΏ½οΏ½rdοΏ½οΏ½<οΏ½οΏ½οΏ½fddοΏ½}|οΏ½οΏ½D]οΏ½}|j}t|tοΏ½rZ|jοΏ½krοΏ½||jοΏ½n<t|tοΏ½rv|οΏ½krοΏ½||οΏ½n |dk	rοΏ½|tk	rοΏ½|tk	rοΏ½t|οΏ½|οΏ½	οΏ½D]F\}}t|tοΏ½rοΏ½|j}|οΏ½krοΏ½||οΏ½t|tοΏ½rοΏ½|jοΏ½krοΏ½||jοΏ½qοΏ½|j}t|tοΏ½r0|jοΏ½kr0||jοΏ½q0οΏ½οΏ½fS)NοΏ½csοΏ½zοΏ½|ddοΏ½dkrοΏ½|ddοΏ½οΏ½ddοΏ½\}}οΏ½οΏ½|οΏ½}|dkrjtοΏ½|οΏ½}|dkrZdtοΏ½οΏ½}|dkrj|οΏ½|<|rοΏ½d||fοΏ½|<qοΏ½|οΏ½|<nοΏ½rοΏ½tdοΏ½οΏ½|οΏ½|<Wntk
rοΏ½t|οΏ½YnXdS)NrοΏ½{οΏ½}zns%drοΏ½z%s:%sz<cannot use non-qualified names with default_namespace option)οΏ½rsplitr_οΏ½_namespace_mapr7rοΏ½r'οΏ½_raise_serialization_error)οΏ½qnameοΏ½urir"οΏ½prefixοΏ½rοΏ½rXrοΏ½r r!οΏ½	add_qnameMs(


οΏ½z_namespaces.<locals>.add_qname)
rfr"r%r
r3rkrrrοΏ½rd)r5rοΏ½rοΏ½r"r`rar3r rοΏ½r!rοΏ½Bs4




rοΏ½cKsοΏ½|j}|j}|tkr$|d|οΏ½οΏ½nv|tkr<|d|οΏ½οΏ½n^||}|dkr||r\|t|οΏ½οΏ½|D]}t|||d|dοΏ½q`οΏ½n|d|οΏ½t|οΏ½οΏ½οΏ½}	|	sοΏ½|οΏ½r2|rοΏ½t|οΏ½οΏ½ddοΏ½dοΏ½D](\}
}|rοΏ½d|}|d	|t	|
οΏ½fοΏ½qοΏ½|	D]L\}}
t
|tοΏ½rοΏ½|j}t
|
tοΏ½οΏ½r||
j}
nt	|
οΏ½}
|d
|||
fοΏ½qοΏ½|οΏ½sHt|οΏ½οΏ½sH|οΏ½sοΏ½|dοΏ½|οΏ½rb|t|οΏ½οΏ½|D]}t|||d|dοΏ½οΏ½qf|d|dοΏ½n|d
οΏ½|j
οΏ½rοΏ½|t|j
οΏ½οΏ½dS)NοΏ½	<!--%s-->οΏ½<?%s?>rοΏ½οΏ½<cSs|dSοΏ½Nrr οΏ½οΏ½xr r r!rοΏ½οΏ½rοΏ½z _serialize_xml.<locals>.<lambda>οΏ½r`οΏ½:οΏ½
 xmlns%s="%s"οΏ½ %s="%s"οΏ½>οΏ½</z />)r"r3rrοΏ½
_escape_cdataοΏ½_serialize_xmlrhrdοΏ½sortedοΏ½_escape_attribr%r
r7r4)rοΏ½r5rοΏ½rXrοΏ½οΏ½kwargsr"r3rQrdοΏ½vοΏ½kr r r!rοΏ½s\
οΏ½
οΏ½οΏ½


οΏ½
rοΏ½)
ZareaοΏ½baseZbasefontοΏ½brοΏ½colοΏ½frameZhrZimgοΏ½inputZisindexοΏ½linkοΏ½metaZparamcKsοΏ½|j}|j}|tkr(|dt|οΏ½οΏ½οΏ½nοΏ½|tkrD|dt|οΏ½οΏ½οΏ½nh||}|dkrοΏ½|rd|t|οΏ½οΏ½|D]}t|||dοΏ½qhοΏ½n,|d|οΏ½t|οΏ½οΏ½οΏ½}|sοΏ½|οΏ½r8|rοΏ½t|οΏ½οΏ½ddοΏ½dοΏ½D](\}	}
|
rοΏ½d|
}
|d|
t	|	οΏ½fοΏ½qοΏ½|D]N\}
}	t
|
tοΏ½οΏ½r|
j}
t
|	tοΏ½οΏ½r||	j}	nt|	οΏ½}	|d	||
|	fοΏ½qοΏ½|d
οΏ½|οΏ½
οΏ½}|οΏ½rx|dkοΏ½sb|dkοΏ½rl||οΏ½n|t|οΏ½οΏ½|D]}t|||dοΏ½οΏ½q||tkοΏ½rοΏ½|d
|d
οΏ½|jοΏ½rοΏ½|t|jοΏ½οΏ½dS)NrοΏ½rοΏ½rοΏ½cSs|dSrοΏ½r rοΏ½r r r!rοΏ½οΏ½rοΏ½z!_serialize_html.<locals>.<lambda>rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½ZscriptZstylerοΏ½)r"r3rrοΏ½rοΏ½_serialize_htmlrhrdrοΏ½rοΏ½r%r
οΏ½_escape_attrib_htmlrοΏ½οΏ½
HTML_EMPTYr4)rοΏ½r5rοΏ½rXrοΏ½r"r3rQrdrοΏ½rοΏ½Zltagr r r!rοΏ½οΏ½sX
οΏ½οΏ½


rοΏ½cCs*|οΏ½οΏ½D]}||οΏ½q|jr&||jοΏ½dSr1)rlr4)rοΏ½r5οΏ½partr r r!rοΏ½οΏ½s
rοΏ½)rοΏ½οΏ½htmlr3cCsLtοΏ½d|οΏ½rtdοΏ½οΏ½ttοΏ½οΏ½οΏ½D]\}}||ks8||kr t|=q |t|<dS)Nzns\d+$z'Prefix format reserved for internal use)οΏ½reοΏ½matchrοΏ½rhrοΏ½rd)rοΏ½rοΏ½rοΏ½rοΏ½r r r!rοΏ½srοΏ½rοΏ½ZrdfZwsdlZxsZxsiZdc)οΏ½$http://www.w3.org/XML/1998/namespacezhttp://www.w3.org/1999/xhtmlz+http://www.w3.org/1999/02/22-rdf-syntax-ns#z http://schemas.xmlsoap.org/wsdl/z http://www.w3.org/2001/XMLSchemaz)http://www.w3.org/2001/XMLSchema-instancez http://purl.org/dc/elements/1.1/cCstd|t|οΏ½jfοΏ½οΏ½dS)Nzcannot serialize %r (type %s))r'rPrrqr r r!rοΏ½sοΏ½rοΏ½c	CshzBd|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}|WSttfk
rbt|οΏ½YnXdS)NοΏ½&οΏ½&amp;rοΏ½οΏ½&lt;rοΏ½οΏ½&gt;οΏ½οΏ½replacer'rοΏ½rοΏ½rqr r r!rοΏ½!srοΏ½c	CsοΏ½zοΏ½d|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}d|krR|οΏ½ddοΏ½}d	|krf|οΏ½d	d
οΏ½}d|krz|οΏ½dd
οΏ½}d
|krοΏ½|οΏ½d
dοΏ½}d
|krοΏ½|οΏ½d
dοΏ½}|WSttfk
rοΏ½t|οΏ½YnXdS)NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½"οΏ½&quot;z
rοΏ½οΏ½
z&#10;οΏ½	z&#09;rοΏ½rqr r r!rοΏ½1s(rοΏ½c	CshzBd|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}|WSttfk
rbt|οΏ½YnXdS)NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rqr r r!rοΏ½MsrοΏ½T)rοΏ½rοΏ½rοΏ½cCs:|dkrtοΏ½οΏ½ntοΏ½οΏ½}t|οΏ½j||||||dοΏ½|οΏ½οΏ½S)NrοΏ½οΏ½rοΏ½rοΏ½rοΏ½rοΏ½)rοΏ½οΏ½StringIOοΏ½BytesIOrrοΏ½οΏ½getvalue)r$rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½streamr r r!r\sοΏ½c@s4eZdZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZdS)οΏ½_ListDataStreamcCs
||_dSr1)οΏ½lst)r+rοΏ½r r r!r-vsz_ListDataStream.__init__cCsdSrοΏ½r r/r r r!rοΏ½ysz_ListDataStream.writablecCsdSrοΏ½r r/r r r!rοΏ½|sz_ListDataStream.seekablecCs|jοΏ½|οΏ½dSr1)rοΏ½rI)r+οΏ½br r r!rοΏ½sz_ListDataStream.writecCs
t|jοΏ½Sr1)r7rοΏ½r/r r r!rοΏ½οΏ½sz_ListDataStream.tellN)rrrr-rοΏ½rοΏ½rοΏ½rοΏ½r r r r!rοΏ½ts
rοΏ½cCs*g}t|οΏ½}t|οΏ½j||||||dοΏ½|S)NrοΏ½)rοΏ½rrοΏ½)r$rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r r r!rοΏ½sοΏ½cCsLt|tοΏ½st|οΏ½}|jtjddοΏ½|οΏ½οΏ½j}|r<|ddkrHtjοΏ½dοΏ½dS)NrοΏ½)rοΏ½οΏ½οΏ½οΏ½rοΏ½)r%rrοΏ½οΏ½sysοΏ½stdoutrοΏ½r4)r5r4r r r!rοΏ½s

cCstοΏ½}|οΏ½||οΏ½|Sr1)rr	)rοΏ½rοΏ½οΏ½treer r r!r	οΏ½s	csft||dοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½fddοΏ½οΏ½GοΏ½fddοΏ½dtjjοΏ½}|οΏ½οΏ½dοΏ½_οΏ½~dοΏ½tοΏ½dοΏ½sbtοΏ½dοΏ½οΏ½d	οΏ½οΏ½S)
N)οΏ½eventsοΏ½_parserc3s^zJοΏ½οΏ½οΏ½EdHοΏ½οΏ½dοΏ½}|s q,οΏ½οΏ½|οΏ½qοΏ½οΏ½οΏ½}οΏ½οΏ½οΏ½EdH|οΏ½_W5οΏ½rXοΏ½οΏ½οΏ½XdS)Ni@)rοΏ½οΏ½read_eventsrοΏ½rοΏ½οΏ½_close_and_return_rootοΏ½root)rοΏ½r)rοΏ½οΏ½itοΏ½
pullparserrοΏ½r r!οΏ½iteratorοΏ½s

ziterparse.<locals>.iteratorcseZdZοΏ½οΏ½jZdS)z$iterparse.<locals>.IterParseIteratorN)rrrοΏ½__next__r )rr r!οΏ½IterParseIteratorοΏ½srFrοΏ½rοΏ½T)rοΏ½collectionsοΏ½abcοΏ½Iteratorrr#rοΏ½)rοΏ½rοΏ½rοΏ½rr )rοΏ½rrrrοΏ½r!rοΏ½s

c@s<eZdZd
ddοΏ½ddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½ZdS)rN)rοΏ½cCs<tοΏ½οΏ½|_|pttοΏ½dοΏ½|_|dkr(d}|jοΏ½|j|οΏ½dS)NοΏ½rp)οΏ½end)rοΏ½dequeοΏ½
_events_queuerrrοΏ½οΏ½
_setevents)r+rοΏ½rοΏ½r r r!r-οΏ½s

zXMLPullParser.__init__c
CsZ|jdkrtdοΏ½οΏ½|rVz|jοΏ½|οΏ½Wn.tk
rT}z|jοΏ½|οΏ½W5d}~XYnXdS)Nz!feed() called after end of stream)rοΏ½rοΏ½rοΏ½οΏ½SyntaxErrorrrI)r+rοΏ½οΏ½excr r r!rοΏ½οΏ½s
zXMLPullParser.feedcCs|jοΏ½οΏ½}d|_|Sr1)rοΏ½rοΏ½)r+rr r r!rοΏ½s
z$XMLPullParser._close_and_return_rootcCs|οΏ½οΏ½dSr1)rr/r r r!rοΏ½szXMLPullParser.closeccs.|j}|r*|οΏ½οΏ½}t|tοΏ½r"|οΏ½q|VqdSr1)rοΏ½popleftr%οΏ½	Exception)r+rοΏ½οΏ½eventr r r!rs
zXMLPullParser.read_events)N)rrrr-rοΏ½rrοΏ½rr r r r!rοΏ½s

cCs"|sttοΏ½dοΏ½}|οΏ½|οΏ½|οΏ½οΏ½SοΏ½NrοΏ½rrrοΏ½rοΏ½)r3rοΏ½r r r!rs
cCsR|sttοΏ½dοΏ½}|οΏ½|οΏ½|οΏ½οΏ½}i}|οΏ½οΏ½D]}|οΏ½dοΏ½}|r.|||<q.||fS)Nrr.)rrrοΏ½rοΏ½rfr_)r3rοΏ½rοΏ½Zidsr5r.r r r!r,s



cCs,|sttοΏ½dοΏ½}|D]}|οΏ½|οΏ½q|οΏ½οΏ½Srr)ZsequencerοΏ½r3r r r!rDs
	c@sdeZdZddddddοΏ½ddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½ZddοΏ½Z	dddοΏ½Z
ddοΏ½ZdS)rNF)οΏ½comment_factoryοΏ½
pi_factoryοΏ½insert_commentsοΏ½
insert_piscCsdg|_g|_d|_d|_d|_|dkr*t}||_||_|dkrBt}||_	||_
|dkrZt}||_dSr1)
οΏ½_dataοΏ½_elemοΏ½_lastr}οΏ½_tailrοΏ½_comment_factoryrrοΏ½_pi_factoryrrοΏ½_factory)r+Zelement_factoryrrrrr r r!r-js zTreeBuilder.__init__cCs|jSr1rr/r r r!rοΏ½~szTreeBuilder.closecCs>|jr:|jdk	r4dοΏ½|jοΏ½}|jr,||j_n||j_g|_dSοΏ½NrοΏ½)rrοΏ½joinrr4r3οΏ½r+r3r r r!οΏ½_flushοΏ½s

zTreeBuilder._flushcCs|jοΏ½|οΏ½dSr1)rrIοΏ½r+rοΏ½r r r!rοΏ½οΏ½szTreeBuilder.datacCsX|οΏ½οΏ½|οΏ½||οΏ½|_}|jr2|jdοΏ½|οΏ½n|jdkrB||_|jοΏ½|οΏ½d|_|S)NrοΏ½r)r%r!rrrIr}r)r+r"οΏ½attrsr5r r r!οΏ½startοΏ½s
zTreeBuilder.startcCs |οΏ½οΏ½|jοΏ½οΏ½|_d|_|jSrοΏ½)r%rοΏ½poprrrir r r!rοΏ½szTreeBuilder.endcCs|οΏ½|j|j|οΏ½Sr1)οΏ½_handle_singlerrr$r r r!οΏ½commentοΏ½s
οΏ½zTreeBuilder.commentcCs|οΏ½|j|j||οΏ½Sr1)r*r r)r+rpr3r r r!οΏ½piοΏ½sοΏ½zTreeBuilder.picGs:||οΏ½}|r6|οΏ½οΏ½||_|jr0|jdοΏ½|οΏ½d|_|S)NrοΏ½r)r%rrrIr)r+οΏ½factoryrNοΏ½argsr5r r r!r*οΏ½szTreeBuilder._handle_single)N)N)rrrr-rοΏ½r%rοΏ½r(rr+r,r*r r r r!rVsοΏ½
	c@sleZdZdddοΏ½ddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½ZddοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
dS)rN)rprοΏ½cCsdzddlm}Wn>tk
rNzddl}Wntk
rHtdοΏ½οΏ½YnXYnX|οΏ½|dοΏ½}|dkrjtοΏ½}||_|_||_|_	|j
|_i|_|j
|_t|dοΏ½rοΏ½|j|_t|dοΏ½rοΏ½|j|_t|dοΏ½rοΏ½|j|_t|dοΏ½rοΏ½|j|_t|d	οΏ½rοΏ½|j|_t|d
οΏ½οΏ½r|j|_t|dοΏ½οΏ½r|j|_d|_d|_d|_ d|_!i|_"zd
|j#|_$Wnt%k
οΏ½r^YnXdS)NrοΏ½οΏ½expatz7No module named expat; use SimpleXMLTreeBuilder insteadrοΏ½r(rοΏ½start_nsοΏ½end_nsrοΏ½r+r,rzExpat %d.%d.%d)&οΏ½xml.parsersr0οΏ½ImportErrorZpyexpatZParserCreaterrοΏ½rοΏ½rpοΏ½_targetοΏ½errorοΏ½_errorοΏ½_namesοΏ½_defaultZDefaultHandlerExpandr#οΏ½_startοΏ½StartElementHandlerοΏ½_endοΏ½EndElementHandlerοΏ½	_start_nsοΏ½StartNamespaceDeclHandlerοΏ½_end_nsοΏ½EndNamespaceDeclHandlerrοΏ½ZCharacterDataHandlerr+οΏ½CommentHandlerr,οΏ½ProcessingInstructionHandlerZbuffer_textοΏ½ordered_attributesοΏ½specified_attributesοΏ½_doctypeοΏ½entityοΏ½version_infoοΏ½versionrοΏ½)r+rprοΏ½r0rοΏ½r r r!r-οΏ½sPοΏ½




zXMLParser.__init__cCs8|j}|j}|DοΏ½] }|dkrDd|_d|_|||jfddοΏ½}||_q|dkrf|||jfddοΏ½}||_q|dkrοΏ½t|j	dοΏ½rοΏ½|||j
fd	dοΏ½}n||fd
dοΏ½}||_q|dkrοΏ½t|j	dοΏ½rοΏ½|||jfd
dοΏ½}n||fddοΏ½}||_
q|dkοΏ½r|||fddοΏ½}||_q|dkοΏ½r&|||fddοΏ½}||_qtd|οΏ½οΏ½qdS)Nr(rcSs|||||οΏ½fοΏ½dSr1r )r"Z	attrib_inrrIr(r r r!οΏ½handlersz%XMLParser._setevents.<locals>.handlerrcSs||||οΏ½fοΏ½dSr1r )r"rrIrr r r!rJszstart-nsr1cSs|||||οΏ½fοΏ½dSr1r )rοΏ½rοΏ½rrIr1r r r!rJ!scSs|||p
d|pdffοΏ½dSr"r )rοΏ½rοΏ½rrIr r r!rJ%szend-nsr2cSs||||οΏ½fοΏ½dSr1r )rοΏ½rrIr2r r r!rJ+scSs||dfοΏ½dSr1r )rοΏ½rrIr r r!rJ/sr+cSs|||jοΏ½|οΏ½fοΏ½dSr1)rpr+)r3rrIr+r r r!rJ3sr,cSs|||jοΏ½||οΏ½fοΏ½dSr1)rpr,)Z	pi_targetrοΏ½rrIr+r r r!rJ7szunknown event %r)rοΏ½rIrDrEr:r;r<r=r#rpr>r?r@rArBrCrοΏ½)r+Zevents_queueZevents_to_reportrοΏ½rIZ
event_namerJr r r!rsL
οΏ½
οΏ½
οΏ½οΏ½

οΏ½
zXMLParser._seteventscCs&t|οΏ½}|j|_|j|jf|_|οΏ½dSr1)r
οΏ½codeοΏ½linenoοΏ½offsetZposition)r+raοΏ½errr r r!οΏ½_raiseerror>szXMLParser._raiseerrorcCsFz|j|}Wn2tk
r@|}d|kr2d|}||j|<YnX|S)NrοΏ½rοΏ½)r8οΏ½KeyError)r+r`οΏ½namer r r!οΏ½_fixnameDszXMLParser._fixnamecCs|jοΏ½|pd|pdοΏ½Sr")rpr1οΏ½r+rοΏ½rοΏ½r r r!r>OszXMLParser._start_nscCs|jοΏ½|pdοΏ½Sr")rpr2)r+rοΏ½r r r!r@RszXMLParser._end_nscCsR|j}||οΏ½}i}|rDtdt|οΏ½dοΏ½D]}||d||||οΏ½<q&|jοΏ½||οΏ½S)Nrr9r)rRοΏ½ranger7rpr()r+r"οΏ½	attr_listZfixnamer)οΏ½ir r r!r:UszXMLParser._startcCs|jοΏ½|οΏ½|οΏ½οΏ½Sr1)rprrRrir r r!r<aszXMLParser._endc	CsοΏ½|ddοΏ½}|dkrοΏ½z|jj}Wntk
r6YdSXz||j|ddοΏ½οΏ½WnZtk
rοΏ½ddlm}|οΏ½d||jj	|jj
fοΏ½}d|_|jj	|_|jj
|_
|οΏ½YnXοΏ½n"|dkrοΏ½|dd	οΏ½d
krοΏ½g|_οΏ½n|jdk	οΏ½rοΏ½|dkrοΏ½d|_dS|οΏ½οΏ½}|οΏ½sdS|jοΏ½|οΏ½t|jοΏ½}|dkοΏ½rοΏ½|jd}|d
kοΏ½rd|dkοΏ½rd|j\}}}	}
|	οΏ½rοΏ½|	ddοΏ½}	n*|dkοΏ½rοΏ½|dkοΏ½rοΏ½|j\}}}
d}	ndSt|jdοΏ½οΏ½rοΏ½|jοΏ½||	|
ddοΏ½οΏ½nt|dοΏ½οΏ½rοΏ½tοΏ½dtοΏ½d|_dS)NrrοΏ½rοΏ½rr/z'undefined entity %s: line %d, column %dοΏ½rοΏ½οΏ½	z	<!DOCTYPErοΏ½r9ZPUBLICοΏ½ZSYSTEMοΏ½οΏ½doctypezaThe doctype() method of XMLParser is ignored.  Define doctype() method on the TreeBuilder target.)rprοΏ½rοΏ½rGrPr3r0r6rοΏ½ZErrorLineNumberZErrorColumnNumberrKrLrMrFοΏ½striprIr7r#r[r<r=οΏ½RuntimeWarning)r+r3rοΏ½Zdata_handlerr0rNοΏ½nrPrQZpubidοΏ½systemr r r!r9dsdοΏ½οΏ½οΏ½





οΏ½zXMLParser._defaultc
CsFz|jοΏ½|dοΏ½Wn.|jk
r@}z|οΏ½|οΏ½W5d}~XYnXdS)Nr)rοΏ½οΏ½Parser7rO)r+rοΏ½rοΏ½r r r!rοΏ½οΏ½szXMLParser.feedc
CsοΏ½z|jοΏ½ddοΏ½Wn.|jk
r@}z|οΏ½|οΏ½W5d}~XYnXz0z|jj}Wntk
rdYnX|οΏ½WοΏ½SW5|`|`|`|`XdS)NrοΏ½r)	rοΏ½r`r7rOrοΏ½rpr5rοΏ½rοΏ½)r+rοΏ½Z
close_handlerr r r!rοΏ½οΏ½szXMLParser.close)rrrr-rrOrRr>r@r:r<r9rοΏ½rοΏ½r r r r!rοΏ½s
.66)οΏ½outοΏ½	from_filecKsοΏ½|dkr|dkrtdοΏ½οΏ½d}|dkr0tοΏ½οΏ½}}tt|jf|οΏ½dοΏ½}|dk	r`|οΏ½|οΏ½|οΏ½οΏ½n|dk	rtt||dοΏ½|dk	rοΏ½|οΏ½	οΏ½SdS)Nz:Either 'xml_data' or 'from_file' must be provided as inputr)rοΏ½)
rοΏ½rοΏ½rοΏ½rrrοΏ½rοΏ½rοΏ½r	rοΏ½)Zxml_datararbZoptionsZsiorοΏ½r r r!rοΏ½s


z	^\w+:\w+$c@sοΏ½eZdZddddddddοΏ½ddοΏ½ZefddοΏ½Zdd	οΏ½Zdd
dοΏ½Zdd
οΏ½Zdj	fddοΏ½Z
ddοΏ½ZddοΏ½ZdddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZdS)rFN)οΏ½
with_commentsοΏ½
strip_textοΏ½rewrite_prefixesοΏ½qname_aware_tagsοΏ½qname_aware_attrsοΏ½
exclude_attrsοΏ½exclude_tagsc	CsοΏ½||_g|_||_||_|r$t|οΏ½nd|_|r6t|οΏ½nd|_||_|rRt|οΏ½|_nd|_|rjt|οΏ½j	|_
nd|_
dgg|_g|_|sοΏ½|jοΏ½
ttοΏ½οΏ½οΏ½οΏ½|jοΏ½
gοΏ½i|_dg|_d|_d|_d|_d|_dS)N)rοΏ½rοΏ½Fr)οΏ½_writerοΏ½_with_commentsοΏ½_strip_textrbοΏ½_exclude_attrsοΏ½
_exclude_tagsοΏ½_rewrite_prefixesοΏ½_qname_aware_tagsοΏ½intersectionοΏ½_find_qname_aware_attrsοΏ½_declared_ns_stackοΏ½	_ns_stackrIrhrοΏ½rdοΏ½_prefix_mapοΏ½_preserve_spaceοΏ½_pending_startοΏ½
_root_seenοΏ½
_root_doneοΏ½_ignored_depth)	r+rοΏ½rcrdrerfrgrhrir r r!r-οΏ½s2οΏ½zC14NWriterTarget.__init__ccs ||οΏ½D]}|r|EdHqdSr1r )r+Zns_stackZ	_reversedrXr r r!οΏ½_iter_namespacessz!C14NWriterTarget._iter_namespacescCs\|οΏ½ddοΏ½\}}|οΏ½|jοΏ½D]$\}}||krd|οΏ½d|οΏ½οΏ½Sqtd|οΏ½d|οΏ½dοΏ½οΏ½οΏ½dS)NrοΏ½rrοΏ½rοΏ½zPrefix z of QName "οΏ½" is not declared in scope)οΏ½splitr{rtrοΏ½)r+Z
prefixed_namerοΏ½rQrοΏ½οΏ½pr r r!οΏ½_resolve_prefix_names
z%C14NWriterTarget._resolve_prefix_namecCsοΏ½|dkr:|ddοΏ½dkr,|ddοΏ½οΏ½ddοΏ½nd|f\}}n|}tοΏ½}|οΏ½|jοΏ½D]B\}}||krοΏ½||krοΏ½|rz|οΏ½d|οΏ½οΏ½n|||fS|οΏ½|οΏ½qP|jrοΏ½||jkrοΏ½|j|}ndt|jοΏ½οΏ½οΏ½}|j|<|jdοΏ½||fοΏ½|οΏ½d|οΏ½οΏ½||fS|οΏ½sd|kοΏ½r|||fS|οΏ½|j	οΏ½D]J\}}||kοΏ½r|jdοΏ½||fοΏ½|οΏ½rR|οΏ½d|οΏ½οΏ½n|||fSοΏ½q|οΏ½st|||fSt
d|οΏ½d	οΏ½οΏ½οΏ½dS)
NrrοΏ½rοΏ½rοΏ½rοΏ½r^rοΏ½zNamespace "r|)rοΏ½rbr{rsοΏ½addrorur7rIrtrοΏ½)r+rοΏ½rοΏ½r"Z
prefixes_seenοΏ½urοΏ½r r r!οΏ½_qnames.2 


&
zC14NWriterTarget._qnamecCs|js|jοΏ½|οΏ½dSr1)rzrrIr&r r r!rοΏ½CszC14NWriterTarget.datarοΏ½cCsοΏ½||jοΏ½}|jddοΏ½=|jr.|jds.|οΏ½οΏ½}|jdk	rv|jd}|_|rVt|οΏ½rV|nd}|j||fοΏ½οΏ½|dk	rvdS|rοΏ½|jrοΏ½|οΏ½t	|οΏ½οΏ½dSοΏ½NrοΏ½)
rrlrvr\rwοΏ½_looks_like_prefix_namer:rxrjοΏ½_escape_cdata_c14n)r+Z
_join_textrοΏ½r.οΏ½
qname_textr r r!r%Gs


zC14NWriterTarget._flushcCs0|jr
dS|jr|οΏ½οΏ½|jdοΏ½||fοΏ½dSrοΏ½)rzrr%rtrIrSr r r!r1Us
zC14NWriterTarget.start_nscCsοΏ½|jdk	r,|js||jkr,|jd7_dS|jr:|οΏ½οΏ½g}|jοΏ½|οΏ½|jdk	rn||jkrn|||f|_dS|οΏ½|||οΏ½dSrοΏ½)	rnrzrr%rsrIrprwr:)r+r"r'οΏ½new_namespacesr r r!r(]s
οΏ½οΏ½zC14NWriterTarget.startcsοΏ½jdk	r$|r$οΏ½fddοΏ½|οΏ½οΏ½DοΏ½}|h|οΏ½}i}|dk	rVοΏ½οΏ½|οΏ½}||<|οΏ½|οΏ½οΏ½jdk	rοΏ½|rοΏ½οΏ½οΏ½|οΏ½}|rοΏ½|D]0}	||	}
t|
οΏ½rvοΏ½οΏ½|
οΏ½}||
<|οΏ½|οΏ½qvqοΏ½d}nd}οΏ½jοΏ½οΏ½fddοΏ½t|ddοΏ½dοΏ½DοΏ½}|rοΏ½ddοΏ½|DοΏ½}|οΏ½οΏ½ng}|οΏ½rjt|οΏ½οΏ½οΏ½D]^\}
}|dk	οΏ½r@|
|kοΏ½r@||kοΏ½r@|||d	}||
\}}	}|οΏ½	|οΏ½r\|n|	|fοΏ½οΏ½q
|οΏ½
d
οΏ½}οΏ½jοΏ½	|οΏ½rοΏ½|dknοΏ½jdοΏ½οΏ½j}|d
||d	οΏ½|οΏ½rοΏ½|dοΏ½
ddοΏ½|DοΏ½οΏ½οΏ½|dοΏ½|dk	οΏ½rοΏ½|t|||d	οΏ½οΏ½dοΏ½_οΏ½jοΏ½	gοΏ½dS)Ncs i|]\}}|οΏ½jkr||οΏ½qSr )rmοΏ½οΏ½.0rοΏ½rοΏ½r/r r!οΏ½
<dictcomp>ps
z+C14NWriterTarget._start.<locals>.<dictcomp>csi|]}|οΏ½|οΏ½οΏ½qSr r )rοΏ½r^)οΏ½parse_qnamer r!rοΏ½οΏ½scSs|οΏ½ddοΏ½S)NrοΏ½r)r})r^r r r!rοΏ½οΏ½rοΏ½z)C14NWriterTarget._start.<locals>.<lambda>rοΏ½cSs$g|]\}}|rd|nd|fοΏ½qS)zxmlns:Zxmlnsr )rοΏ½rοΏ½rοΏ½r r r!οΏ½
<listcomp>οΏ½sοΏ½z+C14NWriterTarget._start.<locals>.<listcomp>rz+{http://www.w3.org/XML/1998/namespace}spaceZpreserverοΏ½rοΏ½rοΏ½cSs&g|]\}}d|οΏ½dt|οΏ½οΏ½dοΏ½οΏ½qS)roz="rοΏ½)οΏ½_escape_attrib_c14nrοΏ½r r r!rοΏ½οΏ½srοΏ½T)rmrdrrοΏ½rrrοΏ½rοΏ½rοΏ½οΏ½sortrIr_rvrjr#rοΏ½rxrt)r+r"r'rοΏ½rοΏ½rοΏ½Zresolved_namesrοΏ½ZqattrsZ	attr_nameraZ
parsed_qnamesrUrοΏ½rοΏ½Z
attr_qnamerοΏ½Zspace_behaviourrοΏ½r )rοΏ½r+r!r:ns`


οΏ½
οΏ½

οΏ½
zC14NWriterTarget._startcCst|jr|jd8_dS|jr&|οΏ½οΏ½|οΏ½d|οΏ½|οΏ½dοΏ½dοΏ½οΏ½|jοΏ½οΏ½t|jοΏ½dk|_|j	οΏ½οΏ½|j
οΏ½οΏ½dS)NrrοΏ½rrοΏ½)rzrr%rjrοΏ½rvr)r7ryrsrtrir r r!rοΏ½s

zC14NWriterTarget.endcCsd|js
dS|jrdS|jr&|οΏ½dοΏ½n|jr:|jr:|οΏ½οΏ½|οΏ½dt|οΏ½οΏ½dοΏ½οΏ½|js`|οΏ½dοΏ½dS)NrοΏ½z<!--z-->)rkrzryrjrxrr%rοΏ½r$r r r!r+οΏ½szC14NWriterTarget.commentcCsp|jr
dS|jr|οΏ½dοΏ½n|jr0|jr0|οΏ½οΏ½|οΏ½|rNd|οΏ½dt|οΏ½οΏ½dοΏ½n
d|οΏ½dοΏ½οΏ½|jsl|οΏ½dοΏ½dS)NrοΏ½z<?roz?>)rzryrjrxrr%rοΏ½)r+rprοΏ½r r r!r,οΏ½s$οΏ½zC14NWriterTarget.pi)N)N)rrrr-οΏ½reversedr{rrοΏ½rοΏ½r#r%r1r(r:rr+r,r r r r!rοΏ½s&οΏ½%
%
E
c	Cs|zVd|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}d|krR|οΏ½ddοΏ½}|WSttfk
rvt|οΏ½YnXdS)	NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½&#xD;rοΏ½rqr r r!rοΏ½οΏ½srοΏ½c	CsοΏ½z~d|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}d|krR|οΏ½ddοΏ½}d	|krf|οΏ½d	d
οΏ½}d|krz|οΏ½ddοΏ½}|WSttfk
rοΏ½t|οΏ½YnXdS)
NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½z&#x9;rοΏ½z&#xA;rοΏ½rοΏ½rοΏ½rqr r r!rοΏ½οΏ½s rοΏ½)re)οΏ½_set_factories)N)N)N)NN)NN)N)NN)N)N)N)N)?οΏ½__all__rrοΏ½rοΏ½r<rοΏ½rZcollections.abcrοΏ½rοΏ½rrr
rrrrrrr
rοΏ½contextmanagerrοΏ½rοΏ½rοΏ½rοΏ½rbοΏ½	NameErrorrοΏ½rοΏ½rοΏ½rrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrοΏ½rοΏ½rrr	rrrrrrrrrοΏ½compileοΏ½UNICODErοΏ½rοΏ½rrοΏ½rοΏ½rOZ_elementtreerοΏ½r4r r r r!οΏ½<module>KsοΏ½οΏ½>

0s
3
=22οΏ½	οΏ½
οΏ½οΏ½


05


zgU

e5d>3οΏ½@sοΏ½ddlZeοΏ½dοΏ½Zd"ddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½ZddοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½Zeee	ee
edοΏ½Z
iZGddοΏ½dοΏ½Zd#ddοΏ½Zd$ddοΏ½Zd%ddοΏ½Zd&d d!οΏ½ZdS)'οΏ½Nz\('[^']*'|\"[^\"]*\"|::|//?|\.\.|\(\)|[/.*:\[\]\(\)@=])|((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|\s+c		csοΏ½|r|οΏ½dοΏ½nd}d}tοΏ½|οΏ½D]οΏ½}|\}}|rοΏ½|ddkrοΏ½d|krοΏ½|οΏ½ddοΏ½\}}z"|s^tοΏ½|d|||ffVWqοΏ½tk
rοΏ½td|οΏ½dοΏ½YqοΏ½Xn"|rοΏ½|sοΏ½|d||ffVn|Vd}q |V|d	k}q dS)
NοΏ½FrοΏ½{οΏ½:οΏ½z{%s}%sz!prefix %r not found in prefix mapοΏ½@)οΏ½getοΏ½xpath_tokenizer_reοΏ½findallοΏ½splitοΏ½KeyErrorοΏ½SyntaxError)	οΏ½patternοΏ½
namespacesZdefault_namespaceZparsing_attributeοΏ½tokenZttypeοΏ½tagοΏ½prefixZuriοΏ½rοΏ½-/usr/lib64/python3.8/xml/etree/ElementPath.pyοΏ½xpath_tokenizerIs&rcCs>|j}|dkr:i|_}|jοΏ½οΏ½D]}|D]}|||<q*q"|SοΏ½N)οΏ½
parent_mapοΏ½rootοΏ½iter)οΏ½contextrοΏ½pοΏ½errrοΏ½get_parent_mapas
rcCs |ddοΏ½dkp|ddοΏ½dkS)NοΏ½οΏ½{*}οΏ½οΏ½οΏ½οΏ½}*rοΏ½rrrrοΏ½_is_wildcard_tagksr"csοΏ½ttοΏ½οΏ½οΏ½dkr"οΏ½οΏ½fddοΏ½}nοΏ½οΏ½dkr:οΏ½οΏ½fddοΏ½}nοΏ½οΏ½ddοΏ½dkrοΏ½οΏ½ddοΏ½οΏ½ttοΏ½οΏ½dοΏ½οΏ½οΏ½ddοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½fd	dοΏ½}nLοΏ½d
d�dkrƈdd��tdt��������fd
dοΏ½}ntdοΏ½οΏ½οΏ½οΏ½οΏ½|S)Nz{*}*c3s |D]}οΏ½|jοΏ½οΏ½r|VqdSrr!οΏ½rοΏ½resultοΏ½elemοΏ½οΏ½_isinstanceοΏ½_strrrοΏ½selectusz_prepare_tag.<locals>.selectz{}*c3s0|D]&}|j}οΏ½|οΏ½οΏ½r|ddkr|VqdS)Nrrr!οΏ½rr$r%Zel_tagr&rrr){srrοΏ½c3s8|D].}|j}|οΏ½ks,οΏ½|οΏ½οΏ½r|οΏ½οΏ½kr|VqdSrr!r*)r'r(οΏ½no_nsοΏ½suffixrrrr)οΏ½srr οΏ½οΏ½οΏ½c3s0|D]&}|j}οΏ½|οΏ½οΏ½r|οΏ½οΏ½kr|VqdSrr!r*)r'r(οΏ½nsοΏ½ns_onlyrrr)οΏ½szinternal parser error, got )οΏ½
isinstanceοΏ½strοΏ½sliceοΏ½lenοΏ½RuntimeError)rr)r)r'r(r,r/r0r-rrοΏ½_prepare_tagos 
r6csR|dοΏ½tοΏ½οΏ½r&tοΏ½οΏ½οΏ½οΏ½fddοΏ½}n(οΏ½ddοΏ½dkrBοΏ½ddοΏ½οΏ½οΏ½fddοΏ½}|S)NrcsddοΏ½}οΏ½|||οΏ½οΏ½S)Ncss|D]}|EdHqdSrr)r$r%rrrοΏ½select_childοΏ½sz3prepare_child.<locals>.select.<locals>.select_childrοΏ½rr$r7οΏ½οΏ½
select_tagrrr)οΏ½szprepare_child.<locals>.selectr+οΏ½{}c3s(|D]}|D]}|jοΏ½kr|VqqdSrr!οΏ½rr$r%rr!rrr)οΏ½s
)r"r6οΏ½οΏ½nextrr)rοΏ½r:rrοΏ½
prepare_childοΏ½sr@cCsddοΏ½}|S)Ncss|D]}|EdHqdSrrr#rrrr)οΏ½szprepare_star.<locals>.selectrr=rrrοΏ½prepare_starοΏ½srAcCsddοΏ½}|S)Ncss|EdHdSrr)rr$rrrr)οΏ½szprepare_self.<locals>.selectrr=rrrοΏ½prepare_selfοΏ½srBcsοΏ½z
|οΏ½}Wntk
r YdSX|ddkr4dοΏ½n|dsF|dοΏ½ntdοΏ½οΏ½tοΏ½οΏ½rltοΏ½οΏ½οΏ½οΏ½fddοΏ½}n(οΏ½ddοΏ½dkrοΏ½οΏ½ddοΏ½οΏ½οΏ½fd	dοΏ½}|S)
NrοΏ½*rzinvalid descendantcsddοΏ½}οΏ½|||οΏ½οΏ½S)Ncss*|D] }|οΏ½οΏ½D]}||k	r|VqqdSrοΏ½r)r$r%rrrrr7οΏ½sz8prepare_descendant.<locals>.select.<locals>.select_childrr8r9rrr)οΏ½sz"prepare_descendant.<locals>.selectr+r;c3s,|D]"}|οΏ½οΏ½οΏ½D]}||k	r|VqqdSrrDr<r!rrr)οΏ½s)οΏ½
StopIterationrr"r6r=rr?rοΏ½prepare_descendantοΏ½s 

rFcCsddοΏ½}|S)Ncss@t|οΏ½}i}|D]*}||kr||}||krd||<|VqdSr)r)rr$rZ
result_mapr%οΏ½parentrrrr)οΏ½szprepare_parent.<locals>.selectrr=rrrοΏ½prepare_parentοΏ½s
rHcsLg}g}z
|οΏ½}Wntk
r(YdSX|ddkr8qοΏ½|dkrBq|drr|dddοΏ½dkrrd|dddοΏ½f}|οΏ½|dpοΏ½dοΏ½|οΏ½|dοΏ½qd	οΏ½|οΏ½}|d
krοΏ½|dοΏ½οΏ½fddοΏ½}|S|d
krοΏ½|dοΏ½|dοΏ½οΏ½οΏ½fddοΏ½}|S|dkοΏ½rtοΏ½d|dοΏ½οΏ½s|dοΏ½οΏ½fddοΏ½}|S|dkοΏ½sB|dkοΏ½rxtοΏ½d|dοΏ½οΏ½sx|dοΏ½|dοΏ½οΏ½οΏ½rhοΏ½οΏ½fddοΏ½}nοΏ½fddοΏ½}|S|dkοΏ½sοΏ½|dkοΏ½sοΏ½|dkοΏ½r@|dkοΏ½rοΏ½t|dοΏ½dοΏ½οΏ½dkοΏ½r0tdοΏ½οΏ½nl|ddkοΏ½rοΏ½tdοΏ½οΏ½|dkοΏ½r,zt|dοΏ½dοΏ½Wntk
οΏ½rtdοΏ½οΏ½YnXοΏ½dkοΏ½r0tdοΏ½οΏ½ndοΏ½οΏ½fddοΏ½}|StdοΏ½οΏ½dS) NrοΏ½])rrrz'"οΏ½'r.οΏ½-rz@-c3s"|D]}|οΏ½οΏ½οΏ½dk	r|VqdSrοΏ½rr#)οΏ½keyrrr)οΏ½sz!prepare_predicate.<locals>.selectz@-='c3s"|D]}|οΏ½οΏ½οΏ½οΏ½kr|VqdSrrLr#)rMοΏ½valuerrr)sz\-?\d+$c3s"|D]}|οΏ½οΏ½οΏ½dk	r|VqdSr)οΏ½findr#r!rrr)sz.='z-='c3s:|D]0}|οΏ½οΏ½οΏ½D] }dοΏ½|οΏ½οΏ½οΏ½οΏ½kr|VqqqdSοΏ½Nr)r	οΏ½joinοΏ½itertextr<)rrNrrr)s
c3s&|D]}dοΏ½|οΏ½οΏ½οΏ½οΏ½kr|VqdSrP)rQrRr#)rNrrr)sz-()z-()-zXPath position >= 1 expectedZlastzunsupported functionr+zunsupported expressionrz)XPath offset from last() must be negativec
3s^t|οΏ½}|D]L}z.||}t|οΏ½|jοΏ½οΏ½}|οΏ½|kr<|VWqttfk
rVYqXqdSr)rοΏ½listr	rοΏ½
IndexErrorr)rr$rr%rGZelems)οΏ½indexrrr)5s
zinvalid predicate)rEοΏ½appendrQοΏ½reοΏ½matchοΏ½intrοΏ½
ValueError)r>rZ	signatureZ	predicater)r)rUrMrrNrοΏ½prepare_predicateοΏ½sj

&





r[)rrCοΏ½.z..z//οΏ½[c@seZdZdZddοΏ½ZdS)οΏ½_SelectorContextNcCs
||_dSr)r)οΏ½selfrrrrοΏ½__init__Psz_SelectorContext.__init__)οΏ½__name__οΏ½
__module__οΏ½__qualname__rr`rrrrr^Nsr^c
Csj|ddοΏ½dkr|d}|f}|r6|tt|οΏ½οΏ½οΏ½οΏ½7}zt|}WοΏ½nοΏ½tk
οΏ½r@ttοΏ½dkrjtοΏ½οΏ½|ddοΏ½dkrοΏ½tdοΏ½οΏ½tt	||οΏ½οΏ½j
}z
|οΏ½}Wntk
rοΏ½YYdSXg}z|οΏ½t
|d||οΏ½οΏ½Wntk
rοΏ½tdοΏ½dοΏ½YnXz|οΏ½}|ddkοΏ½r|οΏ½}WqοΏ½tk
οΏ½r0YοΏ½q4YqοΏ½XqοΏ½|t|<YnX|g}t|οΏ½}|D]}	|	||οΏ½}οΏ½qT|S)	Nr.οΏ½/rCοΏ½drz#cannot use absolute path on elementrzinvalid path)οΏ½tupleοΏ½sortedοΏ½itemsοΏ½_cacherr4οΏ½clearrrrοΏ½__next__rErVοΏ½opsr^)
r%οΏ½pathrZ	cache_keyZselectorr>rr$rr)rrrοΏ½iterfindXsD


rncCstt|||οΏ½dοΏ½Sr)r>rnοΏ½r%rmrrrrrOοΏ½srOcCstt|||οΏ½οΏ½Sr)rSrnrorrrr	οΏ½sr	cCs:ztt|||οΏ½οΏ½}|jpdWStk
r4|YSXdSrP)r>rnοΏ½textrE)r%rmοΏ½defaultrrrrοΏ½findtextοΏ½s
rr)N)N)N)N)NN)rWοΏ½compilerrrr"r6r@rArBrFrHr[rlrir^rnrOr	rrrrrrοΏ½<module>;s4οΏ½

)
bοΏ½	

,

U

e5dRοΏ½@sddlTdS)οΏ½)οΏ½*N)Zxml.etree.ElementTreeοΏ½rrοΏ½./usr/lib64/python3.8/xml/etree/cElementTree.pyοΏ½<module>οΏ½U

e5dοΏ½@sPddlZddlmZdZedZedZGddοΏ½deοΏ½Zdd	d
οΏ½Zd
ddοΏ½Z	dS)οΏ½NοΏ½)οΏ½ElementTreez!{http://www.w3.org/2001/XInclude}οΏ½includeZfallbackc@seZdZdS)οΏ½FatalIncludeErrorN)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½r	r	οΏ½0/usr/lib64/python3.8/xml/etree/ElementInclude.pyr>src	Cs\|dkr.t|dοΏ½οΏ½}tοΏ½|οΏ½οΏ½οΏ½}W5QRXn*|s6d}t|d|dοΏ½οΏ½}|οΏ½οΏ½}W5QRX|S)NοΏ½xmlοΏ½rbzUTF-8οΏ½r)οΏ½encoding)οΏ½openrοΏ½parseZgetrootοΏ½read)οΏ½hrefrrοΏ½fileοΏ½datar	r	r
οΏ½default_loaderMsrcCsh|dkrt}d}|t|οΏ½kοΏ½rd||}|jtkοΏ½r4|οΏ½dοΏ½}|οΏ½ddοΏ½}|dkrοΏ½|||οΏ½}|dkrrtd||fοΏ½οΏ½tοΏ½|οΏ½}|jrοΏ½|jpοΏ½d|j|_|||<nοΏ½|dkοΏ½r&||||οΏ½dοΏ½οΏ½}|dkrοΏ½td||fοΏ½οΏ½|rοΏ½||d	}|jpοΏ½d||jpοΏ½d|_n|jοΏ½pd||jοΏ½pd|_||=qntd
|οΏ½οΏ½n&|jt	kοΏ½rPtd|jοΏ½οΏ½n
t
||οΏ½|d	}qdS)Nrrrrzcannot load %r as %rοΏ½οΏ½textrrz)unknown parse type in xi:include tag (%r)z0xi:fallback tag must be child of xi:include (%r))rοΏ½lenοΏ½tagοΏ½XINCLUDE_INCLUDEοΏ½getrοΏ½copyοΏ½tailrοΏ½XINCLUDE_FALLBACKr)οΏ½elemοΏ½loaderοΏ½iοΏ½errZnoderr	r	r
rcsN


οΏ½



οΏ½οΏ½οΏ½
)N)N)
rrrZXINCLUDErrοΏ½SyntaxErrorrrrr	r	r	r
οΏ½<module>3s
U

e5dοΏ½οΏ½@sοΏ½dZddddddddd	d
ddd
ddddddddddddgZdZddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZGdd
οΏ½d
eοΏ½Z
d dοΏ½ZGd!dοΏ½dοΏ½Zifd"dοΏ½Zd]d#dοΏ½Zd^d$dοΏ½ZeZGd%d
οΏ½d
οΏ½ZGd&dοΏ½dοΏ½Ze	jd'd(οΏ½οΏ½Zd_d)d*οΏ½Zd+d,οΏ½Zd-ZzeeοΏ½ZWnek
οΏ½r.YnXd.d/οΏ½Zd0d1οΏ½Zeeed2οΏ½Zd3dοΏ½Z d4d5d6d7d8d9d:d;οΏ½Z!e!e _!d<d=οΏ½Z"d>d?οΏ½Z#d@dAοΏ½Z$dBdCοΏ½Z%d`dddDdEοΏ½dFdοΏ½Z&GdGdHοΏ½dHej'οΏ½Z(dadddDdEοΏ½dIdοΏ½Z)dJdοΏ½Z*dbdKd	οΏ½Z+dcdLdοΏ½Z,GdMdοΏ½dοΏ½Z-dddNdοΏ½Z.dedOdοΏ½Z/e.Z0dfdPdοΏ½Z1GdQdοΏ½dοΏ½Z2GdRdοΏ½dοΏ½Z3dgdddSοΏ½dTdοΏ½Z4eοΏ½5dUej6οΏ½j7Z8GdVdοΏ½dοΏ½Z9dWdXοΏ½Z:dYdZοΏ½Z;zeZ<dd[l=Tdd\l=m>Z>Wne?k
οΏ½rοΏ½YnXe>eeοΏ½dS)haLightweight XML support for Python.

 XML is an inherently hierarchical data format, and the most natural way to
 represent it is with a tree.  This module has two classes for this purpose:

    1. ElementTree represents the whole XML document as a tree and

    2. Element represents a single node in this tree.

 Interactions with the whole document (reading and writing to/from files) are
 usually done on the ElementTree level.  Interactions with a single XML element
 and its sub-elements are done on the Element level.

 Element is a flexible container object designed to store hierarchical data
 structures in memory. It can be described as a cross between a list and a
 dictionary.  Each Element has a number of properties associated with it:

    'tag' - a string containing the element's name.

    'attributes' - a Python dictionary storing the element's attributes.

    'text' - a string containing the element's text content.

    'tail' - an optional string containing text after the element's end tag.

    And a number of child elements stored in a Python sequence.

 To create an element instance, use the Element constructor,
 or the SubElement factory function.

 You can also use the ElementTree class to wrap an element structure
 and convert it to and from XML.

οΏ½CommentοΏ½dumpοΏ½ElementοΏ½ElementTreeοΏ½
fromstringοΏ½fromstringlistοΏ½	iselementοΏ½	iterparseοΏ½parseοΏ½
ParseErrorοΏ½PIοΏ½ProcessingInstructionοΏ½QNameοΏ½
SubElementοΏ½tostringοΏ½tostringlistοΏ½TreeBuilderοΏ½VERSIONοΏ½XMLοΏ½XMLIDοΏ½	XMLParserοΏ½
XMLPullParserοΏ½register_namespaceοΏ½canonicalizeοΏ½C14NWriterTargetz1.3.0οΏ½NοΏ½)οΏ½ElementPathc@seZdZdZdS)r
zοΏ½An error when parsing an XML document.

    In addition to its exception value, a ParseError contains
    two extra attributes:
        'code'     - the specific exception code
        'position' - the line and column of the error

    N)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½__doc__οΏ½r!r!οΏ½-/usr/lib64/python3.8/xml/etree/ElementTree.pyr
jscCs
t|dοΏ½S)z2Return True if *element* appears to be an Element.οΏ½tag)οΏ½hasattr)οΏ½elementr!r!r"rxsc@s
eZdZdZdZdZdZdZifddοΏ½ZddοΏ½Z	ddοΏ½Z
d	d
οΏ½ZddοΏ½Zd
dοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zdd οΏ½Zd9d!d"οΏ½Zd:d#d$οΏ½Zd;d%d&οΏ½Zd<d'd(οΏ½Zd)d*οΏ½Zd=d+d,οΏ½Zd-d.οΏ½Zd/d0οΏ½Zd1d2οΏ½Zd>d3d4οΏ½Z d?d5d6οΏ½Z!d7d8οΏ½Z"dS)@rahAn XML element.

    This class is the reference implementation of the Element interface.

    An element's length is its number of subelements.  That means if you
    want to check if an element is truly empty, you should check BOTH
    its length AND its text attribute.

    The element tag, attribute names, and attribute values can be either
    bytes or strings.

    *tag* is the element name.  *attrib* is an optional dictionary containing
    element attributes. *extra* are additional element attributes given as
    keyword arguments.

    Example form:
        <tag attrib>text<child/>...</tag>tail

    NcKs6t|tοΏ½std|jjfοΏ½οΏ½||_||οΏ½|_g|_dS)Nzattrib must be dict, not %s)οΏ½
isinstanceοΏ½dictοΏ½	TypeErrorοΏ½	__class__rr#οΏ½attribοΏ½	_children)οΏ½selfr#r*οΏ½extrar!r!r"οΏ½__init__οΏ½s
οΏ½
zElement.__init__cCsd|jj|jt|οΏ½fS)Nz<%s %r at %#x>)r)rr#οΏ½idοΏ½r,r!r!r"οΏ½__repr__οΏ½szElement.__repr__cCs|οΏ½||οΏ½S)zοΏ½Create a new element with the same type.

        *tag* is a string containing the element name.
        *attrib* is a dictionary containing the element attributes.

        Do not call this method, use the SubElement factory function instead.

        )r))r,r#r*r!r!r"οΏ½makeelementοΏ½s	zElement.makeelementcCs0|οΏ½|j|jοΏ½}|j|_|j|_||ddοΏ½<|S)zοΏ½Return copy of current element.

        This creates a shallow copy. Subelements will be shared with the
        original tree.

        N)r2r#r*οΏ½textοΏ½tail)r,οΏ½elemr!r!r"οΏ½copyοΏ½s
zElement.copycCs
t|jοΏ½SοΏ½N)οΏ½lenr+r0r!r!r"οΏ½__len__οΏ½szElement.__len__cCstjdtddοΏ½t|jοΏ½dkS)NzyThe behavior of this method will change in future versions.  Use specific 'len(elem)' or 'elem is not None' test instead.οΏ½οΏ½οΏ½
stacklevelr)οΏ½warningsοΏ½warnοΏ½
FutureWarningr8r+r0r!r!r"οΏ½__bool__οΏ½sοΏ½zElement.__bool__cCs
|j|Sr7οΏ½r+οΏ½r,οΏ½indexr!r!r"οΏ½__getitem__οΏ½szElement.__getitem__cCs8t|tοΏ½r |D]}|οΏ½|οΏ½qn
|οΏ½|οΏ½||j|<dSr7)r&οΏ½sliceοΏ½_assert_is_elementr+)r,rCr%Zeltr!r!r"οΏ½__setitem__οΏ½s


zElement.__setitem__cCs|j|=dSr7rArBr!r!r"οΏ½__delitem__οΏ½szElement.__delitem__cCs|οΏ½|οΏ½|jοΏ½|οΏ½dS)aAdd *subelement* to the end of this element.

        The new element will appear in document order after the last existing
        subelement (or directly after the text, if it's the first subelement),
        but before the end tag for this element.

        NοΏ½rFr+οΏ½appendοΏ½r,οΏ½
subelementr!r!r"rJοΏ½s
zElement.appendcCs$|D]}|οΏ½|οΏ½|jοΏ½|οΏ½qdS)zkAppend subelements from a sequence.

        *elements* is a sequence with zero or more elements.

        NrI)r,οΏ½elementsr%r!r!r"οΏ½extendοΏ½s
zElement.extendcCs|οΏ½|οΏ½|jοΏ½||οΏ½dS)z(Insert *subelement* at position *index*.N)rFr+οΏ½insert)r,rCrLr!r!r"rOοΏ½s
zElement.insertcCs t|tοΏ½stdt|οΏ½jοΏ½οΏ½dS)Nzexpected an Element, not %s)r&οΏ½_Element_Pyr(οΏ½typer)r,οΏ½er!r!r"rFοΏ½s
zElement._assert_is_elementcCs|jοΏ½|οΏ½dS)aοΏ½Remove matching subelement.

        Unlike the find methods, this method compares elements based on
        identity, NOT ON tag value or contents.  To remove subelements by
        other means, the easiest way is to use a list comprehension to
        select what elements to keep, and then use slice assignment to update
        the parent element.

        ValueError is raised if a matching element could not be found.

        N)r+οΏ½removerKr!r!r"rSs
zElement.removecCstjdtddοΏ½|jS)z`(Deprecated) Return all subelements.

        Elements are returned in document order.

        zaThis method will be removed in future versions.  Use 'list(elem)' or iteration over elem instead.r:r;)r=r>οΏ½DeprecationWarningr+r0r!r!r"οΏ½getchildrensοΏ½zElement.getchildrencCstοΏ½|||οΏ½S)aFind first matching element by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        )rοΏ½findοΏ½r,οΏ½pathοΏ½
namespacesr!r!r"rV!s	zElement.findcCstοΏ½||||οΏ½S)aοΏ½Find text for first matching element by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *default* is the value to return if the element was not found,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return text content of first matching element, or default value if
        none was found.  Note that if an element is found having no text
        content, the empty string is returned.

        )rοΏ½findtextοΏ½r,rXοΏ½defaultrYr!r!r"rZ,szElement.findtextcCstοΏ½|||οΏ½S)aFind all matching subelements by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Returns list containing all matching elements in document order.

        )rοΏ½findallrWr!r!r"r]:s	zElement.findallcCstοΏ½|||οΏ½S)a Find all matching subelements by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return an iterable yielding all matching elements in document order.

        )rοΏ½iterfindrWr!r!r"r^Es	zElement.iterfindcCs |jοΏ½οΏ½g|_d|_|_dS)zοΏ½Reset element.

        This function removes all subelements, clears all attributes, and sets
        the text and tail attributes to None.

        N)r*οΏ½clearr+r3r4r0r!r!r"r_Ps
z
Element.clearcCs|jοΏ½||οΏ½S)agGet element attribute.

        Equivalent to attrib.get, but some implementations may handle this a
        bit more efficiently.  *key* is what attribute to look for, and
        *default* is what to return if the attribute was not found.

        Returns a string containing the attribute value, or the default if
        attribute was not found.

        )r*οΏ½get)r,οΏ½keyr\r!r!r"r`[szElement.getcCs||j|<dS)zοΏ½Set element attribute.

        Equivalent to attrib[key] = value, but some implementations may handle
        this a bit more efficiently.  *key* is what attribute to set, and
        *value* is the attribute value to set it to.

        N)r*)r,raοΏ½valuer!r!r"οΏ½sethszElement.setcCs
|jοΏ½οΏ½S)zοΏ½Get list of attribute names.

        Names are returned in an arbitrary order, just like an ordinary
        Python dict.  Equivalent to attrib.keys()

        )r*οΏ½keysr0r!r!r"rdrszElement.keyscCs
|jοΏ½οΏ½S)zοΏ½Get element attributes as a sequence.

        The attributes are returned in arbitrary order.  Equivalent to
        attrib.items().

        Return a list of (name, value) tuples.

        )r*οΏ½itemsr0r!r!r"re{s	z
Element.itemsccsD|dkrd}|dks|j|kr$|V|jD]}|οΏ½|οΏ½EdHq*dS)aCreate tree iterator.

        The iterator loops over the element and all subelements in document
        order, returning all elements with a matching tag.

        If the tree structure is modified during iteration, new or removed
        elements may or may not be included.  To get a stable set, use the
        list() function on the iterator, and loop over the resulting list.

        *tag* is what tags to look for (default is to return all elements)

        Return an iterator containing all the matching elements.

        οΏ½*N)r#r+οΏ½iter)r,r#rRr!r!r"rgοΏ½s
zElement.itercCstjdtddοΏ½t|οΏ½|οΏ½οΏ½S)NzbThis method will be removed in future versions.  Use 'elem.iter()' or 'list(elem.iter())' instead.r:r;οΏ½r=r>rTοΏ½listrgοΏ½r,r#r!r!r"οΏ½getiteratorοΏ½sοΏ½zElement.getiteratorccsX|j}t|tοΏ½s|dk	rdS|j}|r,|V|D]"}|οΏ½οΏ½EdH|j}|r0|Vq0dS)zοΏ½Create text iterator.

        The iterator loops over the element and all subelements in document
        order, returning all inner text.

        N)r#r&οΏ½strr3οΏ½itertextr4)r,r#οΏ½trRr!r!r"rmοΏ½szElement.itertext)N)NN)N)N)N)N)N)#rrrr r#r*r3r4r.r1r2r6r9r@rDrGrHrJrNrOrFrSrUrVrZr]r^r_r`rcrdrergrkrmr!r!r!r"r}s@	








	

cKs"||οΏ½}|οΏ½||οΏ½}|οΏ½|οΏ½|S)aοΏ½Subelement factory which creates an element instance, and appends it
    to an existing parent.

    The element tag, attribute names, and attribute values can be either
    bytes or Unicode strings.

    *parent* is the parent element, *tag* is the subelements name, *attrib* is
    an optional directory containing element attributes, *extra* are
    additional attributes given as keyword arguments.

    )r2rJ)οΏ½parentr#r*r-r%r!r!r"rοΏ½s
cCsttοΏ½}||_|S)zοΏ½Comment element factory.

    This function creates a special element which the standard serializer
    serializes as an XML comment.

    *text* is a string containing the comment string.

    )rrr3)r3r%r!r!r"rοΏ½s	cCs&ttοΏ½}||_|r"|jd||_|S)a*Processing Instruction element factory.

    This function creates a special element which the standard serializer
    serializes as an XML comment.

    *target* is a string containing the processing instruction, *text* is a
    string containing the processing instruction contents, if any.

    οΏ½ )rrr3)οΏ½targetr3r%r!r!r"rοΏ½s

c@sZeZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZdS)r
aοΏ½Qualified name wrapper.

    This class can be used to wrap a QName attribute value in order to get
    proper namespace handing on output.

    *text_or_uri* is a string containing the QName value either in the form
    {uri}local, or if the tag argument is given, the URI part of a QName.

    *tag* is an optional argument which if given, will make the first
    argument (text_or_uri) be interpreted as a URI, and this argument (tag)
    be interpreted as a local name.

    NcCs|rd||f}||_dS)Nz{%s}%sοΏ½r3)r,Ztext_or_urir#r!r!r"r.οΏ½szQName.__init__cCs|jSr7rrr0r!r!r"οΏ½__str__οΏ½sz
QName.__str__cCsd|jj|jfS)Nz<%s %r>)r)rr3r0r!r!r"r1szQName.__repr__cCs
t|jοΏ½Sr7)οΏ½hashr3r0r!r!r"οΏ½__hash__szQName.__hash__cCs t|tοΏ½r|j|jkS|j|kSr7οΏ½r&r
r3οΏ½r,οΏ½otherr!r!r"οΏ½__le__s
zQName.__le__cCs t|tοΏ½r|j|jkS|j|kSr7rvrwr!r!r"οΏ½__lt__s
zQName.__lt__cCs t|tοΏ½r|j|jkS|j|kSr7rvrwr!r!r"οΏ½__ge__s
zQName.__ge__cCs t|tοΏ½r|j|jkS|j|kSr7rvrwr!r!r"οΏ½__gt__s
zQName.__gt__cCs t|tοΏ½r|j|jkS|j|kSr7rvrwr!r!r"οΏ½__eq__s
zQName.__eq__)N)
rrrr r.rsr1ruryrzr{r|r}r!r!r!r"r
οΏ½s
c@sοΏ½eZdZdZdddοΏ½ZddοΏ½ZddοΏ½Zdd	d
οΏ½ZdddοΏ½Zd d
dοΏ½Z	d!ddοΏ½Z
d"ddοΏ½Zd#ddοΏ½Zd$ddοΏ½Z
d%ddοΏ½ddοΏ½ZddοΏ½ZdS)&ra%An XML element hierarchy.

    This class also provides support for serialization to and from
    standard XML.

    *element* is an optional root element node,
    *file* is an optional file handle or file name of an XML file whose
    contents will be used to initialize the tree with.

    NcCs||_|r|οΏ½|οΏ½dSr7)οΏ½_rootr	)r,r%οΏ½filer!r!r"r.'szElementTree.__init__cCs|jS)z!Return root element of this tree.οΏ½r~r0r!r!r"οΏ½getroot-szElementTree.getrootcCs
||_dS)zοΏ½Replace root element of this tree.

        This will discard the current contents of the tree and replace it
        with the given element.  Use with care!

        NrοΏ½)r,r%r!r!r"οΏ½_setroot1szElementTree._setrootcCsοΏ½d}t|dοΏ½st|dοΏ½}d}z^|dkrLtοΏ½}t|dοΏ½rL|οΏ½|οΏ½|_|jWοΏ½2S|οΏ½dοΏ½}|s\qh|οΏ½|οΏ½qL|οΏ½οΏ½|_|jWοΏ½S|rοΏ½|οΏ½οΏ½XdS)a=Load external XML document into element tree.

        *source* is a file name or file object, *parser* is an optional parser
        instance that defaults to XMLParser.

        ParseError is raised if the parser fails to parse the document.

        Returns the root element of the given source document.

        FοΏ½readοΏ½rbTNοΏ½_parse_wholei)r$οΏ½openοΏ½closerrοΏ½r~rοΏ½οΏ½feed)r,οΏ½sourceοΏ½parserοΏ½close_sourceοΏ½datar!r!r"r	;s$






zElementTree.parsecCs|jοΏ½|οΏ½S)zοΏ½Create and return tree iterator for the root element.

        The iterator loops over all elements in this tree, in document order.

        *tag* is a string with the tag name to iterate over
        (default is to return all elements).

        )r~rgrjr!r!r"rg`s
zElementTree.itercCstjdtddοΏ½t|οΏ½|οΏ½οΏ½S)NzbThis method will be removed in future versions.  Use 'tree.iter()' or 'list(tree.iter())' instead.r:r;rhrjr!r!r"rkmsοΏ½zElementTree.getiteratorcCs:|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½||οΏ½S)a\Find first matching element by tag name or path.

        Same as getroot().find(path), which is Element.find()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        NrοΏ½/οΏ½.οΏ½οΏ½This search is broken in 1.3 and earlier, and will be fixed in a future version.  If you rely on the current behaviour, change it to %rr:r;)r=r>r?r~rVrWr!r!r"rVusοΏ½οΏ½zElementTree.findcCs<|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½|||οΏ½S)aeFind first matching element by tag name or path.

        Same as getroot().findtext(path),  which is Element.findtext()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        NrrοΏ½rοΏ½rοΏ½r:r;)r=r>r?r~rZr[r!r!r"rZοΏ½sοΏ½οΏ½zElementTree.findtextcCs:|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½||οΏ½S)aaFind all matching subelements by tag name or path.

        Same as getroot().findall(path), which is Element.findall().

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return list containing all matching elements in document order.

        NrrοΏ½rοΏ½rοΏ½r:r;)r=r>r?r~r]rWr!r!r"r]οΏ½sοΏ½οΏ½zElementTree.findallcCs:|ddοΏ½dkr,d|}tjd|tddοΏ½|jοΏ½||οΏ½S)agFind all matching subelements by tag name or path.

        Same as getroot().iterfind(path), which is element.iterfind()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return an iterable yielding all matching elements in document order.

        NrrοΏ½rοΏ½rοΏ½r:r;)r=r>r?r~r^rWr!r!r"r^οΏ½sοΏ½οΏ½zElementTree.iterfindTοΏ½οΏ½short_empty_elementsc	CsοΏ½|s
d}n|tkrtd|οΏ½οΏ½|s4|dkr0d}nd}|οΏ½οΏ½}t||οΏ½οΏ½οΏ½}|dkrοΏ½|sd|dkrοΏ½|dkrοΏ½|}	|dkrοΏ½d	dl}
|
οΏ½οΏ½}	|d
|	fοΏ½|dkrοΏ½t||jοΏ½n,t|j|οΏ½\}}t|}
|
||j|||dοΏ½W5QRXdS)
aοΏ½Write element tree to a file as XML.

        Arguments:
          *file_or_filename* -- file name or a file object opened for writing

          *encoding* -- the output encoding (default: US-ASCII)

          *xml_declaration* -- bool indicating if an XML declaration should be
                               added to the output. If None, an XML declaration
                               is added if encoding IS NOT either of:
                               US-ASCII, UTF-8, or Unicode

          *default_namespace* -- sets the default XML namespace (for "xmlns")

          *method* -- either "xml" (default), "html, "text", or "c14n"

          *short_empty_elements* -- controls the formatting of elements
                                    that contain no content. If True (default)
                                    they are emitted as a single self-closed
                                    tag, otherwise they are emitted as a pair
                                    of start/end tags

        οΏ½xmlzunknown method %rοΏ½c14nοΏ½utf-8οΏ½us-asciiN)rοΏ½rοΏ½οΏ½unicoderοΏ½rz$<?xml version='1.0' encoding='%s'?>
r3rοΏ½)	οΏ½
_serializeοΏ½
ValueErrorοΏ½lowerοΏ½_get_writerοΏ½localeZgetpreferredencodingοΏ½_serialize_textr~οΏ½_namespaces)r,οΏ½file_or_filenameοΏ½encodingοΏ½xml_declarationοΏ½default_namespaceοΏ½methodrοΏ½Z	enc_lowerοΏ½writeZdeclared_encodingrοΏ½οΏ½qnamesrYZ	serializer!r!r"rοΏ½οΏ½s:οΏ½οΏ½οΏ½οΏ½zElementTree.writecCs|j|ddοΏ½S)NrοΏ½)rοΏ½)rοΏ½)r,rr!r!r"οΏ½
write_c14nszElementTree.write_c14n)NN)N)N)N)N)NN)N)N)NNNN)rrrr r.rοΏ½rοΏ½r	rgrkrVrZr]r^rοΏ½rοΏ½r!r!r!r"rs&



%





οΏ½οΏ½:ccs"z
|j}WnPtk
rZ|dkr.t|dοΏ½}nt|d|ddοΏ½}|οΏ½|jVW5QRXYnοΏ½X|dkrl|VnοΏ½tοΏ½οΏ½οΏ½οΏ½}t|tjοΏ½rοΏ½|}nft|tjοΏ½rοΏ½tοΏ½	|οΏ½}|οΏ½
|jοΏ½nBtοΏ½οΏ½}ddοΏ½|_||_z|j
|_
|j|_Wntk
rοΏ½YnXtj||dddοΏ½}|οΏ½
|jοΏ½|jVW5QRXdS)	NrοΏ½οΏ½wοΏ½xmlcharrefreplace)rοΏ½οΏ½errorscSsdSοΏ½NTr!r!r!r!r"οΏ½<lambda>0οΏ½z_get_writer.<locals>.<lambda>οΏ½
)rοΏ½rοΏ½οΏ½newline)rοΏ½οΏ½AttributeErrorrοΏ½οΏ½
contextlibοΏ½	ExitStackr&οΏ½ioοΏ½BufferedIOBaseοΏ½	RawIOBaseοΏ½BufferedWriterοΏ½callbackοΏ½detachοΏ½writableοΏ½seekableοΏ½tellοΏ½
TextIOWrapper)rοΏ½rοΏ½rοΏ½rοΏ½stackr!r!r"rοΏ½sB
οΏ½


οΏ½rοΏ½csddiοΏ½iοΏ½οΏ½rdοΏ½οΏ½<οΏ½οΏ½οΏ½fddοΏ½}|οΏ½οΏ½D]οΏ½}|j}t|tοΏ½rZ|jοΏ½krοΏ½||jοΏ½n<t|tοΏ½rv|οΏ½krοΏ½||οΏ½n |dk	rοΏ½|tk	rοΏ½|tk	rοΏ½t|οΏ½|οΏ½	οΏ½D]F\}}t|tοΏ½rοΏ½|j}|οΏ½krοΏ½||οΏ½t|tοΏ½rοΏ½|jοΏ½krοΏ½||jοΏ½qοΏ½|j}t|tοΏ½r0|jοΏ½kr0||jοΏ½q0οΏ½οΏ½fS)NοΏ½csοΏ½zοΏ½|ddοΏ½dkrοΏ½|ddοΏ½οΏ½ddοΏ½\}}οΏ½οΏ½|οΏ½}|dkrjtοΏ½|οΏ½}|dkrZdtοΏ½οΏ½}|dkrj|οΏ½|<|rοΏ½d||fοΏ½|<qοΏ½|οΏ½|<nοΏ½rοΏ½tdοΏ½οΏ½|οΏ½|<Wntk
rοΏ½t|οΏ½YnXdS)NrοΏ½{οΏ½}zns%drοΏ½z%s:%sz<cannot use non-qualified names with default_namespace option)οΏ½rsplitr`οΏ½_namespace_mapr8rοΏ½r(οΏ½_raise_serialization_error)οΏ½qnameοΏ½urir#οΏ½prefixοΏ½rοΏ½rYrοΏ½r!r"οΏ½	add_qnameMs(


οΏ½z_namespaces.<locals>.add_qname)
rgr#r&r
r3rlrrrοΏ½re)r5rοΏ½rοΏ½r#rarbr3r!rοΏ½r"rοΏ½Bs4




rοΏ½cKsοΏ½|j}|j}|tkr$|d|οΏ½οΏ½nv|tkr<|d|οΏ½οΏ½n^||}|dkr||r\|t|οΏ½οΏ½|D]}t|||d|dοΏ½q`οΏ½n|d|οΏ½t|οΏ½οΏ½οΏ½}	|	sοΏ½|οΏ½r2|rοΏ½t|οΏ½οΏ½ddοΏ½dοΏ½D](\}
}|rοΏ½d|}|d	|t	|
οΏ½fοΏ½qοΏ½|	D]L\}}
t
|tοΏ½rοΏ½|j}t
|
tοΏ½οΏ½r||
j}
nt	|
οΏ½}
|d
|||
fοΏ½qοΏ½|οΏ½sHt|οΏ½οΏ½sH|οΏ½sοΏ½|dοΏ½|οΏ½rb|t|οΏ½οΏ½|D]}t|||d|dοΏ½οΏ½qf|d|dοΏ½n|d
οΏ½|j
οΏ½rοΏ½|t|j
οΏ½οΏ½dS)NοΏ½	<!--%s-->οΏ½<?%s?>rοΏ½οΏ½<cSs|dSοΏ½Nrr!οΏ½οΏ½xr!r!r"rοΏ½οΏ½rοΏ½z _serialize_xml.<locals>.<lambda>οΏ½raοΏ½:οΏ½
 xmlns%s="%s"οΏ½ %s="%s"οΏ½>οΏ½</z />)r#r3rrοΏ½
_escape_cdataοΏ½_serialize_xmlrireοΏ½sortedοΏ½_escape_attribr&r
r8r4)rοΏ½r5rοΏ½rYrοΏ½οΏ½kwargsr#r3rRreοΏ½vοΏ½kr!r!r"rοΏ½s\
οΏ½
οΏ½οΏ½


οΏ½
rοΏ½)
ZareaοΏ½baseZbasefontοΏ½brοΏ½colοΏ½frameZhrZimgοΏ½inputZisindexοΏ½linkοΏ½metaZparamcKsοΏ½|j}|j}|tkr(|dt|οΏ½οΏ½οΏ½nοΏ½|tkrD|dt|οΏ½οΏ½οΏ½nh||}|dkrοΏ½|rd|t|οΏ½οΏ½|D]}t|||dοΏ½qhοΏ½n,|d|οΏ½t|οΏ½οΏ½οΏ½}|sοΏ½|οΏ½r8|rοΏ½t|οΏ½οΏ½ddοΏ½dοΏ½D](\}	}
|
rοΏ½d|
}
|d|
t	|	οΏ½fοΏ½qοΏ½|D]N\}
}	t
|
tοΏ½οΏ½r|
j}
t
|	tοΏ½οΏ½r||	j}	nt|	οΏ½}	|d	||
|	fοΏ½qοΏ½|d
οΏ½|οΏ½
οΏ½}|οΏ½rx|dkοΏ½sb|dkοΏ½rl||οΏ½n|t|οΏ½οΏ½|D]}t|||dοΏ½οΏ½q||tkοΏ½rοΏ½|d
|d
οΏ½|jοΏ½rοΏ½|t|jοΏ½οΏ½dS)NrοΏ½rοΏ½rοΏ½cSs|dSrοΏ½r!rοΏ½r!r!r"rοΏ½οΏ½rοΏ½z!_serialize_html.<locals>.<lambda>rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½ZscriptZstylerοΏ½)r#r3rrοΏ½rοΏ½_serialize_htmlrirerοΏ½rοΏ½r&r
οΏ½_escape_attrib_htmlrοΏ½οΏ½
HTML_EMPTYr4)rοΏ½r5rοΏ½rYrοΏ½r#r3rRrerοΏ½rοΏ½Zltagr!r!r"rοΏ½οΏ½sX
οΏ½οΏ½


rοΏ½cCs*|οΏ½οΏ½D]}||οΏ½q|jr&||jοΏ½dSr7)rmr4)rοΏ½r5οΏ½partr!r!r"rοΏ½οΏ½s
rοΏ½)rοΏ½οΏ½htmlr3cCsLtοΏ½d|οΏ½rtdοΏ½οΏ½ttοΏ½οΏ½οΏ½D]\}}||ks8||kr t|=q |t|<dS)atRegister a namespace prefix.

    The registry is global, and any existing mapping for either the
    given prefix or the namespace URI will be removed.

    *prefix* is the namespace prefix, *uri* is a namespace uri. Tags and
    attributes in this namespace will be serialized with prefix if possible.

    ValueError is raised if prefix is reserved or is invalid.

    zns\d+$z'Prefix format reserved for internal useN)οΏ½reοΏ½matchrοΏ½rirοΏ½re)rοΏ½rοΏ½rοΏ½rοΏ½r!r!r"rοΏ½srοΏ½rοΏ½ZrdfZwsdlZxsZxsiZdc)οΏ½$http://www.w3.org/XML/1998/namespacezhttp://www.w3.org/1999/xhtmlz+http://www.w3.org/1999/02/22-rdf-syntax-ns#z http://schemas.xmlsoap.org/wsdl/z http://www.w3.org/2001/XMLSchemaz)http://www.w3.org/2001/XMLSchema-instancez http://purl.org/dc/elements/1.1/cCstd|t|οΏ½jfοΏ½οΏ½dS)Nzcannot serialize %r (type %s))r(rQrrrr!r!r"rοΏ½sοΏ½rοΏ½c	CshzBd|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}|WSttfk
rbt|οΏ½YnXdS)NοΏ½&οΏ½&amp;rοΏ½οΏ½&lt;rοΏ½οΏ½&gt;οΏ½οΏ½replacer(rοΏ½rοΏ½rrr!r!r"rοΏ½!srοΏ½c	CsοΏ½zοΏ½d|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}d|krR|οΏ½ddοΏ½}d	|krf|οΏ½d	d
οΏ½}d|krz|οΏ½dd
οΏ½}d
|krοΏ½|οΏ½d
dοΏ½}d
|krοΏ½|οΏ½d
dοΏ½}|WSttfk
rοΏ½t|οΏ½YnXdS)NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½"οΏ½&quot;z
rοΏ½οΏ½
z&#10;οΏ½	z&#09;rοΏ½rrr!r!r"rοΏ½1s(rοΏ½c	CshzBd|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}|WSttfk
rbt|οΏ½YnXdS)NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrr!r!r"rοΏ½MsrοΏ½T)rοΏ½rοΏ½rοΏ½cCs:|dkrtοΏ½οΏ½ntοΏ½οΏ½}t|οΏ½j||||||dοΏ½|οΏ½οΏ½S)a
Generate string representation of XML element.

    All subelements are included.  If encoding is "unicode", a string
    is returned. Otherwise a bytestring is returned.

    *element* is an Element instance, *encoding* is an optional output
    encoding defaulting to US-ASCII, *method* is an optional output which can
    be one of "xml" (default), "html", "text" or "c14n", *default_namespace*
    sets the default XML namespace (for "xmlns").

    Returns an (optionally) encoded string containing the XML data.

    rοΏ½οΏ½rοΏ½rοΏ½rοΏ½rοΏ½)rοΏ½οΏ½StringIOοΏ½BytesIOrrοΏ½οΏ½getvalue)r%rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½streamr!r!r"r\sοΏ½c@s8eZdZdZddοΏ½ZddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½ZdS)
οΏ½_ListDataStreamz7An auxiliary stream accumulating into a list reference.cCs
||_dSr7)οΏ½lst)r,rοΏ½r!r!r"r.vsz_ListDataStream.__init__cCsdSrοΏ½r!r0r!r!r"rοΏ½ysz_ListDataStream.writablecCsdSrοΏ½r!r0r!r!r"rοΏ½|sz_ListDataStream.seekablecCs|jοΏ½|οΏ½dSr7)rοΏ½rJ)r,οΏ½br!r!r"rοΏ½sz_ListDataStream.writecCs
t|jοΏ½Sr7)r8rοΏ½r0r!r!r"rοΏ½οΏ½sz_ListDataStream.tellN)	rrrr r.rοΏ½rοΏ½rοΏ½rοΏ½r!r!r!r"rοΏ½tsrοΏ½cCs*g}t|οΏ½}t|οΏ½j||||||dοΏ½|S)NrοΏ½)rοΏ½rrοΏ½)r%rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½r!r!r"rοΏ½sοΏ½cCsLt|tοΏ½st|οΏ½}|jtjddοΏ½|οΏ½οΏ½j}|r<|ddkrHtjοΏ½dοΏ½dS)a#Write element tree or element structure to sys.stdout.

    This function should be used for debugging only.

    *elem* is either an ElementTree, or a single Element.  The exact output
    format is implementation dependent.  In this version, it's written as an
    ordinary XML file.

    rοΏ½)rοΏ½οΏ½οΏ½οΏ½rοΏ½N)r&rrοΏ½οΏ½sysοΏ½stdoutrοΏ½r4)r5r4r!r!r"rοΏ½s

cCstοΏ½}|οΏ½||οΏ½|S)zοΏ½Parse XML document into element tree.

    *source* is a filename or file object containing XML data,
    *parser* is an optional parser instance defaulting to XMLParser.

    Return an ElementTree instance.

    )rr	)rοΏ½rοΏ½οΏ½treer!r!r"r	οΏ½s	csft||dοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½fddοΏ½οΏ½GοΏ½fddοΏ½dtjjοΏ½}|οΏ½οΏ½dοΏ½_οΏ½~dοΏ½tοΏ½dοΏ½sbtοΏ½d	οΏ½οΏ½d
οΏ½οΏ½S)aJIncrementally parse XML document into ElementTree.

    This class also reports what's going on to the user based on the
    *events* it is initialized with.  The supported events are the strings
    "start", "end", "start-ns" and "end-ns" (the "ns" events are used to get
    detailed namespace information).  If *events* is omitted, only
    "end" events are reported.

    *source* is a filename or file object containing XML data, *events* is
    a list of events to report back, *parser* is an optional parser instance.

    Returns an iterator providing (event, elem) pairs.

    )οΏ½eventsοΏ½_parserc3s^zJοΏ½οΏ½οΏ½EdHοΏ½οΏ½dοΏ½}|s q,οΏ½οΏ½|οΏ½qοΏ½οΏ½οΏ½}οΏ½οΏ½οΏ½EdH|οΏ½_W5οΏ½rXοΏ½οΏ½οΏ½XdS)Ni@)rοΏ½οΏ½read_eventsrοΏ½rοΏ½οΏ½_close_and_return_rootοΏ½root)rοΏ½r)rοΏ½οΏ½itοΏ½
pullparserrοΏ½r!r"οΏ½iteratorοΏ½s

ziterparse.<locals>.iteratorcseZdZοΏ½οΏ½jZdS)z$iterparse.<locals>.IterParseIteratorN)rrrοΏ½__next__r!)rr!r"οΏ½IterParseIteratorοΏ½srNFrοΏ½rοΏ½T)rοΏ½collectionsοΏ½abcοΏ½Iteratorrr$rοΏ½)rοΏ½rοΏ½rοΏ½rr!)rοΏ½rrrrοΏ½r"rοΏ½s

c@s<eZdZd
ddοΏ½ddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½ZdS)rN)rcCs<tοΏ½οΏ½|_|pttοΏ½dοΏ½|_|dkr(d}|jοΏ½|j|οΏ½dS)NοΏ½rq)οΏ½end)r	οΏ½dequeοΏ½
_events_queuerrrοΏ½
_setevents)r,rοΏ½rr!r!r"r.οΏ½s

zXMLPullParser.__init__c
CsZ|jdkrtdοΏ½οΏ½|rVz|jοΏ½|οΏ½Wn.tk
rT}z|jοΏ½|οΏ½W5d}~XYnXdS)οΏ½Feed encoded data to parser.Nz!feed() called after end of stream)rrοΏ½rοΏ½οΏ½SyntaxErrorrrJ)r,rοΏ½οΏ½excr!r!r"rοΏ½οΏ½s
zXMLPullParser.feedcCs|jοΏ½οΏ½}d|_|Sr7)rrοΏ½)r,rr!r!r"rοΏ½s
z$XMLPullParser._close_and_return_rootcCs|οΏ½οΏ½dS)zοΏ½Finish feeding data to parser.

        Unlike XMLParser, does not return the root element. Use
        read_events() to consume elements from XMLPullParser.
        N)rr0r!r!r"rοΏ½szXMLPullParser.closeccs.|j}|r*|οΏ½οΏ½}t|tοΏ½r"|οΏ½q|VqdS)zοΏ½Return an iterator over currently available (event, elem) pairs.

        Events are consumed from the internal event queue as they are
        retrieved from the iterator.
        N)rοΏ½popleftr&οΏ½	Exception)r,rοΏ½οΏ½eventr!r!r"rs
zXMLPullParser.read_events)N)rrrr.rοΏ½rrοΏ½rr!r!r!r"rοΏ½s

cCs"|sttοΏ½dοΏ½}|οΏ½|οΏ½|οΏ½οΏ½S)aParse XML document from string constant.

    This function can be used to embed "XML Literals" in Python code.

    *text* is a string containing XML data, *parser* is an
    optional parser instance, defaulting to the standard XMLParser.

    Returns an Element instance.

    rοΏ½rrrοΏ½rοΏ½)r3rοΏ½r!r!r"rs
cCsR|sttοΏ½dοΏ½}|οΏ½|οΏ½|οΏ½οΏ½}i}|οΏ½οΏ½D]}|οΏ½dοΏ½}|r.|||<q.||fS)aParse XML document from string constant for its IDs.

    *text* is a string containing XML data, *parser* is an
    optional parser instance, defaulting to the standard XMLParser.

    Returns an (Element, dict) tuple, in which the
    dict maps element id:s to elements.

    rr/)rrrοΏ½rοΏ½rgr`)r3rοΏ½rοΏ½Zidsr5r/r!r!r"r,s



cCs,|sttοΏ½dοΏ½}|D]}|οΏ½|οΏ½q|οΏ½οΏ½S)zοΏ½Parse XML document from sequence of string fragments.

    *sequence* is a list of other sequence, *parser* is an optional parser
    instance, defaulting to the standard XMLParser.

    Returns an Element instance.

    rr)ZsequencerοΏ½r3r!r!r"rDs
	c@sheZdZdZddddddοΏ½ddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½ZddοΏ½Z	ddοΏ½Z
dddοΏ½ZddοΏ½ZdS)ra8Generic element structure builder.

    This builder converts a sequence of start, data, and end method
    calls to a well-formed element structure.

    You can use this class to build an element structure using a custom XML
    parser, or a parser for some other XML-like format.

    *element_factory* is an optional element factory which is called
    to create new Element instances, as necessary.

    *comment_factory* is a factory to create comments to be used instead of
    the standard factory.  If *insert_comments* is false (the default),
    comments will not be inserted into the tree.

    *pi_factory* is a factory to create processing instructions to be used
    instead of the standard factory.  If *insert_pis* is false (the default),
    processing instructions will not be inserted into the tree.
    NF)οΏ½comment_factoryοΏ½
pi_factoryοΏ½insert_commentsοΏ½
insert_piscCsdg|_g|_d|_d|_d|_|dkr*t}||_||_|dkrBt}||_	||_
|dkrZt}||_dSr7)
οΏ½_dataοΏ½_elemοΏ½_lastr~οΏ½_tailrοΏ½_comment_factoryrrοΏ½_pi_factoryrrοΏ½_factory)r,Zelement_factoryrrrrr!r!r"r.js zTreeBuilder.__init__cCs.t|jοΏ½dkstdοΏ½οΏ½|jdk	s(tdοΏ½οΏ½|jS)z;Flush builder buffers and return toplevel document Element.rzmissing end tagsNzmissing toplevel element)r8rοΏ½AssertionErrorr~r0r!r!r"rοΏ½~szTreeBuilder.closecCsf|jrb|jdk	r\dοΏ½|jοΏ½}|jr@|jjdks6tdοΏ½οΏ½||j_n|jjdksTtdοΏ½οΏ½||j_g|_dS)NrοΏ½zinternal error (tail)zinternal error (text))rrοΏ½joinrr4r#r3οΏ½r,r3r!r!r"οΏ½_flushοΏ½s

zTreeBuilder._flushcCs|jοΏ½|οΏ½dS)zAdd text to current element.N)rrJοΏ½r,rοΏ½r!r!r"rοΏ½οΏ½szTreeBuilder.datacCsX|οΏ½οΏ½|οΏ½||οΏ½|_}|jr2|jdοΏ½|οΏ½n|jdkrB||_|jοΏ½|οΏ½d|_|S)zοΏ½Open new element and return it.

        *tag* is the element name, *attrs* is a dict containing element
        attributes.

        rοΏ½Nr)r&r"rrrJr~r)r,r#οΏ½attrsr5r!r!r"οΏ½startοΏ½s
zTreeBuilder.startcCs@|οΏ½οΏ½|jοΏ½οΏ½|_|jj|ks4td|jj|fοΏ½οΏ½d|_|jS)zOClose and return current Element.

        *tag* is the element name.

        z&end tag mismatch (expected %s, got %s)r)r&rοΏ½poprr#r#rrjr!r!r"r
οΏ½sοΏ½οΏ½zTreeBuilder.endcCs|οΏ½|j|j|οΏ½S)z`Create a comment using the comment_factory.

        *text* is the text of the comment.
        )οΏ½_handle_singler rr%r!r!r"οΏ½commentοΏ½s
οΏ½zTreeBuilder.commentcCs|οΏ½|j|j||οΏ½S)zοΏ½Create a processing instruction using the pi_factory.

        *target* is the target name of the processing instruction.
        *text* is the data of the processing instruction, or ''.
        )r+r!r)r,rqr3r!r!r"οΏ½piοΏ½sοΏ½zTreeBuilder.picGs:||οΏ½}|r6|οΏ½οΏ½||_|jr0|jdοΏ½|οΏ½d|_|S)NrοΏ½r)r&rrrJr)r,οΏ½factoryrOοΏ½argsr5r!r!r"r+οΏ½szTreeBuilder._handle_single)N)N)
rrrr r.rοΏ½r&rοΏ½r)r
r,r-r+r!r!r!r"rVsοΏ½
	c@speZdZdZdddοΏ½ddοΏ½ZddοΏ½Zdd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZdS)raaElement structure builder for XML source data based on the expat parser.

    *target* is an optional target object which defaults to an instance of the
    standard TreeBuilder class, *encoding* is an optional encoding string
    which if given, overrides the encoding specified in the XML file:
    http://www.iana.org/assignments/character-sets

    N)rqrοΏ½cCsdzddlm}Wn>tk
rNzddl}Wntk
rHtdοΏ½οΏ½YnXYnX|οΏ½|dοΏ½}|dkrjtοΏ½}||_|_||_|_	|j
|_i|_|j
|_t|dοΏ½rοΏ½|j|_t|dοΏ½rοΏ½|j|_t|dοΏ½rοΏ½|j|_t|dοΏ½rοΏ½|j|_t|d	οΏ½rοΏ½|j|_t|d
οΏ½οΏ½r|j|_t|dοΏ½οΏ½r|j|_d|_d|_d|_ d|_!i|_"zd
|j#|_$Wnt%k
οΏ½r^YnXdS)NrοΏ½οΏ½expatz7No module named expat; use SimpleXMLTreeBuilder insteadrοΏ½r)r
οΏ½start_nsοΏ½end_nsrοΏ½r,r-rzExpat %d.%d.%d)&οΏ½xml.parsersr1οΏ½ImportErrorZpyexpatZParserCreaterrοΏ½rrqοΏ½_targetοΏ½errorοΏ½_errorοΏ½_namesοΏ½_defaultZDefaultHandlerExpandr$οΏ½_startοΏ½StartElementHandlerοΏ½_endοΏ½EndElementHandlerοΏ½	_start_nsοΏ½StartNamespaceDeclHandlerοΏ½_end_nsοΏ½EndNamespaceDeclHandlerrοΏ½ZCharacterDataHandlerr,οΏ½CommentHandlerr-οΏ½ProcessingInstructionHandlerZbuffer_textοΏ½ordered_attributesοΏ½specified_attributesοΏ½_doctypeοΏ½entityοΏ½version_infoοΏ½versionrοΏ½)r,rqrοΏ½r1rοΏ½r!r!r"r.οΏ½sPοΏ½




zXMLParser.__init__cCs8|j}|j}|DοΏ½] }|dkrDd|_d|_|||jfddοΏ½}||_q|dkrf|||jfddοΏ½}||_q|dkrοΏ½t|j	dοΏ½rοΏ½|||j
fd	dοΏ½}n||fd
dοΏ½}||_q|dkrοΏ½t|j	dοΏ½rοΏ½|||jfd
dοΏ½}n||fddοΏ½}||_
q|dkοΏ½r|||fddοΏ½}||_q|dkοΏ½r&|||fddοΏ½}||_qtd|οΏ½οΏ½qdS)Nr)rcSs|||||οΏ½fοΏ½dSr7r!)r#Z	attrib_inrrJr)r!r!r"οΏ½handlersz%XMLParser._setevents.<locals>.handlerr
cSs||||οΏ½fοΏ½dSr7r!)r#rrJr
r!r!r"rKszstart-nsr2cSs|||||οΏ½fοΏ½dSr7r!)rοΏ½rοΏ½rrJr2r!r!r"rK!scSs|||p
d|pdffοΏ½dSοΏ½NrοΏ½r!)rοΏ½rοΏ½rrJr!r!r"rK%szend-nsr3cSs||||οΏ½fοΏ½dSr7r!)rοΏ½rrJr3r!r!r"rK+scSs||dfοΏ½dSr7r!)rοΏ½rrJr!r!r"rK/sr,cSs|||jοΏ½|οΏ½fοΏ½dSr7)rqr,)r3rrJr,r!r!r"rK3sr-cSs|||jοΏ½||οΏ½fοΏ½dSr7)rqr-)Z	pi_targetrοΏ½rrJr,r!r!r"rK7szunknown event %r)rrJrErFr;r<r=r>r$rqr?r@rArBrCrDrοΏ½)r,Zevents_queueZevents_to_reportrοΏ½rJZ
event_namerKr!r!r"rsL
οΏ½
οΏ½
οΏ½οΏ½

οΏ½
zXMLParser._seteventscCs&t|οΏ½}|j|_|j|jf|_|οΏ½dSr7)r
οΏ½codeοΏ½linenoοΏ½offsetZposition)r,rbοΏ½errr!r!r"οΏ½_raiseerror>szXMLParser._raiseerrorcCsFz|j|}Wn2tk
r@|}d|kr2d|}||j|<YnX|S)NrοΏ½rοΏ½)r9οΏ½KeyError)r,raοΏ½namer!r!r"οΏ½_fixnameDszXMLParser._fixnamecCs|jοΏ½|pd|pdοΏ½SrL)rqr2οΏ½r,rοΏ½rοΏ½r!r!r"r?OszXMLParser._start_nscCs|jοΏ½|pdοΏ½SrL)rqr3)r,rοΏ½r!r!r"rARszXMLParser._end_nscCsR|j}||οΏ½}i}|rDtdt|οΏ½dοΏ½D]}||d||||οΏ½<q&|jοΏ½||οΏ½S)Nrr:r)rTοΏ½ranger8rqr))r,r#οΏ½	attr_listZfixnamer*οΏ½ir!r!r"r;UszXMLParser._startcCs|jοΏ½|οΏ½|οΏ½οΏ½Sr7)rqr
rTrjr!r!r"r=aszXMLParser._endc	CsοΏ½|ddοΏ½}|dkrοΏ½z|jj}Wntk
r6YdSXz||j|ddοΏ½οΏ½WnZtk
rοΏ½ddlm}|οΏ½d||jj	|jj
fοΏ½}d|_|jj	|_|jj
|_
|οΏ½YnXοΏ½n"|dkrοΏ½|dd	οΏ½d
krοΏ½g|_οΏ½n|jdk	οΏ½rοΏ½|dkrοΏ½d|_dS|οΏ½οΏ½}|οΏ½sdS|jοΏ½|οΏ½t|jοΏ½}|dkοΏ½rοΏ½|jd}|d
kοΏ½rd|dkοΏ½rd|j\}}}	}
|	οΏ½rοΏ½|	ddοΏ½}	n*|dkοΏ½rοΏ½|dkοΏ½rοΏ½|j\}}}
d}	ndSt|jdοΏ½οΏ½rοΏ½|jοΏ½||	|
ddοΏ½οΏ½nt|dοΏ½οΏ½rοΏ½tοΏ½dtοΏ½d|_dS)NrrοΏ½rοΏ½rr0z'undefined entity %s: line %d, column %dοΏ½rοΏ½οΏ½	z	<!DOCTYPErοΏ½r:ZPUBLICοΏ½ZSYSTEMοΏ½οΏ½doctypezaThe doctype() method of XMLParser is ignored.  Define doctype() method on the TreeBuilder target.)rqrοΏ½rοΏ½rHrRr4r1r7rοΏ½ZErrorLineNumberZErrorColumnNumberrMrNrOrGοΏ½striprJr8r$r]r=r>οΏ½RuntimeWarning)r,r3rοΏ½Zdata_handlerr1rPοΏ½nrQrSZpubidοΏ½systemr!r!r"r:dsdοΏ½οΏ½οΏ½





οΏ½zXMLParser._defaultc
CsFz|jοΏ½|dοΏ½Wn.|jk
r@}z|οΏ½|οΏ½W5d}~XYnXdS)rrN)rοΏ½οΏ½Parser8rQ)r,rοΏ½rοΏ½r!r!r"rοΏ½οΏ½szXMLParser.feedc
CsοΏ½z|jοΏ½ddοΏ½Wn.|jk
r@}z|οΏ½|οΏ½W5d}~XYnXz0z|jj}Wntk
rdYnX|οΏ½WοΏ½SW5|`|`|`|`XdS)z;Finish feeding data to parser and return element structure.rοΏ½rN)	rοΏ½rbr8rQrrqr6rοΏ½rοΏ½)r,rοΏ½Z
close_handlerr!r!r"rοΏ½οΏ½szXMLParser.close)rrrr r.rrQrTr?rAr;r=r:rοΏ½rοΏ½r!r!r!r"rοΏ½s	.66)οΏ½outοΏ½	from_filecKsοΏ½|dkr|dkrtdοΏ½οΏ½d}|dkr0tοΏ½οΏ½}}tt|jf|οΏ½dοΏ½}|dk	r`|οΏ½|οΏ½|οΏ½οΏ½n|dk	rtt||dοΏ½|dk	rοΏ½|οΏ½	οΏ½SdS)a3Convert XML to its C14N 2.0 serialised form.

    If *out* is provided, it must be a file or file-like object that receives
    the serialised canonical XML output (text, not bytes) through its ``.write()``
    method.  To write to a file, open it in text mode with encoding "utf-8".
    If *out* is not provided, this function returns the output as text string.

    Either *xml_data* (an XML string) or *from_file* (a file path or
    file-like object) must be provided as input.

    The configuration options are the same as for the ``C14NWriterTarget``.
    Nz:Either 'xml_data' or 'from_file' must be provided as inputr)rοΏ½)
rοΏ½rοΏ½rοΏ½rrrοΏ½rοΏ½rοΏ½r	rοΏ½)Zxml_datarcrdZoptionsZsiorοΏ½r!r!r"rοΏ½s


z	^\w+:\w+$c@sοΏ½eZdZdZddddddddοΏ½ddοΏ½ZefddοΏ½Zd	d
οΏ½ZdddοΏ½Zd
dοΏ½Z	dj
fddοΏ½ZddοΏ½ZddοΏ½Z
dddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½ZdS) raοΏ½
    Canonicalization writer target for the XMLParser.

    Serialises parse events to XML C14N 2.0.

    The *write* function is used for writing out the resulting data stream
    as text (not bytes).  To write to a file, open it in text mode with encoding
    "utf-8" and pass its ``.write`` method.

    Configuration options:

    - *with_comments*: set to true to include comments
    - *strip_text*: set to true to strip whitespace before and after text content
    - *rewrite_prefixes*: set to true to replace namespace prefixes by "n{number}"
    - *qname_aware_tags*: a set of qname aware tag names in which prefixes
                          should be replaced in text content
    - *qname_aware_attrs*: a set of qname aware attribute names in which prefixes
                           should be replaced in text content
    - *exclude_attrs*: a set of attribute names that should not be serialised
    - *exclude_tags*: a set of tag names that should not be serialised
    FN)οΏ½
with_commentsοΏ½
strip_textοΏ½rewrite_prefixesοΏ½qname_aware_tagsοΏ½qname_aware_attrsοΏ½
exclude_attrsοΏ½exclude_tagsc	CsοΏ½||_g|_||_||_|r$t|οΏ½nd|_|r6t|οΏ½nd|_||_|rRt|οΏ½|_nd|_|rjt|οΏ½j	|_
nd|_
dgg|_g|_|sοΏ½|jοΏ½
ttοΏ½οΏ½οΏ½οΏ½|jοΏ½
gοΏ½i|_dg|_d|_d|_d|_d|_dS)N)rοΏ½rοΏ½Fr)οΏ½_writerοΏ½_with_commentsοΏ½_strip_textrcοΏ½_exclude_attrsοΏ½
_exclude_tagsοΏ½_rewrite_prefixesοΏ½_qname_aware_tagsοΏ½intersectionοΏ½_find_qname_aware_attrsοΏ½_declared_ns_stackοΏ½	_ns_stackrJrirοΏ½reοΏ½_prefix_mapοΏ½_preserve_spaceοΏ½_pending_startοΏ½
_root_seenοΏ½
_root_doneοΏ½_ignored_depth)	r,rοΏ½rerfrgrhrirjrkr!r!r"r.οΏ½s2οΏ½zC14NWriterTarget.__init__ccs ||οΏ½D]}|r|EdHqdSr7r!)r,Zns_stackZ	_reversedrYr!r!r"οΏ½_iter_namespacessz!C14NWriterTarget._iter_namespacescCs\|οΏ½ddοΏ½\}}|οΏ½|jοΏ½D]$\}}||krd|οΏ½d|οΏ½οΏ½Sqtd|οΏ½d|οΏ½dοΏ½οΏ½οΏ½dS)NrοΏ½rrοΏ½rοΏ½zPrefix z of QName "οΏ½" is not declared in scope)οΏ½splitr}rvrοΏ½)r,Z
prefixed_namerοΏ½rSrοΏ½οΏ½pr!r!r"οΏ½_resolve_prefix_names
z%C14NWriterTarget._resolve_prefix_namecCsοΏ½|dkr:|ddοΏ½dkr,|ddοΏ½οΏ½ddοΏ½nd|f\}}n|}tοΏ½}|οΏ½|jοΏ½D]B\}}||krοΏ½||krοΏ½|rz|οΏ½d|οΏ½οΏ½n|||fS|οΏ½|οΏ½qP|jrοΏ½||jkrοΏ½|j|}ndt|jοΏ½οΏ½οΏ½}|j|<|jdοΏ½||fοΏ½|οΏ½d|οΏ½οΏ½||fS|οΏ½sd|kοΏ½r|||fS|οΏ½|j	οΏ½D]J\}}||kοΏ½r|jdοΏ½||fοΏ½|οΏ½rR|οΏ½d|οΏ½οΏ½n|||fSοΏ½q|οΏ½st|||fSt
d|οΏ½d	οΏ½οΏ½οΏ½dS)
NrrοΏ½rοΏ½rοΏ½rοΏ½r`rοΏ½zNamespace "r~)rοΏ½rcr}ruοΏ½addrqrwr8rJrvrοΏ½)r,rοΏ½rοΏ½r#Z
prefixes_seenοΏ½urοΏ½r!r!r"οΏ½_qnames.2 


&
zC14NWriterTarget._qnamecCs|js|jοΏ½|οΏ½dSr7)r|rrJr'r!r!r"rοΏ½CszC14NWriterTarget.datarοΏ½cCsοΏ½||jοΏ½}|jddοΏ½=|jr.|jds.|οΏ½οΏ½}|jdk	rv|jd}|_|rVt|οΏ½rV|nd}|j||fοΏ½οΏ½|dk	rvdS|rοΏ½|jrοΏ½|οΏ½t	|οΏ½οΏ½dSοΏ½NrοΏ½)
rrnrxr^ryοΏ½_looks_like_prefix_namer;rzrlοΏ½_escape_cdata_c14n)r,Z
_join_textrοΏ½r/οΏ½
qname_textr!r!r"r&Gs


zC14NWriterTarget._flushcCs0|jr
dS|jr|οΏ½οΏ½|jdοΏ½||fοΏ½dSrοΏ½)r|rr&rvrJrUr!r!r"r2Us
zC14NWriterTarget.start_nscCsοΏ½|jdk	r,|js||jkr,|jd7_dS|jr:|οΏ½οΏ½g}|jοΏ½|οΏ½|jdk	rn||jkrn|||f|_dS|οΏ½|||οΏ½dSrοΏ½)	rpr|rr&rurJrrryr;)r,r#r(οΏ½new_namespacesr!r!r"r)]s
οΏ½οΏ½zC14NWriterTarget.startcsοΏ½jdk	r$|r$οΏ½fddοΏ½|οΏ½οΏ½DοΏ½}|h|οΏ½}i}|dk	rVοΏ½οΏ½|οΏ½}||<|οΏ½|οΏ½οΏ½jdk	rοΏ½|rοΏ½οΏ½οΏ½|οΏ½}|rοΏ½|D]0}	||	}
t|
οΏ½rvοΏ½οΏ½|
οΏ½}||
<|οΏ½|οΏ½qvqοΏ½d}nd}οΏ½jοΏ½οΏ½fddοΏ½t|ddοΏ½dοΏ½DοΏ½}|rοΏ½ddοΏ½|DοΏ½}|οΏ½οΏ½ng}|οΏ½rjt|οΏ½οΏ½οΏ½D]^\}
}|dk	οΏ½r@|
|kοΏ½r@||kοΏ½r@|||d	}||
\}}	}|οΏ½	|οΏ½r\|n|	|fοΏ½οΏ½q
|οΏ½
d
οΏ½}οΏ½jοΏ½	|οΏ½rοΏ½|dknοΏ½jdοΏ½οΏ½j}|d
||d	οΏ½|οΏ½rοΏ½|dοΏ½
ddοΏ½|DοΏ½οΏ½οΏ½|dοΏ½|dk	οΏ½rοΏ½|t|||d	οΏ½οΏ½dοΏ½_οΏ½jοΏ½	gοΏ½dS)Ncs i|]\}}|οΏ½jkr||οΏ½qSr!)roοΏ½οΏ½.0rοΏ½rοΏ½r0r!r"οΏ½
<dictcomp>ps
z+C14NWriterTarget._start.<locals>.<dictcomp>csi|]}|οΏ½|οΏ½οΏ½qSr!r!)rοΏ½r`)οΏ½parse_qnamer!r"rοΏ½οΏ½scSs|οΏ½ddοΏ½S)NrοΏ½r)r)r`r!r!r"rοΏ½οΏ½rοΏ½z)C14NWriterTarget._start.<locals>.<lambda>rοΏ½cSs$g|]\}}|rd|nd|fοΏ½qS)zxmlns:Zxmlnsr!)rοΏ½rοΏ½rοΏ½r!r!r"οΏ½
<listcomp>οΏ½sοΏ½z+C14NWriterTarget._start.<locals>.<listcomp>rz+{http://www.w3.org/XML/1998/namespace}spaceZpreserverοΏ½rοΏ½rοΏ½cSs&g|]\}}d|οΏ½dt|οΏ½οΏ½dοΏ½οΏ½qS)rpz="rοΏ½)οΏ½_escape_attrib_c14nrοΏ½r!r!r"rοΏ½οΏ½srοΏ½T)rorerοΏ½rοΏ½rtrοΏ½rοΏ½rοΏ½οΏ½sortrJr`rxrlr$rοΏ½rzrv)r,r#r(rοΏ½rοΏ½rοΏ½Zresolved_namesrοΏ½ZqattrsZ	attr_namerbZ
parsed_qnamesrWrοΏ½rοΏ½Z
attr_qnamerοΏ½Zspace_behaviourrοΏ½r!)rοΏ½r,r"r;ns`


οΏ½
οΏ½

οΏ½
zC14NWriterTarget._startcCst|jr|jd8_dS|jr&|οΏ½οΏ½|οΏ½d|οΏ½|οΏ½dοΏ½dοΏ½οΏ½|jοΏ½οΏ½t|jοΏ½dk|_|j	οΏ½οΏ½|j
οΏ½οΏ½dS)NrrοΏ½rrοΏ½)r|rr&rlrοΏ½rxr*r8r{rurvrjr!r!r"r
οΏ½s

zC14NWriterTarget.endcCsd|js
dS|jrdS|jr&|οΏ½dοΏ½n|jr:|jr:|οΏ½οΏ½|οΏ½dt|οΏ½οΏ½dοΏ½οΏ½|js`|οΏ½dοΏ½dS)NrοΏ½z<!--z-->)rmr|r{rlrzrr&rοΏ½r%r!r!r"r,οΏ½szC14NWriterTarget.commentcCsp|jr
dS|jr|οΏ½dοΏ½n|jr0|jr0|οΏ½οΏ½|οΏ½|rNd|οΏ½dt|οΏ½οΏ½dοΏ½n
d|οΏ½dοΏ½οΏ½|jsl|οΏ½dοΏ½dS)NrοΏ½z<?rpz?>)r|r{rlrzrr&rοΏ½)r,rqrοΏ½r!r!r"r-οΏ½s$οΏ½zC14NWriterTarget.pi)N)N)rrrr r.οΏ½reversedr}rοΏ½rοΏ½rοΏ½r$r&r2r)r;r
r,r-r!r!r!r"rοΏ½s(οΏ½%
%
E
c	Cs|zVd|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}d|krR|οΏ½ddοΏ½}|WSttfk
rvt|οΏ½YnXdS)	NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½οΏ½&#xD;rοΏ½rrr!r!r"rοΏ½οΏ½srοΏ½c	CsοΏ½z~d|kr|οΏ½ddοΏ½}d|kr*|οΏ½ddοΏ½}d|kr>|οΏ½ddοΏ½}d|krR|οΏ½ddοΏ½}d	|krf|οΏ½d	d
οΏ½}d|krz|οΏ½ddοΏ½}|WSttfk
rοΏ½t|οΏ½YnXdS)
NrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½z&#x9;rοΏ½z&#xA;rοΏ½rοΏ½rοΏ½rrr!r!r"rοΏ½οΏ½s rοΏ½)rf)οΏ½_set_factories)N)N)N)NN)NN)N)NN)N)N)N)N)@r οΏ½__all__rrοΏ½rοΏ½r=rοΏ½r	Zcollections.abcrοΏ½rοΏ½rrr
rrrrrrr
rοΏ½contextmanagerrοΏ½rοΏ½rοΏ½rοΏ½rcοΏ½	NameErrorrοΏ½rοΏ½rοΏ½rrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrοΏ½rοΏ½rrr	rrrrrrrrrοΏ½compileοΏ½UNICODErοΏ½rοΏ½rrοΏ½rοΏ½rPZ_elementtreerοΏ½r5r!r!r!r"οΏ½<module>sοΏ½JοΏ½>

0s
3
=22οΏ½	οΏ½
οΏ½οΏ½


05


zgU

e5dοΏ½@sPddlZddlmZdZedZedZGddοΏ½deοΏ½Zdd	d
οΏ½Zd
ddοΏ½Z	dS)οΏ½NοΏ½)οΏ½ElementTreez!{http://www.w3.org/2001/XInclude}οΏ½includeZfallbackc@seZdZdS)οΏ½FatalIncludeErrorN)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½r	r	οΏ½0/usr/lib64/python3.8/xml/etree/ElementInclude.pyr>src	Cs\|dkr.t|dοΏ½οΏ½}tοΏ½|οΏ½οΏ½οΏ½}W5QRXn*|s6d}t|d|dοΏ½οΏ½}|οΏ½οΏ½}W5QRX|S)NοΏ½xmlοΏ½rbzUTF-8οΏ½r)οΏ½encoding)οΏ½openrοΏ½parseZgetrootοΏ½read)οΏ½hrefrrοΏ½fileοΏ½datar	r	r
οΏ½default_loaderMsrcCsh|dkrt}d}|t|οΏ½kοΏ½rd||}|jtkοΏ½r4|οΏ½dοΏ½}|οΏ½ddοΏ½}|dkrοΏ½|||οΏ½}|dkrrtd||fοΏ½οΏ½tοΏ½|οΏ½}|jrοΏ½|jpοΏ½d|j|_|||<nοΏ½|dkοΏ½r&||||οΏ½dοΏ½οΏ½}|dkrοΏ½td||fοΏ½οΏ½|rοΏ½||d	}|jpοΏ½d||jpοΏ½d|_n|jοΏ½pd||jοΏ½pd|_||=qntd
|οΏ½οΏ½n&|jt	kοΏ½rPtd|jοΏ½οΏ½n
t
||οΏ½|d	}qdS)Nrrrrzcannot load %r as %rοΏ½οΏ½textrrz)unknown parse type in xi:include tag (%r)z0xi:fallback tag must be child of xi:include (%r))rοΏ½lenοΏ½tagοΏ½XINCLUDE_INCLUDEοΏ½getrοΏ½copyοΏ½tailrοΏ½XINCLUDE_FALLBACKr)οΏ½elemοΏ½loaderοΏ½iοΏ½errZnoderr	r	r
rcsN


οΏ½



οΏ½οΏ½οΏ½
)N)N)
rrrZXINCLUDErrοΏ½SyntaxErrorrrrr	r	r	r
οΏ½<module>3s
# $Id: __init__.py 3375 2008-02-13 08:05:08Z fredrik $
# elementtree package

# --------------------------------------------------------------------
# The ElementTree toolkit is
#
# Copyright (c) 1999-2008 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------

# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/psf/license for licensing details.
"""Lightweight XML support for Python.

 XML is an inherently hierarchical data format, and the most natural way to
 represent it is with a tree.  This module has two classes for this purpose:

    1. ElementTree represents the whole XML document as a tree and

    2. Element represents a single node in this tree.

 Interactions with the whole document (reading and writing to/from files) are
 usually done on the ElementTree level.  Interactions with a single XML element
 and its sub-elements are done on the Element level.

 Element is a flexible container object designed to store hierarchical data
 structures in memory. It can be described as a cross between a list and a
 dictionary.  Each Element has a number of properties associated with it:

    'tag' - a string containing the element's name.

    'attributes' - a Python dictionary storing the element's attributes.

    'text' - a string containing the element's text content.

    'tail' - an optional string containing text after the element's end tag.

    And a number of child elements stored in a Python sequence.

 To create an element instance, use the Element constructor,
 or the SubElement factory function.

 You can also use the ElementTree class to wrap an element structure
 and convert it to and from XML.

"""

#---------------------------------------------------------------------
# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/psf/license for licensing details.
#
# ElementTree
# Copyright (c) 1999-2008 by Fredrik Lundh.  All rights reserved.
#
# fredrik@pythonware.com
# http://www.pythonware.com
# --------------------------------------------------------------------
# The ElementTree toolkit is
#
# Copyright (c) 1999-2008 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------

__all__ = [
    # public symbols
    "Comment",
    "dump",
    "Element", "ElementTree",
    "fromstring", "fromstringlist",
    "iselement", "iterparse",
    "parse", "ParseError",
    "PI", "ProcessingInstruction",
    "QName",
    "SubElement",
    "tostring", "tostringlist",
    "TreeBuilder",
    "VERSION",
    "XML", "XMLID",
    "XMLParser", "XMLPullParser",
    "register_namespace",
    "canonicalize", "C14NWriterTarget",
    ]

VERSION = "1.3.0"

import sys
import re
import warnings
import io
import collections
import collections.abc
import contextlib

from . import ElementPath


class ParseError(SyntaxError):
    """An error when parsing an XML document.

    In addition to its exception value, a ParseError contains
    two extra attributes:
        'code'     - the specific exception code
        'position' - the line and column of the error

    """
    pass

# --------------------------------------------------------------------


def iselement(element):
    """Return True if *element* appears to be an Element."""
    return hasattr(element, 'tag')


class Element:
    """An XML element.

    This class is the reference implementation of the Element interface.

    An element's length is its number of subelements.  That means if you
    want to check if an element is truly empty, you should check BOTH
    its length AND its text attribute.

    The element tag, attribute names, and attribute values can be either
    bytes or strings.

    *tag* is the element name.  *attrib* is an optional dictionary containing
    element attributes. *extra* are additional element attributes given as
    keyword arguments.

    Example form:
        <tag attrib>text<child/>...</tag>tail

    """

    tag = None
    """The element's name."""

    attrib = None
    """Dictionary of the element's attributes."""

    text = None
    """
    Text before first subelement. This is either a string or the value None.
    Note that if there is no text, this attribute may be either
    None or the empty string, depending on the parser.

    """

    tail = None
    """
    Text after this element's end tag, but before the next sibling element's
    start tag.  This is either a string or the value None.  Note that if there
    was no text, this attribute may be either None or an empty string,
    depending on the parser.

    """

    def __init__(self, tag, attrib={}, **extra):
        if not isinstance(attrib, dict):
            raise TypeError("attrib must be dict, not %s" % (
                attrib.__class__.__name__,))
        self.tag = tag
        self.attrib = {**attrib, **extra}
        self._children = []

    def __repr__(self):
        return "<%s %r at %#x>" % (self.__class__.__name__, self.tag, id(self))

    def makeelement(self, tag, attrib):
        """Create a new element with the same type.

        *tag* is a string containing the element name.
        *attrib* is a dictionary containing the element attributes.

        Do not call this method, use the SubElement factory function instead.

        """
        return self.__class__(tag, attrib)

    def copy(self):
        """Return copy of current element.

        This creates a shallow copy. Subelements will be shared with the
        original tree.

        """
        elem = self.makeelement(self.tag, self.attrib)
        elem.text = self.text
        elem.tail = self.tail
        elem[:] = self
        return elem

    def __len__(self):
        return len(self._children)

    def __bool__(self):
        warnings.warn(
            "The behavior of this method will change in future versions.  "
            "Use specific 'len(elem)' or 'elem is not None' test instead.",
            FutureWarning, stacklevel=2
            )
        return len(self._children) != 0 # emulate old behaviour, for now

    def __getitem__(self, index):
        return self._children[index]

    def __setitem__(self, index, element):
        if isinstance(index, slice):
            for elt in element:
                self._assert_is_element(elt)
        else:
            self._assert_is_element(element)
        self._children[index] = element

    def __delitem__(self, index):
        del self._children[index]

    def append(self, subelement):
        """Add *subelement* to the end of this element.

        The new element will appear in document order after the last existing
        subelement (or directly after the text, if it's the first subelement),
        but before the end tag for this element.

        """
        self._assert_is_element(subelement)
        self._children.append(subelement)

    def extend(self, elements):
        """Append subelements from a sequence.

        *elements* is a sequence with zero or more elements.

        """
        for element in elements:
            self._assert_is_element(element)
            self._children.append(element)

    def insert(self, index, subelement):
        """Insert *subelement* at position *index*."""
        self._assert_is_element(subelement)
        self._children.insert(index, subelement)

    def _assert_is_element(self, e):
        # Need to refer to the actual Python implementation, not the
        # shadowing C implementation.
        if not isinstance(e, _Element_Py):
            raise TypeError('expected an Element, not %s' % type(e).__name__)

    def remove(self, subelement):
        """Remove matching subelement.

        Unlike the find methods, this method compares elements based on
        identity, NOT ON tag value or contents.  To remove subelements by
        other means, the easiest way is to use a list comprehension to
        select what elements to keep, and then use slice assignment to update
        the parent element.

        ValueError is raised if a matching element could not be found.

        """
        # assert iselement(element)
        self._children.remove(subelement)

    def getchildren(self):
        """(Deprecated) Return all subelements.

        Elements are returned in document order.

        """
        warnings.warn(
            "This method will be removed in future versions.  "
            "Use 'list(elem)' or iteration over elem instead.",
            DeprecationWarning, stacklevel=2
            )
        return self._children

    def find(self, path, namespaces=None):
        """Find first matching element by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        """
        return ElementPath.find(self, path, namespaces)

    def findtext(self, path, default=None, namespaces=None):
        """Find text for first matching element by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *default* is the value to return if the element was not found,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return text content of first matching element, or default value if
        none was found.  Note that if an element is found having no text
        content, the empty string is returned.

        """
        return ElementPath.findtext(self, path, default, namespaces)

    def findall(self, path, namespaces=None):
        """Find all matching subelements by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Returns list containing all matching elements in document order.

        """
        return ElementPath.findall(self, path, namespaces)

    def iterfind(self, path, namespaces=None):
        """Find all matching subelements by tag name or path.

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return an iterable yielding all matching elements in document order.

        """
        return ElementPath.iterfind(self, path, namespaces)

    def clear(self):
        """Reset element.

        This function removes all subelements, clears all attributes, and sets
        the text and tail attributes to None.

        """
        self.attrib.clear()
        self._children = []
        self.text = self.tail = None

    def get(self, key, default=None):
        """Get element attribute.

        Equivalent to attrib.get, but some implementations may handle this a
        bit more efficiently.  *key* is what attribute to look for, and
        *default* is what to return if the attribute was not found.

        Returns a string containing the attribute value, or the default if
        attribute was not found.

        """
        return self.attrib.get(key, default)

    def set(self, key, value):
        """Set element attribute.

        Equivalent to attrib[key] = value, but some implementations may handle
        this a bit more efficiently.  *key* is what attribute to set, and
        *value* is the attribute value to set it to.

        """
        self.attrib[key] = value

    def keys(self):
        """Get list of attribute names.

        Names are returned in an arbitrary order, just like an ordinary
        Python dict.  Equivalent to attrib.keys()

        """
        return self.attrib.keys()

    def items(self):
        """Get element attributes as a sequence.

        The attributes are returned in arbitrary order.  Equivalent to
        attrib.items().

        Return a list of (name, value) tuples.

        """
        return self.attrib.items()

    def iter(self, tag=None):
        """Create tree iterator.

        The iterator loops over the element and all subelements in document
        order, returning all elements with a matching tag.

        If the tree structure is modified during iteration, new or removed
        elements may or may not be included.  To get a stable set, use the
        list() function on the iterator, and loop over the resulting list.

        *tag* is what tags to look for (default is to return all elements)

        Return an iterator containing all the matching elements.

        """
        if tag == "*":
            tag = None
        if tag is None or self.tag == tag:
            yield self
        for e in self._children:
            yield from e.iter(tag)

    # compatibility
    def getiterator(self, tag=None):
        warnings.warn(
            "This method will be removed in future versions.  "
            "Use 'elem.iter()' or 'list(elem.iter())' instead.",
            DeprecationWarning, stacklevel=2
        )
        return list(self.iter(tag))

    def itertext(self):
        """Create text iterator.

        The iterator loops over the element and all subelements in document
        order, returning all inner text.

        """
        tag = self.tag
        if not isinstance(tag, str) and tag is not None:
            return
        t = self.text
        if t:
            yield t
        for e in self:
            yield from e.itertext()
            t = e.tail
            if t:
                yield t


def SubElement(parent, tag, attrib={}, **extra):
    """Subelement factory which creates an element instance, and appends it
    to an existing parent.

    The element tag, attribute names, and attribute values can be either
    bytes or Unicode strings.

    *parent* is the parent element, *tag* is the subelements name, *attrib* is
    an optional directory containing element attributes, *extra* are
    additional attributes given as keyword arguments.

    """
    attrib = {**attrib, **extra}
    element = parent.makeelement(tag, attrib)
    parent.append(element)
    return element


def Comment(text=None):
    """Comment element factory.

    This function creates a special element which the standard serializer
    serializes as an XML comment.

    *text* is a string containing the comment string.

    """
    element = Element(Comment)
    element.text = text
    return element


def ProcessingInstruction(target, text=None):
    """Processing Instruction element factory.

    This function creates a special element which the standard serializer
    serializes as an XML comment.

    *target* is a string containing the processing instruction, *text* is a
    string containing the processing instruction contents, if any.

    """
    element = Element(ProcessingInstruction)
    element.text = target
    if text:
        element.text = element.text + " " + text
    return element

PI = ProcessingInstruction


class QName:
    """Qualified name wrapper.

    This class can be used to wrap a QName attribute value in order to get
    proper namespace handing on output.

    *text_or_uri* is a string containing the QName value either in the form
    {uri}local, or if the tag argument is given, the URI part of a QName.

    *tag* is an optional argument which if given, will make the first
    argument (text_or_uri) be interpreted as a URI, and this argument (tag)
    be interpreted as a local name.

    """
    def __init__(self, text_or_uri, tag=None):
        if tag:
            text_or_uri = "{%s}%s" % (text_or_uri, tag)
        self.text = text_or_uri
    def __str__(self):
        return self.text
    def __repr__(self):
        return '<%s %r>' % (self.__class__.__name__, self.text)
    def __hash__(self):
        return hash(self.text)
    def __le__(self, other):
        if isinstance(other, QName):
            return self.text <= other.text
        return self.text <= other
    def __lt__(self, other):
        if isinstance(other, QName):
            return self.text < other.text
        return self.text < other
    def __ge__(self, other):
        if isinstance(other, QName):
            return self.text >= other.text
        return self.text >= other
    def __gt__(self, other):
        if isinstance(other, QName):
            return self.text > other.text
        return self.text > other
    def __eq__(self, other):
        if isinstance(other, QName):
            return self.text == other.text
        return self.text == other

# --------------------------------------------------------------------


class ElementTree:
    """An XML element hierarchy.

    This class also provides support for serialization to and from
    standard XML.

    *element* is an optional root element node,
    *file* is an optional file handle or file name of an XML file whose
    contents will be used to initialize the tree with.

    """
    def __init__(self, element=None, file=None):
        # assert element is None or iselement(element)
        self._root = element # first node
        if file:
            self.parse(file)

    def getroot(self):
        """Return root element of this tree."""
        return self._root

    def _setroot(self, element):
        """Replace root element of this tree.

        This will discard the current contents of the tree and replace it
        with the given element.  Use with care!

        """
        # assert iselement(element)
        self._root = element

    def parse(self, source, parser=None):
        """Load external XML document into element tree.

        *source* is a file name or file object, *parser* is an optional parser
        instance that defaults to XMLParser.

        ParseError is raised if the parser fails to parse the document.

        Returns the root element of the given source document.

        """
        close_source = False
        if not hasattr(source, "read"):
            source = open(source, "rb")
            close_source = True
        try:
            if parser is None:
                # If no parser was specified, create a default XMLParser
                parser = XMLParser()
                if hasattr(parser, '_parse_whole'):
                    # The default XMLParser, when it comes from an accelerator,
                    # can define an internal _parse_whole API for efficiency.
                    # It can be used to parse the whole source without feeding
                    # it with chunks.
                    self._root = parser._parse_whole(source)
                    return self._root
            while True:
                data = source.read(65536)
                if not data:
                    break
                parser.feed(data)
            self._root = parser.close()
            return self._root
        finally:
            if close_source:
                source.close()

    def iter(self, tag=None):
        """Create and return tree iterator for the root element.

        The iterator loops over all elements in this tree, in document order.

        *tag* is a string with the tag name to iterate over
        (default is to return all elements).

        """
        # assert self._root is not None
        return self._root.iter(tag)

    # compatibility
    def getiterator(self, tag=None):
        warnings.warn(
            "This method will be removed in future versions.  "
            "Use 'tree.iter()' or 'list(tree.iter())' instead.",
            DeprecationWarning, stacklevel=2
        )
        return list(self.iter(tag))

    def find(self, path, namespaces=None):
        """Find first matching element by tag name or path.

        Same as getroot().find(path), which is Element.find()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        """
        # assert self._root is not None
        if path[:1] == "/":
            path = "." + path
            warnings.warn(
                "This search is broken in 1.3 and earlier, and will be "
                "fixed in a future version.  If you rely on the current "
                "behaviour, change it to %r" % path,
                FutureWarning, stacklevel=2
                )
        return self._root.find(path, namespaces)

    def findtext(self, path, default=None, namespaces=None):
        """Find first matching element by tag name or path.

        Same as getroot().findtext(path),  which is Element.findtext()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return the first matching element, or None if no element was found.

        """
        # assert self._root is not None
        if path[:1] == "/":
            path = "." + path
            warnings.warn(
                "This search is broken in 1.3 and earlier, and will be "
                "fixed in a future version.  If you rely on the current "
                "behaviour, change it to %r" % path,
                FutureWarning, stacklevel=2
                )
        return self._root.findtext(path, default, namespaces)

    def findall(self, path, namespaces=None):
        """Find all matching subelements by tag name or path.

        Same as getroot().findall(path), which is Element.findall().

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return list containing all matching elements in document order.

        """
        # assert self._root is not None
        if path[:1] == "/":
            path = "." + path
            warnings.warn(
                "This search is broken in 1.3 and earlier, and will be "
                "fixed in a future version.  If you rely on the current "
                "behaviour, change it to %r" % path,
                FutureWarning, stacklevel=2
                )
        return self._root.findall(path, namespaces)

    def iterfind(self, path, namespaces=None):
        """Find all matching subelements by tag name or path.

        Same as getroot().iterfind(path), which is element.iterfind()

        *path* is a string having either an element tag or an XPath,
        *namespaces* is an optional mapping from namespace prefix to full name.

        Return an iterable yielding all matching elements in document order.

        """
        # assert self._root is not None
        if path[:1] == "/":
            path = "." + path
            warnings.warn(
                "This search is broken in 1.3 and earlier, and will be "
                "fixed in a future version.  If you rely on the current "
                "behaviour, change it to %r" % path,
                FutureWarning, stacklevel=2
                )
        return self._root.iterfind(path, namespaces)

    def write(self, file_or_filename,
              encoding=None,
              xml_declaration=None,
              default_namespace=None,
              method=None, *,
              short_empty_elements=True):
        """Write element tree to a file as XML.

        Arguments:
          *file_or_filename* -- file name or a file object opened for writing

          *encoding* -- the output encoding (default: US-ASCII)

          *xml_declaration* -- bool indicating if an XML declaration should be
                               added to the output. If None, an XML declaration
                               is added if encoding IS NOT either of:
                               US-ASCII, UTF-8, or Unicode

          *default_namespace* -- sets the default XML namespace (for "xmlns")

          *method* -- either "xml" (default), "html, "text", or "c14n"

          *short_empty_elements* -- controls the formatting of elements
                                    that contain no content. If True (default)
                                    they are emitted as a single self-closed
                                    tag, otherwise they are emitted as a pair
                                    of start/end tags

        """
        if not method:
            method = "xml"
        elif method not in _serialize:
            raise ValueError("unknown method %r" % method)
        if not encoding:
            if method == "c14n":
                encoding = "utf-8"
            else:
                encoding = "us-ascii"
        enc_lower = encoding.lower()
        with _get_writer(file_or_filename, enc_lower) as write:
            if method == "xml" and (xml_declaration or
                    (xml_declaration is None and
                     enc_lower not in ("utf-8", "us-ascii", "unicode"))):
                declared_encoding = encoding
                if enc_lower == "unicode":
                    # Retrieve the default encoding for the xml declaration
                    import locale
                    declared_encoding = locale.getpreferredencoding()
                write("<?xml version='1.0' encoding='%s'?>\n" % (
                    declared_encoding,))
            if method == "text":
                _serialize_text(write, self._root)
            else:
                qnames, namespaces = _namespaces(self._root, default_namespace)
                serialize = _serialize[method]
                serialize(write, self._root, qnames, namespaces,
                          short_empty_elements=short_empty_elements)

    def write_c14n(self, file):
        # lxml.etree compatibility.  use output method instead
        return self.write(file, method="c14n")

# --------------------------------------------------------------------
# serialization support

@contextlib.contextmanager
def _get_writer(file_or_filename, encoding):
    # returns text write method and release all resources after using
    try:
        write = file_or_filename.write
    except AttributeError:
        # file_or_filename is a file name
        if encoding == "unicode":
            file = open(file_or_filename, "w")
        else:
            file = open(file_or_filename, "w", encoding=encoding,
                        errors="xmlcharrefreplace")
        with file:
            yield file.write
    else:
        # file_or_filename is a file-like object
        # encoding determines if it is a text or binary writer
        if encoding == "unicode":
            # use a text writer as is
            yield write
        else:
            # wrap a binary writer with TextIOWrapper
            with contextlib.ExitStack() as stack:
                if isinstance(file_or_filename, io.BufferedIOBase):
                    file = file_or_filename
                elif isinstance(file_or_filename, io.RawIOBase):
                    file = io.BufferedWriter(file_or_filename)
                    # Keep the original file open when the BufferedWriter is
                    # destroyed
                    stack.callback(file.detach)
                else:
                    # This is to handle passed objects that aren't in the
                    # IOBase hierarchy, but just have a write method
                    file = io.BufferedIOBase()
                    file.writable = lambda: True
                    file.write = write
                    try:
                        # TextIOWrapper uses this methods to determine
                        # if BOM (for UTF-16, etc) should be added
                        file.seekable = file_or_filename.seekable
                        file.tell = file_or_filename.tell
                    except AttributeError:
                        pass
                file = io.TextIOWrapper(file,
                                        encoding=encoding,
                                        errors="xmlcharrefreplace",
                                        newline="\n")
                # Keep the original file open when the TextIOWrapper is
                # destroyed
                stack.callback(file.detach)
                yield file.write

def _namespaces(elem, default_namespace=None):
    # identify namespaces used in this tree

    # maps qnames to *encoded* prefix:local names
    qnames = {None: None}

    # maps uri:s to prefixes
    namespaces = {}
    if default_namespace:
        namespaces[default_namespace] = ""

    def add_qname(qname):
        # calculate serialized qname representation
        try:
            if qname[:1] == "{":
                uri, tag = qname[1:].rsplit("}", 1)
                prefix = namespaces.get(uri)
                if prefix is None:
                    prefix = _namespace_map.get(uri)
                    if prefix is None:
                        prefix = "ns%d" % len(namespaces)
                    if prefix != "xml":
                        namespaces[uri] = prefix
                if prefix:
                    qnames[qname] = "%s:%s" % (prefix, tag)
                else:
                    qnames[qname] = tag # default element
            else:
                if default_namespace:
                    # FIXME: can this be handled in XML 1.0?
                    raise ValueError(
                        "cannot use non-qualified names with "
                        "default_namespace option"
                        )
                qnames[qname] = qname
        except TypeError:
            _raise_serialization_error(qname)

    # populate qname and namespaces table
    for elem in elem.iter():
        tag = elem.tag
        if isinstance(tag, QName):
            if tag.text not in qnames:
                add_qname(tag.text)
        elif isinstance(tag, str):
            if tag not in qnames:
                add_qname(tag)
        elif tag is not None and tag is not Comment and tag is not PI:
            _raise_serialization_error(tag)
        for key, value in elem.items():
            if isinstance(key, QName):
                key = key.text
            if key not in qnames:
                add_qname(key)
            if isinstance(value, QName) and value.text not in qnames:
                add_qname(value.text)
        text = elem.text
        if isinstance(text, QName) and text.text not in qnames:
            add_qname(text.text)
    return qnames, namespaces

def _serialize_xml(write, elem, qnames, namespaces,
                   short_empty_elements, **kwargs):
    tag = elem.tag
    text = elem.text
    if tag is Comment:
        write("<!--%s-->" % text)
    elif tag is ProcessingInstruction:
        write("<?%s?>" % text)
    else:
        tag = qnames[tag]
        if tag is None:
            if text:
                write(_escape_cdata(text))
            for e in elem:
                _serialize_xml(write, e, qnames, None,
                               short_empty_elements=short_empty_elements)
        else:
            write("<" + tag)
            items = list(elem.items())
            if items or namespaces:
                if namespaces:
                    for v, k in sorted(namespaces.items(),
                                       key=lambda x: x[1]):  # sort on prefix
                        if k:
                            k = ":" + k
                        write(" xmlns%s=\"%s\"" % (
                            k,
                            _escape_attrib(v)
                            ))
                for k, v in items:
                    if isinstance(k, QName):
                        k = k.text
                    if isinstance(v, QName):
                        v = qnames[v.text]
                    else:
                        v = _escape_attrib(v)
                    write(" %s=\"%s\"" % (qnames[k], v))
            if text or len(elem) or not short_empty_elements:
                write(">")
                if text:
                    write(_escape_cdata(text))
                for e in elem:
                    _serialize_xml(write, e, qnames, None,
                                   short_empty_elements=short_empty_elements)
                write("</" + tag + ">")
            else:
                write(" />")
    if elem.tail:
        write(_escape_cdata(elem.tail))

HTML_EMPTY = ("area", "base", "basefont", "br", "col", "frame", "hr",
              "img", "input", "isindex", "link", "meta", "param")

try:
    HTML_EMPTY = set(HTML_EMPTY)
except NameError:
    pass

def _serialize_html(write, elem, qnames, namespaces, **kwargs):
    tag = elem.tag
    text = elem.text
    if tag is Comment:
        write("<!--%s-->" % _escape_cdata(text))
    elif tag is ProcessingInstruction:
        write("<?%s?>" % _escape_cdata(text))
    else:
        tag = qnames[tag]
        if tag is None:
            if text:
                write(_escape_cdata(text))
            for e in elem:
                _serialize_html(write, e, qnames, None)
        else:
            write("<" + tag)
            items = list(elem.items())
            if items or namespaces:
                if namespaces:
                    for v, k in sorted(namespaces.items(),
                                       key=lambda x: x[1]):  # sort on prefix
                        if k:
                            k = ":" + k
                        write(" xmlns%s=\"%s\"" % (
                            k,
                            _escape_attrib(v)
                            ))
                for k, v in items:
                    if isinstance(k, QName):
                        k = k.text
                    if isinstance(v, QName):
                        v = qnames[v.text]
                    else:
                        v = _escape_attrib_html(v)
                    # FIXME: handle boolean attributes
                    write(" %s=\"%s\"" % (qnames[k], v))
            write(">")
            ltag = tag.lower()
            if text:
                if ltag == "script" or ltag == "style":
                    write(text)
                else:
                    write(_escape_cdata(text))
            for e in elem:
                _serialize_html(write, e, qnames, None)
            if ltag not in HTML_EMPTY:
                write("</" + tag + ">")
    if elem.tail:
        write(_escape_cdata(elem.tail))

def _serialize_text(write, elem):
    for part in elem.itertext():
        write(part)
    if elem.tail:
        write(elem.tail)

_serialize = {
    "xml": _serialize_xml,
    "html": _serialize_html,
    "text": _serialize_text,
# this optional method is imported at the end of the module
#   "c14n": _serialize_c14n,
}


def register_namespace(prefix, uri):
    """Register a namespace prefix.

    The registry is global, and any existing mapping for either the
    given prefix or the namespace URI will be removed.

    *prefix* is the namespace prefix, *uri* is a namespace uri. Tags and
    attributes in this namespace will be serialized with prefix if possible.

    ValueError is raised if prefix is reserved or is invalid.

    """
    if re.match(r"ns\d+$", prefix):
        raise ValueError("Prefix format reserved for internal use")
    for k, v in list(_namespace_map.items()):
        if k == uri or v == prefix:
            del _namespace_map[k]
    _namespace_map[uri] = prefix

_namespace_map = {
    # "well-known" namespace prefixes
    "http://www.w3.org/XML/1998/namespace": "xml",
    "http://www.w3.org/1999/xhtml": "html",
    "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",
    "http://schemas.xmlsoap.org/wsdl/": "wsdl",
    # xml schema
    "http://www.w3.org/2001/XMLSchema": "xs",
    "http://www.w3.org/2001/XMLSchema-instance": "xsi",
    # dublin core
    "http://purl.org/dc/elements/1.1/": "dc",
}
# For tests and troubleshooting
register_namespace._namespace_map = _namespace_map

def _raise_serialization_error(text):
    raise TypeError(
        "cannot serialize %r (type %s)" % (text, type(text).__name__)
        )

def _escape_cdata(text):
    # escape character data
    try:
        # it's worth avoiding do-nothing calls for strings that are
        # shorter than 500 characters, or so.  assume that's, by far,
        # the most common case in most applications.
        if "&" in text:
            text = text.replace("&", "&amp;")
        if "<" in text:
            text = text.replace("<", "&lt;")
        if ">" in text:
            text = text.replace(">", "&gt;")
        return text
    except (TypeError, AttributeError):
        _raise_serialization_error(text)

def _escape_attrib(text):
    # escape attribute value
    try:
        if "&" in text:
            text = text.replace("&", "&amp;")
        if "<" in text:
            text = text.replace("<", "&lt;")
        if ">" in text:
            text = text.replace(">", "&gt;")
        if "\"" in text:
            text = text.replace("\"", "&quot;")
        # The following business with carriage returns is to satisfy
        # Section 2.11 of the XML specification, stating that
        # CR or CR LN should be replaced with just LN
        # http://www.w3.org/TR/REC-xml/#sec-line-ends
        if "\r\n" in text:
            text = text.replace("\r\n", "\n")
        if "\r" in text:
            text = text.replace("\r", "\n")
        #The following four lines are issue 17582
        if "\n" in text:
            text = text.replace("\n", "&#10;")
        if "\t" in text:
            text = text.replace("\t", "&#09;")
        return text
    except (TypeError, AttributeError):
        _raise_serialization_error(text)

def _escape_attrib_html(text):
    # escape attribute value
    try:
        if "&" in text:
            text = text.replace("&", "&amp;")
        if ">" in text:
            text = text.replace(">", "&gt;")
        if "\"" in text:
            text = text.replace("\"", "&quot;")
        return text
    except (TypeError, AttributeError):
        _raise_serialization_error(text)

# --------------------------------------------------------------------

def tostring(element, encoding=None, method=None, *,
             xml_declaration=None, default_namespace=None,
             short_empty_elements=True):
    """Generate string representation of XML element.

    All subelements are included.  If encoding is "unicode", a string
    is returned. Otherwise a bytestring is returned.

    *element* is an Element instance, *encoding* is an optional output
    encoding defaulting to US-ASCII, *method* is an optional output which can
    be one of "xml" (default), "html", "text" or "c14n", *default_namespace*
    sets the default XML namespace (for "xmlns").

    Returns an (optionally) encoded string containing the XML data.

    """
    stream = io.StringIO() if encoding == 'unicode' else io.BytesIO()
    ElementTree(element).write(stream, encoding,
                               xml_declaration=xml_declaration,
                               default_namespace=default_namespace,
                               method=method,
                               short_empty_elements=short_empty_elements)
    return stream.getvalue()

class _ListDataStream(io.BufferedIOBase):
    """An auxiliary stream accumulating into a list reference."""
    def __init__(self, lst):
        self.lst = lst

    def writable(self):
        return True

    def seekable(self):
        return True

    def write(self, b):
        self.lst.append(b)

    def tell(self):
        return len(self.lst)

def tostringlist(element, encoding=None, method=None, *,
                 xml_declaration=None, default_namespace=None,
                 short_empty_elements=True):
    lst = []
    stream = _ListDataStream(lst)
    ElementTree(element).write(stream, encoding,
                               xml_declaration=xml_declaration,
                               default_namespace=default_namespace,
                               method=method,
                               short_empty_elements=short_empty_elements)
    return lst


def dump(elem):
    """Write element tree or element structure to sys.stdout.

    This function should be used for debugging only.

    *elem* is either an ElementTree, or a single Element.  The exact output
    format is implementation dependent.  In this version, it's written as an
    ordinary XML file.

    """
    # debugging
    if not isinstance(elem, ElementTree):
        elem = ElementTree(elem)
    elem.write(sys.stdout, encoding="unicode")
    tail = elem.getroot().tail
    if not tail or tail[-1] != "\n":
        sys.stdout.write("\n")

# --------------------------------------------------------------------
# parsing


def parse(source, parser=None):
    """Parse XML document into element tree.

    *source* is a filename or file object containing XML data,
    *parser* is an optional parser instance defaulting to XMLParser.

    Return an ElementTree instance.

    """
    tree = ElementTree()
    tree.parse(source, parser)
    return tree


def iterparse(source, events=None, parser=None):
    """Incrementally parse XML document into ElementTree.

    This class also reports what's going on to the user based on the
    *events* it is initialized with.  The supported events are the strings
    "start", "end", "start-ns" and "end-ns" (the "ns" events are used to get
    detailed namespace information).  If *events* is omitted, only
    "end" events are reported.

    *source* is a filename or file object containing XML data, *events* is
    a list of events to report back, *parser* is an optional parser instance.

    Returns an iterator providing (event, elem) pairs.

    """
    # Use the internal, undocumented _parser argument for now; When the
    # parser argument of iterparse is removed, this can be killed.
    pullparser = XMLPullParser(events=events, _parser=parser)
    def iterator():
        try:
            while True:
                yield from pullparser.read_events()
                # load event buffer
                data = source.read(16 * 1024)
                if not data:
                    break
                pullparser.feed(data)
            root = pullparser._close_and_return_root()
            yield from pullparser.read_events()
            it.root = root
        finally:
            if close_source:
                source.close()

    class IterParseIterator(collections.abc.Iterator):
        __next__ = iterator().__next__
    it = IterParseIterator()
    it.root = None
    del iterator, IterParseIterator

    close_source = False
    if not hasattr(source, "read"):
        source = open(source, "rb")
        close_source = True

    return it


class XMLPullParser:

    def __init__(self, events=None, *, _parser=None):
        # The _parser argument is for internal use only and must not be relied
        # upon in user code. It will be removed in a future release.
        # See http://bugs.python.org/issue17741 for more details.

        self._events_queue = collections.deque()
        self._parser = _parser or XMLParser(target=TreeBuilder())
        # wire up the parser for event reporting
        if events is None:
            events = ("end",)
        self._parser._setevents(self._events_queue, events)

    def feed(self, data):
        """Feed encoded data to parser."""
        if self._parser is None:
            raise ValueError("feed() called after end of stream")
        if data:
            try:
                self._parser.feed(data)
            except SyntaxError as exc:
                self._events_queue.append(exc)

    def _close_and_return_root(self):
        # iterparse needs this to set its root attribute properly :(
        root = self._parser.close()
        self._parser = None
        return root

    def close(self):
        """Finish feeding data to parser.

        Unlike XMLParser, does not return the root element. Use
        read_events() to consume elements from XMLPullParser.
        """
        self._close_and_return_root()

    def read_events(self):
        """Return an iterator over currently available (event, elem) pairs.

        Events are consumed from the internal event queue as they are
        retrieved from the iterator.
        """
        events = self._events_queue
        while events:
            event = events.popleft()
            if isinstance(event, Exception):
                raise event
            else:
                yield event


def XML(text, parser=None):
    """Parse XML document from string constant.

    This function can be used to embed "XML Literals" in Python code.

    *text* is a string containing XML data, *parser* is an
    optional parser instance, defaulting to the standard XMLParser.

    Returns an Element instance.

    """
    if not parser:
        parser = XMLParser(target=TreeBuilder())
    parser.feed(text)
    return parser.close()


def XMLID(text, parser=None):
    """Parse XML document from string constant for its IDs.

    *text* is a string containing XML data, *parser* is an
    optional parser instance, defaulting to the standard XMLParser.

    Returns an (Element, dict) tuple, in which the
    dict maps element id:s to elements.

    """
    if not parser:
        parser = XMLParser(target=TreeBuilder())
    parser.feed(text)
    tree = parser.close()
    ids = {}
    for elem in tree.iter():
        id = elem.get("id")
        if id:
            ids[id] = elem
    return tree, ids

# Parse XML document from string constant.  Alias for XML().
fromstring = XML

def fromstringlist(sequence, parser=None):
    """Parse XML document from sequence of string fragments.

    *sequence* is a list of other sequence, *parser* is an optional parser
    instance, defaulting to the standard XMLParser.

    Returns an Element instance.

    """
    if not parser:
        parser = XMLParser(target=TreeBuilder())
    for text in sequence:
        parser.feed(text)
    return parser.close()

# --------------------------------------------------------------------


class TreeBuilder:
    """Generic element structure builder.

    This builder converts a sequence of start, data, and end method
    calls to a well-formed element structure.

    You can use this class to build an element structure using a custom XML
    parser, or a parser for some other XML-like format.

    *element_factory* is an optional element factory which is called
    to create new Element instances, as necessary.

    *comment_factory* is a factory to create comments to be used instead of
    the standard factory.  If *insert_comments* is false (the default),
    comments will not be inserted into the tree.

    *pi_factory* is a factory to create processing instructions to be used
    instead of the standard factory.  If *insert_pis* is false (the default),
    processing instructions will not be inserted into the tree.
    """
    def __init__(self, element_factory=None, *,
                 comment_factory=None, pi_factory=None,
                 insert_comments=False, insert_pis=False):
        self._data = [] # data collector
        self._elem = [] # element stack
        self._last = None # last element
        self._root = None # root element
        self._tail = None # true if we're after an end tag
        if comment_factory is None:
            comment_factory = Comment
        self._comment_factory = comment_factory
        self.insert_comments = insert_comments
        if pi_factory is None:
            pi_factory = ProcessingInstruction
        self._pi_factory = pi_factory
        self.insert_pis = insert_pis
        if element_factory is None:
            element_factory = Element
        self._factory = element_factory

    def close(self):
        """Flush builder buffers and return toplevel document Element."""
        assert len(self._elem) == 0, "missing end tags"
        assert self._root is not None, "missing toplevel element"
        return self._root

    def _flush(self):
        if self._data:
            if self._last is not None:
                text = "".join(self._data)
                if self._tail:
                    assert self._last.tail is None, "internal error (tail)"
                    self._last.tail = text
                else:
                    assert self._last.text is None, "internal error (text)"
                    self._last.text = text
            self._data = []

    def data(self, data):
        """Add text to current element."""
        self._data.append(data)

    def start(self, tag, attrs):
        """Open new element and return it.

        *tag* is the element name, *attrs* is a dict containing element
        attributes.

        """
        self._flush()
        self._last = elem = self._factory(tag, attrs)
        if self._elem:
            self._elem[-1].append(elem)
        elif self._root is None:
            self._root = elem
        self._elem.append(elem)
        self._tail = 0
        return elem

    def end(self, tag):
        """Close and return current Element.

        *tag* is the element name.

        """
        self._flush()
        self._last = self._elem.pop()
        assert self._last.tag == tag,\
               "end tag mismatch (expected %s, got %s)" % (
                   self._last.tag, tag)
        self._tail = 1
        return self._last

    def comment(self, text):
        """Create a comment using the comment_factory.

        *text* is the text of the comment.
        """
        return self._handle_single(
            self._comment_factory, self.insert_comments, text)

    def pi(self, target, text=None):
        """Create a processing instruction using the pi_factory.

        *target* is the target name of the processing instruction.
        *text* is the data of the processing instruction, or ''.
        """
        return self._handle_single(
            self._pi_factory, self.insert_pis, target, text)

    def _handle_single(self, factory, insert, *args):
        elem = factory(*args)
        if insert:
            self._flush()
            self._last = elem
            if self._elem:
                self._elem[-1].append(elem)
            self._tail = 1
        return elem


# also see ElementTree and TreeBuilder
class XMLParser:
    """Element structure builder for XML source data based on the expat parser.

    *target* is an optional target object which defaults to an instance of the
    standard TreeBuilder class, *encoding* is an optional encoding string
    which if given, overrides the encoding specified in the XML file:
    http://www.iana.org/assignments/character-sets

    """

    def __init__(self, *, target=None, encoding=None):
        try:
            from xml.parsers import expat
        except ImportError:
            try:
                import pyexpat as expat
            except ImportError:
                raise ImportError(
                    "No module named expat; use SimpleXMLTreeBuilder instead"
                    )
        parser = expat.ParserCreate(encoding, "}")
        if target is None:
            target = TreeBuilder()
        # underscored names are provided for compatibility only
        self.parser = self._parser = parser
        self.target = self._target = target
        self._error = expat.error
        self._names = {} # name memo cache
        # main callbacks
        parser.DefaultHandlerExpand = self._default
        if hasattr(target, 'start'):
            parser.StartElementHandler = self._start
        if hasattr(target, 'end'):
            parser.EndElementHandler = self._end
        if hasattr(target, 'start_ns'):
            parser.StartNamespaceDeclHandler = self._start_ns
        if hasattr(target, 'end_ns'):
            parser.EndNamespaceDeclHandler = self._end_ns
        if hasattr(target, 'data'):
            parser.CharacterDataHandler = target.data
        # miscellaneous callbacks
        if hasattr(target, 'comment'):
            parser.CommentHandler = target.comment
        if hasattr(target, 'pi'):
            parser.ProcessingInstructionHandler = target.pi
        # Configure pyexpat: buffering, new-style attribute handling.
        parser.buffer_text = 1
        parser.ordered_attributes = 1
        parser.specified_attributes = 1
        self._doctype = None
        self.entity = {}
        try:
            self.version = "Expat %d.%d.%d" % expat.version_info
        except AttributeError:
            pass # unknown

    def _setevents(self, events_queue, events_to_report):
        # Internal API for XMLPullParser
        # events_to_report: a list of events to report during parsing (same as
        # the *events* of XMLPullParser's constructor.
        # events_queue: a list of actual parsing events that will be populated
        # by the underlying parser.
        #
        parser = self._parser
        append = events_queue.append
        for event_name in events_to_report:
            if event_name == "start":
                parser.ordered_attributes = 1
                parser.specified_attributes = 1
                def handler(tag, attrib_in, event=event_name, append=append,
                            start=self._start):
                    append((event, start(tag, attrib_in)))
                parser.StartElementHandler = handler
            elif event_name == "end":
                def handler(tag, event=event_name, append=append,
                            end=self._end):
                    append((event, end(tag)))
                parser.EndElementHandler = handler
            elif event_name == "start-ns":
                # TreeBuilder does not implement .start_ns()
                if hasattr(self.target, "start_ns"):
                    def handler(prefix, uri, event=event_name, append=append,
                                start_ns=self._start_ns):
                        append((event, start_ns(prefix, uri)))
                else:
                    def handler(prefix, uri, event=event_name, append=append):
                        append((event, (prefix or '', uri or '')))
                parser.StartNamespaceDeclHandler = handler
            elif event_name == "end-ns":
                # TreeBuilder does not implement .end_ns()
                if hasattr(self.target, "end_ns"):
                    def handler(prefix, event=event_name, append=append,
                                end_ns=self._end_ns):
                        append((event, end_ns(prefix)))
                else:
                    def handler(prefix, event=event_name, append=append):
                        append((event, None))
                parser.EndNamespaceDeclHandler = handler
            elif event_name == 'comment':
                def handler(text, event=event_name, append=append, self=self):
                    append((event, self.target.comment(text)))
                parser.CommentHandler = handler
            elif event_name == 'pi':
                def handler(pi_target, data, event=event_name, append=append,
                            self=self):
                    append((event, self.target.pi(pi_target, data)))
                parser.ProcessingInstructionHandler = handler
            else:
                raise ValueError("unknown event %r" % event_name)

    def _raiseerror(self, value):
        err = ParseError(value)
        err.code = value.code
        err.position = value.lineno, value.offset
        raise err

    def _fixname(self, key):
        # expand qname, and convert name string to ascii, if possible
        try:
            name = self._names[key]
        except KeyError:
            name = key
            if "}" in name:
                name = "{" + name
            self._names[key] = name
        return name

    def _start_ns(self, prefix, uri):
        return self.target.start_ns(prefix or '', uri or '')

    def _end_ns(self, prefix):
        return self.target.end_ns(prefix or '')

    def _start(self, tag, attr_list):
        # Handler for expat's StartElementHandler. Since ordered_attributes
        # is set, the attributes are reported as a list of alternating
        # attribute name,value.
        fixname = self._fixname
        tag = fixname(tag)
        attrib = {}
        if attr_list:
            for i in range(0, len(attr_list), 2):
                attrib[fixname(attr_list[i])] = attr_list[i+1]
        return self.target.start(tag, attrib)

    def _end(self, tag):
        return self.target.end(self._fixname(tag))

    def _default(self, text):
        prefix = text[:1]
        if prefix == "&":
            # deal with undefined entities
            try:
                data_handler = self.target.data
            except AttributeError:
                return
            try:
                data_handler(self.entity[text[1:-1]])
            except KeyError:
                from xml.parsers import expat
                err = expat.error(
                    "undefined entity %s: line %d, column %d" %
                    (text, self.parser.ErrorLineNumber,
                    self.parser.ErrorColumnNumber)
                    )
                err.code = 11 # XML_ERROR_UNDEFINED_ENTITY
                err.lineno = self.parser.ErrorLineNumber
                err.offset = self.parser.ErrorColumnNumber
                raise err
        elif prefix == "<" and text[:9] == "<!DOCTYPE":
            self._doctype = [] # inside a doctype declaration
        elif self._doctype is not None:
            # parse doctype contents
            if prefix == ">":
                self._doctype = None
                return
            text = text.strip()
            if not text:
                return
            self._doctype.append(text)
            n = len(self._doctype)
            if n > 2:
                type = self._doctype[1]
                if type == "PUBLIC" and n == 4:
                    name, type, pubid, system = self._doctype
                    if pubid:
                        pubid = pubid[1:-1]
                elif type == "SYSTEM" and n == 3:
                    name, type, system = self._doctype
                    pubid = None
                else:
                    return
                if hasattr(self.target, "doctype"):
                    self.target.doctype(name, pubid, system[1:-1])
                elif hasattr(self, "doctype"):
                    warnings.warn(
                        "The doctype() method of XMLParser is ignored.  "
                        "Define doctype() method on the TreeBuilder target.",
                        RuntimeWarning)

                self._doctype = None

    def feed(self, data):
        """Feed encoded data to parser."""
        try:
            self.parser.Parse(data, 0)
        except self._error as v:
            self._raiseerror(v)

    def close(self):
        """Finish feeding data to parser and return element structure."""
        try:
            self.parser.Parse("", 1) # end of data
        except self._error as v:
            self._raiseerror(v)
        try:
            close_handler = self.target.close
        except AttributeError:
            pass
        else:
            return close_handler()
        finally:
            # get rid of circular references
            del self.parser, self._parser
            del self.target, self._target


# --------------------------------------------------------------------
# C14N 2.0

def canonicalize(xml_data=None, *, out=None, from_file=None, **options):
    """Convert XML to its C14N 2.0 serialised form.

    If *out* is provided, it must be a file or file-like object that receives
    the serialised canonical XML output (text, not bytes) through its ``.write()``
    method.  To write to a file, open it in text mode with encoding "utf-8".
    If *out* is not provided, this function returns the output as text string.

    Either *xml_data* (an XML string) or *from_file* (a file path or
    file-like object) must be provided as input.

    The configuration options are the same as for the ``C14NWriterTarget``.
    """
    if xml_data is None and from_file is None:
        raise ValueError("Either 'xml_data' or 'from_file' must be provided as input")
    sio = None
    if out is None:
        sio = out = io.StringIO()

    parser = XMLParser(target=C14NWriterTarget(out.write, **options))

    if xml_data is not None:
        parser.feed(xml_data)
        parser.close()
    elif from_file is not None:
        parse(from_file, parser=parser)

    return sio.getvalue() if sio is not None else None


_looks_like_prefix_name = re.compile(r'^\w+:\w+$', re.UNICODE).match


class C14NWriterTarget:
    """
    Canonicalization writer target for the XMLParser.

    Serialises parse events to XML C14N 2.0.

    The *write* function is used for writing out the resulting data stream
    as text (not bytes).  To write to a file, open it in text mode with encoding
    "utf-8" and pass its ``.write`` method.

    Configuration options:

    - *with_comments*: set to true to include comments
    - *strip_text*: set to true to strip whitespace before and after text content
    - *rewrite_prefixes*: set to true to replace namespace prefixes by "n{number}"
    - *qname_aware_tags*: a set of qname aware tag names in which prefixes
                          should be replaced in text content
    - *qname_aware_attrs*: a set of qname aware attribute names in which prefixes
                           should be replaced in text content
    - *exclude_attrs*: a set of attribute names that should not be serialised
    - *exclude_tags*: a set of tag names that should not be serialised
    """
    def __init__(self, write, *,
                 with_comments=False, strip_text=False, rewrite_prefixes=False,
                 qname_aware_tags=None, qname_aware_attrs=None,
                 exclude_attrs=None, exclude_tags=None):
        self._write = write
        self._data = []
        self._with_comments = with_comments
        self._strip_text = strip_text
        self._exclude_attrs = set(exclude_attrs) if exclude_attrs else None
        self._exclude_tags = set(exclude_tags) if exclude_tags else None

        self._rewrite_prefixes = rewrite_prefixes
        if qname_aware_tags:
            self._qname_aware_tags = set(qname_aware_tags)
        else:
            self._qname_aware_tags = None
        if qname_aware_attrs:
            self._find_qname_aware_attrs = set(qname_aware_attrs).intersection
        else:
            self._find_qname_aware_attrs = None

        # Stack with globally and newly declared namespaces as (uri, prefix) pairs.
        self._declared_ns_stack = [[
            ("http://www.w3.org/XML/1998/namespace", "xml"),
        ]]
        # Stack with user declared namespace prefixes as (uri, prefix) pairs.
        self._ns_stack = []
        if not rewrite_prefixes:
            self._ns_stack.append(list(_namespace_map.items()))
        self._ns_stack.append([])
        self._prefix_map = {}
        self._preserve_space = [False]
        self._pending_start = None
        self._root_seen = False
        self._root_done = False
        self._ignored_depth = 0

    def _iter_namespaces(self, ns_stack, _reversed=reversed):
        for namespaces in _reversed(ns_stack):
            if namespaces:  # almost no element declares new namespaces
                yield from namespaces

    def _resolve_prefix_name(self, prefixed_name):
        prefix, name = prefixed_name.split(':', 1)
        for uri, p in self._iter_namespaces(self._ns_stack):
            if p == prefix:
                return f'{{{uri}}}{name}'
        raise ValueError(f'Prefix {prefix} of QName "{prefixed_name}" is not declared in scope')

    def _qname(self, qname, uri=None):
        if uri is None:
            uri, tag = qname[1:].rsplit('}', 1) if qname[:1] == '{' else ('', qname)
        else:
            tag = qname

        prefixes_seen = set()
        for u, prefix in self._iter_namespaces(self._declared_ns_stack):
            if u == uri and prefix not in prefixes_seen:
                return f'{prefix}:{tag}' if prefix else tag, tag, uri
            prefixes_seen.add(prefix)

        # Not declared yet => add new declaration.
        if self._rewrite_prefixes:
            if uri in self._prefix_map:
                prefix = self._prefix_map[uri]
            else:
                prefix = self._prefix_map[uri] = f'n{len(self._prefix_map)}'
            self._declared_ns_stack[-1].append((uri, prefix))
            return f'{prefix}:{tag}', tag, uri

        if not uri and '' not in prefixes_seen:
            # No default namespace declared => no prefix needed.
            return tag, tag, uri

        for u, prefix in self._iter_namespaces(self._ns_stack):
            if u == uri:
                self._declared_ns_stack[-1].append((uri, prefix))
                return f'{prefix}:{tag}' if prefix else tag, tag, uri

        if not uri:
            # As soon as a default namespace is defined,
            # anything that has no namespace (and thus, no prefix) goes there.
            return tag, tag, uri

        raise ValueError(f'Namespace "{uri}" is not declared in scope')

    def data(self, data):
        if not self._ignored_depth:
            self._data.append(data)

    def _flush(self, _join_text=''.join):
        data = _join_text(self._data)
        del self._data[:]
        if self._strip_text and not self._preserve_space[-1]:
            data = data.strip()
        if self._pending_start is not None:
            args, self._pending_start = self._pending_start, None
            qname_text = data if data and _looks_like_prefix_name(data) else None
            self._start(*args, qname_text)
            if qname_text is not None:
                return
        if data and self._root_seen:
            self._write(_escape_cdata_c14n(data))

    def start_ns(self, prefix, uri):
        if self._ignored_depth:
            return
        # we may have to resolve qnames in text content
        if self._data:
            self._flush()
        self._ns_stack[-1].append((uri, prefix))

    def start(self, tag, attrs):
        if self._exclude_tags is not None and (
                self._ignored_depth or tag in self._exclude_tags):
            self._ignored_depth += 1
            return
        if self._data:
            self._flush()

        new_namespaces = []
        self._declared_ns_stack.append(new_namespaces)

        if self._qname_aware_tags is not None and tag in self._qname_aware_tags:
            # Need to parse text first to see if it requires a prefix declaration.
            self._pending_start = (tag, attrs, new_namespaces)
            return
        self._start(tag, attrs, new_namespaces)

    def _start(self, tag, attrs, new_namespaces, qname_text=None):
        if self._exclude_attrs is not None and attrs:
            attrs = {k: v for k, v in attrs.items() if k not in self._exclude_attrs}

        qnames = {tag, *attrs}
        resolved_names = {}

        # Resolve prefixes in attribute and tag text.
        if qname_text is not None:
            qname = resolved_names[qname_text] = self._resolve_prefix_name(qname_text)
            qnames.add(qname)
        if self._find_qname_aware_attrs is not None and attrs:
            qattrs = self._find_qname_aware_attrs(attrs)
            if qattrs:
                for attr_name in qattrs:
                    value = attrs[attr_name]
                    if _looks_like_prefix_name(value):
                        qname = resolved_names[value] = self._resolve_prefix_name(value)
                        qnames.add(qname)
            else:
                qattrs = None
        else:
            qattrs = None

        # Assign prefixes in lexicographical order of used URIs.
        parse_qname = self._qname
        parsed_qnames = {n: parse_qname(n) for n in sorted(
            qnames, key=lambda n: n.split('}', 1))}

        # Write namespace declarations in prefix order ...
        if new_namespaces:
            attr_list = [
                ('xmlns:' + prefix if prefix else 'xmlns', uri)
                for uri, prefix in new_namespaces
            ]
            attr_list.sort()
        else:
            # almost always empty
            attr_list = []

        # ... followed by attributes in URI+name order
        if attrs:
            for k, v in sorted(attrs.items()):
                if qattrs is not None and k in qattrs and v in resolved_names:
                    v = parsed_qnames[resolved_names[v]][0]
                attr_qname, attr_name, uri = parsed_qnames[k]
                # No prefix for attributes in default ('') namespace.
                attr_list.append((attr_qname if uri else attr_name, v))

        # Honour xml:space attributes.
        space_behaviour = attrs.get('{http://www.w3.org/XML/1998/namespace}space')
        self._preserve_space.append(
            space_behaviour == 'preserve' if space_behaviour
            else self._preserve_space[-1])

        # Write the tag.
        write = self._write
        write('<' + parsed_qnames[tag][0])
        if attr_list:
            write(''.join([f' {k}="{_escape_attrib_c14n(v)}"' for k, v in attr_list]))
        write('>')

        # Write the resolved qname text content.
        if qname_text is not None:
            write(_escape_cdata_c14n(parsed_qnames[resolved_names[qname_text]][0]))

        self._root_seen = True
        self._ns_stack.append([])

    def end(self, tag):
        if self._ignored_depth:
            self._ignored_depth -= 1
            return
        if self._data:
            self._flush()
        self._write(f'</{self._qname(tag)[0]}>')
        self._preserve_space.pop()
        self._root_done = len(self._preserve_space) == 1
        self._declared_ns_stack.pop()
        self._ns_stack.pop()

    def comment(self, text):
        if not self._with_comments:
            return
        if self._ignored_depth:
            return
        if self._root_done:
            self._write('\n')
        elif self._root_seen and self._data:
            self._flush()
        self._write(f'<!--{_escape_cdata_c14n(text)}-->')
        if not self._root_seen:
            self._write('\n')

    def pi(self, target, data):
        if self._ignored_depth:
            return
        if self._root_done:
            self._write('\n')
        elif self._root_seen and self._data:
            self._flush()
        self._write(
            f'<?{target} {_escape_cdata_c14n(data)}?>' if data else f'<?{target}?>')
        if not self._root_seen:
            self._write('\n')


def _escape_cdata_c14n(text):
    # escape character data
    try:
        # it's worth avoiding do-nothing calls for strings that are
        # shorter than 500 character, or so.  assume that's, by far,
        # the most common case in most applications.
        if '&' in text:
            text = text.replace('&', '&amp;')
        if '<' in text:
            text = text.replace('<', '&lt;')
        if '>' in text:
            text = text.replace('>', '&gt;')
        if '\r' in text:
            text = text.replace('\r', '&#xD;')
        return text
    except (TypeError, AttributeError):
        _raise_serialization_error(text)


def _escape_attrib_c14n(text):
    # escape attribute value
    try:
        if '&' in text:
            text = text.replace('&', '&amp;')
        if '<' in text:
            text = text.replace('<', '&lt;')
        if '"' in text:
            text = text.replace('"', '&quot;')
        if '\t' in text:
            text = text.replace('\t', '&#x9;')
        if '\n' in text:
            text = text.replace('\n', '&#xA;')
        if '\r' in text:
            text = text.replace('\r', '&#xD;')
        return text
    except (TypeError, AttributeError):
        _raise_serialization_error(text)


# --------------------------------------------------------------------

# Import the C accelerators
try:
    # Element is going to be shadowed by the C implementation. We need to keep
    # the Python version of it accessible for some "creative" by external code
    # (see tests)
    _Element_Py = Element

    # Element, SubElement, ParseError, TreeBuilder, XMLParser, _set_factories
    from _elementtree import *
    from _elementtree import _set_factories
except ImportError:
    pass
else:
    _set_factories(Comment, ProcessingInstruction)
# Deprecated alias for xml.etree.ElementTree

from xml.etree.ElementTree import *
U

e5d-οΏ½@sddddgZdS)ZdomZparsersZsaxZetreeN)οΏ½__all__οΏ½rrοΏ½$/usr/lib64/python3.8/xml/__init__.pyοΏ½<module>οΏ½U

e5d-οΏ½@sdZddddgZdS)aοΏ½Core XML support for Python.

This package contains four sub-packages:

dom -- The W3C Document Object Model.  This supports DOM Level 1 +
       Namespaces.

parsers -- Python wrappers for XML parsers (currently only supports Expat).

sax -- The Simple API for XML, developed by XML-Dev, led by David
       Megginson and ported to Python by Lars Marius Garshol.  This
       supports the SAX 2 API.

etree -- The ElementTree XML library.  This is a subset of the full
       ElementTree XML release.

ZdomZparsersZsaxZetreeN)οΏ½__doc__οΏ½__all__οΏ½rrοΏ½$/usr/lib64/python3.8/xml/__init__.pyοΏ½<module>sU

e5d-οΏ½@sdZddddgZdS)aοΏ½Core XML support for Python.

This package contains four sub-packages:

dom -- The W3C Document Object Model.  This supports DOM Level 1 +
       Namespaces.

parsers -- Python wrappers for XML parsers (currently only supports Expat).

sax -- The Simple API for XML, developed by XML-Dev, led by David
       Megginson and ported to Python by Lars Marius Garshol.  This
       supports the SAX 2 API.

etree -- The ElementTree XML library.  This is a subset of the full
       ElementTree XML release.

ZdomZparsersZsaxZetreeN)οΏ½__doc__οΏ½__all__οΏ½rrοΏ½$/usr/lib64/python3.8/xml/__init__.pyοΏ½<module>s"""Core XML support for Python.

This package contains four sub-packages:

dom -- The W3C Document Object Model.  This supports DOM Level 1 +
       Namespaces.

parsers -- Python wrappers for XML parsers (currently only supports Expat).

sax -- The Simple API for XML, developed by XML-Dev, led by David
       Megginson and ported to Python by Lars Marius Garshol.  This
       supports the SAX 2 API.

etree -- The ElementTree XML library.  This is a subset of the full
       ElementTree XML release.

"""


__all__ = ["dom", "parsers", "sax", "etree"]
"""An XML Reader is the SAX 2 name for an XML parser. XML Parsers
should be based on this code. """

from . import handler

from ._exceptions import SAXNotSupportedException, SAXNotRecognizedException


# ===== XMLREADER =====

class XMLReader:
    """Interface for reading an XML document using callbacks.

    XMLReader is the interface that an XML parser's SAX2 driver must
    implement. This interface allows an application to set and query
    features and properties in the parser, to register event handlers
    for document processing, and to initiate a document parse.

    All SAX interfaces are assumed to be synchronous: the parse
    methods must not return until parsing is complete, and readers
    must wait for an event-handler callback to return before reporting
    the next event."""

    def __init__(self):
        self._cont_handler = handler.ContentHandler()
        self._dtd_handler = handler.DTDHandler()
        self._ent_handler = handler.EntityResolver()
        self._err_handler = handler.ErrorHandler()

    def parse(self, source):
        "Parse an XML document from a system identifier or an InputSource."
        raise NotImplementedError("This method must be implemented!")

    def getContentHandler(self):
        "Returns the current ContentHandler."
        return self._cont_handler

    def setContentHandler(self, handler):
        "Registers a new object to receive document content events."
        self._cont_handler = handler

    def getDTDHandler(self):
        "Returns the current DTD handler."
        return self._dtd_handler

    def setDTDHandler(self, handler):
        "Register an object to receive basic DTD-related events."
        self._dtd_handler = handler

    def getEntityResolver(self):
        "Returns the current EntityResolver."
        return self._ent_handler

    def setEntityResolver(self, resolver):
        "Register an object to resolve external entities."
        self._ent_handler = resolver

    def getErrorHandler(self):
        "Returns the current ErrorHandler."
        return self._err_handler

    def setErrorHandler(self, handler):
        "Register an object to receive error-message events."
        self._err_handler = handler

    def setLocale(self, locale):
        """Allow an application to set the locale for errors and warnings.

        SAX parsers are not required to provide localization for errors
        and warnings; if they cannot support the requested locale,
        however, they must raise a SAX exception. Applications may
        request a locale change in the middle of a parse."""
        raise SAXNotSupportedException("Locale support not implemented")

    def getFeature(self, name):
        "Looks up and returns the state of a SAX2 feature."
        raise SAXNotRecognizedException("Feature '%s' not recognized" % name)

    def setFeature(self, name, state):
        "Sets the state of a SAX2 feature."
        raise SAXNotRecognizedException("Feature '%s' not recognized" % name)

    def getProperty(self, name):
        "Looks up and returns the value of a SAX2 property."
        raise SAXNotRecognizedException("Property '%s' not recognized" % name)

    def setProperty(self, name, value):
        "Sets the value of a SAX2 property."
        raise SAXNotRecognizedException("Property '%s' not recognized" % name)

class IncrementalParser(XMLReader):
    """This interface adds three extra methods to the XMLReader
    interface that allow XML parsers to support incremental
    parsing. Support for this interface is optional, since not all
    underlying XML parsers support this functionality.

    When the parser is instantiated it is ready to begin accepting
    data from the feed method immediately. After parsing has been
    finished with a call to close the reset method must be called to
    make the parser ready to accept new data, either from feed or
    using the parse method.

    Note that these methods must _not_ be called during parsing, that
    is, after parse has been called and before it returns.

    By default, the class also implements the parse method of the XMLReader
    interface using the feed, close and reset methods of the
    IncrementalParser interface as a convenience to SAX 2.0 driver
    writers."""

    def __init__(self, bufsize=2**16):
        self._bufsize = bufsize
        XMLReader.__init__(self)

    def parse(self, source):
        from . import saxutils
        source = saxutils.prepare_input_source(source)

        self.prepareParser(source)
        file = source.getCharacterStream()
        if file is None:
            file = source.getByteStream()
        buffer = file.read(self._bufsize)
        while buffer:
            self.feed(buffer)
            buffer = file.read(self._bufsize)
        self.close()

    def feed(self, data):
        """This method gives the raw XML data in the data parameter to
        the parser and makes it parse the data, emitting the
        corresponding events. It is allowed for XML constructs to be
        split across several calls to feed.

        feed may raise SAXException."""
        raise NotImplementedError("This method must be implemented!")

    def prepareParser(self, source):
        """This method is called by the parse implementation to allow
        the SAX 2.0 driver to prepare itself for parsing."""
        raise NotImplementedError("prepareParser must be overridden!")

    def close(self):
        """This method is called when the entire XML document has been
        passed to the parser through the feed method, to notify the
        parser that there are no more data. This allows the parser to
        do the final checks on the document and empty the internal
        data buffer.

        The parser will not be ready to parse another document until
        the reset method has been called.

        close may raise SAXException."""
        raise NotImplementedError("This method must be implemented!")

    def reset(self):
        """This method is called after close has been called to reset
        the parser so that it is ready to parse new documents. The
        results of calling parse or feed after close without calling
        reset are undefined."""
        raise NotImplementedError("This method must be implemented!")

# ===== LOCATOR =====

class Locator:
    """Interface for associating a SAX event with a document
    location. A locator object will return valid results only during
    calls to DocumentHandler methods; at any other time, the
    results are unpredictable."""

    def getColumnNumber(self):
        "Return the column number where the current event ends."
        return -1

    def getLineNumber(self):
        "Return the line number where the current event ends."
        return -1

    def getPublicId(self):
        "Return the public identifier for the current event."
        return None

    def getSystemId(self):
        "Return the system identifier for the current event."
        return None

# ===== INPUTSOURCE =====

class InputSource:
    """Encapsulation of the information needed by the XMLReader to
    read entities.

    This class may include information about the public identifier,
    system identifier, byte stream (possibly with character encoding
    information) and/or the character stream of an entity.

    Applications will create objects of this class for use in the
    XMLReader.parse method and for returning from
    EntityResolver.resolveEntity.

    An InputSource belongs to the application, the XMLReader is not
    allowed to modify InputSource objects passed to it from the
    application, although it may make copies and modify those."""

    def __init__(self, system_id = None):
        self.__system_id = system_id
        self.__public_id = None
        self.__encoding  = None
        self.__bytefile  = None
        self.__charfile  = None

    def setPublicId(self, public_id):
        "Sets the public identifier of this InputSource."
        self.__public_id = public_id

    def getPublicId(self):
        "Returns the public identifier of this InputSource."
        return self.__public_id

    def setSystemId(self, system_id):
        "Sets the system identifier of this InputSource."
        self.__system_id = system_id

    def getSystemId(self):
        "Returns the system identifier of this InputSource."
        return self.__system_id

    def setEncoding(self, encoding):
        """Sets the character encoding of this InputSource.

        The encoding must be a string acceptable for an XML encoding
        declaration (see section 4.3.3 of the XML recommendation).

        The encoding attribute of the InputSource is ignored if the
        InputSource also contains a character stream."""
        self.__encoding = encoding

    def getEncoding(self):
        "Get the character encoding of this InputSource."
        return self.__encoding

    def setByteStream(self, bytefile):
        """Set the byte stream (a Python file-like object which does
        not perform byte-to-character conversion) for this input
        source.

        The SAX parser will ignore this if there is also a character
        stream specified, but it will use a byte stream in preference
        to opening a URI connection itself.

        If the application knows the character encoding of the byte
        stream, it should set it with the setEncoding method."""
        self.__bytefile = bytefile

    def getByteStream(self):
        """Get the byte stream for this input source.

        The getEncoding method will return the character encoding for
        this byte stream, or None if unknown."""
        return self.__bytefile

    def setCharacterStream(self, charfile):
        """Set the character stream for this input source. (The stream
        must be a Python 2.0 Unicode-wrapped file-like that performs
        conversion to Unicode strings.)

        If there is a character stream specified, the SAX parser will
        ignore any byte stream and will not attempt to open a URI
        connection to the system identifier."""
        self.__charfile = charfile

    def getCharacterStream(self):
        "Get the character stream for this input source."
        return self.__charfile

# ===== ATTRIBUTESIMPL =====

class AttributesImpl:

    def __init__(self, attrs):
        """Non-NS-aware implementation.

        attrs should be of the form {name : value}."""
        self._attrs = attrs

    def getLength(self):
        return len(self._attrs)

    def getType(self, name):
        return "CDATA"

    def getValue(self, name):
        return self._attrs[name]

    def getValueByQName(self, name):
        return self._attrs[name]

    def getNameByQName(self, name):
        if name not in self._attrs:
            raise KeyError(name)
        return name

    def getQNameByName(self, name):
        if name not in self._attrs:
            raise KeyError(name)
        return name

    def getNames(self):
        return list(self._attrs.keys())

    def getQNames(self):
        return list(self._attrs.keys())

    def __len__(self):
        return len(self._attrs)

    def __getitem__(self, name):
        return self._attrs[name]

    def keys(self):
        return list(self._attrs.keys())

    def __contains__(self, name):
        return name in self._attrs

    def get(self, name, alternative=None):
        return self._attrs.get(name, alternative)

    def copy(self):
        return self.__class__(self._attrs)

    def items(self):
        return list(self._attrs.items())

    def values(self):
        return list(self._attrs.values())

# ===== ATTRIBUTESNSIMPL =====

class AttributesNSImpl(AttributesImpl):

    def __init__(self, attrs, qnames):
        """NS-aware implementation.

        attrs should be of the form {(ns_uri, lname): value, ...}.
        qnames of the form {(ns_uri, lname): qname, ...}."""
        self._attrs = attrs
        self._qnames = qnames

    def getValueByQName(self, name):
        for (nsname, qname) in self._qnames.items():
            if qname == name:
                return self._attrs[nsname]

        raise KeyError(name)

    def getNameByQName(self, name):
        for (nsname, qname) in self._qnames.items():
            if qname == name:
                return nsname

        raise KeyError(name)

    def getQNameByName(self, name):
        return self._qnames[name]

    def getQNames(self):
        return list(self._qnames.values())

    def copy(self):
        return self.__class__(self._attrs, self._qnames)


def _test():
    XMLReader()
    IncrementalParser()
    Locator()

if __name__ == "__main__":
    _test()
"""\
A library of useful helper classes to the SAX classes, for the
convenience of application and driver writers.
"""

import os, urllib.parse, urllib.request
import io
import codecs
from . import handler
from . import xmlreader

def __dict_replace(s, d):
    """Replace substrings of a string using a dictionary."""
    for key, value in d.items():
        s = s.replace(key, value)
    return s

def escape(data, entities={}):
    """Escape &, <, and > in a string of data.

    You can escape other strings of data by passing a dictionary as
    the optional entities parameter.  The keys and values must all be
    strings; each key will be replaced with its corresponding value.
    """

    # must do ampersand first
    data = data.replace("&", "&amp;")
    data = data.replace(">", "&gt;")
    data = data.replace("<", "&lt;")
    if entities:
        data = __dict_replace(data, entities)
    return data

def unescape(data, entities={}):
    """Unescape &amp;, &lt;, and &gt; in a string of data.

    You can unescape other strings of data by passing a dictionary as
    the optional entities parameter.  The keys and values must all be
    strings; each key will be replaced with its corresponding value.
    """
    data = data.replace("&lt;", "<")
    data = data.replace("&gt;", ">")
    if entities:
        data = __dict_replace(data, entities)
    # must do ampersand last
    return data.replace("&amp;", "&")

def quoteattr(data, entities={}):
    """Escape and quote an attribute value.

    Escape &, <, and > in a string of data, then quote it for use as
    an attribute value.  The \" character will be escaped as well, if
    necessary.

    You can escape other strings of data by passing a dictionary as
    the optional entities parameter.  The keys and values must all be
    strings; each key will be replaced with its corresponding value.
    """
    entities = {**entities, '\n': '&#10;', '\r': '&#13;', '\t':'&#9;'}
    data = escape(data, entities)
    if '"' in data:
        if "'" in data:
            data = '"%s"' % data.replace('"', "&quot;")
        else:
            data = "'%s'" % data
    else:
        data = '"%s"' % data
    return data


def _gettextwriter(out, encoding):
    if out is None:
        import sys
        return sys.stdout

    if isinstance(out, io.TextIOBase):
        # use a text writer as is
        return out

    if isinstance(out, (codecs.StreamWriter, codecs.StreamReaderWriter)):
        # use a codecs stream writer as is
        return out

    # wrap a binary writer with TextIOWrapper
    if isinstance(out, io.RawIOBase):
        # Keep the original file open when the TextIOWrapper is
        # destroyed
        class _wrapper:
            __class__ = out.__class__
            def __getattr__(self, name):
                return getattr(out, name)
        buffer = _wrapper()
        buffer.close = lambda: None
    else:
        # This is to handle passed objects that aren't in the
        # IOBase hierarchy, but just have a write method
        buffer = io.BufferedIOBase()
        buffer.writable = lambda: True
        buffer.write = out.write
        try:
            # TextIOWrapper uses this methods to determine
            # if BOM (for UTF-16, etc) should be added
            buffer.seekable = out.seekable
            buffer.tell = out.tell
        except AttributeError:
            pass
    return io.TextIOWrapper(buffer, encoding=encoding,
                            errors='xmlcharrefreplace',
                            newline='\n',
                            write_through=True)

class XMLGenerator(handler.ContentHandler):

    def __init__(self, out=None, encoding="iso-8859-1", short_empty_elements=False):
        handler.ContentHandler.__init__(self)
        out = _gettextwriter(out, encoding)
        self._write = out.write
        self._flush = out.flush
        self._ns_contexts = [{}] # contains uri -> prefix dicts
        self._current_context = self._ns_contexts[-1]
        self._undeclared_ns_maps = []
        self._encoding = encoding
        self._short_empty_elements = short_empty_elements
        self._pending_start_element = False

    def _qname(self, name):
        """Builds a qualified name from a (ns_url, localname) pair"""
        if name[0]:
            # Per http://www.w3.org/XML/1998/namespace, The 'xml' prefix is
            # bound by definition to http://www.w3.org/XML/1998/namespace.  It
            # does not need to be declared and will not usually be found in
            # self._current_context.
            if 'http://www.w3.org/XML/1998/namespace' == name[0]:
                return 'xml:' + name[1]
            # The name is in a non-empty namespace
            prefix = self._current_context[name[0]]
            if prefix:
                # If it is not the default namespace, prepend the prefix
                return prefix + ":" + name[1]
        # Return the unqualified name
        return name[1]

    def _finish_pending_start_element(self,endElement=False):
        if self._pending_start_element:
            self._write('>')
            self._pending_start_element = False

    # ContentHandler methods

    def startDocument(self):
        self._write('<?xml version="1.0" encoding="%s"?>\n' %
                        self._encoding)

    def endDocument(self):
        self._flush()

    def startPrefixMapping(self, prefix, uri):
        self._ns_contexts.append(self._current_context.copy())
        self._current_context[uri] = prefix
        self._undeclared_ns_maps.append((prefix, uri))

    def endPrefixMapping(self, prefix):
        self._current_context = self._ns_contexts[-1]
        del self._ns_contexts[-1]

    def startElement(self, name, attrs):
        self._finish_pending_start_element()
        self._write('<' + name)
        for (name, value) in attrs.items():
            self._write(' %s=%s' % (name, quoteattr(value)))
        if self._short_empty_elements:
            self._pending_start_element = True
        else:
            self._write(">")

    def endElement(self, name):
        if self._pending_start_element:
            self._write('/>')
            self._pending_start_element = False
        else:
            self._write('</%s>' % name)

    def startElementNS(self, name, qname, attrs):
        self._finish_pending_start_element()
        self._write('<' + self._qname(name))

        for prefix, uri in self._undeclared_ns_maps:
            if prefix:
                self._write(' xmlns:%s="%s"' % (prefix, uri))
            else:
                self._write(' xmlns="%s"' % uri)
        self._undeclared_ns_maps = []

        for (name, value) in attrs.items():
            self._write(' %s=%s' % (self._qname(name), quoteattr(value)))
        if self._short_empty_elements:
            self._pending_start_element = True
        else:
            self._write(">")

    def endElementNS(self, name, qname):
        if self._pending_start_element:
            self._write('/>')
            self._pending_start_element = False
        else:
            self._write('</%s>' % self._qname(name))

    def characters(self, content):
        if content:
            self._finish_pending_start_element()
            if not isinstance(content, str):
                content = str(content, self._encoding)
            self._write(escape(content))

    def ignorableWhitespace(self, content):
        if content:
            self._finish_pending_start_element()
            if not isinstance(content, str):
                content = str(content, self._encoding)
            self._write(content)

    def processingInstruction(self, target, data):
        self._finish_pending_start_element()
        self._write('<?%s %s?>' % (target, data))


class XMLFilterBase(xmlreader.XMLReader):
    """This class is designed to sit between an XMLReader and the
    client application's event handlers.  By default, it does nothing
    but pass requests up to the reader and events on to the handlers
    unmodified, but subclasses can override specific methods to modify
    the event stream or the configuration requests as they pass
    through."""

    def __init__(self, parent = None):
        xmlreader.XMLReader.__init__(self)
        self._parent = parent

    # ErrorHandler methods

    def error(self, exception):
        self._err_handler.error(exception)

    def fatalError(self, exception):
        self._err_handler.fatalError(exception)

    def warning(self, exception):
        self._err_handler.warning(exception)

    # ContentHandler methods

    def setDocumentLocator(self, locator):
        self._cont_handler.setDocumentLocator(locator)

    def startDocument(self):
        self._cont_handler.startDocument()

    def endDocument(self):
        self._cont_handler.endDocument()

    def startPrefixMapping(self, prefix, uri):
        self._cont_handler.startPrefixMapping(prefix, uri)

    def endPrefixMapping(self, prefix):
        self._cont_handler.endPrefixMapping(prefix)

    def startElement(self, name, attrs):
        self._cont_handler.startElement(name, attrs)

    def endElement(self, name):
        self._cont_handler.endElement(name)

    def startElementNS(self, name, qname, attrs):
        self._cont_handler.startElementNS(name, qname, attrs)

    def endElementNS(self, name, qname):
        self._cont_handler.endElementNS(name, qname)

    def characters(self, content):
        self._cont_handler.characters(content)

    def ignorableWhitespace(self, chars):
        self._cont_handler.ignorableWhitespace(chars)

    def processingInstruction(self, target, data):
        self._cont_handler.processingInstruction(target, data)

    def skippedEntity(self, name):
        self._cont_handler.skippedEntity(name)

    # DTDHandler methods

    def notationDecl(self, name, publicId, systemId):
        self._dtd_handler.notationDecl(name, publicId, systemId)

    def unparsedEntityDecl(self, name, publicId, systemId, ndata):
        self._dtd_handler.unparsedEntityDecl(name, publicId, systemId, ndata)

    # EntityResolver methods

    def resolveEntity(self, publicId, systemId):
        return self._ent_handler.resolveEntity(publicId, systemId)

    # XMLReader methods

    def parse(self, source):
        self._parent.setContentHandler(self)
        self._parent.setErrorHandler(self)
        self._parent.setEntityResolver(self)
        self._parent.setDTDHandler(self)
        self._parent.parse(source)

    def setLocale(self, locale):
        self._parent.setLocale(locale)

    def getFeature(self, name):
        return self._parent.getFeature(name)

    def setFeature(self, name, state):
        self._parent.setFeature(name, state)

    def getProperty(self, name):
        return self._parent.getProperty(name)

    def setProperty(self, name, value):
        self._parent.setProperty(name, value)

    # XMLFilter methods

    def getParent(self):
        return self._parent

    def setParent(self, parent):
        self._parent = parent

# --- Utility functions

def prepare_input_source(source, base=""):
    """This function takes an InputSource and an optional base URL and
    returns a fully resolved InputSource object ready for reading."""

    if isinstance(source, os.PathLike):
        source = os.fspath(source)
    if isinstance(source, str):
        source = xmlreader.InputSource(source)
    elif hasattr(source, "read"):
        f = source
        source = xmlreader.InputSource()
        if isinstance(f.read(0), str):
            source.setCharacterStream(f)
        else:
            source.setByteStream(f)
        if hasattr(f, "name") and isinstance(f.name, str):
            source.setSystemId(f.name)

    if source.getCharacterStream() is None and source.getByteStream() is None:
        sysid = source.getSystemId()
        basehead = os.path.dirname(os.path.normpath(base))
        sysidfilename = os.path.join(basehead, sysid)
        if os.path.isfile(sysidfilename):
            source.setSystemId(sysidfilename)
            f = open(sysidfilename, "rb")
        else:
            source.setSystemId(urllib.parse.urljoin(base, sysid))
            f = urllib.request.urlopen(source.getSystemId())

        source.setByteStream(f)

    return source
U

e5dοΏ½/οΏ½@sοΏ½dZddlZddlZddlZddlZddlZddlmZddlm	Z	ddοΏ½Z
ifdd	οΏ½Zifd
dοΏ½Zifdd
οΏ½Z
ddοΏ½ZGddοΏ½dejοΏ½ZGddοΏ½de	jοΏ½ZdddοΏ½ZdS)znA library of useful helper classes to the SAX classes, for the
convenience of application and driver writers.
οΏ½NοΏ½)οΏ½handler)οΏ½	xmlreadercCs"|οΏ½οΏ½D]\}}|οΏ½||οΏ½}q|S)z2Replace substrings of a string using a dictionary.)οΏ½itemsοΏ½replace)οΏ½sοΏ½dοΏ½keyοΏ½valueοΏ½rοΏ½(/usr/lib64/python3.8/xml/sax/saxutils.pyοΏ½__dict_replacesr
cCs6|οΏ½ddοΏ½}|οΏ½ddοΏ½}|οΏ½ddοΏ½}|r2t||οΏ½}|S)zοΏ½Escape &, <, and > in a string of data.

    You can escape other strings of data by passing a dictionary as
    the optional entities parameter.  The keys and values must all be
    strings; each key will be replaced with its corresponding value.
    οΏ½&οΏ½&amp;οΏ½>οΏ½&gt;οΏ½<οΏ½&lt;οΏ½rr
οΏ½οΏ½dataZentitiesrrrοΏ½escapes	
rcCs2|οΏ½ddοΏ½}|οΏ½ddοΏ½}|r&t||οΏ½}|οΏ½ddοΏ½S)a
Unescape &amp;, &lt;, and &gt; in a string of data.

    You can unescape other strings of data by passing a dictionary as
    the optional entities parameter.  The keys and values must all be
    strings; each key will be replaced with its corresponding value.
    rrrrrrrrrrrοΏ½unescape"s

rcCsR|ddddοΏ½οΏ½}t||οΏ½}d|krFd|kr<d|οΏ½ddοΏ½}qNd	|}nd|}|S)
aοΏ½Escape and quote an attribute value.

    Escape &, <, and > in a string of data, then quote it for use as
    an attribute value.  The " character will be escaped as well, if
    necessary.

    You can escape other strings of data by passing a dictionary as
    the optional entities parameter.  The keys and values must all be
    strings; each key will be replaced with its corresponding value.
    z&#10;z&#13;z&#9;)οΏ½
οΏ½
οΏ½	οΏ½"οΏ½'z"%s"z&quot;z'%s')rrrrrrοΏ½	quoteattr0s

rcsοΏ½οΏ½dkrddl}|jStοΏ½tjοΏ½r&οΏ½StοΏ½tjtjfοΏ½r<οΏ½StοΏ½tjοΏ½rlGοΏ½fddοΏ½dοΏ½}|οΏ½}ddοΏ½|_	nDtοΏ½
οΏ½}ddοΏ½|_οΏ½j|_zοΏ½j
|_
οΏ½j|_Wntk
rοΏ½YnXtj||ddd	d
οΏ½S)NrcseZdZοΏ½jZοΏ½fddοΏ½ZdS)z _gettextwriter.<locals>._wrappercs
tοΏ½|οΏ½SοΏ½N)οΏ½getattrοΏ½οΏ½selfοΏ½nameοΏ½οΏ½outrrοΏ½__getattr__Zsz,_gettextwriter.<locals>._wrapper.__getattr__N)οΏ½__name__οΏ½
__module__οΏ½__qualname__οΏ½	__class__r&rr$rrοΏ½_wrapperXsr+cSsdSrrrrrrοΏ½<lambda>]οΏ½z _gettextwriter.<locals>.<lambda>cSsdS)NTrrrrrr,br-οΏ½xmlcharrefreplacerT)οΏ½encodingοΏ½errorsοΏ½newlineοΏ½
write_through)οΏ½sysοΏ½stdoutοΏ½
isinstanceοΏ½ioοΏ½
TextIOBaseοΏ½codecsοΏ½StreamWriterοΏ½StreamReaderWriterοΏ½	RawIOBaseοΏ½closeοΏ½BufferedIOBaseοΏ½writableοΏ½writeοΏ½seekableοΏ½tellοΏ½AttributeErrorοΏ½
TextIOWrapper)r%r/r3r+οΏ½bufferrr$rοΏ½_gettextwriterGs0
οΏ½rEc@sοΏ½eZdZd ddοΏ½ZddοΏ½Zd!dd	οΏ½Zd
dοΏ½Zdd
οΏ½ZddοΏ½ZddοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZdS)"οΏ½XMLGeneratorNοΏ½
iso-8859-1FcCsVtjοΏ½|οΏ½t||οΏ½}|j|_|j|_ig|_|jd|_	g|_
||_||_d|_
dS)NοΏ½οΏ½οΏ½F)rοΏ½ContentHandlerοΏ½__init__rEr?οΏ½_writeοΏ½flushοΏ½_flushοΏ½_ns_contextsοΏ½_current_contextοΏ½_undeclared_ns_mapsοΏ½	_encodingοΏ½_short_empty_elementsοΏ½_pending_start_element)r"r%r/Zshort_empty_elementsrrrrJrs
zXMLGenerator.__init__cCsJ|drBd|dkr d|dS|j|d}|rB|d|dS|dS)z7Builds a qualified name from a (ns_url, localname) pairrz$http://www.w3.org/XML/1998/namespacezxml:rοΏ½:)rO)r"r#οΏ½prefixrrrοΏ½_qname~szXMLGenerator._qnamecCs|jr|οΏ½dοΏ½d|_dS)NrFοΏ½rSrK)r"οΏ½
endElementrrrοΏ½_finish_pending_start_elementοΏ½s
z*XMLGenerator._finish_pending_start_elementcCs|οΏ½d|jοΏ½dS)Nz$<?xml version="1.0" encoding="%s"?>
)rKrQοΏ½r"rrrοΏ½
startDocumentοΏ½sοΏ½zXMLGenerator.startDocumentcCs|οΏ½οΏ½dSr)rMrZrrrοΏ½endDocumentοΏ½szXMLGenerator.endDocumentcCs0|jοΏ½|jοΏ½οΏ½οΏ½||j|<|jοΏ½||fοΏ½dSr)rNοΏ½appendrOοΏ½copyrPοΏ½r"rUοΏ½urirrrοΏ½startPrefixMappingοΏ½s
zXMLGenerator.startPrefixMappingcCs|jd|_|jd=dS)NrH)rNrOοΏ½r"rUrrrοΏ½endPrefixMappingοΏ½szXMLGenerator.endPrefixMappingcCsZ|οΏ½οΏ½|οΏ½d|οΏ½|οΏ½οΏ½D]\}}|οΏ½d|t|οΏ½fοΏ½q|jrLd|_n
|οΏ½dοΏ½dS)NrοΏ½ %s=%sTr)rYrKrrrRrS)r"r#οΏ½attrsr
rrrοΏ½startElementοΏ½szXMLGenerator.startElementcCs*|jr|οΏ½dοΏ½d|_n|οΏ½d|οΏ½dSοΏ½Nz/>Fz</%s>rWr!rrrrXοΏ½s
zXMLGenerator.endElementcCsοΏ½|οΏ½οΏ½|οΏ½d|οΏ½|οΏ½οΏ½|jD].\}}|rB|οΏ½d||fοΏ½q"|οΏ½d|οΏ½q"g|_|οΏ½οΏ½D]$\}}|οΏ½d|οΏ½|οΏ½t|οΏ½fοΏ½q`|jrοΏ½d|_n
|οΏ½dοΏ½dS)Nrz xmlns:%s="%s"z xmlns="%s"rdTr)rYrKrVrPrrrRrS)r"r#οΏ½qnamererUr`r
rrrοΏ½startElementNSοΏ½szXMLGenerator.startElementNScCs0|jr|οΏ½dοΏ½d|_n|οΏ½d|οΏ½|οΏ½οΏ½dSrg)rSrKrVοΏ½r"r#rhrrrοΏ½endElementNSοΏ½s
zXMLGenerator.endElementNScCs4|r0|οΏ½οΏ½t|tοΏ½s"t||jοΏ½}|οΏ½t|οΏ½οΏ½dSr)rYr5οΏ½strrQrKrοΏ½r"ZcontentrrrοΏ½
charactersοΏ½s

zXMLGenerator.characterscCs0|r,|οΏ½οΏ½t|tοΏ½s"t||jοΏ½}|οΏ½|οΏ½dSr)rYr5rlrQrKrmrrrοΏ½ignorableWhitespaceοΏ½s

z XMLGenerator.ignorableWhitespacecCs|οΏ½οΏ½|οΏ½d||fοΏ½dS)Nz	<?%s %s?>)rYrKοΏ½r"οΏ½targetrrrrοΏ½processingInstructionοΏ½sz"XMLGenerator.processingInstruction)NrGF)F)r'r(r)rJrVrYr[r\rarcrfrXrirkrnrorrrrrrrFps


rFc@sοΏ½eZdZdZd;ddοΏ½ZddοΏ½ZddοΏ½Zd	d
οΏ½ZddοΏ½Zd
dοΏ½Z	ddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½Z
ddοΏ½ZddοΏ½ZddοΏ½ZddοΏ½Zdd οΏ½Zd!d"οΏ½Zd#d$οΏ½Zd%d&οΏ½Zd'd(οΏ½Zd)d*οΏ½Zd+d,οΏ½Zd-d.οΏ½Zd/d0οΏ½Zd1d2οΏ½Zd3d4οΏ½Zd5d6οΏ½Zd7d8οΏ½Zd9d:οΏ½ZdS)<οΏ½
XMLFilterBaseaYThis class is designed to sit between an XMLReader and the
    client application's event handlers.  By default, it does nothing
    but pass requests up to the reader and events on to the handlers
    unmodified, but subclasses can override specific methods to modify
    the event stream or the configuration requests as they pass
    through.NcCstjοΏ½|οΏ½||_dSr)rοΏ½	XMLReaderrJοΏ½_parentοΏ½r"οΏ½parentrrrrJοΏ½szXMLFilterBase.__init__cCs|jοΏ½|οΏ½dSr)οΏ½_err_handlerοΏ½errorοΏ½r"Z	exceptionrrrryοΏ½szXMLFilterBase.errorcCs|jοΏ½|οΏ½dSr)rxοΏ½
fatalErrorrzrrrr{οΏ½szXMLFilterBase.fatalErrorcCs|jοΏ½|οΏ½dSr)rxοΏ½warningrzrrrr|οΏ½szXMLFilterBase.warningcCs|jοΏ½|οΏ½dSr)οΏ½
_cont_handlerοΏ½setDocumentLocator)r"Zlocatorrrrr~οΏ½sz XMLFilterBase.setDocumentLocatorcCs|jοΏ½οΏ½dSr)r}r[rZrrrr[οΏ½szXMLFilterBase.startDocumentcCs|jοΏ½οΏ½dSr)r}r\rZrrrr\szXMLFilterBase.endDocumentcCs|jοΏ½||οΏ½dSr)r}rar_rrrrasz XMLFilterBase.startPrefixMappingcCs|jοΏ½|οΏ½dSr)r}rcrbrrrrcszXMLFilterBase.endPrefixMappingcCs|jοΏ½||οΏ½dSr)r}rf)r"r#rerrrrfszXMLFilterBase.startElementcCs|jοΏ½|οΏ½dSr)r}rXr!rrrrXszXMLFilterBase.endElementcCs|jοΏ½|||οΏ½dSr)r}ri)r"r#rhrerrrriszXMLFilterBase.startElementNScCs|jοΏ½||οΏ½dSr)r}rkrjrrrrkszXMLFilterBase.endElementNScCs|jοΏ½|οΏ½dSr)r}rnrmrrrrnszXMLFilterBase.characterscCs|jοΏ½|οΏ½dSr)r}ro)r"οΏ½charsrrrrosz!XMLFilterBase.ignorableWhitespacecCs|jοΏ½||οΏ½dSr)r}rrrprrrrrsz#XMLFilterBase.processingInstructioncCs|jοΏ½|οΏ½dSr)r}οΏ½
skippedEntityr!rrrrοΏ½ szXMLFilterBase.skippedEntitycCs|jοΏ½|||οΏ½dSr)οΏ½_dtd_handlerοΏ½notationDecl)r"r#οΏ½publicIdοΏ½systemIdrrrrοΏ½%szXMLFilterBase.notationDeclcCs|jοΏ½||||οΏ½dSr)rοΏ½οΏ½unparsedEntityDecl)r"r#rοΏ½rοΏ½ZndatarrrrοΏ½(sz XMLFilterBase.unparsedEntityDeclcCs|jοΏ½||οΏ½Sr)Z_ent_handlerοΏ½
resolveEntity)r"rοΏ½rοΏ½rrrrοΏ½-szXMLFilterBase.resolveEntitycCs@|jοΏ½|οΏ½|jοΏ½|οΏ½|jοΏ½|οΏ½|jοΏ½|οΏ½|jοΏ½|οΏ½dSr)ruZsetContentHandlerZsetErrorHandlerZsetEntityResolverZ
setDTDHandlerοΏ½parse)r"οΏ½sourcerrrrοΏ½2s
zXMLFilterBase.parsecCs|jοΏ½|οΏ½dSr)ruοΏ½	setLocale)r"ZlocalerrrrοΏ½9szXMLFilterBase.setLocalecCs|jοΏ½|οΏ½Sr)ruοΏ½
getFeaturer!rrrrοΏ½<szXMLFilterBase.getFeaturecCs|jοΏ½||οΏ½dSr)ruοΏ½
setFeature)r"r#οΏ½staterrrrοΏ½?szXMLFilterBase.setFeaturecCs|jοΏ½|οΏ½Sr)ruοΏ½getPropertyr!rrrrοΏ½BszXMLFilterBase.getPropertycCs|jοΏ½||οΏ½dSr)ruοΏ½setProperty)r"r#r
rrrrοΏ½EszXMLFilterBase.setPropertycCs|jSrοΏ½rurZrrrοΏ½	getParentJszXMLFilterBase.getParentcCs
||_dSrrοΏ½rvrrrοΏ½	setParentMszXMLFilterBase.setParent)N) r'r(r)οΏ½__doc__rJryr{r|r~r[r\rarcrfrXrirkrnrorrrοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rοΏ½rrrrrsοΏ½s:
rsοΏ½cCs$t|tjοΏ½rtοΏ½|οΏ½}t|tοΏ½r,tοΏ½|οΏ½}n^t|dοΏ½rοΏ½|}tοΏ½οΏ½}t|οΏ½dοΏ½tοΏ½r^|οΏ½	|οΏ½n
|οΏ½
|οΏ½t|dοΏ½rοΏ½t|jtοΏ½rοΏ½|οΏ½|jοΏ½|οΏ½
οΏ½dkοΏ½r |οΏ½οΏ½dkοΏ½r |οΏ½οΏ½}tjοΏ½tjοΏ½|οΏ½οΏ½}tjοΏ½||οΏ½}tjοΏ½|οΏ½rοΏ½|οΏ½|οΏ½t|dοΏ½}n$|οΏ½tjοΏ½||οΏ½οΏ½tjοΏ½|οΏ½οΏ½οΏ½}|οΏ½
|οΏ½|S)zοΏ½This function takes an InputSource and an optional base URL and
    returns a fully resolved InputSource object ready for reading.οΏ½readrr#NοΏ½rb)r5οΏ½osοΏ½PathLikeοΏ½fspathrlrZInputSourceοΏ½hasattrrοΏ½ZsetCharacterStreamZ
setByteStreamr#ZsetSystemIdZgetCharacterStreamZ
getByteStreamZgetSystemIdοΏ½pathοΏ½dirnameοΏ½normpathοΏ½joinοΏ½isfileοΏ½openοΏ½urllibrοΏ½ZurljoinZrequestZurlopen)rοΏ½οΏ½baseοΏ½fZsysidZbaseheadZ
sysidfilenamerrrοΏ½prepare_input_sourceRs.





rοΏ½)rοΏ½)rοΏ½rοΏ½Zurllib.parserοΏ½Zurllib.requestr6r8rοΏ½rrr
rrrrErIrFrtrsrοΏ½rrrrοΏ½<module>s)so


πŸ“€ Upload File


πŸ“ Create Folder