/home/fresvfqn/waterdamagerestorationgerritsenbeach.com/xml.zip
PK0![Q
�PP.parsers/__pycache__/expat.cpython-38.opt-1.pycnu�[���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
PK0![����1parsers/__pycache__/__init__.cpython-38.opt-2.pycnu�[���U

e5d��@sdS)N�rrr�,/usr/lib64/python3.8/xml/parsers/__init__.py�<module>�PK0![Q
�PP(parsers/__pycache__/expat.cpython-38.pycnu�[���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
PK0![,t��331parsers/__pycache__/__init__.cpython-38.opt-1.pycnu�[���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>�PK0![,t��33+parsers/__pycache__/__init__.cpython-38.pycnu�[���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>�PK0![V�W�.parsers/__pycache__/expat.cpython-38.opt-2.pycnu�[���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
PK0![�v��rrparsers/expat.pynu�[���"""Interface to the Expat non-validating XML parser."""
__version__ = '$Revision: 17640 $'

from pyexpat import *
PK0![;�|���parsers/__init__.pynu�[���"""Python interfaces to XML parsers.

This package contains one module:

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

"""
PK0![�df��dom/minidom.pynu�[���"""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 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 __nonzero__(self):
        return True

    def toxml(self, encoding = None):
        return self.toprettyxml("", "", encoding)

    def toprettyxml(self, indent="\t", newl="\n", encoding = None):
        # indent = the indentation string to prepend, per level
        # newl = the newline string to append
        writer = _get_StringIO()
        if encoding is not None:
            import codecs
            # Can't use codecs.getwriter to preserve 2.0 compatibility
            writer = codecs.lookup(encoding)[3](writer)
        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)
        return writer.getvalue()

    def hasChildNodes(self):
        if self.childNodes:
            return True
        else:
            return False

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

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.__dict__["previousSibling"] = last
        last.__dict__["nextSibling"] = node
    childNodes.append(node)
    node.__dict__["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):
    nodeType = Node.ATTRIBUTE_NODE
    attributes = None
    ownerElement = 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):
        # skip setattr for performance
        d = self.__dict__
        d["nodeName"] = d["name"] = qName
        d["namespaceURI"] = namespaceURI
        d["prefix"] = prefix
        d['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):
        return self.nodeName.split(":", 1)[-1]

    def _get_specified(self):
        return self.specified

    def __setattr__(self, name, value):
        d = self.__dict__
        if name in ("value", "nodeValue"):
            d["value"] = d["nodeValue"] = value
            d2 = self.childNodes[0].__dict__
            d2["data"] = d2["nodeValue"] = value
            if self.ownerElement is not None:
                _clear_id_cache(self.ownerElement)
        elif name in ("name", "nodeName"):
            d["name"] = d["nodeName"] = value
            if self.ownerElement is not None:
                _clear_id_cache(self.ownerElement)
        else:
            d[name] = value

    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")
        d = self.__dict__
        d['prefix'] = prefix
        if prefix is None:
            newName = self.localName
        else:
            newName = "%s:%s" % (prefix, self.localName)
        if self.ownerElement:
            _clear_id_cache(self.ownerElement)
        d['nodeName'] = d['name'] = newName

    def _set_value(self, value):
        d = self.__dict__
        d['value'] = d['nodeValue'] = value
        if self.ownerElement:
            _clear_id_cache(self.ownerElement)
        self.childNodes[0].data = value

    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[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 has_key(self, key):
        if isinstance(key, StringTypes):
            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

    __hash__ = None # Mutable type can't be correctly hashed
    def __cmp__(self, other):
        if self._attrs is getattr(other, "_attrs", None):
            return 0
        else:
            return cmp(id(self), id(other))

    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, StringTypes):
            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 'ownerElement' in n.__dict__:
                n.__dict__['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 'ownerElement' in n.__dict__:
                n.__dict__['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 "<TypeInfo %r (from %r)>" % (self.name, self.namespace)
        else:
            return "<TypeInfo %r>" % self.name

    def _get_name(self):
        return self.name

    def _get_namespace(self):
        return self.namespace

_no_type = TypeInfo(None, None)

class Element(Node):
    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.tagName = self.nodeName = tagName
        self.prefix = prefix
        self.namespaceURI = namespaceURI
        self.childNodes = NodeList()

        self._attrs = {}   # attributes are double-indexed:
        self._attrsNS = {} #    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.

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

    def _get_tagName(self):
        return self.tagName

    def unlink(self):
        for attr in self._attrs.values():
            attr.unlink()
        self._attrs = None
        self._attrsNS = None
        Node.unlink(self)

    def getAttribute(self, attname):
        try:
            return self._attrs[attname].value
        except KeyError:
            return ""

    def getAttributeNS(self, namespaceURI, localName):
        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)
            # for performance
            d = attr.__dict__
            d["value"] = d["nodeValue"] = value
            d["ownerDocument"] = self.ownerDocument
            self.setAttributeNode(attr)
        elif value != attr.value:
            d = attr.__dict__
            d["value"] = d["nodeValue"] = 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:
            # for performance
            attr = Attr(qualifiedName, namespaceURI, localname, prefix)
            d = attr.__dict__
            d["prefix"] = prefix
            d["nodeName"] = qualifiedName
            d["value"] = d["nodeValue"] = value
            d["ownerDocument"] = self.ownerDocument
            self.setAttributeNode(attr)
        else:
            d = attr.__dict__
            if value != attr.value:
                d["value"] = d["nodeValue"] = value
                if attr.isId:
                    _clear_id_cache(self)
            if attr.prefix != prefix:
                d["prefix"] = prefix
                d["nodeName"] = qualifiedName

    def getAttributeNode(self, attrname):
        return self._attrs.get(attrname)

    def getAttributeNodeNS(self, namespaceURI, localName):
        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")
        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):
        try:
            attr = self._attrs[name]
        except KeyError:
            raise xml.dom.NotFoundErr()
        self.removeAttributeNode(attr)

    def removeAttributeNS(self, namespaceURI, localName):
        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

    removeAttributeNodeNS = removeAttributeNode

    def hasAttribute(self, name):
        return name in self._attrs

    def hasAttributeNS(self, namespaceURI, localName):
        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()
        a_names = attrs.keys()
        a_names.sort()

        for a_name in a_names:
            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 == Node.TEXT_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):
        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.__dict__['_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._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.__dict__['ownerElement'] = element


class Childless:
    """Mixin that makes childless-ness easy to implement and avoids
    the complexity of the Node methods that deal with children.
    """

    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

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

    def _get_data(self):
        return self.data
    def _set_data(self, value):
        d = self.__dict__
        d['data'] = d['nodeValue'] = value

    def _get_target(self):
        return self.target
    def _set_target(self, value):
        d = self.__dict__
        d['target'] = d['nodeName'] = value

    def __setattr__(self, name, value):
        if name == "data" or name == "nodeValue":
            self.__dict__['data'] = self.__dict__['nodeValue'] = value
        elif name == "target" or name == "nodeName":
            self.__dict__['target'] = self.__dict__['nodeName'] = value
        else:
            self.__dict__[name] = value

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


class CharacterData(Childless, Node):
    def _get_length(self):
        return len(self.data)
    __len__ = _get_length

    def _get_data(self):
        return self.__dict__['data']
    def _set_data(self, data):
        d = self.__dict__
        d['data'] = d['nodeValue'] = data

    _get_nodeValue = _get_data
    _set_nodeValue = _set_data

    def __setattr__(self, name, value):
        if name == "data" or name == "nodeValue":
            self.__dict__['data'] = self.__dict__['nodeValue'] = value
        else:
            self.__dict__[name] = value

    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):
    # Make sure we don't add an instance __dict__ if we don't already
    # have one, at least when that's possible:
    # XXX this does not work, CharacterData is an old-style class
    # __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:
            d = self.__dict__
            d['data'] = content
            d['nodeValue'] = 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(Childless, CharacterData):
    nodeType = Node.COMMENT_NODE
    nodeName = "#comment"

    def __init__(self, data):
        self.data = self.nodeValue = 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):
    # Make sure we don't add an instance __dict__ if we don't already
    # have one, at least when that's possible:
    # XXX this does not work, Text is an old-style class
    # __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."""

    # XXX this does not work, this is an old-style class
    # __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):
    _child_node_types = (Node.ELEMENT_NODE, Node.PROCESSING_INSTRUCTION_NODE,
                         Node.COMMENT_NODE, Node.DOCUMENT_TYPE_NODE)

    nodeType = Node.DOCUMENT_NODE
    nodeName = "#document"
    nodeValue = None
    attributes = None
    doctype = None
    parentNode = None
    previousSibling = nextSibling = None

    implementation = DOMImplementation()

    # 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.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, StringTypes):
            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, StringTypes):
            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
        # avoid __setattr__
        d = n.__dict__
        d['prefix'] = prefix
        d['localName'] = localName
        d['namespaceURI'] = namespaceURI
        d['nodeName'] = name
        if n.nodeType == Node.ELEMENT_NODE:
            d['tagName'] = name
        else:
            # attribute node
            d['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 _get_StringIO():
    # we can't use cStringIO since it doesn't support Unicode strings
    from StringIO import StringIO
    return StringIO()

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, StringTypes):
            features = domreg._parse_feature_string(features)
        for f, v in features:
            if not Document.implementation.hasFeature(f, v):
                return None
    return Document.implementation
PK0![�);�

dom/minicompat.pynu�[���"""Python version compatibility support for minidom."""

# 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

try:
    unicode
except NameError:
    StringTypes = type(''),
else:
    StringTypes = type(''), type(unicode(''))


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)).im_func
    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)
PK0![l$ń1010dom/xmlbuilder.pynu�[���"""Implementation of the DOM Level 3 'LS-Load' feature."""

import copy
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,))
            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 urllib2
            fp = urllib2.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, urlparse
        parts = urlparse.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 = urlparse.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 urllib2
        return urllib2.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, async):
        if async:
            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()
PK0![��Cp��dom/expatbuilder.pynu�[���"""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

from xml.dom.minicompat import *

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)
    else:
        uri, localname = parts
        prefix = EMPTY_PREFIX
        qname = localname = intern(localname, localname)
    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
            d = node.__dict__
            d['data'] = d['nodeValue'] = value
            return
        else:
            node = minidom.Text()
            d = node.__dict__
            d['data'] = d['nodeValue'] = data
            d['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]
            d = node.__dict__
            d['data'] = d['nodeValue'] = node.data + data
            return
        node = minidom.Text()
        d = node.__dict__
        d['data'] = d['nodeValue'] = node.data + data
        d['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]
                d = a.childNodes[0].__dict__
                d['data'] = d['nodeValue'] = value
                d = a.__dict__
                d['value'] = d['nodeValue'] = value
                d['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)
                d = a.childNodes[0].__dict__
                d['data'] = d['nodeValue'] = uri
                d = a.__dict__
                d['value'] = d['nodeValue'] = uri
                d['ownerDocument'] = self.document
                _set_attribute_node(node, a)
            del self._ns_ordered_prefixes[:]

        if 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
                d = a.childNodes[0].__dict__
                d['data'] = d['nodeValue'] = value
                d = a.__dict__
                d['ownerDocument'] = self.document
                d['value'] = d['nodeValue'] = value
                d['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, StringTypes):
        fp = open(file, 'rb')
        try:
            result = builder.parseFile(fp)
        finally:
            fp.close()
    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, StringTypes):
        fp = open(file, 'rb')
        try:
            result = builder.parseFile(fp)
        finally:
            fp.close()
    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)
PK0![`���.�.dom/pulldom.pynu�[���import xml.sax
import xml.sax.handler
import types

try:
    _StringTypes = [types.StringType, types.UnicodeType]
except AttributeError:
    _StringTypes = [types.StringType]

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):
        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 type(stream_or_string) in _StringTypes:
        stream = open(stream_or_string)
    else:
        stream = stream_or_string
    if not parser:
        parser = xml.sax.make_parser()
    return DOMEventStream(stream, parser, bufsize)

def parseString(string, parser=None):
    try:
        from cStringIO import StringIO
    except ImportError:
        from StringIO import StringIO

    bufsize = len(string)
    buf = StringIO(string)
    if not parser:
        parser = xml.sax.make_parser()
    return DOMEventStream(buf, parser, bufsize)
PK0![�Cxr�
�

dom/domreg.pynu�[���"""Registration facilities for DOM. This module should not be used
directly. Instead, the functions getDOMImplementation and
registerDOMImplementation should be imported from xml.dom."""

from xml.dom.minicompat import *  # isinstance, StringTypes

# 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, StringTypes):
        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 StandardError: # 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)
PK0![��rr+dom/__pycache__/domreg.cpython-38.opt-2.pycnu�[���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�
+PK0![�{$$+dom/__pycache__/domreg.cpython-38.opt-1.pycnu�[���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�
+PK0![�˯<����,dom/__pycache__/minidom.cpython-38.opt-1.pycnu�[���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



PK0![��z���-dom/__pycache__/__init__.cpython-38.opt-2.pycnu�[���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
PK0![�}��\
\
/dom/__pycache__/minicompat.cpython-38.opt-1.pycnu�[���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*PK0![2@RD�0�0/dom/__pycache__/xmlbuilder.cpython-38.opt-1.pycnu�[���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!PK0![�{$$%dom/__pycache__/domreg.cpython-38.pycnu�[���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�
+PK0![Qf�((,dom/__pycache__/pulldom.cpython-38.opt-2.pycnu�[���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\!
PK0![��S�h�h1dom/__pycache__/expatbuilder.cpython-38.opt-1.pycnu�[���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_%,



PK0![D�>W��-dom/__pycache__/__init__.cpython-38.opt-1.pycnu�[���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
PK0![^���)�)&dom/__pycache__/pulldom.cpython-38.pycnu�[���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\!
PK0![D�>W��'dom/__pycache__/__init__.cpython-38.pycnu�[���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
PK0![> �P�P�&dom/__pycache__/minidom.cpython-38.pycnu�[���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



PK0![�Dll/dom/__pycache__/NodeFilter.cpython-38.opt-2.pycnu�[���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>�PK0![����
�
)dom/__pycache__/minicompat.cpython-38.pycnu�[���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*PK0![K�c�^�^1dom/__pycache__/expatbuilder.cpython-38.opt-2.pycnu�[���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_%,



PK0![6[z(�j�j+dom/__pycache__/expatbuilder.cpython-38.pycnu�[���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_%,



PK0![£ߝ�	�	/dom/__pycache__/minicompat.cpython-38.opt-2.pycnu�[���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
PK0![�`ZT///dom/__pycache__/xmlbuilder.cpython-38.opt-2.pycnu�[���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!PK0![��}�0�0)dom/__pycache__/xmlbuilder.cpython-38.pycnu�[���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!PK0![^���)�),dom/__pycache__/pulldom.cpython-38.opt-1.pycnu�[���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\!
PK0![�_���)dom/__pycache__/NodeFilter.cpython-38.pycnu�[���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>�PK0![�,
O����,dom/__pycache__/minidom.cpython-38.opt-2.pycnu�[���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



PK0![�_���/dom/__pycache__/NodeFilter.cpython-38.opt-1.pycnu�[���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>�PK0![XB��dom/__init__.pynu�[���"""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."""

    # 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
PK0![�Cc��dom/NodeFilter.pynu�[���# 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                    = 0xFFFFFFFFL
    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
PK0![E��g%%etree/ElementPath.pynu�[���#
# 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(
    "("
    "'[^']*'|\"[^\"]*\"|"
    "::|"
    "//?|"
    "\.\.|"
    "\(\)|"
    "[/.*:\[\]\(\)@=])|"
    "((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|"
    "\s+"
    )

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

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 prepare_child(next, token):
    tag = token[1]
    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:
            for e in elem:
                yield e
    return select

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

def prepare_descendant(next, token):
    token = next()
    if token[0] == "*":
        tag = "*"
    elif not token[0]:
        tag = token[1]
    else:
        raise SyntaxError("invalid descendant")
    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:
        token = next()
        if token[0] == "]":
            break
        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("\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 == "-='" and not re.match("\d+$", predicate[0]):
        # [tag='value']
        tag = predicate[0]
        value = predicate[-1]
        def select(context, result):
            for elem in result:
                for e in elem.findall(tag):
                    if "".join(e.itertext()) == value:
                        yield elem
                        break
        return select
    if signature == "-" or signature == "-()" or signature == "-()-":
        # [index] or [last()] or [last()-index]
        if signature == "-":
            index = int(predicate[0]) - 1
        else:
            if predicate[0] != "last":
                raise SyntaxError("unsupported function")
            if signature == "-()-":
                try:
                    index = int(predicate[2]) - 1
                except ValueError:
                    raise SyntaxError("unsupported expression")
            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?)
    try:
        selector = _cache[path]
    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
        token = next()
        selector = []
        while 1:
            try:
                selector.append(ops[token[0]](next, token))
            except StopIteration:
                raise SyntaxError("invalid path")
            try:
                token = next()
                if token[0] == "/":
                    token = next()
            except StopIteration:
                break
        _cache[path] = 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):
    try:
        return iterfind(elem, path, namespaces).next()
    except StopIteration:
        return 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 = iterfind(elem, path, namespaces).next()
        return elem.text or ""
    except StopIteration:
        return default
PK0![����etree/ElementInclude.pynu�[���#
# 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.
# @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 IOError exception.
# @throws IOError If the loader fails to load the resource.

def default_loader(href, parse, encoding=None):
    with open(href) as file:
        if parse == "xml":
            data = ElementTree.parse(file).getroot()
        else:
            data = file.read()
            if encoding:
                data = data.decode(encoding)
    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 IOError 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
PK0![�%�'��/etree/__pycache__/__init__.cpython-38.opt-2.pycnu�[���U

e5dD�@sdS)N�rrr�*/usr/lib64/python3.8/xml/etree/__init__.py�<module>�PK0![�b�2��3etree/__pycache__/cElementTree.cpython-38.opt-2.pycnu�[���U

e5dR�@sddlTdS)�)�*N)Zxml.etree.ElementTree�rr�./usr/lib64/python3.8/xml/etree/cElementTree.py�<module>�PK0![��J--5etree/__pycache__/ElementInclude.cpython-38.opt-2.pycnu�[���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
PK0![�r�� � 2etree/__pycache__/ElementPath.cpython-38.opt-2.pycnu�[���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�	

,

PK0![�b�2��-etree/__pycache__/cElementTree.cpython-38.pycnu�[���U

e5dR�@sddlTdS)�)�*N)Zxml.etree.ElementTree�rr�./usr/lib64/python3.8/xml/etree/cElementTree.py�<module>�PK0![�%�'��/etree/__pycache__/__init__.cpython-38.opt-1.pycnu�[���U

e5dD�@sdS)N�rrr�*/usr/lib64/python3.8/xml/etree/__init__.py�<module>�PK0![�%�'��)etree/__pycache__/__init__.cpython-38.pycnu�[���U

e5dD�@sdS)N�rrr�*/usr/lib64/python3.8/xml/etree/__init__.py�<module>�PK0![�r�� � 2etree/__pycache__/ElementPath.cpython-38.opt-1.pycnu�[���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�	

,

PK0![n=mE��2etree/__pycache__/ElementTree.cpython-38.opt-1.pycnu�[���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


zgPK0![4��1�1�2etree/__pycache__/ElementTree.cpython-38.opt-2.pycnu�[���U

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


zgPK0![�r�� � ,etree/__pycache__/ElementPath.cpython-38.pycnu�[���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�	

,

PK0![�b�2��3etree/__pycache__/cElementTree.cpython-38.opt-1.pycnu�[���U

e5dR�@sddlTdS)�)�*N)Zxml.etree.ElementTree�rr�./usr/lib64/python3.8/xml/etree/cElementTree.py�<module>�PK0![��J--5etree/__pycache__/ElementInclude.cpython-38.opt-1.pycnu�[���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
PK0![��H�H�,etree/__pycache__/ElementTree.cpython-38.pycnu�[���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


zgPK0![��J--/etree/__pycache__/ElementInclude.cpython-38.pycnu�[���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
PK0![W�Z�DDetree/__init__.pynu�[���# $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.
PK0![�"/�����etree/ElementTree.pynu�[���#
# ElementTree
# $Id: ElementTree.py 3440 2008-07-18 14:45:01Z fredrik $
#
# light-weight XML support for Python 2.3 and later.
#
# history (since 1.2.6):
# 2005-11-12 fl   added tostringlist/fromstringlist helpers
# 2006-07-05 fl   merged in selected changes from the 1.3 sandbox
# 2006-07-05 fl   removed support for 2.1 and earlier
# 2007-06-21 fl   added deprecation/future warnings
# 2007-08-25 fl   added doctype hook, added parser version attribute etc
# 2007-08-26 fl   added new serializer code (better namespace handling, etc)
# 2007-08-27 fl   warn for broken /tag searches on tree level
# 2007-09-02 fl   added html/text methods to serializer (experimental)
# 2007-09-05 fl   added method argument to tostring/tostringlist
# 2007-09-06 fl   improved error handling
# 2007-09-13 fl   added itertext, iterfind; assorted cleanups
# 2007-12-15 fl   added C14N hooks, copy method (experimental)
#
# 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.
# --------------------------------------------------------------------

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

__all__ = [
    # public symbols
    "Comment",
    "dump",
    "Element", "ElementTree",
    "fromstring", "fromstringlist",
    "iselement", "iterparse",
    "parse", "ParseError",
    "PI", "ProcessingInstruction",
    "QName",
    "SubElement",
    "tostring", "tostringlist",
    "TreeBuilder",
    "VERSION",
    "XML",
    "XMLParser", "XMLTreeBuilder",
    ]

VERSION = "1.3.0"

##
# The <b>Element</b> type is a flexible container object, designed to
# store hierarchical data structures in memory. The type can be
# described as a cross between a list and a dictionary.
# <p>
# Each element has a number of properties associated with it:
# <ul>
# <li>a <i>tag</i>. This is a string identifying what kind of data
# this element represents (the element type, in other words).</li>
# <li>a number of <i>attributes</i>, stored in a Python dictionary.</li>
# <li>a <i>text</i> string.</li>
# <li>an optional <i>tail</i> string.</li>
# <li>a number of <i>child elements</i>, stored in a Python sequence</li>
# </ul>
#
# To create an element instance, use the {@link #Element} constructor
# or the {@link #SubElement} factory function.
# <p>
# The {@link #ElementTree} class can be used to wrap an element
# structure, and convert it from and to XML.
##

import sys
import re
import warnings


class _SimpleElementPath(object):
    # emulate pre-1.2 find/findtext/findall behaviour
    def find(self, element, tag, namespaces=None):
        for elem in element:
            if elem.tag == tag:
                return elem
        return None
    def findtext(self, element, tag, default=None, namespaces=None):
        elem = self.find(element, tag)
        if elem is None:
            return default
        return elem.text or ""
    def iterfind(self, element, tag, namespaces=None):
        if tag[:3] == ".//":
            for elem in element.iter(tag[3:]):
                yield elem
        for elem in element:
            if elem.tag == tag:
                yield elem
    def findall(self, element, tag, namespaces=None):
        return list(self.iterfind(element, tag, namespaces))

try:
    from . import ElementPath
except ImportError:
    ElementPath = _SimpleElementPath()

##
# Parser error.  This is a subclass of <b>SyntaxError</b>.
# <p>
# In addition to the exception value, an exception instance contains a
# specific exception code in the <b>code</b> attribute, and the line and
# column of the error in the <b>position</b> attribute.

class ParseError(SyntaxError):
    pass

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

##
# Checks if an object appears to be a valid element object.
#
# @param An element instance.
# @return A true value if this is an element object.
# @defreturn flag

def iselement(element):
    # FIXME: not sure about this; might be a better idea to look
    # for tag/attrib/text attributes
    return isinstance(element, Element) or hasattr(element, "tag")

##
# Element class.  This class defines the Element interface, and
# provides a reference implementation of this interface.
# <p>
# The element name, attribute names, and attribute values can be
# either ASCII strings (ordinary Python strings containing only 7-bit
# ASCII characters) or Unicode strings.
#
# @param tag The element name.
# @param attrib An optional dictionary, containing element attributes.
# @param **extra Additional attributes, given as keyword arguments.
# @see Element
# @see SubElement
# @see Comment
# @see ProcessingInstruction

class Element(object):
    # <tag attrib>text<child/>...</tag>tail

    ##
    # (Attribute) Element tag.

    tag = None

    ##
    # (Attribute) Element attribute dictionary.  Where possible, use
    # {@link #Element.get},
    # {@link #Element.set},
    # {@link #Element.keys}, and
    # {@link #Element.items} to access
    # element attributes.

    attrib = None

    ##
    # (Attribute) Text before first subelement.  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.

    text = None

    ##
    # (Attribute) 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.

    tail = None # text after end tag, if any

    # constructor

    def __init__(self, tag, attrib={}, **extra):
        attrib = attrib.copy()
        attrib.update(extra)
        self.tag = tag
        self.attrib = attrib
        self._children = []

    def __repr__(self):
        return "<Element %s at 0x%x>" % (repr(self.tag), id(self))

    ##
    # Creates a new element object of the same type as this element.
    #
    # @param tag Element tag.
    # @param attrib Element attributes, given as a dictionary.
    # @return A new element instance.

    def makeelement(self, tag, attrib):
        return self.__class__(tag, attrib)

    ##
    # (Experimental) Copies the current element.  This creates a
    # shallow copy; subelements will be shared with the original tree.
    #
    # @return A new element instance.

    def copy(self):
        elem = self.makeelement(self.tag, self.attrib)
        elem.text = self.text
        elem.tail = self.tail
        elem[:] = self
        return elem

    ##
    # Returns the number of subelements.  Note that this only counts
    # full elements; to check if there's any content in an element, you
    # have to check both the length and the <b>text</b> attribute.
    #
    # @return The number of subelements.

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

    def __nonzero__(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

    ##
    # Returns the given subelement, by index.
    #
    # @param index What subelement to return.
    # @return The given subelement.
    # @exception IndexError If the given element does not exist.

    def __getitem__(self, index):
        return self._children[index]

    ##
    # Replaces the given subelement, by index.
    #
    # @param index What subelement to replace.
    # @param element The new element value.
    # @exception IndexError If the given element does not exist.

    def __setitem__(self, index, element):
        # if isinstance(index, slice):
        #     for elt in element:
        #         assert iselement(elt)
        # else:
        #     assert iselement(element)
        self._children[index] = element

    ##
    # Deletes the given subelement, by index.
    #
    # @param index What subelement to delete.
    # @exception IndexError If the given element does not exist.

    def __delitem__(self, index):
        del self._children[index]

    ##
    # Adds a subelement to the end of this element.  In document order,
    # the new element will appear after the last existing subelement (or
    # directly after the text, if it's the first subelement), but before
    # the end tag for this element.
    #
    # @param element The element to add.

    def append(self, element):
        # assert iselement(element)
        self._children.append(element)

    ##
    # Appends subelements from a sequence.
    #
    # @param elements A sequence object with zero or more elements.
    # @since 1.3

    def extend(self, elements):
        # for element in elements:
        #     assert iselement(element)
        self._children.extend(elements)

    ##
    # Inserts a subelement at the given position in this element.
    #
    # @param index Where to insert the new subelement.

    def insert(self, index, element):
        # assert iselement(element)
        self._children.insert(index, element)

    ##
    # Removes a matching subelement.  Unlike the <b>find</b> methods,
    # this method compares elements based on identity, not on tag
    # value or contents.  To remove subelements by other means, the
    # easiest way is often to use a list comprehension to select what
    # elements to keep, and use slice assignment to update the parent
    # element.
    #
    # @param element What element to remove.
    # @exception ValueError If a matching element could not be found.

    def remove(self, element):
        # assert iselement(element)
        self._children.remove(element)

    ##
    # (Deprecated) Returns all subelements.  The elements are returned
    # in document order.
    #
    # @return A list of subelements.
    # @defreturn list of Element instances

    def getchildren(self):
        warnings.warn(
            "This method will be removed in future versions.  "
            "Use 'list(elem)' or iteration over elem instead.",
            DeprecationWarning, stacklevel=2
            )
        return self._children

    ##
    # Finds the first matching subelement, by tag name or path.
    #
    # @param path What element to look for.
    # @keyparam namespaces Optional namespace prefix map.
    # @return The first matching element, or None if no element was found.
    # @defreturn Element or None

    def find(self, path, namespaces=None):
        return ElementPath.find(self, path, namespaces)

    ##
    # Finds text for the first matching subelement, by tag name or path.
    #
    # @param path What element to look for.
    # @param default What to return if the element was not found.
    # @keyparam namespaces Optional namespace prefix map.
    # @return The text content of the first matching element, or the
    #     default value no element was found.  Note that if the element
    #     is found, but has no text content, this method returns an
    #     empty string.
    # @defreturn string

    def findtext(self, path, default=None, namespaces=None):
        return ElementPath.findtext(self, path, default, namespaces)

    ##
    # Finds all matching subelements, by tag name or path.
    #
    # @param path What element to look for.
    # @keyparam namespaces Optional namespace prefix map.
    # @return A list or other sequence containing all matching elements,
    #    in document order.
    # @defreturn list of Element instances

    def findall(self, path, namespaces=None):
        return ElementPath.findall(self, path, namespaces)

    ##
    # Finds all matching subelements, by tag name or path.
    #
    # @param path What element to look for.
    # @keyparam namespaces Optional namespace prefix map.
    # @return An iterator or sequence containing all matching elements,
    #    in document order.
    # @defreturn a generated sequence of Element instances

    def iterfind(self, path, namespaces=None):
        return ElementPath.iterfind(self, path, namespaces)

    ##
    # Resets an element.  This function removes all subelements, clears
    # all attributes, and sets the <b>text</b> and <b>tail</b> attributes
    # to None.

    def clear(self):
        self.attrib.clear()
        self._children = []
        self.text = self.tail = None

    ##
    # Gets an element attribute.  Equivalent to <b>attrib.get</b>, but
    # some implementations may handle this a bit more efficiently.
    #
    # @param key What attribute to look for.
    # @param default What to return if the attribute was not found.
    # @return The attribute value, or the default value, if the
    #     attribute was not found.
    # @defreturn string or None

    def get(self, key, default=None):
        return self.attrib.get(key, default)

    ##
    # Sets an element attribute.  Equivalent to <b>attrib[key] = value</b>,
    # but some implementations may handle this a bit more efficiently.
    #
    # @param key What attribute to set.
    # @param value The attribute value.

    def set(self, key, value):
        self.attrib[key] = value

    ##
    # Gets a list of attribute names.  The names are returned in an
    # arbitrary order (just like for an ordinary Python dictionary).
    # Equivalent to <b>attrib.keys()</b>.
    #
    # @return A list of element attribute names.
    # @defreturn list of strings

    def keys(self):
        return self.attrib.keys()

    ##
    # Gets element attributes, as a sequence.  The attributes are
    # returned in an arbitrary order.  Equivalent to <b>attrib.items()</b>.
    #
    # @return A list of (name, value) tuples for all attributes.
    # @defreturn list of (string, string) tuples

    def items(self):
        return self.attrib.items()

    ##
    # Creates a tree iterator.  The iterator loops over this element
    # and all subelements, in document order, and returns all elements
    # with a matching tag.
    # <p>
    # 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.
    #
    # @param tag What tags to look for (default is to return all elements).
    # @return An iterator containing all the matching elements.
    # @defreturn iterator

    def iter(self, tag=None):
        if tag == "*":
            tag = None
        if tag is None or self.tag == tag:
            yield self
        for e in self._children:
            for e in e.iter(tag):
                yield e

    # compatibility
    def getiterator(self, tag=None):
        # Change for a DeprecationWarning in 1.4
        warnings.warn(
            "This method will be removed in future versions.  "
            "Use 'elem.iter()' or 'list(elem.iter())' instead.",
            PendingDeprecationWarning, stacklevel=2
        )
        return list(self.iter(tag))

    ##
    # Creates a text iterator.  The iterator loops over this element
    # and all subelements, in document order, and returns all inner
    # text.
    #
    # @return An iterator containing all inner text.
    # @defreturn iterator

    def itertext(self):
        tag = self.tag
        if not isinstance(tag, basestring) and tag is not None:
            return
        if self.text:
            yield self.text
        for e in self:
            for s in e.itertext():
                yield s
            if e.tail:
                yield e.tail

# compatibility
_Element = _ElementInterface = Element

##
# Subelement factory.  This function creates an element instance, and
# appends it to an existing element.
# <p>
# The element name, attribute names, and attribute values can be
# either 8-bit ASCII strings or Unicode strings.
#
# @param parent The parent element.
# @param tag The subelement name.
# @param attrib An optional dictionary, containing element attributes.
# @param **extra Additional attributes, given as keyword arguments.
# @return An element instance.
# @defreturn Element

def SubElement(parent, tag, attrib={}, **extra):
    attrib = attrib.copy()
    attrib.update(extra)
    element = parent.makeelement(tag, attrib)
    parent.append(element)
    return element

##
# Comment element factory.  This factory function creates a special
# element that will be serialized as an XML comment by the standard
# serializer.
# <p>
# The comment string can be either an 8-bit ASCII string or a Unicode
# string.
#
# @param text A string containing the comment string.
# @return An element instance, representing a comment.
# @defreturn Element

def Comment(text=None):
    element = Element(Comment)
    element.text = text
    return element

##
# PI element factory.  This factory function creates a special element
# that will be serialized as an XML processing instruction by the standard
# serializer.
#
# @param target A string containing the PI target.
# @param text A string containing the PI contents, if any.
# @return An element instance, representing a PI.
# @defreturn Element

def ProcessingInstruction(target, text=None):
    element = Element(ProcessingInstruction)
    element.text = target
    if text:
        element.text = element.text + " " + text
    return element

PI = ProcessingInstruction

##
# QName wrapper.  This can be used to wrap a QName attribute value, in
# order to get proper namespace handling on output.
#
# @param text A string containing the QName value, in the form {uri}local,
#     or, if the tag argument is given, the URI part of a QName.
# @param tag Optional tag.  If given, the first argument is interpreted as
#     a URI, and this argument is interpreted as a local name.
# @return An opaque object, representing the QName.

class QName(object):
    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 __hash__(self):
        return hash(self.text)
    def __cmp__(self, other):
        if isinstance(other, QName):
            return cmp(self.text, other.text)
        return cmp(self.text, other)

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

##
# ElementTree wrapper class.  This class represents an entire element
# hierarchy, and adds some extra support for serialization to and from
# standard XML.
#
# @param element Optional root element.
# @keyparam file Optional file handle or file name.  If given, the
#     tree is initialized with the contents of this XML file.

class ElementTree(object):

    def __init__(self, element=None, file=None):
        # assert element is None or iselement(element)
        self._root = element # first node
        if file:
            self.parse(file)

    ##
    # Gets the root element for this tree.
    #
    # @return An element instance.
    # @defreturn Element

    def getroot(self):
        return self._root

    ##
    # Replaces the root element for this tree.  This discards the
    # current contents of the tree, and replaces it with the given
    # element.  Use with care.
    #
    # @param element An element instance.

    def _setroot(self, element):
        # assert iselement(element)
        self._root = element

    ##
    # Loads an external XML document into this element tree.
    #
    # @param source A file name or file object.  If a file object is
    #     given, it only has to implement a <b>read(n)</b> method.
    # @keyparam parser An optional parser instance.  If not given, the
    #     standard {@link XMLParser} parser is used.
    # @return The document root element.
    # @defreturn Element
    # @exception ParseError If the parser fails to parse the document.

    def parse(self, source, parser=None):
        close_source = False
        if not hasattr(source, "read"):
            source = open(source, "rb")
            close_source = True
        try:
            if not parser:
                parser = XMLParser(target=TreeBuilder())
            while 1:
                data = source.read(65536)
                if not data:
                    break
                parser.feed(data)
            self._root = parser.close()
            return self._root
        finally:
            if close_source:
                source.close()

    ##
    # Creates a tree iterator for the root element.  The iterator loops
    # over all elements in this tree, in document order.
    #
    # @param tag What tags to look for (default is to return all elements)
    # @return An iterator.
    # @defreturn iterator

    def iter(self, tag=None):
        # assert self._root is not None
        return self._root.iter(tag)

    # compatibility
    def getiterator(self, tag=None):
        # Change for a DeprecationWarning in 1.4
        warnings.warn(
            "This method will be removed in future versions.  "
            "Use 'tree.iter()' or 'list(tree.iter())' instead.",
            PendingDeprecationWarning, stacklevel=2
        )
        return list(self.iter(tag))

    ##
    # Same as getroot().find(path), starting at the root of the
    # tree.
    #
    # @param path What element to look for.
    # @keyparam namespaces Optional namespace prefix map.
    # @return The first matching element, or None if no element was found.
    # @defreturn Element or None

    def find(self, path, namespaces=None):
        # 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)

    ##
    # Same as getroot().findtext(path), starting at the root of the tree.
    #
    # @param path What element to look for.
    # @param default What to return if the element was not found.
    # @keyparam namespaces Optional namespace prefix map.
    # @return The text content of the first matching element, or the
    #     default value no element was found.  Note that if the element
    #     is found, but has no text content, this method returns an
    #     empty string.
    # @defreturn string

    def findtext(self, path, default=None, namespaces=None):
        # 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)

    ##
    # Same as getroot().findall(path), starting at the root of the tree.
    #
    # @param path What element to look for.
    # @keyparam namespaces Optional namespace prefix map.
    # @return A list or iterator containing all matching elements,
    #    in document order.
    # @defreturn list of Element instances

    def findall(self, path, namespaces=None):
        # 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)

    ##
    # Finds all matching subelements, by tag name or path.
    # Same as getroot().iterfind(path).
    #
    # @param path What element to look for.
    # @keyparam namespaces Optional namespace prefix map.
    # @return An iterator or sequence containing all matching elements,
    #    in document order.
    # @defreturn a generated sequence of Element instances

    def iterfind(self, path, namespaces=None):
        # 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)

    ##
    # Writes the element tree to a file, as XML.
    #
    # @def write(file, **options)
    # @param file A file name, or a file object opened for writing.
    # @param **options Options, given as keyword arguments.
    # @keyparam encoding Optional output encoding (default is US-ASCII).
    # @keyparam xml_declaration Controls if an XML declaration should
    #     be added to the file.  Use False for never, True for always,
    #     None for only if not US-ASCII or UTF-8.  None is default.
    # @keyparam default_namespace Sets the default XML namespace (for "xmlns").
    # @keyparam method Optional output method ("xml", "html", "text" or
    #     "c14n"; default is "xml").

    def write(self, file_or_filename,
              # keyword arguments
              encoding=None,
              xml_declaration=None,
              default_namespace=None,
              method=None):
        # assert self._root is not None
        if not method:
            method = "xml"
        elif method not in _serialize:
            # FIXME: raise an ImportError for c14n if ElementC14N is missing?
            raise ValueError("unknown method %r" % method)
        if hasattr(file_or_filename, "write"):
            file = file_or_filename
        else:
            file = open(file_or_filename, "wb")
        write = file.write
        if not encoding:
            if method == "c14n":
                encoding = "utf-8"
            else:
                encoding = "us-ascii"
        elif xml_declaration or (xml_declaration is None and
                                 encoding not in ("utf-8", "us-ascii")):
            if method == "xml":
                write("<?xml version='1.0' encoding='%s'?>\n" % encoding)
        if method == "text":
            _serialize_text(write, self._root, encoding)
        else:
            qnames, namespaces = _namespaces(
                self._root, encoding, default_namespace
                )
            serialize = _serialize[method]
            serialize(write, self._root, encoding, qnames, namespaces)
        if file_or_filename is not file:
            file.close()

    def write_c14n(self, file):
        # lxml.etree compatibility.  use output method instead
        return self.write(file, method="c14n")

# --------------------------------------------------------------------
# serialization support

def _namespaces(elem, encoding, 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 encode(text):
        return text.encode(encoding)

    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] = encode("%s:%s" % (prefix, tag))
                else:
                    qnames[qname] = encode(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] = encode(qname)
        except TypeError:
            _raise_serialization_error(qname)

    # populate qname and namespaces table
    try:
        iterate = elem.iter
    except AttributeError:
        iterate = elem.getiterator # cET compatibility
    for elem in iterate():
        tag = elem.tag
        if isinstance(tag, QName):
            if tag.text not in qnames:
                add_qname(tag.text)
        elif isinstance(tag, basestring):
            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, encoding, qnames, namespaces):
    tag = elem.tag
    text = elem.text
    if tag is Comment:
        write("<!--%s-->" % _encode(text, encoding))
    elif tag is ProcessingInstruction:
        write("<?%s?>" % _encode(text, encoding))
    else:
        tag = qnames[tag]
        if tag is None:
            if text:
                write(_escape_cdata(text, encoding))
            for e in elem:
                _serialize_xml(write, e, encoding, qnames, None)
        else:
            write("<" + tag)
            items = 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.encode(encoding),
                            _escape_attrib(v, encoding)
                            ))
                for k, v in sorted(items):  # lexical order
                    if isinstance(k, QName):
                        k = k.text
                    if isinstance(v, QName):
                        v = qnames[v.text]
                    else:
                        v = _escape_attrib(v, encoding)
                    write(" %s=\"%s\"" % (qnames[k], v))
            if text or len(elem):
                write(">")
                if text:
                    write(_escape_cdata(text, encoding))
                for e in elem:
                    _serialize_xml(write, e, encoding, qnames, None)
                write("</" + tag + ">")
            else:
                write(" />")
    if elem.tail:
        write(_escape_cdata(elem.tail, encoding))

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, encoding, qnames, namespaces):
    tag = elem.tag
    text = elem.text
    if tag is Comment:
        write("<!--%s-->" % _escape_cdata(text, encoding))
    elif tag is ProcessingInstruction:
        write("<?%s?>" % _escape_cdata(text, encoding))
    else:
        tag = qnames[tag]
        if tag is None:
            if text:
                write(_escape_cdata(text, encoding))
            for e in elem:
                _serialize_html(write, e, encoding, qnames, None)
        else:
            write("<" + tag)
            items = 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.encode(encoding),
                            _escape_attrib(v, encoding)
                            ))
                for k, v in sorted(items):  # lexical order
                    if isinstance(k, QName):
                        k = k.text
                    if isinstance(v, QName):
                        v = qnames[v.text]
                    else:
                        v = _escape_attrib_html(v, encoding)
                    # FIXME: handle boolean attributes
                    write(" %s=\"%s\"" % (qnames[k], v))
            write(">")
            ltag = tag.lower()
            if text:
                if ltag == "script" or ltag == "style":
                    write(_encode(text, encoding))
                else:
                    write(_escape_cdata(text, encoding))
            for e in elem:
                _serialize_html(write, e, encoding, qnames, None)
            if ltag not in HTML_EMPTY:
                write("</" + tag + ">")
    if elem.tail:
        write(_escape_cdata(elem.tail, encoding))

def _serialize_text(write, elem, encoding):
    for part in elem.itertext():
        write(part.encode(encoding))
    if elem.tail:
        write(elem.tail.encode(encoding))

_serialize = {
    "xml": _serialize_xml,
    "html": _serialize_html,
    "text": _serialize_text,
# this optional method is imported at the end of the module
#   "c14n": _serialize_c14n,
}

##
# Registers a namespace prefix.  The registry is global, and any
# existing mapping for either the given prefix or the namespace URI
# will be removed.
#
# @param prefix Namespace prefix.
# @param uri Namespace uri.  Tags and attributes in this namespace
#     will be serialized with the given prefix, if at all possible.
# @exception ValueError If the prefix is reserved, or is otherwise
#     invalid.

def register_namespace(prefix, uri):
    if re.match("ns\d+$", prefix):
        raise ValueError("Prefix format reserved for internal use")
    for k, v in _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",
}

def _raise_serialization_error(text):
    raise TypeError(
        "cannot serialize %r (type %s)" % (text, type(text).__name__)
        )

def _encode(text, encoding):
    try:
        return text.encode(encoding, "xmlcharrefreplace")
    except (TypeError, AttributeError):
        _raise_serialization_error(text)

def _escape_cdata(text, encoding):
    # 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;")
        return text.encode(encoding, "xmlcharrefreplace")
    except (TypeError, AttributeError):
        _raise_serialization_error(text)

def _escape_attrib(text, encoding):
    # 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;")
        if "\n" in text:
            text = text.replace("\n", "&#10;")
        return text.encode(encoding, "xmlcharrefreplace")
    except (TypeError, AttributeError):
        _raise_serialization_error(text)

def _escape_attrib_html(text, encoding):
    # 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.encode(encoding, "xmlcharrefreplace")
    except (TypeError, AttributeError):
        _raise_serialization_error(text)

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

##
# Generates a string representation of an XML element, including all
# subelements.
#
# @param element An Element instance.
# @keyparam encoding Optional output encoding (default is US-ASCII).
# @keyparam method Optional output method ("xml", "html", "text" or
#     "c14n"; default is "xml").
# @return An encoded string containing the XML data.
# @defreturn string

def tostring(element, encoding=None, method=None):
    class dummy:
        pass
    data = []
    file = dummy()
    file.write = data.append
    ElementTree(element).write(file, encoding, method=method)
    return "".join(data)

##
# Generates a string representation of an XML element, including all
# subelements.  The string is returned as a sequence of string fragments.
#
# @param element An Element instance.
# @keyparam encoding Optional output encoding (default is US-ASCII).
# @keyparam method Optional output method ("xml", "html", "text" or
#     "c14n"; default is "xml").
# @return A sequence object containing the XML data.
# @defreturn sequence
# @since 1.3

def tostringlist(element, encoding=None, method=None):
    class dummy:
        pass
    data = []
    file = dummy()
    file.write = data.append
    ElementTree(element).write(file, encoding, method=method)
    # FIXME: merge small fragments into larger parts
    return data

##
# Writes an element tree or element structure to sys.stdout.  This
# function should be used for debugging only.
# <p>
# The exact output format is implementation dependent.  In this
# version, it's written as an ordinary XML file.
#
# @param elem An element tree or an individual element.

def dump(elem):
    # debugging
    if not isinstance(elem, ElementTree):
        elem = ElementTree(elem)
    elem.write(sys.stdout)
    tail = elem.getroot().tail
    if not tail or tail[-1] != "\n":
        sys.stdout.write("\n")

# --------------------------------------------------------------------
# parsing

##
# Parses an XML document into an element tree.
#
# @param source A filename or file object containing XML data.
# @param parser An optional parser instance.  If not given, the
#     standard {@link XMLParser} parser is used.
# @return An ElementTree instance

def parse(source, parser=None):
    tree = ElementTree()
    tree.parse(source, parser)
    return tree

##
# Parses an XML document into an element tree incrementally, and reports
# what's going on to the user.
#
# @param source A filename or file object containing XML data.
# @param events A list of events to report back.  If omitted, only "end"
#     events are reported.
# @param parser An optional parser instance.  If not given, the
#     standard {@link XMLParser} parser is used.
# @return A (event, elem) iterator.

def iterparse(source, events=None, parser=None):
    close_source = False
    if not hasattr(source, "read"):
        source = open(source, "rb")
        close_source = True
    try:
        if not parser:
            parser = XMLParser(target=TreeBuilder())
        return _IterParseIterator(source, events, parser, close_source)
    except:
        if close_source:
            source.close()
        raise

class _IterParseIterator(object):

    def __init__(self, source, events, parser, close_source=False):
        self._file = source
        self._close_file = close_source
        self._events = []
        self._index = 0
        self._error = None
        self.root = self._root = None
        self._parser = parser
        # wire up the parser for event reporting
        parser = self._parser._parser
        append = self._events.append
        if events is None:
            events = ["end"]
        for event in events:
            if event == "start":
                try:
                    parser.ordered_attributes = 1
                    parser.specified_attributes = 1
                    def handler(tag, attrib_in, event=event, append=append,
                                start=self._parser._start_list):
                        append((event, start(tag, attrib_in)))
                    parser.StartElementHandler = handler
                except AttributeError:
                    def handler(tag, attrib_in, event=event, append=append,
                                start=self._parser._start):
                        append((event, start(tag, attrib_in)))
                    parser.StartElementHandler = handler
            elif event == "end":
                def handler(tag, event=event, append=append,
                            end=self._parser._end):
                    append((event, end(tag)))
                parser.EndElementHandler = handler
            elif event == "start-ns":
                def handler(prefix, uri, event=event, append=append):
                    try:
                        uri = (uri or "").encode("ascii")
                    except UnicodeError:
                        pass
                    append((event, (prefix or "", uri or "")))
                parser.StartNamespaceDeclHandler = handler
            elif event == "end-ns":
                def handler(prefix, event=event, append=append):
                    append((event, None))
                parser.EndNamespaceDeclHandler = handler
            else:
                raise ValueError("unknown event %r" % event)

    def next(self):
        try:
            while 1:
                try:
                    item = self._events[self._index]
                    self._index += 1
                    return item
                except IndexError:
                    pass
                if self._error:
                    e = self._error
                    self._error = None
                    raise e
                if self._parser is None:
                    self.root = self._root
                    break
                # load event buffer
                del self._events[:]
                self._index = 0
                data = self._file.read(16384)
                if data:
                    try:
                        self._parser.feed(data)
                    except SyntaxError as exc:
                        self._error = exc
                else:
                    self._root = self._parser.close()
                    self._parser = None
        except:
            if self._close_file:
                self._file.close()
            raise
        if self._close_file:
            self._file.close()
        raise StopIteration

    def __iter__(self):
        return self

##
# Parses an XML document from a string constant.  This function can
# be used to embed "XML literals" in Python code.
#
# @param source A string containing XML data.
# @param parser An optional parser instance.  If not given, the
#     standard {@link XMLParser} parser is used.
# @return An Element instance.
# @defreturn Element

def XML(text, parser=None):
    if not parser:
        parser = XMLParser(target=TreeBuilder())
    parser.feed(text)
    return parser.close()

##
# Parses an XML document from a string constant, and also returns
# a dictionary which maps from element id:s to elements.
#
# @param source A string containing XML data.
# @param parser An optional parser instance.  If not given, the
#     standard {@link XMLParser} parser is used.
# @return A tuple containing an Element instance and a dictionary.
# @defreturn (Element, dictionary)

def XMLID(text, parser=None):
    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

##
# Parses an XML document from a string constant.  Same as {@link #XML}.
#
# @def fromstring(text)
# @param source A string containing XML data.
# @return An Element instance.
# @defreturn Element

fromstring = XML

##
# Parses an XML document from a sequence of string fragments.
#
# @param sequence A list or other sequence containing XML data fragments.
# @param parser An optional parser instance.  If not given, the
#     standard {@link XMLParser} parser is used.
# @return An Element instance.
# @defreturn Element
# @since 1.3

def fromstringlist(sequence, parser=None):
    if not parser:
        parser = XMLParser(target=TreeBuilder())
    for text in sequence:
        parser.feed(text)
    return parser.close()

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

##
# Generic element structure builder.  This builder converts a sequence
# of {@link #TreeBuilder.start}, {@link #TreeBuilder.data}, and {@link
# #TreeBuilder.end} method calls to a well-formed element structure.
# <p>
# You can use this class to build an element structure using a custom XML
# parser, or a parser for some other XML-like format.
#
# @param element_factory Optional element factory.  This factory
#    is called to create new Element instances, as necessary.

class TreeBuilder(object):

    def __init__(self, element_factory=None):
        self._data = [] # data collector
        self._elem = [] # element stack
        self._last = None # last element
        self._tail = None # true if we're after an end tag
        if element_factory is None:
            element_factory = Element
        self._factory = element_factory

    ##
    # Flushes the builder buffers, and returns the toplevel document
    # element.
    #
    # @return An Element instance.
    # @defreturn Element

    def close(self):
        assert len(self._elem) == 0, "missing end tags"
        assert self._last is not None, "missing toplevel element"
        return self._last

    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 = []

    ##
    # Adds text to the current element.
    #
    # @param data A string.  This should be either an 8-bit string
    #    containing ASCII text, or a Unicode string.

    def data(self, data):
        self._data.append(data)

    ##
    # Opens a new element.
    #
    # @param tag The element name.
    # @param attrib A dictionary containing element attributes.
    # @return The opened element.
    # @defreturn Element

    def start(self, tag, attrs):
        self._flush()
        self._last = elem = self._factory(tag, attrs)
        if self._elem:
            self._elem[-1].append(elem)
        self._elem.append(elem)
        self._tail = 0
        return elem

    ##
    # Closes the current element.
    #
    # @param tag The element name.
    # @return The closed element.
    # @defreturn Element

    def end(self, tag):
        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

_sentinel = ['sentinel']

##
# Element structure builder for XML source data, based on the
# <b>expat</b> parser.
#
# @keyparam target Target object.  If omitted, the builder uses an
#     instance of the standard {@link #TreeBuilder} class.
# @keyparam html Predefine HTML entities.  This flag is not supported
#     by the current implementation.
# @keyparam encoding Optional encoding.  If given, the value overrides
#     the encoding specified in the XML file.
# @see #ElementTree
# @see #TreeBuilder

class XMLParser(object):

    def __init__(self, html=_sentinel, target=None, encoding=None):
        if html is not _sentinel:
            warnings.warnpy3k(
                "The html argument of XMLParser() is deprecated",
                DeprecationWarning, stacklevel=2)
        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
        # callbacks
        parser.DefaultHandlerExpand = self._default
        parser.StartElementHandler = self._start
        parser.EndElementHandler = self._end
        parser.CharacterDataHandler = self._data
        # optional callbacks
        parser.CommentHandler = self._comment
        parser.ProcessingInstructionHandler = self._pi
        # let expat do the buffering, if supported
        try:
            self._parser.buffer_text = 1
        except AttributeError:
            pass
        # use new-style attribute handling, if supported
        try:
            self._parser.ordered_attributes = 1
            self._parser.specified_attributes = 1
            parser.StartElementHandler = self._start_list
        except AttributeError:
            pass
        self._doctype = None
        self.entity = {}
        try:
            self.version = "Expat %d.%d.%d" % expat.version_info
        except AttributeError:
            pass # unknown

    def _raiseerror(self, value):
        err = ParseError(value)
        err.code = value.code
        err.position = value.lineno, value.offset
        raise err

    def _fixtext(self, text):
        # convert text string to ascii, if possible
        try:
            return text.encode("ascii")
        except UnicodeError:
            return text

    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 = self._fixtext(name)
        return name

    def _start(self, tag, attrib_in):
        fixname = self._fixname
        fixtext = self._fixtext
        tag = fixname(tag)
        attrib = {}
        for key, value in attrib_in.items():
            attrib[fixname(key)] = fixtext(value)
        return self.target.start(tag, attrib)

    def _start_list(self, tag, attrib_in):
        fixname = self._fixname
        fixtext = self._fixtext
        tag = fixname(tag)
        attrib = {}
        if attrib_in:
            for i in range(0, len(attrib_in), 2):
                attrib[fixname(attrib_in[i])] = fixtext(attrib_in[i+1])
        return self.target.start(tag, attrib)

    def _data(self, text):
        return self.target.data(self._fixtext(text))

    def _end(self, tag):
        return self.target.end(self._fixname(tag))

    def _comment(self, data):
        try:
            comment = self.target.comment
        except AttributeError:
            pass
        else:
            return comment(self._fixtext(data))

    def _pi(self, target, data):
        try:
            pi = self.target.pi
        except AttributeError:
            pass
        else:
            return pi(self._fixtext(target), self._fixtext(data))

    def _default(self, text):
        prefix = text[:1]
        if prefix == "&":
            # deal with undefined entities
            try:
                self.target.data(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
                elif type == "SYSTEM" and n == 3:
                    name, type, system = self._doctype
                    pubid = None
                else:
                    return
                if pubid:
                    pubid = pubid[1:-1]
                if hasattr(self.target, "doctype"):
                    self.target.doctype(name, pubid, system[1:-1])
                elif self.doctype != self._XMLParser__doctype:
                    # warn about deprecated call
                    self._XMLParser__doctype(name, pubid, system[1:-1])
                    self.doctype(name, pubid, system[1:-1])
                self._doctype = None

    ##
    # (Deprecated) Handles a doctype declaration.
    #
    # @param name Doctype name.
    # @param pubid Public identifier.
    # @param system System identifier.

    def doctype(self, name, pubid, system):
        """This method of XMLParser is deprecated."""
        warnings.warn(
            "This method of XMLParser is deprecated.  Define doctype() "
            "method on the TreeBuilder target.",
            DeprecationWarning,
            )

    # sentinel, if doctype is redefined in a subclass
    __doctype = doctype

    ##
    # Feeds data to the parser.
    #
    # @param data Encoded data.

    def feed(self, data):
        try:
            self._parser.Parse(data, 0)
        except self._error, v:
            self._raiseerror(v)

    ##
    # Finishes feeding data to the parser.
    #
    # @return An element structure.
    # @defreturn Element

    def close(self):
        try:
            self._parser.Parse("", 1) # end of data
        except self._error, v:
            self._raiseerror(v)
        tree = self.target.close()
        del self.target, self._parser # get rid of circular references
        return tree

# compatibility
XMLTreeBuilder = XMLParser

# workaround circular import.
try:
    from ElementC14N import _serialize_c14n
    _serialize["c14n"] = _serialize_c14n
except ImportError:
    pass
PK0![�>)>>etree/cElementTree.pynu�[���# Wrapper module for _elementtree

from _elementtree import *
PK0![U�2��)__pycache__/__init__.cpython-38.opt-2.pycnu�[���U

e5d-�@sddddgZdS)ZdomZparsersZsaxZetreeN)�__all__�rr�$/usr/lib64/python3.8/xml/__init__.py�<module>�PK0![�^���)__pycache__/__init__.cpython-38.opt-1.pycnu�[���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>sPK0![�^���#__pycache__/__init__.cpython-38.pycnu�[���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>sPK0![16���__init__.pynu�[���"""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"]

_MINIMUM_XMLPLUS_VERSION = (0, 8, 4)


try:
    import _xmlplus
except ImportError:
    pass
else:
    try:
        v = _xmlplus.version_info
    except AttributeError:
        # _xmlplus is too old; ignore it
        pass
    else:
        if v >= _MINIMUM_XMLPLUS_VERSION:
            import sys
            _xmlplus.__path__.extend(__path__)
            sys.modules[__name__] = _xmlplus
        else:
            del v
PK0![ <bX1X1sax/xmlreader.pynu�[���"""An XML Reader is the SAX 2 name for an XML parser. XML Parsers
should be based on this code. """

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):
        import saxutils
        source = saxutils.prepare_input_source(source)

        self.prepareParser(source)
        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 not name in self._attrs:
            raise KeyError, name
        return name

    def getQNameByName(self, name):
        if not name in self._attrs:
            raise KeyError, name
        return name

    def getNames(self):
        return self._attrs.keys()

    def getQNames(self):
        return self._attrs.keys()

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

    def __getitem__(self, name):
        return self._attrs[name]

    def keys(self):
        return self._attrs.keys()

    def has_key(self, name):
        return name in self._attrs

    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 self._attrs.items()

    def values(self):
        return 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 self._qnames.values()

    def copy(self):
        return self.__class__(self._attrs, self._qnames)


def _test():
    XMLReader()
    IncrementalParser()
    Locator()

if __name__ == "__main__":
    _test()
PK0![�b�B$-$-sax/saxutils.pynu�[���"""\
A library of useful helper classes to the SAX classes, for the
convenience of application and driver writers.
"""

import os, urlparse, urllib, types
import io
import sys
import handler
import xmlreader

try:
    _StringTypes = [types.StringType, types.UnicodeType]
except AttributeError:
    _StringTypes = [types.StringType]

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.copy()
    entities.update({'\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
        out = sys.stdout

    if isinstance(out, io.RawIOBase):
        buffer = io.BufferedIOBase(out)
        # Keep the original file open when the TextIOWrapper is
        # destroyed
        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
    # wrap a binary writer with TextIOWrapper
    return _UnbufferedTextIOWrapper(buffer, encoding=encoding,
                                   errors='xmlcharrefreplace',
                                   newline='\n')


class _UnbufferedTextIOWrapper(io.TextIOWrapper):
    def write(self, s):
        super(_UnbufferedTextIOWrapper, self).write(s)
        self.flush()


class XMLGenerator(handler.ContentHandler):

    def __init__(self, out=None, encoding="iso-8859-1"):
        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

    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]

    # ContentHandler methods

    def startDocument(self):
        self._write(u'<?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._write(u'<' + name)
        for (name, value) in attrs.items():
            self._write(u' %s=%s' % (name, quoteattr(value)))
        self._write(u'>')

    def endElement(self, name):
        self._write(u'</%s>' % name)

    def startElementNS(self, name, qname, attrs):
        self._write(u'<' + self._qname(name))

        for prefix, uri in self._undeclared_ns_maps:
            if prefix:
                self._write(u' xmlns:%s="%s"' % (prefix, uri))
            else:
                self._write(u' xmlns="%s"' % uri)
        self._undeclared_ns_maps = []

        for (name, value) in attrs.items():
            self._write(u' %s=%s' % (self._qname(name), quoteattr(value)))
        self._write(u'>')

    def endElementNS(self, name, qname):
        self._write(u'</%s>' % self._qname(name))

    def characters(self, content):
        if not isinstance(content, unicode):
            content = unicode(content, self._encoding)
        self._write(escape(content))

    def ignorableWhitespace(self, content):
        if not isinstance(content, unicode):
            content = unicode(content, self._encoding)
        self._write(content)

    def processingInstruction(self, target, data):
        self._write(u'<?%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 type(source) in _StringTypes:
        source = xmlreader.InputSource(source)
    elif hasattr(source, "read"):
        f = source
        source = xmlreader.InputSource()
        source.setByteStream(f)
        if hasattr(f, "name"):
            source.setSystemId(f.name)

    if source.getByteStream() is None:
        try:
            sysid = source.getSystemId()
            basehead = os.path.dirname(os.path.normpath(base))
            encoding = sys.getfilesystemencoding()
            if isinstance(sysid, unicode):
                if not isinstance(basehead, unicode):
                    try:
                        basehead = basehead.decode(encoding)
                    except UnicodeDecodeError:
                        sysid = sysid.encode(encoding)
            else:
                if isinstance(basehead, unicode):
                    try:
                        sysid = sysid.decode(encoding)
                    except UnicodeDecodeError:
                        basehead = basehead.encode(encoding)
            sysidfilename = os.path.join(basehead, sysid)
            isfile = os.path.isfile(sysidfilename)
        except UnicodeError:
            isfile = False
        if isfile:
            source.setSystemId(sysidfilename)
            f = open(sysidfilename, "rb")
        else:
            source.setSystemId(urlparse.urljoin(base, source.getSystemId()))
            f = urllib.urlopen(source.getSystemId())

        source.setByteStream(f)

    return source
PK0![�-�y2y2-sax/__pycache__/saxutils.cpython-38.opt-1.pycnu�[���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)soPK0![d�Tۈ0�0&sax/__pycache__/handler.cpython-38.pycnu�[���U

e5db6�@s�dZdZGdd�d�ZGdd�d�ZGdd�d�ZGdd	�d	�Zd
ZdZdZd
Z	dZ
dZeeee	e
egZdZ
dZdZdZdZdZe
eeeeegZdS)a0
This module contains the core classes of version 2.0 of SAX for Python.
This file provides only default classes with absolutely minimum
functionality, from which drivers and applications can be subclassed.

Many of these classes are empty and are included only as documentation
of the interfaces.

$Id$
z2.0betac@s(eZdZdZdd�Zdd�Zdd�ZdS)	�ErrorHandlera�Basic interface for SAX error handlers.

    If you create an object that implements this interface, then
    register the object with your XMLReader, the parser will call the
    methods in your object to report all warnings and errors. There
    are three levels of errors available: warnings, (possibly)
    recoverable errors, and unrecoverable errors. All methods take a
    SAXParseException as the only parameter.cCs|�dS)zHandle a recoverable error.N���selfZ	exceptionrr�'/usr/lib64/python3.8/xml/sax/handler.py�error szErrorHandler.errorcCs|�dS)zHandle a non-recoverable error.Nrrrrr�
fatalError$szErrorHandler.fatalErrorcCst|�dS)zHandle a warning.N)�printrrrr�warning(szErrorHandler.warningN)�__name__�
__module__�__qualname__�__doc__rrr	rrrrrs	rc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�ContentHandlerz�Interface for receiving logical document content events.

    This is the main callback interface in SAX, and the one most
    important to applications. The order of events in this interface
    mirrors the order of the information in the document.cCs
d|_dS)N�Z_locator�rrrr�__init__6szContentHandler.__init__cCs
||_dS)a#Called by the parser to give the application a locator for
        locating the origin of document events.

        SAX parsers are strongly encouraged (though not absolutely
        required) to supply a locator: if it does so, it must supply
        the locator to the application by invoking this method before
        invoking any of the other methods in the DocumentHandler
        interface.

        The locator allows the application to determine the end
        position of any document-related event, even if the parser is
        not reporting an error. Typically, the application will use
        this information for reporting its own errors (such as
        character content that does not match an application's
        business rules). The information returned by the locator is
        probably not sufficient for use with a search engine.

        Note that the locator will return correct information only
        during the invocation of the events in this interface. The
        application should not attempt to use it at any other time.Nr)rZlocatorrrr�setDocumentLocator9sz!ContentHandler.setDocumentLocatorcCsdS)z�Receive notification of the beginning of a document.

        The SAX parser will invoke this method only once, before any
        other methods in this interface or in DTDHandler (except for
        setDocumentLocator).Nrrrrr�
startDocumentPszContentHandler.startDocumentcCsdS)aQReceive notification of the end of a document.

        The SAX parser will invoke this method only once, and it will
        be the last method invoked during the parse. The parser shall
        not invoke this method until it has either abandoned parsing
        (because of an unrecoverable error) or reached the end of
        input.Nrrrrr�endDocumentWszContentHandler.endDocumentcCsdS)aBegin the scope of a prefix-URI Namespace mapping.

        The information from this event is not necessary for normal
        Namespace processing: the SAX XML reader will automatically
        replace prefixes for element and attribute names when the
        http://xml.org/sax/features/namespaces feature is true (the
        default).

        There are cases, however, when applications need to use
        prefixes in character data or in attribute values, where they
        cannot safely be expanded automatically; the
        start/endPrefixMapping event supplies the information to the
        application to expand prefixes in those contexts itself, if
        necessary.

        Note that start/endPrefixMapping events are not guaranteed to
        be properly nested relative to each-other: all
        startPrefixMapping events will occur before the corresponding
        startElement event, and all endPrefixMapping events will occur
        after the corresponding endElement event, but their order is
        not guaranteed.Nr)r�prefixZurirrr�startPrefixMapping`sz!ContentHandler.startPrefixMappingcCsdS)z�End the scope of a prefix-URI mapping.

        See startPrefixMapping for details. This event will always
        occur after the corresponding endElement event, but the order
        of endPrefixMapping events is not otherwise guaranteed.Nr)rrrrr�endPrefixMappingwszContentHandler.endPrefixMappingcCsdS)aSignals the start of an element in non-namespace mode.

        The name parameter contains the raw XML 1.0 name of the
        element type as a string and the attrs parameter holds an
        instance of the Attributes class containing the attributes of
        the element.Nr)r�name�attrsrrr�startElement~szContentHandler.startElementcCsdS)z�Signals the end of an element in non-namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElement event.Nr�rrrrr�
endElement�szContentHandler.endElementcCsdS)a�Signals the start of an element in namespace mode.

        The name parameter contains the name of the element type as a
        (uri, localname) tuple, the qname parameter the raw XML 1.0
        name used in the source document, and the attrs parameter
        holds an instance of the Attributes class containing the
        attributes of the element.

        The uri part of the name tuple is None for elements which have
        no namespace.Nr)rr�qnamerrrr�startElementNS�szContentHandler.startElementNScCsdS)z�Signals the end of an element in namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElementNS event.Nr)rrrrrr�endElementNS�szContentHandler.endElementNScCsdS)a�Receive notification of character data.

        The Parser will call this method to report each chunk of
        character data. SAX parsers may return all contiguous
        character data in a single chunk, or they may split it into
        several chunks; however, all of the characters in any single
        event must come from the same external entity so that the
        Locator provides useful information.Nr)rZcontentrrr�
characters�szContentHandler.characterscCsdS)awReceive notification of ignorable whitespace in element content.

        Validating Parsers must use this method to report each chunk
        of ignorable whitespace (see the W3C XML 1.0 recommendation,
        section 2.10): non-validating parsers may also use this method
        if they are capable of parsing and using content models.

        SAX parsers may return all contiguous whitespace in a single
        chunk, or they may split it into several chunks; however, all
        of the characters in any single event must come from the same
        external entity, so that the Locator provides useful
        information.Nr)rZ
whitespacerrr�ignorableWhitespace�sz"ContentHandler.ignorableWhitespacecCsdS)a�Receive notification of a processing instruction.

        The Parser will invoke this method once for each processing
        instruction found: note that processing instructions may occur
        before or after the main document element.

        A SAX parser should never report an XML declaration (XML 1.0,
        section 2.8) or a text declaration (XML 1.0, section 4.3.1)
        using this method.Nr)r�target�datarrr�processingInstruction�sz$ContentHandler.processingInstructioncCsdS)aReceive notification of a skipped entity.

        The Parser will invoke this method once for each entity
        skipped. Non-validating processors may skip entities if they
        have not seen the declarations (because, for example, the
        entity was declared in an external DTD subset). All processors
        may skip external entities, depending on the values of the
        http://xml.org/sax/features/external-general-entities and the
        http://xml.org/sax/features/external-parameter-entities
        properties.Nrrrrr�
skippedEntity�szContentHandler.skippedEntityN)r
rrr
rrrrrrrrrrr r!r$r%rrrrr/s	
rc@s eZdZdZdd�Zdd�ZdS)�
DTDHandlerz�Handle DTD events.

    This interface specifies only those DTD events required for basic
    parsing (unparsed entities and attributes).cCsdS)z$Handle a notation declaration event.Nr)rr�publicId�systemIdrrr�notationDecl�szDTDHandler.notationDeclcCsdS)z,Handle an unparsed entity declaration event.Nr)rrr'r(Zndatarrr�unparsedEntityDecl�szDTDHandler.unparsedEntityDeclN)r
rrr
r)r*rrrrr&�sr&c@seZdZdZdd�ZdS)�EntityResolvera7Basic interface for resolving entities. If you create an object
    implementing this interface, then register the object with your
    Parser, the parser will call the method in your object to
    resolve all external entities. Note that DefaultHandler implements
    this interface with the default behaviour.cCs|S)z�Resolve the system identifier of an entity and return either
        the system identifier to read from as a string, or an InputSource
        to read from.r)rr'r(rrr�
resolveEntity�szEntityResolver.resolveEntityN)r
rrr
r,rrrrr+�sr+z&http://xml.org/sax/features/namespacesz.http://xml.org/sax/features/namespace-prefixesz,http://xml.org/sax/features/string-interningz&http://xml.org/sax/features/validationz5http://xml.org/sax/features/external-general-entitiesz7http://xml.org/sax/features/external-parameter-entitiesz-http://xml.org/sax/properties/lexical-handlerz1http://xml.org/sax/properties/declaration-handlerz&http://xml.org/sax/properties/dom-nodez(http://xml.org/sax/properties/xml-stringz-http://www.python.org/sax/properties/encodingz3http://www.python.org/sax/properties/interning-dictN)r
�versionrrr&r+Zfeature_namespacesZfeature_namespace_prefixesZfeature_string_interningZfeature_validationZfeature_external_gesZfeature_external_pesZall_featuresZproperty_lexical_handlerZproperty_declaration_handlerZproperty_dom_nodeZproperty_xml_stringZproperty_encodingZproperty_interning_dictZall_propertiesrrrr�<module>s@
"��PK0![�-�y2y2'sax/__pycache__/saxutils.cpython-38.pycnu�[���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)soPK0![�(��0�00sax/__pycache__/expatreader.cpython-38.opt-1.pycnu�[���U

e5dX=�@s�dZdZddlTddlmZmZddlmZddlmZmZddlm	Z	ddlm
Z
mZdd	lZej
d	d
�dkr|edd	��[zdd
lmZWnek
r�edd	��YnXeed�s�edd	��ddlmZmZmZejZejZzdd	lZWnek
�rdd�ZYnXdd	lZejZ[[Gdd�d�ZGdd�dej�ZGdd�dej ej�Z!dd�Z"e#dk�r�dd	l$Z%e"�Z&e&�'e%j(j�)��e&�*e%j(�+��e&�,d�d	S)z]
SAX driver for the pyexpat C module.  This driver works with
pyexpat.__version__ == '2.22'.
z0.20�)�*)�feature_validation�feature_namespaces)�feature_namespace_prefixes)�feature_external_ges�feature_external_pes)�feature_string_interning)�property_xml_string�property_interning_dictN��javazexpat not available in Java)�expatzexpat not supported�ParserCreate)�	xmlreader�saxutils�handlercCs|S�N�)�orr�+/usr/lib64/python3.8/xml/sax/expatreader.py�_mkproxy'src@seZdZdS)�
_ClosedParserN)�__name__�
__module__�__qualname__rrrrr.src@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�ExpatLocatorz�Locator for use with the ExpatParser class.

    This uses a weak reference to the parser object to avoid creating
    a circular reference between the parser and the content handler.
    cCst|�|_dSr)r�_ref��self�parserrrr�__init__9szExpatLocator.__init__cCs|j}|jdkrdS|jjSr)r�_parser�ErrorColumnNumberrrrr�getColumnNumber<s
zExpatLocator.getColumnNumbercCs|j}|jdkrdS|jjS�N�)rr!�ErrorLineNumberrrrr�
getLineNumberBs
zExpatLocator.getLineNumbercCs|j}|dkrdS|j��Sr)r�_source�getPublicIdrrrrr)HszExpatLocator.getPublicIdcCs|j}|dkrdS|j��Sr)rr(�getSystemIdrrrrr*NszExpatLocator.getSystemIdN)	rrr�__doc__r r#r'r)r*rrrrr3src@seZdZdZdCdd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�ZdDdd�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�Zd:d;�Zd<d=�Z d>d?�Z!d@dA�Z"dBS)E�ExpatParserz$SAX driver for the pyexpat C module.r��cCsFtj�||�t��|_d|_||_d|_d|_g|_	d|_
d|_dS)Nr)r�IncrementalParserr ZInputSourcer(r!�_namespaces�_lex_handler_prop�_parsing�
_entity_stack�
_external_ges�
_interning)rZnamespaceHandling�bufsizerrrr Zs
zExpatParser.__init__cCsVt�|�}||_z*|��|j�t|��tj�	||�Wn|�
��YnXdS)z3Parse an XML document from a URL or an InputSource.N)r�prepare_input_sourcer(�reset�
_cont_handlerZsetDocumentLocatorrrr.�parse�
_close_source�r�sourcerrrr9gs
zExpatParser.parsecCs |��dk	r|j�|���dSr)r*r!ZSetBaser;rrr�
prepareParserwszExpatParser.prepareParsercCs tj�||�|jr|��dSr)rr.�setContentHandlerr1�_reset_cont_handler)rrrrrr>}szExpatParser.setContentHandlercCsP|tkr|jS|tkr |jdk	S|tttfkr2dS|tkr@|jSt	d|��dS)Nr�Feature '%s' not recognized)
rr/rr4rrrrr3�SAXNotRecognizedException�r�namerrr�
getFeature�s
�zExpatParser.getFeaturecCs�|jrtd��|tkr||_n�|tkr.||_nt|tkrT|rL|jdkrRi|_q�d|_nN|tkrj|r�td��n8|t	kr�|r�td��n"|t
kr�|r�td��ntd|��dS)Nz!Cannot set features while parsingz!expat does not support validationz/expat does not read external parameter entitiesz(expat does not report namespace prefixesr@)r1�SAXNotSupportedExceptionrr/rr3rr4rrrrA)rrC�staterrr�
setFeature�s:
����zExpatParser.setFeaturecCsd|tjkr|jS|tkr|jS|tkrT|jrLt|jd�rB|j��St	d��nt
d��t	d|��dS)N�GetInputContextz=This version of expat does not support getting the XML stringz.XML string cannot be returned when not parsing�Property '%s' not recognized)r�property_lexical_handlerr0r
r4r	r!�hasattrrHrArErBrrr�getProperty�s

��zExpatParser.getPropertycCsV|tjkr ||_|jrR|��n2|tkr0||_n"|tkrFtd|��nt	d|��dS)NzProperty '%s' cannot be setrI)
rrJr0r1�_reset_lex_handler_propr
r4r	rErA)rrC�valuerrr�setProperty�s

��zExpatParser.setPropertyc
Csz|js|��d|_|j��z|j�||�WnDtjk
rt}z$tt�	|j
�||�}|j�|�W5d}~XYnXdSr$)
r1r7r8Z
startDocumentr!ZParser
�errorZSAXParseExceptionZErrorString�codeZ_err_handlerZ
fatalError)r�data�isFinal�e�excrrr�feed�s
zExpatParser.feedcCsB|j}z|��}|dk	r |��W5|��}|dk	r<|��XdSr)r(Z
getByteStream�closeZgetCharacterStream)rr<�filerrrr:�szExpatParser._close_sourcecCs�|js|jdkst|jt�r dSz(|jddd�|j	�
�d|_d|_W5d|_|jdk	rzt�}|jj|_|jj|_||_|��XdS)Nr�r%)rS)r2r!�
isinstancerr1r"r&r:rVr8ZendDocumentrrrrrW�s 
�




zExpatParser.closecCs|jj|j_|jj|j_dSr)r8�processingInstructionr!ZProcessingInstructionHandler�
charactersZCharacterDataHandler�rrrrr?�s�zExpatParser._reset_cont_handlercCs`|j}|j}|dkr4d|_d|_d|_d|_d|_n(|j|_|j|_|j	|_|j
|_|j|_dSr)r0r!ZCommentHandlerZStartCdataSectionHandlerZEndCdataSectionHandlerZStartDoctypeDeclHandlerZEndDoctypeDeclHandlerZcommentZ
startCDATAZendCDATA�start_doctype_declZendDTD)rZlexrrrrrMsz#ExpatParser._reset_lex_handler_propcCs�|jr>tj|j��d|jd�|_d|j_|j|j_	|j
|j_n,tj|j��|jd�|_|j|j_	|j
|j_|��|j|j_|j|j_|j|j_|j|j_d|_|jr�|��|j|j_z|j|j_Wntk
r�YnX|j�tj �d|_!g|_"dS)N� )�internr%r)#r/r
rr(ZgetEncodingr4r!Znamespace_prefixes�start_element_nsZStartElementHandler�end_element_nsZEndElementHandler�
start_element�end_elementr?�unparsed_entity_declZUnparsedEntityDeclHandler�
notation_declZNotationDeclHandler�start_namespace_declZStartNamespaceDeclHandler�end_namespace_declZEndNamespaceDeclHandlerZ_decl_handler_propr0rM�external_entity_refZExternalEntityRefHandler�skipped_entity_handlerZSkippedEntityHandler�AttributeErrorZSetParamEntityParsingZ*XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONEr1r2r]rrrr7s<�
�






�zExpatParser.resetcCs|jdkrdS|jjSr)r!r"r]rrrr#;s
zExpatParser.getColumnNumbercCs|jdkrdS|jjSr$)r!r&r]rrrr'@s
zExpatParser.getLineNumbercCs
|j��Sr)r(r)r]rrrr)EszExpatParser.getPublicIdcCs
|j��Sr)r(r*r]rrrr*HszExpatParser.getSystemIdcCs|j�|t|��dSr)r8ZstartElement�AttributesImpl)rrC�attrsrrrrcLszExpatParser.start_elementcCs|j�|�dSr)r8Z
endElementrBrrrrdOszExpatParser.end_elementcCs�|��}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}i}i}|��D]|\}}|��}t|�}	|	dkr�|}
d|f}n>|	dkr�d|d|df}
|d|df}n|d}
t|�}|||<|
||<qT|j�|dt||��dS)Nr%�rz%s:%s�)�split�len�tuple�itemsr8ZstartElementNS�AttributesNSImpl)rrCrm�pairZnewattrsZqnamesZanamerN�partsZlengthZqnameZapairrrrraRs0



�zExpatParser.start_element_nscCsV|��}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}|j�|d�dS)Nr%rnr)rprqrrr8ZendElementNS)rrCrurrrrbts
zExpatParser.end_element_nscCs|j�||�dSr)r8r[)r�targetrRrrr�processing_instruction�sz"ExpatParser.processing_instructioncCs|j�|�dSr)r8r\)rrRrrr�character_data�szExpatParser.character_datacCs|j�||�dSr)r8ZstartPrefixMapping)r�prefixZurirrrrg�sz ExpatParser.start_namespace_declcCs|j�|�dSr)r8ZendPrefixMapping)rrzrrrrh�szExpatParser.end_namespace_declcCs|j�|||�dSr)r0ZstartDTD)rrC�sysid�pubidZhas_internal_subsetrrrr^�szExpatParser.start_doctype_declcCs|j�||||�dSr)�_dtd_handlerZunparsedEntityDecl)rrC�baser{r|Z
notation_namerrrre�sz ExpatParser.unparsed_entity_declcCs|j�|||�dSr)r}ZnotationDecl)rrCr~r{r|rrrrf�szExpatParser.notation_declcCs�|js
dS|j�||�}t�||j��p*d�}|j�|j	|jf�|j	�
|�|_	||_ztj�
||�WnYdSX|jd\|_	|_|jd=dS)Nr%rYr���)r3Z_ent_handlerZ
resolveEntityrr6r(r*r2�appendr!ZExternalEntityParserCreaterr.r9)r�contextr~r{r|r<rrrri�s"
�zExpatParser.external_entity_refcCs|rd|}|j�|�dS)N�%)r8Z
skippedEntity)rrCZis_perrrrj�sz"ExpatParser.skipped_entity_handlerN)rr-)r)#rrrr+r r9r=r>rDrGrLrOrVr:rWr?rMr7r#r'r)r*rcrdrarbrxryrgrhr^rerfrirjrrrrr,Ws@


'"r,cOs
t||�Sr)r,)�args�kwargsrrr�
create_parser�sr��__main__z:http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml)-r+�versionZxml.sax._exceptionsZxml.sax.handlerrrrrrrr	r
�sys�platformZSAXReaderNotAvailableZxml.parsersr
�ImportErrorrKZxml.saxrrrrlrt�_weakrefr�weakref�proxyrZLocatorrr.r,r�rZxml.sax.saxutilsZxml�pr>ZsaxZXMLGeneratorZsetErrorHandlerZErrorHandlerr9rrrr�<module>sN


$_
PK0![�nn-sax/__pycache__/__init__.cpython-38.opt-2.pycnu�[���U

e5d?�@sddlmZddlmZmZddlmZmZmZm	Z	m
Z
e�fdd�Ze�fdd�ZdgZ
d	Zerjd	d
lZd	d
lZd	d
lZejjs�dejkr�ejd�d�Z
[d
Zejd
d�dkr�ej�e�r�ej�e��d�Z
ddd�Zejd
d�dkr�dd�Zndd�Z[d
S)�)�InputSource)�ContentHandler�ErrorHandler)�SAXException�SAXNotRecognizedException�SAXParseException�SAXNotSupportedException�SAXReaderNotAvailablecCs(t�}|�|�|�|�|�|�dS)N)�make_parser�setContentHandler�setErrorHandler�parse)�source�handler�errorHandler�parser�r�(/usr/lib64/python3.8/xml/sax/__init__.pyr
s

r
cCspddl}|dkrt�}t�}|�|�|�|�t�}t|t�rR|�|�	|��n|�
|�|��|�|�dS)N�)
�iorr
rrr�
isinstance�strZsetCharacterStream�StringIOZ
setByteStream�BytesIOr
)�stringrrrrZinpsrcrrr�parseString#s


rzxml.sax.expatreaderrNZ
PY_SAX_PARSER�,zpython.xml.sax.parser��javarcCsxt|�tD]\}zt|�WStk
rT}zddl}||jkrD�W5d}~XYqtk
rfYqXqtdd��dS)NrzNo parsers found)�list�default_parser_list�_create_parser�ImportError�sys�modulesr	)Zparser_list�parser_name�er#rrrr
Fs
r
cCs$ddlm}|�|dt��}|��S)Nr)�imp)Zorg.python.corer'Z
importName�globals�
create_parser)r%r'�
drv_modulerrrr!asr!cCst|iidg�}|��S)Nr))�
__import__r))r%r*rrrr!gs)r)Z	xmlreaderrrrr�_exceptionsrrrrr	r
rr �_falseZxml.sax.expatreaderZxml�osr#�flags�ignore_environment�environ�splitZ_key�platform�registryZcontainsKeyZgetPropertyr
r!rrrr�<module>s(

PK0![�Z�;�A�A.sax/__pycache__/xmlreader.cpython-38.opt-1.pycnu�[���U

e5d�1�@s�dZddlmZddlmZmZGdd�d�ZGdd�de�ZGdd	�d	�ZGd
d�d�Z	Gdd
�d
�Z
Gdd�de
�Zdd�Ze
dkr�e�dS)z]An XML Reader is the SAX 2 name for an XML parser. XML Parsers
should be based on this code. �)�handler)�SAXNotSupportedException�SAXNotRecognizedExceptionc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd S)!�	XMLReadera%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.cCs,t��|_t��|_t��|_t��|_dS�N)	rZContentHandler�
_cont_handlerZ
DTDHandler�_dtd_handlerZEntityResolver�_ent_handlerZErrorHandler�_err_handler��self�r
�)/usr/lib64/python3.8/xml/sax/xmlreader.py�__init__s


zXMLReader.__init__cCstd��dS)zAParse an XML document from a system identifier or an InputSource.� This method must be implemented!N��NotImplementedError�r�sourcer
r
r�parseszXMLReader.parsecCs|jS)z#Returns the current ContentHandler.�rrr
r
r�getContentHandler"szXMLReader.getContentHandlercCs
||_dS)z:Registers a new object to receive document content events.Nr�rrr
r
r�setContentHandler&szXMLReader.setContentHandlercCs|jS)z Returns the current DTD handler.�rrr
r
r�
getDTDHandler*szXMLReader.getDTDHandlercCs
||_dS)z7Register an object to receive basic DTD-related events.Nrrr
r
r�
setDTDHandler.szXMLReader.setDTDHandlercCs|jS)z#Returns the current EntityResolver.�r	rr
r
r�getEntityResolver2szXMLReader.getEntityResolvercCs
||_dS)z0Register an object to resolve external entities.Nr)rZresolverr
r
r�setEntityResolver6szXMLReader.setEntityResolvercCs|jS)z!Returns the current ErrorHandler.�r
rr
r
r�getErrorHandler:szXMLReader.getErrorHandlercCs
||_dS)z3Register an object to receive error-message events.Nr rr
r
r�setErrorHandler>szXMLReader.setErrorHandlercCstd��dS)aHAllow 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.zLocale support not implementedN)r)rZlocaler
r
r�	setLocaleBszXMLReader.setLocalecCstd|��dS)z1Looks up and returns the state of a SAX2 feature.�Feature '%s' not recognizedN�r�r�namer
r
r�
getFeatureKszXMLReader.getFeaturecCstd|��dS)z!Sets the state of a SAX2 feature.r$Nr%)rr'�stater
r
r�
setFeatureOszXMLReader.setFeaturecCstd|��dS)z2Looks up and returns the value of a SAX2 property.�Property '%s' not recognizedNr%r&r
r
r�getPropertySszXMLReader.getPropertycCstd|��dS)z"Sets the value of a SAX2 property.r+Nr%)rr'�valuer
r
r�setPropertyWszXMLReader.setPropertyN)�__name__�
__module__�__qualname__�__doc__rrrrrrrrr!r"r#r(r*r,r.r
r
r
rrs 	rc@sBeZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dS)�IncrementalParserasThis 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.�cCs||_t�|�dSr)�_bufsizerr)r�bufsizer
r
rroszIncrementalParser.__init__cCslddlm}|�|�}|�|�|��}|dkr8|��}|�|j�}|r`|�|�|�|j�}qD|�	�dS)Nr)�saxutils)
�r7Zprepare_input_source�
prepareParser�getCharacterStream�
getByteStream�readr5�feed�close)rrr7�file�bufferr
r
rrss


zIncrementalParser.parsecCstd��dS)aThis 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.rNr)r�datar
r
rr=�szIncrementalParser.feedcCstd��dS)ztThis method is called by the parse implementation to allow
        the SAX 2.0 driver to prepare itself for parsing.z!prepareParser must be overridden!Nrrr
r
rr9�szIncrementalParser.prepareParsercCstd��dS)a�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.rNrrr
r
rr>�szIncrementalParser.closecCstd��dS)z�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.rNrrr
r
r�reset�szIncrementalParser.resetN)r4)
r/r0r1r2rrr=r9r>rBr
r
r
rr3[s
	
r3c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�Locatorz�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.cCsdS)z6Return the column number where the current event ends.���r
rr
r
r�getColumnNumber�szLocator.getColumnNumbercCsdS)z4Return the line number where the current event ends.rDr
rr
r
r�
getLineNumber�szLocator.getLineNumbercCsdS)z3Return the public identifier for the current event.Nr
rr
r
r�getPublicId�szLocator.getPublicIdcCsdS)z3Return the system identifier for the current event.Nr
rr
r
r�getSystemId�szLocator.getSystemIdN)r/r0r1r2rErFrGrHr
r
r
rrC�s
rCc@sjeZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�ZdS)�InputSourceanEncapsulation 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.NcCs"||_d|_d|_d|_d|_dSr)�_InputSource__system_id�_InputSource__public_id�_InputSource__encoding�_InputSource__bytefile�_InputSource__charfile�rZ	system_idr
r
rr�s
zInputSource.__init__cCs
||_dS)z/Sets the public identifier of this InputSource.N�rK)rZ	public_idr
r
r�setPublicId�szInputSource.setPublicIdcCs|jS)z2Returns the public identifier of this InputSource.rPrr
r
rrG�szInputSource.getPublicIdcCs
||_dS)z/Sets the system identifier of this InputSource.N�rJrOr
r
r�setSystemId�szInputSource.setSystemIdcCs|jS)z2Returns the system identifier of this InputSource.rRrr
r
rrH�szInputSource.getSystemIdcCs
||_dS)a4Sets 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.N�rL)r�encodingr
r
r�setEncoding�szInputSource.setEncodingcCs|jS)z/Get the character encoding of this InputSource.rTrr
r
r�getEncoding�szInputSource.getEncodingcCs
||_dS)a�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.N�rM)rZbytefiler
r
r�
setByteStream�szInputSource.setByteStreamcCs|jS)z�Get the byte stream for this input source.

        The getEncoding method will return the character encoding for
        this byte stream, or None if unknown.rXrr
r
rr;�szInputSource.getByteStreamcCs
||_dS)a^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.N�rN)rZcharfiler
r
r�setCharacterStreamszInputSource.setCharacterStreamcCs|jS)z/Get the character stream for this input source.rZrr
r
rr:szInputSource.getCharacterStream)N)r/r0r1r2rrQrGrSrHrVrWrYr;r[r:r
r
r
rrI�s



rIc@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zd$dd�Zdd�Zd d!�Zd"d#�ZdS)%�AttributesImplcCs
||_dS)zQNon-NS-aware implementation.

        attrs should be of the form {name : value}.N��_attrs)r�attrsr
r
rrszAttributesImpl.__init__cCs
t|j�Sr��lenr^rr
r
r�	getLengthszAttributesImpl.getLengthcCsdS)NZCDATAr
r&r
r
r�getType!szAttributesImpl.getTypecCs
|j|Srr]r&r
r
r�getValue$szAttributesImpl.getValuecCs
|j|Srr]r&r
r
r�getValueByQName'szAttributesImpl.getValueByQNamecCs||jkrt|��|Sr�r^�KeyErrorr&r
r
r�getNameByQName*s
zAttributesImpl.getNameByQNamecCs||jkrt|��|Srrfr&r
r
r�getQNameByName/s
zAttributesImpl.getQNameByNamecCst|j���Sr��listr^�keysrr
r
r�getNames4szAttributesImpl.getNamescCst|j���Srrjrr
r
r�	getQNames7szAttributesImpl.getQNamescCs
t|j�Srr`rr
r
r�__len__:szAttributesImpl.__len__cCs
|j|Srr]r&r
r
r�__getitem__=szAttributesImpl.__getitem__cCst|j���Srrjrr
r
rrl@szAttributesImpl.keyscCs
||jkSrr]r&r
r
r�__contains__CszAttributesImpl.__contains__NcCs|j�||�Sr)r^�get)rr'�alternativer
r
rrrFszAttributesImpl.getcCs|�|j�Sr)�	__class__r^rr
r
r�copyIszAttributesImpl.copycCst|j���Sr)rkr^�itemsrr
r
rrvLszAttributesImpl.itemscCst|j���Sr)rkr^�valuesrr
r
rrwOszAttributesImpl.values)N)r/r0r1rrbrcrdrerhrirmrnrorprlrqrrrurvrwr
r
r
rr\s"
r\c@s<eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�AttributesNSImplcCs||_||_dS)z�NS-aware implementation.

        attrs should be of the form {(ns_uri, lname): value, ...}.
        qnames of the form {(ns_uri, lname): qname, ...}.N)r^�_qnames)rr_Zqnamesr
r
rrVszAttributesNSImpl.__init__cCs6|j��D]\}}||kr
|j|Sq
t|��dSr)ryrvr^rg�rr'ZnsnameZqnamer
r
rre^sz AttributesNSImpl.getValueByQNamecCs0|j��D]\}}||kr
|Sq
t|��dSr)ryrvrgrzr
r
rrhes
zAttributesNSImpl.getNameByQNamecCs
|j|Sr)ryr&r
r
rrilszAttributesNSImpl.getQNameByNamecCst|j���Sr)rkryrwrr
r
rrnoszAttributesNSImpl.getQNamescCs|�|j|j�Sr)rtr^ryrr
r
rrurszAttributesNSImpl.copyN)	r/r0r1rrerhrirnrur
r
r
rrxTsrxcCst�t�t�dSr)rr3rCr
r
r
r�_testvsr{�__main__N)r2r8r�_exceptionsrrrr3rCrIr\rxr{r/r
r
r
r�<module>sPJY>"PK0![e=�--,sax/__pycache__/handler.cpython-38.opt-2.pycnu�[���U

e5db6�@s�dZGdd�d�ZGdd�d�ZGdd�d�ZGdd�d�Zd	Zd
ZdZdZd
Z	dZ
eeeee	e
gZdZdZ
dZdZdZdZeee
eeegZdS)z2.0betac@s$eZdZdd�Zdd�Zdd�ZdS)�ErrorHandlercCs|�dS�N���selfZ	exceptionrr�'/usr/lib64/python3.8/xml/sax/handler.py�error szErrorHandler.errorcCs|�dSrrrrrr�
fatalError$szErrorHandler.fatalErrorcCst|�dSr)�printrrrr�warning(szErrorHandler.warningN)�__name__�
__module__�__qualname__rrr
rrrrrs
rc@s|eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�ZdS)�ContentHandlercCs
d|_dSr�Z_locator�rrrr�__init__6szContentHandler.__init__cCs
||_dSrr)rZlocatorrrr�setDocumentLocator9sz!ContentHandler.setDocumentLocatorcCsdSrrrrrr�
startDocumentPszContentHandler.startDocumentcCsdSrrrrrr�endDocumentWszContentHandler.endDocumentcCsdSrr)r�prefixZurirrr�startPrefixMapping`sz!ContentHandler.startPrefixMappingcCsdSrr)rrrrr�endPrefixMappingwszContentHandler.endPrefixMappingcCsdSrr)r�name�attrsrrr�startElement~szContentHandler.startElementcCsdSrr�rrrrr�
endElement�szContentHandler.endElementcCsdSrr)rr�qnamerrrr�startElementNS�szContentHandler.startElementNScCsdSrr)rrrrrr�endElementNS�szContentHandler.endElementNScCsdSrr)rZcontentrrr�
characters�szContentHandler.characterscCsdSrr)rZ
whitespacerrr�ignorableWhitespace�sz"ContentHandler.ignorableWhitespacecCsdSrr)r�target�datarrr�processingInstruction�sz$ContentHandler.processingInstructioncCsdSrrrrrr�
skippedEntity�szContentHandler.skippedEntityN)rrr
rrrrrrrrrrr r!r$r%rrrrr/s	
rc@seZdZdd�Zdd�ZdS)�
DTDHandlercCsdSrr)rr�publicId�systemIdrrr�notationDecl�szDTDHandler.notationDeclcCsdSrr)rrr'r(Zndatarrr�unparsedEntityDecl�szDTDHandler.unparsedEntityDeclN)rrr
r)r*rrrrr&�sr&c@seZdZdd�ZdS)�EntityResolvercCs|Srr)rr'r(rrr�
resolveEntity�szEntityResolver.resolveEntityN)rrr
r,rrrrr+�sr+z&http://xml.org/sax/features/namespacesz.http://xml.org/sax/features/namespace-prefixesz,http://xml.org/sax/features/string-interningz&http://xml.org/sax/features/validationz5http://xml.org/sax/features/external-general-entitiesz7http://xml.org/sax/features/external-parameter-entitiesz-http://xml.org/sax/properties/lexical-handlerz1http://xml.org/sax/properties/declaration-handlerz&http://xml.org/sax/properties/dom-nodez(http://xml.org/sax/properties/xml-stringz-http://www.python.org/sax/properties/encodingz3http://www.python.org/sax/properties/interning-dictN)�versionrrr&r+Zfeature_namespacesZfeature_namespace_prefixesZfeature_string_interningZfeature_validationZfeature_external_gesZfeature_external_pesZall_featuresZproperty_lexical_handlerZproperty_declaration_handlerZproperty_dom_nodeZproperty_xml_stringZproperty_encodingZproperty_interning_dictZall_propertiesrrrr�<module>s>
"��PK0![��FF*sax/__pycache__/_exceptions.cpython-38.pycnu�[���U

e5d��@s�dZddlZejdd�dkr*ddlmZ[Gdd�de�ZGdd	�d	e�ZGd
d�de�ZGdd
�d
e�ZGdd�de�Z	dS)z!Different kinds of SAX Exceptions�N��java)�	Exceptionc@s:eZdZdZd
dd�Zdd�Zdd�Zd	d
�Zdd�ZdS)�SAXExceptiona�Encapsulate an XML error or warning. This class can contain
    basic error or warning information from either the XML parser or
    the application: you can subclass it to provide additional
    functionality, or to add localization. Note that although you will
    receive a SAXException as the argument to the handlers in the
    ErrorHandler interface, you are not actually required to raise
    the exception; instead, you can simply read the information in
    it.NcCs||_||_t�||�dS)zUCreates an exception. The message is required, but the exception
        is optional.N)�_msg�
_exceptionr�__init__)�self�msg�	exception�r�+/usr/lib64/python3.8/xml/sax/_exceptions.pyrszSAXException.__init__cCs|jS)z$Return a message for this exception.�r�r	rrr
�
getMessageszSAXException.getMessagecCs|jS)z9Return the embedded exception, or None if there was none.)rrrrr
�getExceptionszSAXException.getExceptioncCs|jS)�0Create a string representation of the exception.rrrrr
�__str__"szSAXException.__str__cCstd��dS)zvAvoids weird error messages if someone does exception[ix] by
        mistake, since Exception has __getitem__ defined.�__getitem__N)�AttributeError)r	Zixrrr
r&szSAXException.__getitem__)N)	�__name__�
__module__�__qualname__�__doc__rrrrrrrrr
r	s	
rc@s@eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�SAXParseExceptiona#Encapsulate an XML parse error or warning.

    This exception will include information for locating the error in
    the original XML document. Note that although the application will
    receive a SAXParseException as the argument to the handlers in the
    ErrorHandler interface, the application is not actually required
    to raise the exception; instead, it can simply read the
    information in it and take a different action.

    Since this exception is a subclass of SAXException, it inherits
    the ability to wrap another exception.cCs<t�|||�||_|j��|_|j��|_|j��|_dS)zECreates the exception. The exception parameter is allowed to be None.N)	rr�_locator�getSystemId�	_systemId�getColumnNumber�_colnum�
getLineNumber�_linenum)r	r
rZlocatorrrr
r;s
zSAXParseException.__init__cCs|jS)zNThe column number of the end of the text where the exception
        occurred.)rrrrr
rHsz!SAXParseException.getColumnNumbercCs|jS)zDThe line number of the end of the text where the exception occurred.)r!rrrr
r MszSAXParseException.getLineNumbercCs
|j��S)zEGet the public identifier of the entity where the exception occurred.)r�getPublicIdrrrr
r"QszSAXParseException.getPublicIdcCs|jS)zEGet the system identifier of the entity where the exception occurred.)rrrrr
rUszSAXParseException.getSystemIdcCsN|��}|dkrd}|��}|dkr(d}|��}|dkr<d}d||||jfS)rNz	<unknown>�?z%s:%s:%s: %s)rr rr)r	ZsysidZlinenumZcolnumrrr
rYszSAXParseException.__str__N)
rrrrrrr r"rrrrrr
r.s
rc@seZdZdZdS)�SAXNotRecognizedExceptionz�Exception class for an unrecognized identifier.

    An XMLReader will raise this exception when it is confronted with an
    unrecognized feature or property. SAX applications and extensions may
    use this class for similar purposes.N�rrrrrrrr
r$isr$c@seZdZdZdS)�SAXNotSupportedExceptionaException class for an unsupported operation.

    An XMLReader will raise this exception when a service it cannot
    perform is requested (specifically setting a state or value). SAX
    applications and extensions may use this class for similar
    purposes.Nr%rrrr
r&ssr&c@seZdZdZdS)�SAXReaderNotAvailableaException class for a missing driver.

    An XMLReader module (driver) should raise this exception when it
    is first imported, e.g. when a support module cannot be imported.
    It also may be raised during parsing, e.g. if executing an external
    program is not permitted.Nr%rrrr
r'}sr')
r�sys�platformZ	java.langrrrr$r&r'rrrr
�<module>s%;

PK0![���6/6/0sax/__pycache__/expatreader.cpython-38.opt-2.pycnu�[���U

e5dX=�@s�dZddlTddlmZmZddlmZddlmZmZddlmZddlm	Z	m
Z
ddlZejdd	�d
krxe
dd��[zddlmZWnek
r�e
d
d��YnXeed�s�e
d
d��ddlmZmZmZejZejZzddlZWnek
�rdd�ZYnXddlZejZ[[Gdd�d�ZGdd�dej�ZGdd�dejej�Z dd�Z!e"dk�r�ddl#Z$e!�Z%e%�&e$j'j�(��e%�)e$j'�*��e%�+d�dS)z0.20�)�*)�feature_validation�feature_namespaces)�feature_namespace_prefixes)�feature_external_ges�feature_external_pes)�feature_string_interning)�property_xml_string�property_interning_dictN��javazexpat not available in Java)�expatzexpat not supported�ParserCreate)�	xmlreader�saxutils�handlercCs|S�N�)�orr�+/usr/lib64/python3.8/xml/sax/expatreader.py�_mkproxy'src@seZdZdS)�
_ClosedParserN)�__name__�
__module__�__qualname__rrrrr.src@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�ExpatLocatorcCst|�|_dSr)r�_ref��self�parserrrr�__init__9szExpatLocator.__init__cCs|j}|jdkrdS|jjSr)r�_parser�ErrorColumnNumberrrrr�getColumnNumber<s
zExpatLocator.getColumnNumbercCs|j}|jdkrdS|jjS�N�)rr!�ErrorLineNumberrrrr�
getLineNumberBs
zExpatLocator.getLineNumbercCs|j}|dkrdS|j��Sr)r�_source�getPublicIdrrrrr)HszExpatLocator.getPublicIdcCs|j}|dkrdS|j��Sr)rr(�getSystemIdrrrrr*NszExpatLocator.getSystemIdN)rrrr r#r'r)r*rrrrr3s
rc@seZdZdBdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Zdd�Z	dd�Z
dCdd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;d<�Zd=d>�Z d?d@�Z!dAS)D�ExpatParserr��cCsFtj�||�t��|_d|_||_d|_d|_g|_	d|_
d|_dS)Nr)r�IncrementalParserr ZInputSourcer(r!�_namespaces�_lex_handler_prop�_parsing�
_entity_stack�
_external_ges�
_interning)rZnamespaceHandling�bufsizerrrr Zs
zExpatParser.__init__cCsVt�|�}||_z*|��|j�t|��tj�	||�Wn|�
��YnXdSr)r�prepare_input_sourcer(�reset�
_cont_handlerZsetDocumentLocatorrrr-�parse�
_close_source�r�sourcerrrr8gs
zExpatParser.parsecCs |��dk	r|j�|���dSr)r*r!ZSetBaser:rrr�
prepareParserwszExpatParser.prepareParsercCs tj�||�|jr|��dSr)rr-�setContentHandlerr0�_reset_cont_handler)rrrrrr=}szExpatParser.setContentHandlercCsP|tkr|jS|tkr |jdk	S|tttfkr2dS|tkr@|jSt	d|��dS)Nr�Feature '%s' not recognized)
rr.rr3rrrrr2�SAXNotRecognizedException�r�namerrr�
getFeature�s
�zExpatParser.getFeaturecCs�|jrtd��|tkr||_n�|tkr.||_nt|tkrT|rL|jdkrRi|_q�d|_nN|tkrj|r�td��n8|t	kr�|r�td��n"|t
kr�|r�td��ntd|��dS)Nz!Cannot set features while parsingz!expat does not support validationz/expat does not read external parameter entitiesz(expat does not report namespace prefixesr?)r0�SAXNotSupportedExceptionrr.rr2rr3rrrr@)rrB�staterrr�
setFeature�s:
����zExpatParser.setFeaturecCsd|tjkr|jS|tkr|jS|tkrT|jrLt|jd�rB|j��St	d��nt
d��t	d|��dS)N�GetInputContextz=This version of expat does not support getting the XML stringz.XML string cannot be returned when not parsing�Property '%s' not recognized)r�property_lexical_handlerr/r
r3r	r!�hasattrrGr@rDrArrr�getProperty�s

��zExpatParser.getPropertycCsV|tjkr ||_|jrR|��n2|tkr0||_n"|tkrFtd|��nt	d|��dS)NzProperty '%s' cannot be setrH)
rrIr/r0�_reset_lex_handler_propr
r3r	rDr@)rrB�valuerrr�setProperty�s

��zExpatParser.setPropertyc
Csz|js|��d|_|j��z|j�||�WnDtjk
rt}z$tt�	|j
�||�}|j�|�W5d}~XYnXdSr$)
r0r6r7Z
startDocumentr!ZParser
�errorZSAXParseExceptionZErrorString�codeZ_err_handlerZ
fatalError)r�data�isFinal�e�excrrr�feed�s
zExpatParser.feedcCsB|j}z|��}|dk	r |��W5|��}|dk	r<|��XdSr)r(Z
getByteStream�closeZgetCharacterStream)rr;�filerrrr9�szExpatParser._close_sourcecCs�|js|jdkst|jt�r dSz(|jddd�|j	�
�d|_d|_W5d|_|jdk	rzt�}|jj|_|jj|_||_|��XdS)Nr�r%)rR)r1r!�
isinstancerr0r"r&r9rUr7ZendDocumentrrrrrV�s 
�




zExpatParser.closecCs|jj|j_|jj|j_dSr)r7�processingInstructionr!ZProcessingInstructionHandler�
charactersZCharacterDataHandler�rrrrr>�s�zExpatParser._reset_cont_handlercCs`|j}|j}|dkr4d|_d|_d|_d|_d|_n(|j|_|j|_|j	|_|j
|_|j|_dSr)r/r!ZCommentHandlerZStartCdataSectionHandlerZEndCdataSectionHandlerZStartDoctypeDeclHandlerZEndDoctypeDeclHandlerZcommentZ
startCDATAZendCDATA�start_doctype_declZendDTD)rZlexrrrrrLsz#ExpatParser._reset_lex_handler_propcCs�|jr>tj|j��d|jd�|_d|j_|j|j_	|j
|j_n,tj|j��|jd�|_|j|j_	|j
|j_|��|j|j_|j|j_|j|j_|j|j_d|_|jr�|��|j|j_z|j|j_Wntk
r�YnX|j�tj �d|_!g|_"dS)N� )�internr%r)#r.r
rr(ZgetEncodingr3r!Znamespace_prefixes�start_element_nsZStartElementHandler�end_element_nsZEndElementHandler�
start_element�end_elementr>�unparsed_entity_declZUnparsedEntityDeclHandler�
notation_declZNotationDeclHandler�start_namespace_declZStartNamespaceDeclHandler�end_namespace_declZEndNamespaceDeclHandlerZ_decl_handler_propr/rL�external_entity_refZExternalEntityRefHandler�skipped_entity_handlerZSkippedEntityHandler�AttributeErrorZSetParamEntityParsingZ*XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONEr0r1r\rrrr6s<�
�






�zExpatParser.resetcCs|jdkrdS|jjSr)r!r"r\rrrr#;s
zExpatParser.getColumnNumbercCs|jdkrdS|jjSr$)r!r&r\rrrr'@s
zExpatParser.getLineNumbercCs
|j��Sr)r(r)r\rrrr)EszExpatParser.getPublicIdcCs
|j��Sr)r(r*r\rrrr*HszExpatParser.getSystemIdcCs|j�|t|��dSr)r7ZstartElement�AttributesImpl)rrB�attrsrrrrbLszExpatParser.start_elementcCs|j�|�dSr)r7Z
endElementrArrrrcOszExpatParser.end_elementcCs�|��}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}i}i}|��D]|\}}|��}t|�}	|	dkr�|}
d|f}n>|	dkr�d|d|df}
|d|df}n|d}
t|�}|||<|
||<qT|j�|dt||��dS)Nr%�rz%s:%s�)�split�len�tuple�itemsr7ZstartElementNS�AttributesNSImpl)rrBrl�pairZnewattrsZqnamesZanamerM�partsZlengthZqnameZapairrrrr`Rs0



�zExpatParser.start_element_nscCsV|��}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}|j�|d�dS)Nr%rmr)rorprqr7ZendElementNS)rrBrtrrrrats
zExpatParser.end_element_nscCs|j�||�dSr)r7rZ)r�targetrQrrr�processing_instruction�sz"ExpatParser.processing_instructioncCs|j�|�dSr)r7r[)rrQrrr�character_data�szExpatParser.character_datacCs|j�||�dSr)r7ZstartPrefixMapping)r�prefixZurirrrrf�sz ExpatParser.start_namespace_declcCs|j�|�dSr)r7ZendPrefixMapping)rryrrrrg�szExpatParser.end_namespace_declcCs|j�|||�dSr)r/ZstartDTD)rrB�sysid�pubidZhas_internal_subsetrrrr]�szExpatParser.start_doctype_declcCs|j�||||�dSr)�_dtd_handlerZunparsedEntityDecl)rrB�baserzr{Z
notation_namerrrrd�sz ExpatParser.unparsed_entity_declcCs|j�|||�dSr)r|ZnotationDecl)rrBr}rzr{rrrre�szExpatParser.notation_declcCs�|js
dS|j�||�}t�||j��p*d�}|j�|j	|jf�|j	�
|�|_	||_ztj�
||�WnYdSX|jd\|_	|_|jd=dS)Nr%rXr���)r2Z_ent_handlerZ
resolveEntityrr5r(r*r1�appendr!ZExternalEntityParserCreaterr-r8)r�contextr}rzr{r;rrrrh�s"
�zExpatParser.external_entity_refcCs|rd|}|j�|�dS)N�%)r7Z
skippedEntity)rrBZis_perrrri�sz"ExpatParser.skipped_entity_handlerN)rr,)r)"rrrr r8r<r=rCrFrKrNrUr9rVr>rLr6r#r'r)r*rbrcr`rarwrxrfrgr]rdrerhrirrrrr+Ws>


'"r+cOs
t||�Sr)r+)�args�kwargsrrr�
create_parser�sr��__main__z:http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml),�versionZxml.sax._exceptionsZxml.sax.handlerrrrrrrr	r
�sys�platformZSAXReaderNotAvailableZxml.parsersr
�ImportErrorrJZxml.saxrrrrkrs�_weakrefr�weakref�proxyrZLocatorrr-r+r�rZxml.sax.saxutilsZxml�pr=ZsaxZXMLGeneratorZsetErrorHandlerZErrorHandlerr8rrrr�<module>sL


$_
PK0![G�2&��-sax/__pycache__/__init__.cpython-38.opt-1.pycnu�[���U

e5d?�@s
dZddlmZddlmZmZddlmZmZm	Z	m
Z
mZe�fdd�Ze�fdd�Z
d	gZd
Zernd
dlZd
dlZd
dlZejjs�dejkr�ejd�d
�Z[dZejdd�dkr�ej�e�r�ej�e��d
�Zddd�Zejdd�dkr�dd�Zndd�Z[dS)a�Simple API for XML (SAX) implementation for Python.

This module provides an implementation of the SAX 2 interface;
information about the Java version of the interface can be found at
http://www.megginson.com/SAX/.  The Python version of the interface is
documented at <...>.

This package contains the following modules:

handler -- Base classes and constants which define the SAX 2 API for
           the 'client-side' of SAX for Python.

saxutils -- Implementation of the convenience classes commonly used to
            work with SAX.

xmlreader -- Base classes and constants which define the SAX 2 API for
             the parsers used with SAX for Python.

expatreader -- Driver that allows use of the Expat parser with SAX.
�)�InputSource)�ContentHandler�ErrorHandler)�SAXException�SAXNotRecognizedException�SAXParseException�SAXNotSupportedException�SAXReaderNotAvailablecCs(t�}|�|�|�|�|�|�dS)N)�make_parser�setContentHandler�setErrorHandler�parse)�source�handler�errorHandler�parser�r�(/usr/lib64/python3.8/xml/sax/__init__.pyr
s

r
cCspddl}|dkrt�}t�}|�|�|�|�t�}t|t�rR|�|�	|��n|�
|�|��|�|�dS)N�)
�iorr
rrr�
isinstance�strZsetCharacterStream�StringIOZ
setByteStream�BytesIOr
)�stringrrrrZinpsrcrrr�parseString#s


rzxml.sax.expatreaderrNZ
PY_SAX_PARSER�,zpython.xml.sax.parser��javarcCsxt|�tD]\}zt|�WStk
rT}zddl}||jkrD�W5d}~XYqtk
rfYqXqtdd��dS)a3Creates and returns a SAX parser.

    Creates the first parser it is able to instantiate of the ones
    given in the iterable created by chaining parser_list and
    default_parser_list.  The iterables must contain the names of Python
    modules containing both a SAX parser and a create_parser function.rNzNo parsers found)�list�default_parser_list�_create_parser�ImportError�sys�modulesr	)Zparser_list�parser_name�er#rrrr
Fs
r
cCs$ddlm}|�|dt��}|��S)Nr)�imp)Zorg.python.corer'Z
importName�globals�
create_parser)r%r'�
drv_modulerrrr!asr!cCst|iidg�}|��S)Nr))�
__import__r))r%r*rrrr!gs)r)�__doc__Z	xmlreaderrrrr�_exceptionsrrrrr	r
rr �_falseZxml.sax.expatreaderZxml�osr#�flags�ignore_environment�environ�splitZ_key�platform�registryZcontainsKeyZgetPropertyr
r!rrrr�<module>s*

PK0![�Z�;�A�A(sax/__pycache__/xmlreader.cpython-38.pycnu�[���U

e5d�1�@s�dZddlmZddlmZmZGdd�d�ZGdd�de�ZGdd	�d	�ZGd
d�d�Z	Gdd
�d
�Z
Gdd�de
�Zdd�Ze
dkr�e�dS)z]An XML Reader is the SAX 2 name for an XML parser. XML Parsers
should be based on this code. �)�handler)�SAXNotSupportedException�SAXNotRecognizedExceptionc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd S)!�	XMLReadera%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.cCs,t��|_t��|_t��|_t��|_dS�N)	rZContentHandler�
_cont_handlerZ
DTDHandler�_dtd_handlerZEntityResolver�_ent_handlerZErrorHandler�_err_handler��self�r
�)/usr/lib64/python3.8/xml/sax/xmlreader.py�__init__s


zXMLReader.__init__cCstd��dS)zAParse an XML document from a system identifier or an InputSource.� This method must be implemented!N��NotImplementedError�r�sourcer
r
r�parseszXMLReader.parsecCs|jS)z#Returns the current ContentHandler.�rrr
r
r�getContentHandler"szXMLReader.getContentHandlercCs
||_dS)z:Registers a new object to receive document content events.Nr�rrr
r
r�setContentHandler&szXMLReader.setContentHandlercCs|jS)z Returns the current DTD handler.�rrr
r
r�
getDTDHandler*szXMLReader.getDTDHandlercCs
||_dS)z7Register an object to receive basic DTD-related events.Nrrr
r
r�
setDTDHandler.szXMLReader.setDTDHandlercCs|jS)z#Returns the current EntityResolver.�r	rr
r
r�getEntityResolver2szXMLReader.getEntityResolvercCs
||_dS)z0Register an object to resolve external entities.Nr)rZresolverr
r
r�setEntityResolver6szXMLReader.setEntityResolvercCs|jS)z!Returns the current ErrorHandler.�r
rr
r
r�getErrorHandler:szXMLReader.getErrorHandlercCs
||_dS)z3Register an object to receive error-message events.Nr rr
r
r�setErrorHandler>szXMLReader.setErrorHandlercCstd��dS)aHAllow 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.zLocale support not implementedN)r)rZlocaler
r
r�	setLocaleBszXMLReader.setLocalecCstd|��dS)z1Looks up and returns the state of a SAX2 feature.�Feature '%s' not recognizedN�r�r�namer
r
r�
getFeatureKszXMLReader.getFeaturecCstd|��dS)z!Sets the state of a SAX2 feature.r$Nr%)rr'�stater
r
r�
setFeatureOszXMLReader.setFeaturecCstd|��dS)z2Looks up and returns the value of a SAX2 property.�Property '%s' not recognizedNr%r&r
r
r�getPropertySszXMLReader.getPropertycCstd|��dS)z"Sets the value of a SAX2 property.r+Nr%)rr'�valuer
r
r�setPropertyWszXMLReader.setPropertyN)�__name__�
__module__�__qualname__�__doc__rrrrrrrrr!r"r#r(r*r,r.r
r
r
rrs 	rc@sBeZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dS)�IncrementalParserasThis 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.�cCs||_t�|�dSr)�_bufsizerr)r�bufsizer
r
rroszIncrementalParser.__init__cCslddlm}|�|�}|�|�|��}|dkr8|��}|�|j�}|r`|�|�|�|j�}qD|�	�dS)Nr)�saxutils)
�r7Zprepare_input_source�
prepareParser�getCharacterStream�
getByteStream�readr5�feed�close)rrr7�file�bufferr
r
rrss


zIncrementalParser.parsecCstd��dS)aThis 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.rNr)r�datar
r
rr=�szIncrementalParser.feedcCstd��dS)ztThis method is called by the parse implementation to allow
        the SAX 2.0 driver to prepare itself for parsing.z!prepareParser must be overridden!Nrrr
r
rr9�szIncrementalParser.prepareParsercCstd��dS)a�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.rNrrr
r
rr>�szIncrementalParser.closecCstd��dS)z�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.rNrrr
r
r�reset�szIncrementalParser.resetN)r4)
r/r0r1r2rrr=r9r>rBr
r
r
rr3[s
	
r3c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�Locatorz�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.cCsdS)z6Return the column number where the current event ends.���r
rr
r
r�getColumnNumber�szLocator.getColumnNumbercCsdS)z4Return the line number where the current event ends.rDr
rr
r
r�
getLineNumber�szLocator.getLineNumbercCsdS)z3Return the public identifier for the current event.Nr
rr
r
r�getPublicId�szLocator.getPublicIdcCsdS)z3Return the system identifier for the current event.Nr
rr
r
r�getSystemId�szLocator.getSystemIdN)r/r0r1r2rErFrGrHr
r
r
rrC�s
rCc@sjeZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�ZdS)�InputSourceanEncapsulation 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.NcCs"||_d|_d|_d|_d|_dSr)�_InputSource__system_id�_InputSource__public_id�_InputSource__encoding�_InputSource__bytefile�_InputSource__charfile�rZ	system_idr
r
rr�s
zInputSource.__init__cCs
||_dS)z/Sets the public identifier of this InputSource.N�rK)rZ	public_idr
r
r�setPublicId�szInputSource.setPublicIdcCs|jS)z2Returns the public identifier of this InputSource.rPrr
r
rrG�szInputSource.getPublicIdcCs
||_dS)z/Sets the system identifier of this InputSource.N�rJrOr
r
r�setSystemId�szInputSource.setSystemIdcCs|jS)z2Returns the system identifier of this InputSource.rRrr
r
rrH�szInputSource.getSystemIdcCs
||_dS)a4Sets 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.N�rL)r�encodingr
r
r�setEncoding�szInputSource.setEncodingcCs|jS)z/Get the character encoding of this InputSource.rTrr
r
r�getEncoding�szInputSource.getEncodingcCs
||_dS)a�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.N�rM)rZbytefiler
r
r�
setByteStream�szInputSource.setByteStreamcCs|jS)z�Get the byte stream for this input source.

        The getEncoding method will return the character encoding for
        this byte stream, or None if unknown.rXrr
r
rr;�szInputSource.getByteStreamcCs
||_dS)a^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.N�rN)rZcharfiler
r
r�setCharacterStreamszInputSource.setCharacterStreamcCs|jS)z/Get the character stream for this input source.rZrr
r
rr:szInputSource.getCharacterStream)N)r/r0r1r2rrQrGrSrHrVrWrYr;r[r:r
r
r
rrI�s



rIc@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zd$dd�Zdd�Zd d!�Zd"d#�ZdS)%�AttributesImplcCs
||_dS)zQNon-NS-aware implementation.

        attrs should be of the form {name : value}.N��_attrs)r�attrsr
r
rrszAttributesImpl.__init__cCs
t|j�Sr��lenr^rr
r
r�	getLengthszAttributesImpl.getLengthcCsdS)NZCDATAr
r&r
r
r�getType!szAttributesImpl.getTypecCs
|j|Srr]r&r
r
r�getValue$szAttributesImpl.getValuecCs
|j|Srr]r&r
r
r�getValueByQName'szAttributesImpl.getValueByQNamecCs||jkrt|��|Sr�r^�KeyErrorr&r
r
r�getNameByQName*s
zAttributesImpl.getNameByQNamecCs||jkrt|��|Srrfr&r
r
r�getQNameByName/s
zAttributesImpl.getQNameByNamecCst|j���Sr��listr^�keysrr
r
r�getNames4szAttributesImpl.getNamescCst|j���Srrjrr
r
r�	getQNames7szAttributesImpl.getQNamescCs
t|j�Srr`rr
r
r�__len__:szAttributesImpl.__len__cCs
|j|Srr]r&r
r
r�__getitem__=szAttributesImpl.__getitem__cCst|j���Srrjrr
r
rrl@szAttributesImpl.keyscCs
||jkSrr]r&r
r
r�__contains__CszAttributesImpl.__contains__NcCs|j�||�Sr)r^�get)rr'�alternativer
r
rrrFszAttributesImpl.getcCs|�|j�Sr)�	__class__r^rr
r
r�copyIszAttributesImpl.copycCst|j���Sr)rkr^�itemsrr
r
rrvLszAttributesImpl.itemscCst|j���Sr)rkr^�valuesrr
r
rrwOszAttributesImpl.values)N)r/r0r1rrbrcrdrerhrirmrnrorprlrqrrrurvrwr
r
r
rr\s"
r\c@s<eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�AttributesNSImplcCs||_||_dS)z�NS-aware implementation.

        attrs should be of the form {(ns_uri, lname): value, ...}.
        qnames of the form {(ns_uri, lname): qname, ...}.N)r^�_qnames)rr_Zqnamesr
r
rrVszAttributesNSImpl.__init__cCs6|j��D]\}}||kr
|j|Sq
t|��dSr)ryrvr^rg�rr'ZnsnameZqnamer
r
rre^sz AttributesNSImpl.getValueByQNamecCs0|j��D]\}}||kr
|Sq
t|��dSr)ryrvrgrzr
r
rrhes
zAttributesNSImpl.getNameByQNamecCs
|j|Sr)ryr&r
r
rrilszAttributesNSImpl.getQNameByNamecCst|j���Sr)rkryrwrr
r
rrnoszAttributesNSImpl.getQNamescCs|�|j|j�Sr)rtr^ryrr
r
rrurszAttributesNSImpl.copyN)	r/r0r1rrerhrirnrur
r
r
rrxTsrxcCst�t�t�dSr)rr3rCr
r
r
r�_testvsr{�__main__N)r2r8r�_exceptionsrrrr3rCrIr\rxr{r/r
r
r
r�<module>sPJY>"PK0![G�2&��'sax/__pycache__/__init__.cpython-38.pycnu�[���U

e5d?�@s
dZddlmZddlmZmZddlmZmZm	Z	m
Z
mZe�fdd�Ze�fdd�Z
d	gZd
Zernd
dlZd
dlZd
dlZejjs�dejkr�ejd�d
�Z[dZejdd�dkr�ej�e�r�ej�e��d
�Zddd�Zejdd�dkr�dd�Zndd�Z[dS)a�Simple API for XML (SAX) implementation for Python.

This module provides an implementation of the SAX 2 interface;
information about the Java version of the interface can be found at
http://www.megginson.com/SAX/.  The Python version of the interface is
documented at <...>.

This package contains the following modules:

handler -- Base classes and constants which define the SAX 2 API for
           the 'client-side' of SAX for Python.

saxutils -- Implementation of the convenience classes commonly used to
            work with SAX.

xmlreader -- Base classes and constants which define the SAX 2 API for
             the parsers used with SAX for Python.

expatreader -- Driver that allows use of the Expat parser with SAX.
�)�InputSource)�ContentHandler�ErrorHandler)�SAXException�SAXNotRecognizedException�SAXParseException�SAXNotSupportedException�SAXReaderNotAvailablecCs(t�}|�|�|�|�|�|�dS)N)�make_parser�setContentHandler�setErrorHandler�parse)�source�handler�errorHandler�parser�r�(/usr/lib64/python3.8/xml/sax/__init__.pyr
s

r
cCspddl}|dkrt�}t�}|�|�|�|�t�}t|t�rR|�|�	|��n|�
|�|��|�|�dS)N�)
�iorr
rrr�
isinstance�strZsetCharacterStream�StringIOZ
setByteStream�BytesIOr
)�stringrrrrZinpsrcrrr�parseString#s


rzxml.sax.expatreaderrNZ
PY_SAX_PARSER�,zpython.xml.sax.parser��javarcCsxt|�tD]\}zt|�WStk
rT}zddl}||jkrD�W5d}~XYqtk
rfYqXqtdd��dS)a3Creates and returns a SAX parser.

    Creates the first parser it is able to instantiate of the ones
    given in the iterable created by chaining parser_list and
    default_parser_list.  The iterables must contain the names of Python
    modules containing both a SAX parser and a create_parser function.rNzNo parsers found)�list�default_parser_list�_create_parser�ImportError�sys�modulesr	)Zparser_list�parser_name�er#rrrr
Fs
r
cCs$ddlm}|�|dt��}|��S)Nr)�imp)Zorg.python.corer'Z
importName�globals�
create_parser)r%r'�
drv_modulerrrr!asr!cCst|iidg�}|��S)Nr))�
__import__r))r%r*rrrr!gs)r)�__doc__Z	xmlreaderrrrr�_exceptionsrrrrr	r
rr �_falseZxml.sax.expatreaderZxml�osr#�flags�ignore_environment�environ�splitZ_key�platform�registryZcontainsKeyZgetPropertyr
r!rrrr�<module>s*

PK0![��FF0sax/__pycache__/_exceptions.cpython-38.opt-1.pycnu�[���U

e5d��@s�dZddlZejdd�dkr*ddlmZ[Gdd�de�ZGdd	�d	e�ZGd
d�de�ZGdd
�d
e�ZGdd�de�Z	dS)z!Different kinds of SAX Exceptions�N��java)�	Exceptionc@s:eZdZdZd
dd�Zdd�Zdd�Zd	d
�Zdd�ZdS)�SAXExceptiona�Encapsulate an XML error or warning. This class can contain
    basic error or warning information from either the XML parser or
    the application: you can subclass it to provide additional
    functionality, or to add localization. Note that although you will
    receive a SAXException as the argument to the handlers in the
    ErrorHandler interface, you are not actually required to raise
    the exception; instead, you can simply read the information in
    it.NcCs||_||_t�||�dS)zUCreates an exception. The message is required, but the exception
        is optional.N)�_msg�
_exceptionr�__init__)�self�msg�	exception�r�+/usr/lib64/python3.8/xml/sax/_exceptions.pyrszSAXException.__init__cCs|jS)z$Return a message for this exception.�r�r	rrr
�
getMessageszSAXException.getMessagecCs|jS)z9Return the embedded exception, or None if there was none.)rrrrr
�getExceptionszSAXException.getExceptioncCs|jS)�0Create a string representation of the exception.rrrrr
�__str__"szSAXException.__str__cCstd��dS)zvAvoids weird error messages if someone does exception[ix] by
        mistake, since Exception has __getitem__ defined.�__getitem__N)�AttributeError)r	Zixrrr
r&szSAXException.__getitem__)N)	�__name__�
__module__�__qualname__�__doc__rrrrrrrrr
r	s	
rc@s@eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�SAXParseExceptiona#Encapsulate an XML parse error or warning.

    This exception will include information for locating the error in
    the original XML document. Note that although the application will
    receive a SAXParseException as the argument to the handlers in the
    ErrorHandler interface, the application is not actually required
    to raise the exception; instead, it can simply read the
    information in it and take a different action.

    Since this exception is a subclass of SAXException, it inherits
    the ability to wrap another exception.cCs<t�|||�||_|j��|_|j��|_|j��|_dS)zECreates the exception. The exception parameter is allowed to be None.N)	rr�_locator�getSystemId�	_systemId�getColumnNumber�_colnum�
getLineNumber�_linenum)r	r
rZlocatorrrr
r;s
zSAXParseException.__init__cCs|jS)zNThe column number of the end of the text where the exception
        occurred.)rrrrr
rHsz!SAXParseException.getColumnNumbercCs|jS)zDThe line number of the end of the text where the exception occurred.)r!rrrr
r MszSAXParseException.getLineNumbercCs
|j��S)zEGet the public identifier of the entity where the exception occurred.)r�getPublicIdrrrr
r"QszSAXParseException.getPublicIdcCs|jS)zEGet the system identifier of the entity where the exception occurred.)rrrrr
rUszSAXParseException.getSystemIdcCsN|��}|dkrd}|��}|dkr(d}|��}|dkr<d}d||||jfS)rNz	<unknown>�?z%s:%s:%s: %s)rr rr)r	ZsysidZlinenumZcolnumrrr
rYszSAXParseException.__str__N)
rrrrrrr r"rrrrrr
r.s
rc@seZdZdZdS)�SAXNotRecognizedExceptionz�Exception class for an unrecognized identifier.

    An XMLReader will raise this exception when it is confronted with an
    unrecognized feature or property. SAX applications and extensions may
    use this class for similar purposes.N�rrrrrrrr
r$isr$c@seZdZdZdS)�SAXNotSupportedExceptionaException class for an unsupported operation.

    An XMLReader will raise this exception when a service it cannot
    perform is requested (specifically setting a state or value). SAX
    applications and extensions may use this class for similar
    purposes.Nr%rrrr
r&ssr&c@seZdZdZdS)�SAXReaderNotAvailableaException class for a missing driver.

    An XMLReader module (driver) should raise this exception when it
    is first imported, e.g. when a support module cannot be imported.
    It also may be raised during parsing, e.g. if executing an external
    program is not permitted.Nr%rrrr
r'}sr')
r�sys�platformZ	java.langrrrr$r&r'rrrr
�<module>s%;

PK0![d�Tۈ0�0,sax/__pycache__/handler.cpython-38.opt-1.pycnu�[���U

e5db6�@s�dZdZGdd�d�ZGdd�d�ZGdd�d�ZGdd	�d	�Zd
ZdZdZd
Z	dZ
dZeeee	e
egZdZ
dZdZdZdZdZe
eeeeegZdS)a0
This module contains the core classes of version 2.0 of SAX for Python.
This file provides only default classes with absolutely minimum
functionality, from which drivers and applications can be subclassed.

Many of these classes are empty and are included only as documentation
of the interfaces.

$Id$
z2.0betac@s(eZdZdZdd�Zdd�Zdd�ZdS)	�ErrorHandlera�Basic interface for SAX error handlers.

    If you create an object that implements this interface, then
    register the object with your XMLReader, the parser will call the
    methods in your object to report all warnings and errors. There
    are three levels of errors available: warnings, (possibly)
    recoverable errors, and unrecoverable errors. All methods take a
    SAXParseException as the only parameter.cCs|�dS)zHandle a recoverable error.N���selfZ	exceptionrr�'/usr/lib64/python3.8/xml/sax/handler.py�error szErrorHandler.errorcCs|�dS)zHandle a non-recoverable error.Nrrrrr�
fatalError$szErrorHandler.fatalErrorcCst|�dS)zHandle a warning.N)�printrrrr�warning(szErrorHandler.warningN)�__name__�
__module__�__qualname__�__doc__rrr	rrrrrs	rc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�ContentHandlerz�Interface for receiving logical document content events.

    This is the main callback interface in SAX, and the one most
    important to applications. The order of events in this interface
    mirrors the order of the information in the document.cCs
d|_dS)N�Z_locator�rrrr�__init__6szContentHandler.__init__cCs
||_dS)a#Called by the parser to give the application a locator for
        locating the origin of document events.

        SAX parsers are strongly encouraged (though not absolutely
        required) to supply a locator: if it does so, it must supply
        the locator to the application by invoking this method before
        invoking any of the other methods in the DocumentHandler
        interface.

        The locator allows the application to determine the end
        position of any document-related event, even if the parser is
        not reporting an error. Typically, the application will use
        this information for reporting its own errors (such as
        character content that does not match an application's
        business rules). The information returned by the locator is
        probably not sufficient for use with a search engine.

        Note that the locator will return correct information only
        during the invocation of the events in this interface. The
        application should not attempt to use it at any other time.Nr)rZlocatorrrr�setDocumentLocator9sz!ContentHandler.setDocumentLocatorcCsdS)z�Receive notification of the beginning of a document.

        The SAX parser will invoke this method only once, before any
        other methods in this interface or in DTDHandler (except for
        setDocumentLocator).Nrrrrr�
startDocumentPszContentHandler.startDocumentcCsdS)aQReceive notification of the end of a document.

        The SAX parser will invoke this method only once, and it will
        be the last method invoked during the parse. The parser shall
        not invoke this method until it has either abandoned parsing
        (because of an unrecoverable error) or reached the end of
        input.Nrrrrr�endDocumentWszContentHandler.endDocumentcCsdS)aBegin the scope of a prefix-URI Namespace mapping.

        The information from this event is not necessary for normal
        Namespace processing: the SAX XML reader will automatically
        replace prefixes for element and attribute names when the
        http://xml.org/sax/features/namespaces feature is true (the
        default).

        There are cases, however, when applications need to use
        prefixes in character data or in attribute values, where they
        cannot safely be expanded automatically; the
        start/endPrefixMapping event supplies the information to the
        application to expand prefixes in those contexts itself, if
        necessary.

        Note that start/endPrefixMapping events are not guaranteed to
        be properly nested relative to each-other: all
        startPrefixMapping events will occur before the corresponding
        startElement event, and all endPrefixMapping events will occur
        after the corresponding endElement event, but their order is
        not guaranteed.Nr)r�prefixZurirrr�startPrefixMapping`sz!ContentHandler.startPrefixMappingcCsdS)z�End the scope of a prefix-URI mapping.

        See startPrefixMapping for details. This event will always
        occur after the corresponding endElement event, but the order
        of endPrefixMapping events is not otherwise guaranteed.Nr)rrrrr�endPrefixMappingwszContentHandler.endPrefixMappingcCsdS)aSignals the start of an element in non-namespace mode.

        The name parameter contains the raw XML 1.0 name of the
        element type as a string and the attrs parameter holds an
        instance of the Attributes class containing the attributes of
        the element.Nr)r�name�attrsrrr�startElement~szContentHandler.startElementcCsdS)z�Signals the end of an element in non-namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElement event.Nr�rrrrr�
endElement�szContentHandler.endElementcCsdS)a�Signals the start of an element in namespace mode.

        The name parameter contains the name of the element type as a
        (uri, localname) tuple, the qname parameter the raw XML 1.0
        name used in the source document, and the attrs parameter
        holds an instance of the Attributes class containing the
        attributes of the element.

        The uri part of the name tuple is None for elements which have
        no namespace.Nr)rr�qnamerrrr�startElementNS�szContentHandler.startElementNScCsdS)z�Signals the end of an element in namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElementNS event.Nr)rrrrrr�endElementNS�szContentHandler.endElementNScCsdS)a�Receive notification of character data.

        The Parser will call this method to report each chunk of
        character data. SAX parsers may return all contiguous
        character data in a single chunk, or they may split it into
        several chunks; however, all of the characters in any single
        event must come from the same external entity so that the
        Locator provides useful information.Nr)rZcontentrrr�
characters�szContentHandler.characterscCsdS)awReceive notification of ignorable whitespace in element content.

        Validating Parsers must use this method to report each chunk
        of ignorable whitespace (see the W3C XML 1.0 recommendation,
        section 2.10): non-validating parsers may also use this method
        if they are capable of parsing and using content models.

        SAX parsers may return all contiguous whitespace in a single
        chunk, or they may split it into several chunks; however, all
        of the characters in any single event must come from the same
        external entity, so that the Locator provides useful
        information.Nr)rZ
whitespacerrr�ignorableWhitespace�sz"ContentHandler.ignorableWhitespacecCsdS)a�Receive notification of a processing instruction.

        The Parser will invoke this method once for each processing
        instruction found: note that processing instructions may occur
        before or after the main document element.

        A SAX parser should never report an XML declaration (XML 1.0,
        section 2.8) or a text declaration (XML 1.0, section 4.3.1)
        using this method.Nr)r�target�datarrr�processingInstruction�sz$ContentHandler.processingInstructioncCsdS)aReceive notification of a skipped entity.

        The Parser will invoke this method once for each entity
        skipped. Non-validating processors may skip entities if they
        have not seen the declarations (because, for example, the
        entity was declared in an external DTD subset). All processors
        may skip external entities, depending on the values of the
        http://xml.org/sax/features/external-general-entities and the
        http://xml.org/sax/features/external-parameter-entities
        properties.Nrrrrr�
skippedEntity�szContentHandler.skippedEntityN)r
rrr
rrrrrrrrrrr r!r$r%rrrrr/s	
rc@s eZdZdZdd�Zdd�ZdS)�
DTDHandlerz�Handle DTD events.

    This interface specifies only those DTD events required for basic
    parsing (unparsed entities and attributes).cCsdS)z$Handle a notation declaration event.Nr)rr�publicId�systemIdrrr�notationDecl�szDTDHandler.notationDeclcCsdS)z,Handle an unparsed entity declaration event.Nr)rrr'r(Zndatarrr�unparsedEntityDecl�szDTDHandler.unparsedEntityDeclN)r
rrr
r)r*rrrrr&�sr&c@seZdZdZdd�ZdS)�EntityResolvera7Basic interface for resolving entities. If you create an object
    implementing this interface, then register the object with your
    Parser, the parser will call the method in your object to
    resolve all external entities. Note that DefaultHandler implements
    this interface with the default behaviour.cCs|S)z�Resolve the system identifier of an entity and return either
        the system identifier to read from as a string, or an InputSource
        to read from.r)rr'r(rrr�
resolveEntity�szEntityResolver.resolveEntityN)r
rrr
r,rrrrr+�sr+z&http://xml.org/sax/features/namespacesz.http://xml.org/sax/features/namespace-prefixesz,http://xml.org/sax/features/string-interningz&http://xml.org/sax/features/validationz5http://xml.org/sax/features/external-general-entitiesz7http://xml.org/sax/features/external-parameter-entitiesz-http://xml.org/sax/properties/lexical-handlerz1http://xml.org/sax/properties/declaration-handlerz&http://xml.org/sax/properties/dom-nodez(http://xml.org/sax/properties/xml-stringz-http://www.python.org/sax/properties/encodingz3http://www.python.org/sax/properties/interning-dictN)r
�versionrrr&r+Zfeature_namespacesZfeature_namespace_prefixesZfeature_string_interningZfeature_validationZfeature_external_gesZfeature_external_pesZall_featuresZproperty_lexical_handlerZproperty_declaration_handlerZproperty_dom_nodeZproperty_xml_stringZproperty_encodingZproperty_interning_dictZall_propertiesrrrr�<module>s@
"��PK0![s�`0sax/__pycache__/_exceptions.cpython-38.opt-2.pycnu�[���U

e5d��@s|ddlZejdd�dkr&ddlmZ[Gdd�de�ZGdd�de�ZGd	d
�d
e�ZGdd�de�ZGd
d�de�ZdS)�N��java)�	Exceptionc@s6eZdZddd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�SAXExceptionNcCs||_||_t�||�dS�N)�_msg�
_exceptionr�__init__)�self�msg�	exception�r
�+/usr/lib64/python3.8/xml/sax/_exceptions.pyr	szSAXException.__init__cCs|jSr�r�r
r
r
r�
getMessageszSAXException.getMessagecCs|jSr)rrr
r
r�getExceptionszSAXException.getExceptioncCs|jSrrrr
r
r�__str__"szSAXException.__str__cCstd��dS)N�__getitem__)�AttributeError)r
Zixr
r
rr&szSAXException.__getitem__)N)�__name__�
__module__�__qualname__r	rrrrr
r
r
rr	s


rc@s<eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�SAXParseExceptioncCs<t�|||�||_|j��|_|j��|_|j��|_dSr)	rr	�_locator�getSystemId�	_systemId�getColumnNumber�_colnum�
getLineNumber�_linenum)r
rrZlocatorr
r
rr	;s
zSAXParseException.__init__cCs|jSr)rrr
r
rrHsz!SAXParseException.getColumnNumbercCs|jSr)r rr
r
rrMszSAXParseException.getLineNumbercCs
|j��Sr)r�getPublicIdrr
r
rr!QszSAXParseException.getPublicIdcCs|jSr)rrr
r
rrUszSAXParseException.getSystemIdcCsN|��}|dkrd}|��}|dkr(d}|��}|dkr<d}d||||jfS)Nz	<unknown>�?z%s:%s:%s: %s)rrrr)r
ZsysidZlinenumZcolnumr
r
rrYszSAXParseException.__str__N)	rrrr	rrr!rrr
r
r
rr.s

rc@seZdZdS)�SAXNotRecognizedExceptionN�rrrr
r
r
rr#isr#c@seZdZdS)�SAXNotSupportedExceptionNr$r
r
r
rr%ssr%c@seZdZdS)�SAXReaderNotAvailableNr$r
r
r
rr&}sr&)	�sys�platformZ	java.langrrrr#r%r&r
r
r
r�<module>s%;

PK0![b�к�(�(.sax/__pycache__/xmlreader.cpython-38.opt-2.pycnu�[���U

e5d�1�@s�ddlmZddlmZmZGdd�d�ZGdd�de�ZGdd�d�ZGd	d
�d
�ZGdd�d�Z	Gd
d�de	�Z
dd�Zedkr�e�dS)�)�handler)�SAXNotSupportedException�SAXNotRecognizedExceptionc@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS) �	XMLReadercCs,t��|_t��|_t��|_t��|_dS�N)	rZContentHandler�
_cont_handlerZ
DTDHandler�_dtd_handlerZEntityResolver�_ent_handlerZErrorHandler�_err_handler��self�r
�)/usr/lib64/python3.8/xml/sax/xmlreader.py�__init__s


zXMLReader.__init__cCstd��dS�Nz This method must be implemented!��NotImplementedError�r�sourcer
r
r�parseszXMLReader.parsecCs|jSr�rrr
r
r�getContentHandler"szXMLReader.getContentHandlercCs
||_dSrr�rrr
r
r�setContentHandler&szXMLReader.setContentHandlercCs|jSr�rrr
r
r�
getDTDHandler*szXMLReader.getDTDHandlercCs
||_dSrrrr
r
r�
setDTDHandler.szXMLReader.setDTDHandlercCs|jSr�r	rr
r
r�getEntityResolver2szXMLReader.getEntityResolvercCs
||_dSrr)rZresolverr
r
r�setEntityResolver6szXMLReader.setEntityResolvercCs|jSr�r
rr
r
r�getErrorHandler:szXMLReader.getErrorHandlercCs
||_dSrr rr
r
r�setErrorHandler>szXMLReader.setErrorHandlercCstd��dS)NzLocale support not implemented)r)rZlocaler
r
r�	setLocaleBszXMLReader.setLocalecCstd|��dS�NzFeature '%s' not recognized�r�r�namer
r
r�
getFeatureKszXMLReader.getFeaturecCstd|��dSr$r%)rr'�stater
r
r�
setFeatureOszXMLReader.setFeaturecCstd|��dS�NzProperty '%s' not recognizedr%r&r
r
r�getPropertySszXMLReader.getPropertycCstd|��dSr+r%)rr'�valuer
r
r�setPropertyWszXMLReader.setPropertyN)�__name__�
__module__�__qualname__rrrrrrrrr!r"r#r(r*r,r.r
r
r
rrs
	rc@s>eZdZddd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�ZdS)�IncrementalParser�cCs||_t�|�dSr)�_bufsizerr)r�bufsizer
r
rroszIncrementalParser.__init__cCslddlm}|�|�}|�|�|��}|dkr8|��}|�|j�}|r`|�|�|�|j�}qD|�	�dS)Nr)�saxutils)
�r6Zprepare_input_source�
prepareParser�getCharacterStream�
getByteStream�readr4�feed�close)rrr6�file�bufferr
r
rrss


zIncrementalParser.parsecCstd��dSrr)r�datar
r
rr<�szIncrementalParser.feedcCstd��dS)Nz!prepareParser must be overridden!rrr
r
rr8�szIncrementalParser.prepareParsercCstd��dSrrrr
r
rr=�szIncrementalParser.closecCstd��dSrrrr
r
r�reset�szIncrementalParser.resetN)r3)	r/r0r1rrr<r8r=rAr
r
r
rr2[s
	
r2c@s,eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�LocatorcCsdS�N���r
rr
r
r�getColumnNumber�szLocator.getColumnNumbercCsdSrCr
rr
r
r�
getLineNumber�szLocator.getLineNumbercCsdSrr
rr
r
r�getPublicId�szLocator.getPublicIdcCsdSrr
rr
r
r�getSystemId�szLocator.getSystemIdN)r/r0r1rErFrGrHr
r
r
rrB�srBc@sfeZdZddd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
dS)�InputSourceNcCs"||_d|_d|_d|_d|_dSr)�_InputSource__system_id�_InputSource__public_id�_InputSource__encoding�_InputSource__bytefile�_InputSource__charfile�rZ	system_idr
r
rr�s
zInputSource.__init__cCs
||_dSr�rK)rZ	public_idr
r
r�setPublicId�szInputSource.setPublicIdcCs|jSrrPrr
r
rrG�szInputSource.getPublicIdcCs
||_dSr�rJrOr
r
r�setSystemId�szInputSource.setSystemIdcCs|jSrrRrr
r
rrH�szInputSource.getSystemIdcCs
||_dSr�rL)r�encodingr
r
r�setEncoding�szInputSource.setEncodingcCs|jSrrTrr
r
r�getEncoding�szInputSource.getEncodingcCs
||_dSr�rM)rZbytefiler
r
r�
setByteStream�szInputSource.setByteStreamcCs|jSrrXrr
r
rr:�szInputSource.getByteStreamcCs
||_dSr�rN)rZcharfiler
r
r�setCharacterStreamszInputSource.setCharacterStreamcCs|jSrrZrr
r
rr9szInputSource.getCharacterStream)N)r/r0r1rrQrGrSrHrVrWrYr:r[r9r
r
r
rrI�s



rIc@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zd$dd�Zdd�Zd d!�Zd"d#�ZdS)%�AttributesImplcCs
||_dSr��_attrs)r�attrsr
r
rrszAttributesImpl.__init__cCs
t|j�Sr��lenr^rr
r
r�	getLengthszAttributesImpl.getLengthcCsdS)NZCDATAr
r&r
r
r�getType!szAttributesImpl.getTypecCs
|j|Srr]r&r
r
r�getValue$szAttributesImpl.getValuecCs
|j|Srr]r&r
r
r�getValueByQName'szAttributesImpl.getValueByQNamecCs||jkrt|��|Sr�r^�KeyErrorr&r
r
r�getNameByQName*s
zAttributesImpl.getNameByQNamecCs||jkrt|��|Srrfr&r
r
r�getQNameByName/s
zAttributesImpl.getQNameByNamecCst|j���Sr��listr^�keysrr
r
r�getNames4szAttributesImpl.getNamescCst|j���Srrjrr
r
r�	getQNames7szAttributesImpl.getQNamescCs
t|j�Srr`rr
r
r�__len__:szAttributesImpl.__len__cCs
|j|Srr]r&r
r
r�__getitem__=szAttributesImpl.__getitem__cCst|j���Srrjrr
r
rrl@szAttributesImpl.keyscCs
||jkSrr]r&r
r
r�__contains__CszAttributesImpl.__contains__NcCs|j�||�Sr)r^�get)rr'�alternativer
r
rrrFszAttributesImpl.getcCs|�|j�Sr)�	__class__r^rr
r
r�copyIszAttributesImpl.copycCst|j���Sr)rkr^�itemsrr
r
rrvLszAttributesImpl.itemscCst|j���Sr)rkr^�valuesrr
r
rrwOszAttributesImpl.values)N)r/r0r1rrbrcrdrerhrirmrnrorprlrqrrrurvrwr
r
r
rr\s"
r\c@s<eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�AttributesNSImplcCs||_||_dSr)r^�_qnames)rr_Zqnamesr
r
rrVszAttributesNSImpl.__init__cCs6|j��D]\}}||kr
|j|Sq
t|��dSr)ryrvr^rg�rr'ZnsnameZqnamer
r
rre^sz AttributesNSImpl.getValueByQNamecCs0|j��D]\}}||kr
|Sq
t|��dSr)ryrvrgrzr
r
rrhes
zAttributesNSImpl.getNameByQNamecCs
|j|Sr)ryr&r
r
rrilszAttributesNSImpl.getQNameByNamecCst|j���Sr)rkryrwrr
r
rrnoszAttributesNSImpl.getQNamescCs|�|j|j�Sr)rtr^ryrr
r
rrurszAttributesNSImpl.copyN)	r/r0r1rrerhrirnrur
r
r
rrxTsrxcCst�t�t�dSr)rr2rBr
r
r
r�_testvsr{�__main__N)
r7r�_exceptionsrrrr2rBrIr\rxr{r/r
r
r
r�<module>sPJY>"PK0![|Ik-,,-sax/__pycache__/saxutils.cpython-38.opt-2.pycnu�[���U

e5d�/�@s�ddlZddlZddlZddlZddlZddlmZddlmZdd�Z	ifdd�Z
ifd	d
�Zifdd�Zd
d�Z
Gdd�dej�ZGdd�dej�Zddd�ZdS)�N�)�handler)�	xmlreadercCs"|��D]\}}|�||�}q|S�N)�items�replace)�s�d�key�value�r�(/usr/lib64/python3.8/xml/sax/saxutils.py�__dict_replacesrcCs6|�dd�}|�dd�}|�dd�}|r2t||�}|S)N�&�&amp;�>�&gt;�<�&lt;�rr��dataZentitiesrrr
�escapes	
rcCs2|�dd�}|�dd�}|r&t||�}|�dd�S)Nrrrrrrrrrrr
�unescape"s

rcCsR|dddd��}t||�}d|krFd|kr<d|�dd�}qNd	|}nd|}|S)
Nz&#10;z&#13;z&#9;)�
�
�	�"�'z"%s"z&quot;z'%s')rrrrrr
�	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�|�Sr)�getattr��self�name��outrr
�__getattr__Zsz,_gettextwriter.<locals>._wrapper.__getattr__N)�__name__�
__module__�__qualname__�	__class__r&rr$rr
�_wrapperXsr+cSsdSrrrrrr
�<lambda>]�z _gettextwriter.<locals>.<lambda>cSsdS)NTrrrrr
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+�bufferrr$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_elementsrrr
rJrs
zXMLGenerator.__init__cCsJ|drBd|dkr d|dS|j|d}|rB|d|dS|dS)Nrz$http://www.w3.org/XML/1998/namespacezxml:r�:)rO)r"r#�prefixrrr
�_qname~szXMLGenerator._qnamecCs|jr|�d�d|_dS)NrF�rSrK)r"�
endElementrrr
�_finish_pending_start_element�s
z*XMLGenerator._finish_pending_start_elementcCs|�d|j�dS)Nz$<?xml version="1.0" encoding="%s"?>
)rKrQ�r"rrr
�
startDocument�s�zXMLGenerator.startDocumentcCs|��dSr)rMrZrrr
�endDocument�szXMLGenerator.endDocumentcCs0|j�|j���||j|<|j�||f�dSr)rN�appendrO�copyrP�r"rU�urirrr
�startPrefixMapping�s
zXMLGenerator.startPrefixMappingcCs|jd|_|jd=dS)NrH)rNrO�r"rUrrr
�endPrefixMapping�szXMLGenerator.endPrefixMappingcCsZ|��|�d|�|��D]\}}|�d|t|�f�q|jrLd|_n
|�d�dS)Nr� %s=%sTr)rYrKrrrRrS)r"r#�attrsrrrr
�startElement�szXMLGenerator.startElementcCs*|jr|�d�d|_n|�d|�dS�Nz/>Fz</%s>rWr!rrr
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`rrrr
�startElementNS�szXMLGenerator.startElementNScCs0|jr|�d�d|_n|�d|�|��dSrg)rSrKrV�r"r#rhrrr
�endElementNS�s
zXMLGenerator.endElementNScCs4|r0|��t|t�s"t||j�}|�t|��dSr)rYr5�strrQrKr�r"Zcontentrrr
�
characters�s

zXMLGenerator.characterscCs0|r,|��t|t�s"t||j�}|�|�dSr)rYr5rlrQrKrmrrr
�ignorableWhitespace�s

z XMLGenerator.ignorableWhitespacecCs|��|�d||f�dS)Nz	<?%s %s?>)rYrK�r"�targetrrrr
�processingInstruction�sz"XMLGenerator.processingInstruction)NrGF)F)r'r(r)rJrVrYr[r\rarcrfrXrirkrnrorrrrrr
rFps


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);�
XMLFilterBaseNcCstj�|�||_dSr)r�	XMLReaderrJ�_parent�r"�parentrrr
rJ�szXMLFilterBase.__init__cCs|j�|�dSr)�_err_handler�error�r"Z	exceptionrrr
ry�szXMLFilterBase.errorcCs|j�|�dSr)rx�
fatalErrorrzrrr
r{�szXMLFilterBase.fatalErrorcCs|j�|�dSr)rx�warningrzrrr
r|�szXMLFilterBase.warningcCs|j�|�dSr)�
_cont_handler�setDocumentLocator)r"Zlocatorrrr
r~�sz XMLFilterBase.setDocumentLocatorcCs|j��dSr)r}r[rZrrr
r[�szXMLFilterBase.startDocumentcCs|j��dSr)r}r\rZrrr
r\szXMLFilterBase.endDocumentcCs|j�||�dSr)r}rar_rrr
rasz XMLFilterBase.startPrefixMappingcCs|j�|�dSr)r}rcrbrrr
rcszXMLFilterBase.endPrefixMappingcCs|j�||�dSr)r}rf)r"r#rerrr
rfszXMLFilterBase.startElementcCs|j�|�dSr)r}rXr!rrr
rXszXMLFilterBase.endElementcCs|j�|||�dSr)r}ri)r"r#rhrerrr
riszXMLFilterBase.startElementNScCs|j�||�dSr)r}rkrjrrr
rkszXMLFilterBase.endElementNScCs|j�|�dSr)r}rnrmrrr
rnszXMLFilterBase.characterscCs|j�|�dSr)r}ro)r"�charsrrr
rosz!XMLFilterBase.ignorableWhitespacecCs|j�||�dSr)r}rrrprrr
rrsz#XMLFilterBase.processingInstructioncCs|j�|�dSr)r}�
skippedEntityr!rrr
r� szXMLFilterBase.skippedEntitycCs|j�|||�dSr)�_dtd_handler�notationDecl)r"r#�publicId�systemIdrrr
r�%szXMLFilterBase.notationDeclcCs|j�||||�dSr)r��unparsedEntityDecl)r"r#r�r�Zndatarrr
r�(sz XMLFilterBase.unparsedEntityDeclcCs|j�||�Sr)Z_ent_handler�
resolveEntity)r"r�r�rrr
r�-szXMLFilterBase.resolveEntitycCs@|j�|�|j�|�|j�|�|j�|�|j�|�dSr)ruZsetContentHandlerZsetErrorHandlerZsetEntityResolverZ
setDTDHandler�parse)r"�sourcerrr
r�2s
zXMLFilterBase.parsecCs|j�|�dSr)ru�	setLocale)r"Zlocalerrr
r�9szXMLFilterBase.setLocalecCs|j�|�Sr)ru�
getFeaturer!rrr
r�<szXMLFilterBase.getFeaturecCs|j�||�dSr)ru�
setFeature)r"r#�staterrr
r�?szXMLFilterBase.setFeaturecCs|j�|�Sr)ru�getPropertyr!rrr
r�BszXMLFilterBase.getPropertycCs|j�||�dSr)ru�setProperty)r"r#rrrr
r�EszXMLFilterBase.setPropertycCs|jSr�rurZrrr
�	getParentJszXMLFilterBase.getParentcCs
||_dSrr�rvrrr
�	setParentMszXMLFilterBase.setParent)N)r'r(r)rJryr{r|r~r[r\rarcrfrXrirkrnrorrr�r�r�r�r�r�r�r�r�r�r�r�rrrr
rs�s8
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)N�readrr#�rb)r5�os�PathLike�fspathrlrZInputSource�hasattrr�ZsetCharacterStreamZ
setByteStreamr#ZsetSystemIdZgetCharacterStreamZ
getByteStreamZgetSystemId�path�dirname�normpath�join�isfile�open�urllibr�ZurljoinZrequestZurlopen)r��base�fZsysidZbaseheadZ
sysidfilenamerrr
�prepare_input_sourceRs.





r�)r�)r�Zurllib.parser�Zurllib.requestr6r8r�rrrrrrrErIrFrtrsr�rrrr
�<module>s)soPK0![�(��0�0*sax/__pycache__/expatreader.cpython-38.pycnu�[���U

e5dX=�@s�dZdZddlTddlmZmZddlmZddlmZmZddlm	Z	ddlm
Z
mZdd	lZej
d	d
�dkr|edd	��[zdd
lmZWnek
r�edd	��YnXeed�s�edd	��ddlmZmZmZejZejZzdd	lZWnek
�rdd�ZYnXdd	lZejZ[[Gdd�d�ZGdd�dej�ZGdd�dej ej�Z!dd�Z"e#dk�r�dd	l$Z%e"�Z&e&�'e%j(j�)��e&�*e%j(�+��e&�,d�d	S)z]
SAX driver for the pyexpat C module.  This driver works with
pyexpat.__version__ == '2.22'.
z0.20�)�*)�feature_validation�feature_namespaces)�feature_namespace_prefixes)�feature_external_ges�feature_external_pes)�feature_string_interning)�property_xml_string�property_interning_dictN��javazexpat not available in Java)�expatzexpat not supported�ParserCreate)�	xmlreader�saxutils�handlercCs|S�N�)�orr�+/usr/lib64/python3.8/xml/sax/expatreader.py�_mkproxy'src@seZdZdS)�
_ClosedParserN)�__name__�
__module__�__qualname__rrrrr.src@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�ExpatLocatorz�Locator for use with the ExpatParser class.

    This uses a weak reference to the parser object to avoid creating
    a circular reference between the parser and the content handler.
    cCst|�|_dSr)r�_ref��self�parserrrr�__init__9szExpatLocator.__init__cCs|j}|jdkrdS|jjSr)r�_parser�ErrorColumnNumberrrrr�getColumnNumber<s
zExpatLocator.getColumnNumbercCs|j}|jdkrdS|jjS�N�)rr!�ErrorLineNumberrrrr�
getLineNumberBs
zExpatLocator.getLineNumbercCs|j}|dkrdS|j��Sr)r�_source�getPublicIdrrrrr)HszExpatLocator.getPublicIdcCs|j}|dkrdS|j��Sr)rr(�getSystemIdrrrrr*NszExpatLocator.getSystemIdN)	rrr�__doc__r r#r'r)r*rrrrr3src@seZdZdZdCdd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�ZdDdd�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�Zd:d;�Zd<d=�Z d>d?�Z!d@dA�Z"dBS)E�ExpatParserz$SAX driver for the pyexpat C module.r��cCsFtj�||�t��|_d|_||_d|_d|_g|_	d|_
d|_dS)Nr)r�IncrementalParserr ZInputSourcer(r!�_namespaces�_lex_handler_prop�_parsing�
_entity_stack�
_external_ges�
_interning)rZnamespaceHandling�bufsizerrrr Zs
zExpatParser.__init__cCsVt�|�}||_z*|��|j�t|��tj�	||�Wn|�
��YnXdS)z3Parse an XML document from a URL or an InputSource.N)r�prepare_input_sourcer(�reset�
_cont_handlerZsetDocumentLocatorrrr.�parse�
_close_source�r�sourcerrrr9gs
zExpatParser.parsecCs |��dk	r|j�|���dSr)r*r!ZSetBaser;rrr�
prepareParserwszExpatParser.prepareParsercCs tj�||�|jr|��dSr)rr.�setContentHandlerr1�_reset_cont_handler)rrrrrr>}szExpatParser.setContentHandlercCsP|tkr|jS|tkr |jdk	S|tttfkr2dS|tkr@|jSt	d|��dS)Nr�Feature '%s' not recognized)
rr/rr4rrrrr3�SAXNotRecognizedException�r�namerrr�
getFeature�s
�zExpatParser.getFeaturecCs�|jrtd��|tkr||_n�|tkr.||_nt|tkrT|rL|jdkrRi|_q�d|_nN|tkrj|r�td��n8|t	kr�|r�td��n"|t
kr�|r�td��ntd|��dS)Nz!Cannot set features while parsingz!expat does not support validationz/expat does not read external parameter entitiesz(expat does not report namespace prefixesr@)r1�SAXNotSupportedExceptionrr/rr3rr4rrrrA)rrC�staterrr�
setFeature�s:
����zExpatParser.setFeaturecCsd|tjkr|jS|tkr|jS|tkrT|jrLt|jd�rB|j��St	d��nt
d��t	d|��dS)N�GetInputContextz=This version of expat does not support getting the XML stringz.XML string cannot be returned when not parsing�Property '%s' not recognized)r�property_lexical_handlerr0r
r4r	r!�hasattrrHrArErBrrr�getProperty�s

��zExpatParser.getPropertycCsV|tjkr ||_|jrR|��n2|tkr0||_n"|tkrFtd|��nt	d|��dS)NzProperty '%s' cannot be setrI)
rrJr0r1�_reset_lex_handler_propr
r4r	rErA)rrC�valuerrr�setProperty�s

��zExpatParser.setPropertyc
Csz|js|��d|_|j��z|j�||�WnDtjk
rt}z$tt�	|j
�||�}|j�|�W5d}~XYnXdSr$)
r1r7r8Z
startDocumentr!ZParser
�errorZSAXParseExceptionZErrorString�codeZ_err_handlerZ
fatalError)r�data�isFinal�e�excrrr�feed�s
zExpatParser.feedcCsB|j}z|��}|dk	r |��W5|��}|dk	r<|��XdSr)r(Z
getByteStream�closeZgetCharacterStream)rr<�filerrrr:�szExpatParser._close_sourcecCs�|js|jdkst|jt�r dSz(|jddd�|j	�
�d|_d|_W5d|_|jdk	rzt�}|jj|_|jj|_||_|��XdS)Nr�r%)rS)r2r!�
isinstancerr1r"r&r:rVr8ZendDocumentrrrrrW�s 
�




zExpatParser.closecCs|jj|j_|jj|j_dSr)r8�processingInstructionr!ZProcessingInstructionHandler�
charactersZCharacterDataHandler�rrrrr?�s�zExpatParser._reset_cont_handlercCs`|j}|j}|dkr4d|_d|_d|_d|_d|_n(|j|_|j|_|j	|_|j
|_|j|_dSr)r0r!ZCommentHandlerZStartCdataSectionHandlerZEndCdataSectionHandlerZStartDoctypeDeclHandlerZEndDoctypeDeclHandlerZcommentZ
startCDATAZendCDATA�start_doctype_declZendDTD)rZlexrrrrrMsz#ExpatParser._reset_lex_handler_propcCs�|jr>tj|j��d|jd�|_d|j_|j|j_	|j
|j_n,tj|j��|jd�|_|j|j_	|j
|j_|��|j|j_|j|j_|j|j_|j|j_d|_|jr�|��|j|j_z|j|j_Wntk
r�YnX|j�tj �d|_!g|_"dS)N� )�internr%r)#r/r
rr(ZgetEncodingr4r!Znamespace_prefixes�start_element_nsZStartElementHandler�end_element_nsZEndElementHandler�
start_element�end_elementr?�unparsed_entity_declZUnparsedEntityDeclHandler�
notation_declZNotationDeclHandler�start_namespace_declZStartNamespaceDeclHandler�end_namespace_declZEndNamespaceDeclHandlerZ_decl_handler_propr0rM�external_entity_refZExternalEntityRefHandler�skipped_entity_handlerZSkippedEntityHandler�AttributeErrorZSetParamEntityParsingZ*XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONEr1r2r]rrrr7s<�
�






�zExpatParser.resetcCs|jdkrdS|jjSr)r!r"r]rrrr#;s
zExpatParser.getColumnNumbercCs|jdkrdS|jjSr$)r!r&r]rrrr'@s
zExpatParser.getLineNumbercCs
|j��Sr)r(r)r]rrrr)EszExpatParser.getPublicIdcCs
|j��Sr)r(r*r]rrrr*HszExpatParser.getSystemIdcCs|j�|t|��dSr)r8ZstartElement�AttributesImpl)rrC�attrsrrrrcLszExpatParser.start_elementcCs|j�|�dSr)r8Z
endElementrBrrrrdOszExpatParser.end_elementcCs�|��}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}i}i}|��D]|\}}|��}t|�}	|	dkr�|}
d|f}n>|	dkr�d|d|df}
|d|df}n|d}
t|�}|||<|
||<qT|j�|dt||��dS)Nr%�rz%s:%s�)�split�len�tuple�itemsr8ZstartElementNS�AttributesNSImpl)rrCrm�pairZnewattrsZqnamesZanamerN�partsZlengthZqnameZapairrrrraRs0



�zExpatParser.start_element_nscCsV|��}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}|j�|d�dS)Nr%rnr)rprqrrr8ZendElementNS)rrCrurrrrbts
zExpatParser.end_element_nscCs|j�||�dSr)r8r[)r�targetrRrrr�processing_instruction�sz"ExpatParser.processing_instructioncCs|j�|�dSr)r8r\)rrRrrr�character_data�szExpatParser.character_datacCs|j�||�dSr)r8ZstartPrefixMapping)r�prefixZurirrrrg�sz ExpatParser.start_namespace_declcCs|j�|�dSr)r8ZendPrefixMapping)rrzrrrrh�szExpatParser.end_namespace_declcCs|j�|||�dSr)r0ZstartDTD)rrC�sysid�pubidZhas_internal_subsetrrrr^�szExpatParser.start_doctype_declcCs|j�||||�dSr)�_dtd_handlerZunparsedEntityDecl)rrC�baser{r|Z
notation_namerrrre�sz ExpatParser.unparsed_entity_declcCs|j�|||�dSr)r}ZnotationDecl)rrCr~r{r|rrrrf�szExpatParser.notation_declcCs�|js
dS|j�||�}t�||j��p*d�}|j�|j	|jf�|j	�
|�|_	||_ztj�
||�WnYdSX|jd\|_	|_|jd=dS)Nr%rYr���)r3Z_ent_handlerZ
resolveEntityrr6r(r*r2�appendr!ZExternalEntityParserCreaterr.r9)r�contextr~r{r|r<rrrri�s"
�zExpatParser.external_entity_refcCs|rd|}|j�|�dS)N�%)r8Z
skippedEntity)rrCZis_perrrrj�sz"ExpatParser.skipped_entity_handlerN)rr-)r)#rrrr+r r9r=r>rDrGrLrOrVr:rWr?rMr7r#r'r)r*rcrdrarbrxryrgrhr^rerfrirjrrrrr,Ws@


'"r,cOs
t||�Sr)r,)�args�kwargsrrr�
create_parser�sr��__main__z:http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml)-r+�versionZxml.sax._exceptionsZxml.sax.handlerrrrrrrr	r
�sys�platformZSAXReaderNotAvailableZxml.parsersr
�ImportErrorrKZxml.saxrrrrlrt�_weakrefr�weakref�proxyrZLocatorrr.r,r�rZxml.sax.saxutilsZxml�pr>ZsaxZXMLGeneratorZsetErrorHandlerZErrorHandlerr9rrrr�<module>sN


$_
PK0![~b���=�=sax/expatreader.pynu�[���"""
SAX driver for the pyexpat C module.  This driver works with
pyexpat.__version__ == '2.22'.
"""

version = "0.20"

from xml.sax._exceptions import *
from xml.sax.handler import feature_validation, feature_namespaces
from xml.sax.handler import feature_namespace_prefixes
from xml.sax.handler import feature_external_ges, feature_external_pes
from xml.sax.handler import feature_string_interning
from xml.sax.handler import property_xml_string, property_interning_dict

# xml.parsers.expat does not raise ImportError in Jython
import sys
if sys.platform[:4] == "java":
    raise SAXReaderNotAvailable("expat not available in Java", None)
del sys

try:
    from xml.parsers import expat
except ImportError:
    raise SAXReaderNotAvailable("expat not supported", None)
else:
    if not hasattr(expat, "ParserCreate"):
        raise SAXReaderNotAvailable("expat not supported", None)
from xml.sax import xmlreader, saxutils, handler

AttributesImpl = xmlreader.AttributesImpl
AttributesNSImpl = xmlreader.AttributesNSImpl

# If we're using a sufficiently recent version of Python, we can use
# weak references to avoid cycles between the parser and content
# handler, otherwise we'll just have to pretend.
try:
    import _weakref
except ImportError:
    def _mkproxy(o):
        return o
else:
    import weakref
    _mkproxy = weakref.proxy
    del weakref, _weakref

class _ClosedParser:
    pass

# --- ExpatLocator

class ExpatLocator(xmlreader.Locator):
    """Locator for use with the ExpatParser class.

    This uses a weak reference to the parser object to avoid creating
    a circular reference between the parser and the content handler.
    """
    def __init__(self, parser):
        self._ref = _mkproxy(parser)

    def getColumnNumber(self):
        parser = self._ref
        if parser._parser is None:
            return None
        return parser._parser.ErrorColumnNumber

    def getLineNumber(self):
        parser = self._ref
        if parser._parser is None:
            return 1
        return parser._parser.ErrorLineNumber

    def getPublicId(self):
        parser = self._ref
        if parser is None:
            return None
        return parser._source.getPublicId()

    def getSystemId(self):
        parser = self._ref
        if parser is None:
            return None
        return parser._source.getSystemId()


# --- ExpatParser

class ExpatParser(xmlreader.IncrementalParser, xmlreader.Locator):
    """SAX driver for the pyexpat C module."""

    def __init__(self, namespaceHandling=0, bufsize=2**16-20):
        xmlreader.IncrementalParser.__init__(self, bufsize)
        self._source = xmlreader.InputSource()
        self._parser = None
        self._namespaces = namespaceHandling
        self._lex_handler_prop = None
        self._parsing = 0
        self._entity_stack = []
        self._external_ges = 1
        self._interning = None

    # XMLReader methods

    def parse(self, source):
        "Parse an XML document from a URL or an InputSource."
        source = saxutils.prepare_input_source(source)

        self._source = source
        try:
            self.reset()
            self._cont_handler.setDocumentLocator(ExpatLocator(self))
            xmlreader.IncrementalParser.parse(self, source)
        except:
            # bpo-30264: Close the source on error to not leak resources:
            # xml.sax.parse() doesn't give access to the underlying parser
            # to the caller
            self._close_source()
            raise

    def prepareParser(self, source):
        if source.getSystemId() is not None:
            base = source.getSystemId()
            if isinstance(base, unicode):
                base = base.encode('utf-8')
            self._parser.SetBase(base)

    # Redefined setContentHandler to allow changing handlers during parsing

    def setContentHandler(self, handler):
        xmlreader.IncrementalParser.setContentHandler(self, handler)
        if self._parsing:
            self._reset_cont_handler()

    def getFeature(self, name):
        if name == feature_namespaces:
            return self._namespaces
        elif name == feature_string_interning:
            return self._interning is not None
        elif name in (feature_validation, feature_external_pes,
                      feature_namespace_prefixes):
            return 0
        elif name == feature_external_ges:
            return self._external_ges
        raise SAXNotRecognizedException("Feature '%s' not recognized" % name)

    def setFeature(self, name, state):
        if self._parsing:
            raise SAXNotSupportedException("Cannot set features while parsing")

        if name == feature_namespaces:
            self._namespaces = state
        elif name == feature_external_ges:
            self._external_ges = state
        elif name == feature_string_interning:
            if state:
                if self._interning is None:
                    self._interning = {}
            else:
                self._interning = None
        elif name == feature_validation:
            if state:
                raise SAXNotSupportedException(
                    "expat does not support validation")
        elif name == feature_external_pes:
            if state:
                raise SAXNotSupportedException(
                    "expat does not read external parameter entities")
        elif name == feature_namespace_prefixes:
            if state:
                raise SAXNotSupportedException(
                    "expat does not report namespace prefixes")
        else:
            raise SAXNotRecognizedException(
                "Feature '%s' not recognized" % name)

    def getProperty(self, name):
        if name == handler.property_lexical_handler:
            return self._lex_handler_prop
        elif name == property_interning_dict:
            return self._interning
        elif name == property_xml_string:
            if self._parser:
                if hasattr(self._parser, "GetInputContext"):
                    return self._parser.GetInputContext()
                else:
                    raise SAXNotRecognizedException(
                        "This version of expat does not support getting"
                        " the XML string")
            else:
                raise SAXNotSupportedException(
                    "XML string cannot be returned when not parsing")
        raise SAXNotRecognizedException("Property '%s' not recognized" % name)

    def setProperty(self, name, value):
        if name == handler.property_lexical_handler:
            self._lex_handler_prop = value
            if self._parsing:
                self._reset_lex_handler_prop()
        elif name == property_interning_dict:
            self._interning = value
        elif name == property_xml_string:
            raise SAXNotSupportedException("Property '%s' cannot be set" %
                                           name)
        else:
            raise SAXNotRecognizedException("Property '%s' not recognized" %
                                            name)

    # IncrementalParser methods

    def feed(self, data, isFinal = 0):
        if not self._parsing:
            self.reset()
            self._parsing = 1
            self._cont_handler.startDocument()

        try:
            # The isFinal parameter is internal to the expat reader.
            # If it is set to true, expat will check validity of the entire
            # document. When feeding chunks, they are not normally final -
            # except when invoked from close.
            self._parser.Parse(data, isFinal)
        except expat.error, e:
            exc = SAXParseException(expat.ErrorString(e.code), e, self)
            # FIXME: when to invoke error()?
            self._err_handler.fatalError(exc)

    def _close_source(self):
        source = self._source
        try:
            file = source.getCharacterStream()
            if file is not None:
                file.close()
        finally:
            file = source.getByteStream()
            if file is not None:
                file.close()

    def close(self):
        if (self._entity_stack or self._parser is None or
            isinstance(self._parser, _ClosedParser)):
            # If we are completing an external entity, do nothing here
            return
        try:
            self.feed("", isFinal = 1)
            self._cont_handler.endDocument()
            self._parsing = 0
            # break cycle created by expat handlers pointing to our methods
            self._parser = None
        finally:
            self._parsing = 0
            if self._parser is not None:
                # Keep ErrorColumnNumber and ErrorLineNumber after closing.
                parser = _ClosedParser()
                parser.ErrorColumnNumber = self._parser.ErrorColumnNumber
                parser.ErrorLineNumber = self._parser.ErrorLineNumber
                self._parser = parser
            self._close_source()

    def _reset_cont_handler(self):
        self._parser.ProcessingInstructionHandler = \
                                    self._cont_handler.processingInstruction
        self._parser.CharacterDataHandler = self._cont_handler.characters

    def _reset_lex_handler_prop(self):
        lex = self._lex_handler_prop
        parser = self._parser
        if lex is None:
            parser.CommentHandler = None
            parser.StartCdataSectionHandler = None
            parser.EndCdataSectionHandler = None
            parser.StartDoctypeDeclHandler = None
            parser.EndDoctypeDeclHandler = None
        else:
            parser.CommentHandler = lex.comment
            parser.StartCdataSectionHandler = lex.startCDATA
            parser.EndCdataSectionHandler = lex.endCDATA
            parser.StartDoctypeDeclHandler = self.start_doctype_decl
            parser.EndDoctypeDeclHandler = lex.endDTD

    def reset(self):
        if self._namespaces:
            self._parser = expat.ParserCreate(self._source.getEncoding(), " ",
                                              intern=self._interning)
            self._parser.namespace_prefixes = 1
            self._parser.StartElementHandler = self.start_element_ns
            self._parser.EndElementHandler = self.end_element_ns
        else:
            self._parser = expat.ParserCreate(self._source.getEncoding(),
                                              intern = self._interning)
            self._parser.StartElementHandler = self.start_element
            self._parser.EndElementHandler = self.end_element

        self._reset_cont_handler()
        self._parser.UnparsedEntityDeclHandler = self.unparsed_entity_decl
        self._parser.NotationDeclHandler = self.notation_decl
        self._parser.StartNamespaceDeclHandler = self.start_namespace_decl
        self._parser.EndNamespaceDeclHandler = self.end_namespace_decl

        self._decl_handler_prop = None
        if self._lex_handler_prop:
            self._reset_lex_handler_prop()
#         self._parser.DefaultHandler =
#         self._parser.DefaultHandlerExpand =
#         self._parser.NotStandaloneHandler =
        self._parser.ExternalEntityRefHandler = self.external_entity_ref
        try:
            self._parser.SkippedEntityHandler = self.skipped_entity_handler
        except AttributeError:
            # This pyexpat does not support SkippedEntity
            pass
        self._parser.SetParamEntityParsing(
            expat.XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)

        self._parsing = 0
        self._entity_stack = []

    # Locator methods

    def getColumnNumber(self):
        if self._parser is None:
            return None
        return self._parser.ErrorColumnNumber

    def getLineNumber(self):
        if self._parser is None:
            return 1
        return self._parser.ErrorLineNumber

    def getPublicId(self):
        return self._source.getPublicId()

    def getSystemId(self):
        return self._source.getSystemId()

    # event handlers
    def start_element(self, name, attrs):
        self._cont_handler.startElement(name, AttributesImpl(attrs))

    def end_element(self, name):
        self._cont_handler.endElement(name)

    def start_element_ns(self, name, attrs):
        pair = name.split()
        if len(pair) == 1:
            # no namespace
            pair = (None, name)
        elif len(pair) == 3:
            pair = pair[0], pair[1]
        else:
            # default namespace
            pair = tuple(pair)

        newattrs = {}
        qnames = {}
        for (aname, value) in attrs.items():
            parts = aname.split()
            length = len(parts)
            if length == 1:
                # no namespace
                qname = aname
                apair = (None, aname)
            elif length == 3:
                qname = "%s:%s" % (parts[2], parts[1])
                apair = parts[0], parts[1]
            else:
                # default namespace
                qname = parts[1]
                apair = tuple(parts)

            newattrs[apair] = value
            qnames[apair] = qname

        self._cont_handler.startElementNS(pair, None,
                                          AttributesNSImpl(newattrs, qnames))

    def end_element_ns(self, name):
        pair = name.split()
        if len(pair) == 1:
            pair = (None, name)
        elif len(pair) == 3:
            pair = pair[0], pair[1]
        else:
            pair = tuple(pair)

        self._cont_handler.endElementNS(pair, None)

    # this is not used (call directly to ContentHandler)
    def processing_instruction(self, target, data):
        self._cont_handler.processingInstruction(target, data)

    # this is not used (call directly to ContentHandler)
    def character_data(self, data):
        self._cont_handler.characters(data)

    def start_namespace_decl(self, prefix, uri):
        self._cont_handler.startPrefixMapping(prefix, uri)

    def end_namespace_decl(self, prefix):
        self._cont_handler.endPrefixMapping(prefix)

    def start_doctype_decl(self, name, sysid, pubid, has_internal_subset):
        self._lex_handler_prop.startDTD(name, pubid, sysid)

    def unparsed_entity_decl(self, name, base, sysid, pubid, notation_name):
        self._dtd_handler.unparsedEntityDecl(name, pubid, sysid, notation_name)

    def notation_decl(self, name, base, sysid, pubid):
        self._dtd_handler.notationDecl(name, pubid, sysid)

    def external_entity_ref(self, context, base, sysid, pubid):
        if not self._external_ges:
            return 1

        source = self._ent_handler.resolveEntity(pubid, sysid)
        source = saxutils.prepare_input_source(source,
                                               self._source.getSystemId() or
                                               "")

        self._entity_stack.append((self._parser, self._source))
        self._parser = self._parser.ExternalEntityParserCreate(context)
        self._source = source

        try:
            xmlreader.IncrementalParser.parse(self, source)
        except:
            return 0  # FIXME: save error info here?

        (self._parser, self._source) = self._entity_stack[-1]
        del self._entity_stack[-1]
        return 1

    def skipped_entity_handler(self, name, is_pe):
        if is_pe:
            # The SAX spec requires to report skipped PEs with a '%'
            name = '%'+name
        self._cont_handler.skippedEntity(name)

# ---

def create_parser(*args, **kwargs):
    return ExpatParser(*args, **kwargs)

# ---

if __name__ == "__main__":
    import xml.sax.saxutils
    p = create_parser()
    p.setContentHandler(xml.sax.saxutils.XMLGenerator())
    p.setErrorHandler(xml.sax.ErrorHandler())
    p.parse("http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml")
PK0![,���""sax/__init__.pynu�[���"""Simple API for XML (SAX) implementation for Python.

This module provides an implementation of the SAX 2 interface;
information about the Java version of the interface can be found at
http://www.megginson.com/SAX/.  The Python version of the interface is
documented at <...>.

This package contains the following modules:

handler -- Base classes and constants which define the SAX 2 API for
           the 'client-side' of SAX for Python.

saxutils -- Implementation of the convenience classes commonly used to
            work with SAX.

xmlreader -- Base classes and constants which define the SAX 2 API for
             the parsers used with SAX for Python.

expatreader -- Driver that allows use of the Expat parser with SAX.
"""

from xmlreader import InputSource
from handler import ContentHandler, ErrorHandler
from _exceptions import SAXException, SAXNotRecognizedException, \
                        SAXParseException, SAXNotSupportedException, \
                        SAXReaderNotAvailable


def parse(source, handler, errorHandler=ErrorHandler()):
    parser = make_parser()
    parser.setContentHandler(handler)
    parser.setErrorHandler(errorHandler)
    parser.parse(source)

def parseString(string, handler, errorHandler=ErrorHandler()):
    try:
        from cStringIO import StringIO
    except ImportError:
        from StringIO import StringIO

    if errorHandler is None:
        errorHandler = ErrorHandler()
    parser = make_parser()
    parser.setContentHandler(handler)
    parser.setErrorHandler(errorHandler)

    inpsrc = InputSource()
    inpsrc.setByteStream(StringIO(string))
    parser.parse(inpsrc)

# this is the parser list used by the make_parser function if no
# alternatives are given as parameters to the function

default_parser_list = ["xml.sax.expatreader"]

# tell modulefinder that importing sax potentially imports expatreader
_false = 0
if _false:
    import xml.sax.expatreader

import os, sys
if not sys.flags.ignore_environment and "PY_SAX_PARSER" in os.environ:
    default_parser_list = os.environ["PY_SAX_PARSER"].split(",")
del os

_key = "python.xml.sax.parser"
if sys.platform[:4] == "java" and sys.registry.containsKey(_key):
    default_parser_list = sys.registry.getProperty(_key).split(",")


def make_parser(parser_list = []):
    """Creates and returns a SAX parser.

    Creates the first parser it is able to instantiate of the ones
    given in the list created by doing parser_list +
    default_parser_list.  The lists must contain the names of Python
    modules containing both a SAX parser and a create_parser function."""

    for parser_name in parser_list + default_parser_list:
        try:
            return _create_parser(parser_name)
        except ImportError,e:
            import sys
            if parser_name in sys.modules:
                # The parser module was found, but importing it
                # failed unexpectedly, pass this exception through
                raise
        except SAXReaderNotAvailable:
            # The parser module detected that it won't work properly,
            # so try the next one
            pass

    raise SAXReaderNotAvailable("No parsers found", None)

# --- Internal utility methods used by make_parser

if sys.platform[ : 4] == "java":
    def _create_parser(parser_name):
        from org.python.core import imp
        drv_module = imp.importName(parser_name, 0, globals())
        return drv_module.create_parser()

else:
    def _create_parser(parser_name):
        drv_module = __import__(parser_name,{},{},['create_parser'])
        return drv_module.create_parser()

del sys
PK0![}F����sax/_exceptions.pynu�[���"""Different kinds of SAX Exceptions"""
import sys
if sys.platform[:4] == "java":
    from java.lang import Exception
del sys

# ===== SAXEXCEPTION =====

class SAXException(Exception):
    """Encapsulate an XML error or warning. This class can contain
    basic error or warning information from either the XML parser or
    the application: you can subclass it to provide additional
    functionality, or to add localization. Note that although you will
    receive a SAXException as the argument to the handlers in the
    ErrorHandler interface, you are not actually required to raise
    the exception; instead, you can simply read the information in
    it."""

    def __init__(self, msg, exception=None):
        """Creates an exception. The message is required, but the exception
        is optional."""
        self._msg = msg
        self._exception = exception
        Exception.__init__(self, msg)

    def getMessage(self):
        "Return a message for this exception."
        return self._msg

    def getException(self):
        "Return the embedded exception, or None if there was none."
        return self._exception

    def __str__(self):
        "Create a string representation of the exception."
        return self._msg

    def __getitem__(self, ix):
        """Avoids weird error messages if someone does exception[ix] by
        mistake, since Exception has __getitem__ defined."""
        raise AttributeError("__getitem__")


# ===== SAXPARSEEXCEPTION =====

class SAXParseException(SAXException):
    """Encapsulate an XML parse error or warning.

    This exception will include information for locating the error in
    the original XML document. Note that although the application will
    receive a SAXParseException as the argument to the handlers in the
    ErrorHandler interface, the application is not actually required
    to raise the exception; instead, it can simply read the
    information in it and take a different action.

    Since this exception is a subclass of SAXException, it inherits
    the ability to wrap another exception."""

    def __init__(self, msg, exception, locator):
        "Creates the exception. The exception parameter is allowed to be None."
        SAXException.__init__(self, msg, exception)
        self._locator = locator

        # We need to cache this stuff at construction time.
        # If this exception is raised, the objects through which we must
        # traverse to get this information may be deleted by the time
        # it gets caught.
        self._systemId = self._locator.getSystemId()
        self._colnum = self._locator.getColumnNumber()
        self._linenum = self._locator.getLineNumber()

    def getColumnNumber(self):
        """The column number of the end of the text where the exception
        occurred."""
        return self._colnum

    def getLineNumber(self):
        "The line number of the end of the text where the exception occurred."
        return self._linenum

    def getPublicId(self):
        "Get the public identifier of the entity where the exception occurred."
        return self._locator.getPublicId()

    def getSystemId(self):
        "Get the system identifier of the entity where the exception occurred."
        return self._systemId

    def __str__(self):
        "Create a string representation of the exception."
        sysid = self.getSystemId()
        if sysid is None:
            sysid = "<unknown>"
        linenum = self.getLineNumber()
        if linenum is None:
            linenum = "?"
        colnum = self.getColumnNumber()
        if colnum is None:
            colnum = "?"
        return "%s:%s:%s: %s" % (sysid, linenum, colnum, self._msg)


# ===== SAXNOTRECOGNIZEDEXCEPTION =====

class SAXNotRecognizedException(SAXException):
    """Exception class for an unrecognized identifier.

    An XMLReader will raise this exception when it is confronted with an
    unrecognized feature or property. SAX applications and extensions may
    use this class for similar purposes."""


# ===== SAXNOTSUPPORTEDEXCEPTION =====

class SAXNotSupportedException(SAXException):
    """Exception class for an unsupported operation.

    An XMLReader will raise this exception when a service it cannot
    perform is requested (specifically setting a state or value). SAX
    applications and extensions may use this class for similar
    purposes."""

# ===== SAXNOTSUPPORTEDEXCEPTION =====

class SAXReaderNotAvailable(SAXNotSupportedException):
    """Exception class for a missing driver.

    An XMLReader module (driver) should raise this exception when it
    is first imported, e.g. when a support module cannot be imported.
    It also may be raised during parsing, e.g. if executing an external
    program is not permitted."""
PK0![sE(�a6a6sax/handler.pynu�[���"""
This module contains the core classes of version 2.0 of SAX for Python.
This file provides only default classes with absolutely minimum
functionality, from which drivers and applications can be subclassed.

Many of these classes are empty and are included only as documentation
of the interfaces.

$Id$
"""

version = '2.0beta'

#============================================================================
#
# HANDLER INTERFACES
#
#============================================================================

# ===== ERRORHANDLER =====

class ErrorHandler:
    """Basic interface for SAX error handlers.

    If you create an object that implements this interface, then
    register the object with your XMLReader, the parser will call the
    methods in your object to report all warnings and errors. There
    are three levels of errors available: warnings, (possibly)
    recoverable errors, and unrecoverable errors. All methods take a
    SAXParseException as the only parameter."""

    def error(self, exception):
        "Handle a recoverable error."
        raise exception

    def fatalError(self, exception):
        "Handle a non-recoverable error."
        raise exception

    def warning(self, exception):
        "Handle a warning."
        print exception


# ===== CONTENTHANDLER =====

class ContentHandler:
    """Interface for receiving logical document content events.

    This is the main callback interface in SAX, and the one most
    important to applications. The order of events in this interface
    mirrors the order of the information in the document."""

    def __init__(self):
        self._locator = None

    def setDocumentLocator(self, locator):
        """Called by the parser to give the application a locator for
        locating the origin of document events.

        SAX parsers are strongly encouraged (though not absolutely
        required) to supply a locator: if it does so, it must supply
        the locator to the application by invoking this method before
        invoking any of the other methods in the DocumentHandler
        interface.

        The locator allows the application to determine the end
        position of any document-related event, even if the parser is
        not reporting an error. Typically, the application will use
        this information for reporting its own errors (such as
        character content that does not match an application's
        business rules). The information returned by the locator is
        probably not sufficient for use with a search engine.

        Note that the locator will return correct information only
        during the invocation of the events in this interface. The
        application should not attempt to use it at any other time."""
        self._locator = locator

    def startDocument(self):
        """Receive notification of the beginning of a document.

        The SAX parser will invoke this method only once, before any
        other methods in this interface or in DTDHandler (except for
        setDocumentLocator)."""

    def endDocument(self):
        """Receive notification of the end of a document.

        The SAX parser will invoke this method only once, and it will
        be the last method invoked during the parse. The parser shall
        not invoke this method until it has either abandoned parsing
        (because of an unrecoverable error) or reached the end of
        input."""

    def startPrefixMapping(self, prefix, uri):
        """Begin the scope of a prefix-URI Namespace mapping.

        The information from this event is not necessary for normal
        Namespace processing: the SAX XML reader will automatically
        replace prefixes for element and attribute names when the
        http://xml.org/sax/features/namespaces feature is true (the
        default).

        There are cases, however, when applications need to use
        prefixes in character data or in attribute values, where they
        cannot safely be expanded automatically; the
        start/endPrefixMapping event supplies the information to the
        application to expand prefixes in those contexts itself, if
        necessary.

        Note that start/endPrefixMapping events are not guaranteed to
        be properly nested relative to each-other: all
        startPrefixMapping events will occur before the corresponding
        startElement event, and all endPrefixMapping events will occur
        after the corresponding endElement event, but their order is
        not guaranteed."""

    def endPrefixMapping(self, prefix):
        """End the scope of a prefix-URI mapping.

        See startPrefixMapping for details. This event will always
        occur after the corresponding endElement event, but the order
        of endPrefixMapping events is not otherwise guaranteed."""

    def startElement(self, name, attrs):
        """Signals the start of an element in non-namespace mode.

        The name parameter contains the raw XML 1.0 name of the
        element type as a string and the attrs parameter holds an
        instance of the Attributes class containing the attributes of
        the element."""

    def endElement(self, name):
        """Signals the end of an element in non-namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElement event."""

    def startElementNS(self, name, qname, attrs):
        """Signals the start of an element in namespace mode.

        The name parameter contains the name of the element type as a
        (uri, localname) tuple, the qname parameter the raw XML 1.0
        name used in the source document, and the attrs parameter
        holds an instance of the Attributes class containing the
        attributes of the element.

        The uri part of the name tuple is None for elements which have
        no namespace."""

    def endElementNS(self, name, qname):
        """Signals the end of an element in namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElementNS event."""

    def characters(self, content):
        """Receive notification of character data.

        The Parser will call this method to report each chunk of
        character data. SAX parsers may return all contiguous
        character data in a single chunk, or they may split it into
        several chunks; however, all of the characters in any single
        event must come from the same external entity so that the
        Locator provides useful information."""

    def ignorableWhitespace(self, whitespace):
        """Receive notification of ignorable whitespace in element content.

        Validating Parsers must use this method to report each chunk
        of ignorable whitespace (see the W3C XML 1.0 recommendation,
        section 2.10): non-validating parsers may also use this method
        if they are capable of parsing and using content models.

        SAX parsers may return all contiguous whitespace in a single
        chunk, or they may split it into several chunks; however, all
        of the characters in any single event must come from the same
        external entity, so that the Locator provides useful
        information."""

    def processingInstruction(self, target, data):
        """Receive notification of a processing instruction.

        The Parser will invoke this method once for each processing
        instruction found: note that processing instructions may occur
        before or after the main document element.

        A SAX parser should never report an XML declaration (XML 1.0,
        section 2.8) or a text declaration (XML 1.0, section 4.3.1)
        using this method."""

    def skippedEntity(self, name):
        """Receive notification of a skipped entity.

        The Parser will invoke this method once for each entity
        skipped. Non-validating processors may skip entities if they
        have not seen the declarations (because, for example, the
        entity was declared in an external DTD subset). All processors
        may skip external entities, depending on the values of the
        http://xml.org/sax/features/external-general-entities and the
        http://xml.org/sax/features/external-parameter-entities
        properties."""


# ===== DTDHandler =====

class DTDHandler:
    """Handle DTD events.

    This interface specifies only those DTD events required for basic
    parsing (unparsed entities and attributes)."""

    def notationDecl(self, name, publicId, systemId):
        "Handle a notation declaration event."

    def unparsedEntityDecl(self, name, publicId, systemId, ndata):
        "Handle an unparsed entity declaration event."


# ===== ENTITYRESOLVER =====

class EntityResolver:
    """Basic interface for resolving entities. If you create an object
    implementing this interface, then register the object with your
    Parser, the parser will call the method in your object to
    resolve all external entities. Note that DefaultHandler implements
    this interface with the default behaviour."""

    def resolveEntity(self, publicId, systemId):
        """Resolve the system identifier of an entity and return either
        the system identifier to read from as a string, or an InputSource
        to read from."""
        return systemId


#============================================================================
#
# CORE FEATURES
#
#============================================================================

feature_namespaces = "http://xml.org/sax/features/namespaces"
# true: Perform Namespace processing (default).
# false: Optionally do not perform Namespace processing
#        (implies namespace-prefixes).
# access: (parsing) read-only; (not parsing) read/write

feature_namespace_prefixes = "http://xml.org/sax/features/namespace-prefixes"
# true: Report the original prefixed names and attributes used for Namespace
#       declarations.
# false: Do not report attributes used for Namespace declarations, and
#        optionally do not report original prefixed names (default).
# access: (parsing) read-only; (not parsing) read/write

feature_string_interning = "http://xml.org/sax/features/string-interning"
# true: All element names, prefixes, attribute names, Namespace URIs, and
#       local names are interned using the built-in intern function.
# false: Names are not necessarily interned, although they may be (default).
# access: (parsing) read-only; (not parsing) read/write

feature_validation = "http://xml.org/sax/features/validation"
# true: Report all validation errors (implies external-general-entities and
#       external-parameter-entities).
# false: Do not report validation errors.
# access: (parsing) read-only; (not parsing) read/write

feature_external_ges = "http://xml.org/sax/features/external-general-entities"
# true: Include all external general (text) entities.
# false: Do not include external general entities.
# access: (parsing) read-only; (not parsing) read/write

feature_external_pes = "http://xml.org/sax/features/external-parameter-entities"
# true: Include all external parameter entities, including the external
#       DTD subset.
# false: Do not include any external parameter entities, even the external
#        DTD subset.
# access: (parsing) read-only; (not parsing) read/write

all_features = [feature_namespaces,
                feature_namespace_prefixes,
                feature_string_interning,
                feature_validation,
                feature_external_ges,
                feature_external_pes]


#============================================================================
#
# CORE PROPERTIES
#
#============================================================================

property_lexical_handler = "http://xml.org/sax/properties/lexical-handler"
# data type: xml.sax.sax2lib.LexicalHandler
# description: An optional extension handler for lexical events like comments.
# access: read/write

property_declaration_handler = "http://xml.org/sax/properties/declaration-handler"
# data type: xml.sax.sax2lib.DeclHandler
# description: An optional extension handler for DTD-related events other
#              than notations and unparsed entities.
# access: read/write

property_dom_node = "http://xml.org/sax/properties/dom-node"
# data type: org.w3c.dom.Node
# description: When parsing, the current DOM node being visited if this is
#              a DOM iterator; when not parsing, the root DOM node for
#              iteration.
# access: (parsing) read-only; (not parsing) read/write

property_xml_string = "http://xml.org/sax/properties/xml-string"
# data type: String
# description: The literal string of characters that was the source for
#              the current event.
# access: read-only

property_encoding = "http://www.python.org/sax/properties/encoding"
# data type: String
# description: The name of the encoding to assume for input data.
# access: write: set the encoding, e.g. established by a higher-level
#                protocol. May change during parsing (e.g. after
#                processing a META tag)
#         read:  return the current encoding (possibly established through
#                auto-detection.
# initial value: UTF-8
#

property_interning_dict = "http://www.python.org/sax/properties/interning-dict"
# data type: Dictionary
# description: The dictionary used to intern common strings in the document
# access: write: Request that the parser uses a specific dictionary, to
#                allow interning across different documents
#         read:  return the current interning dictionary, or None
#

all_properties = [property_lexical_handler,
                  property_dom_node,
                  property_declaration_handler,
                  property_xml_string,
                  property_encoding,
                  property_interning_dict]
PK�"[�0�parsers/expat.pyonu�[����
{fc@sdZdZddlTdS(s1Interface to the Expat non-validating XML parser.s$Revision: 17640 $i����(t*N(t__doc__t__version__tpyexpat(((s)/usr/lib64/python2.7/xml/parsers/expat.pyt<module>sPK�"[�0�parsers/expat.pycnu�[����
{fc@sdZdZddlTdS(s1Interface to the Expat non-validating XML parser.s$Revision: 17640 $i����(t*N(t__doc__t__version__tpyexpat(((s)/usr/lib64/python2.7/xml/parsers/expat.pyt<module>sPK�"[-l��::parsers/__init__.pyonu�[����
{fc@s
dZdS(s�Python interfaces to XML parsers.

This package contains one module:

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

N(t__doc__(((s,/usr/lib64/python2.7/xml/parsers/__init__.pyt<module>tPK�"[-l��::parsers/__init__.pycnu�[����
{fc@s
dZdS(s�Python interfaces to XML parsers.

This package contains one module:

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

N(t__doc__(((s,/usr/lib64/python2.7/xml/parsers/__init__.pyt<module>tPK�"[]�C�n~n~dom/expatbuilder.pyonu�[����
{fc@s�dZddlmZmZmZddlmZmZmZddlm	Z	ddl
mZmZddl
mZddlTejZejZejZejjZejjZejjZejjZej�Zi	ejed�d	6ejed
�d6ejed�d
6ejed�d6ejed�d6ejed�d6ejed�d6ejed�d6ejed�d6Zdefd��YZd�Zd�Z dfd��YZ!eeefZ"d efd!��YZ#d"efd#��YZ$d$e$fd%��YZ%d&e$fd'��YZ&d(Z'd)e'Z(d*e!fd+��YZ)d,fd-��YZ*d.e*e!fd/��YZ+d0e*e)fd1��YZ,d2e-fd3��YZ.d4e!fd5��YZ/e0d6�Z1e0d7�Z2e0d8�Z3e0d9�Z4d:�Z5d;S(<s�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.
i����(t
xmlbuildertminidomtNode(tEMPTY_NAMESPACEtEMPTY_PREFIXtXMLNS_NAMESPACE(texpat(t
_append_childt_set_attribute_node(t
NodeFilter(t*tcdatatCDATAtenumerationtENUMtentitytENTITYtentitiestENTITIEStidtIDtidreftIDREFtidrefstIDREFStnmtokentNMTOKENtnmtokenstNMTOKENStElementInfocBsbeZdZd
d�Zd�Zd�Zd�Zd�Zd�Z	d	�Z
d
�Zd�ZRS(t
_attr_infot_modelttagNamecCs||_g|_||_dS(N(R RR(tselfR tmodel((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt__init__As		cCs|j|j|jfS(N(RRR (R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt__getstate__FscCs|\|_|_|_dS(N(RRR (R!tstate((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt__setstate__IscCs\xR|jD]G}|d|kr
|d}|ddkrBtdSt|dSq
q
WtjS(Nii����it(R(Rt
_typeinfo_mapRt_no_type(R!tanametinfott((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytgetAttributeTypeLs
cCstjS(N(RR)(R!tnamespaceURIt	localName((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytgetAttributeTypeNSVscCs:|jr2|jd}|tjjtjjfkStSdS(Ni(RRR"t
XML_CTYPE_ANYtXML_CTYPE_MIXEDtFalse(R!ttype((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytisElementContentYs
	
cCs(|jr |jdtjjkStSdS(Ni(RRR"tXML_CTYPE_EMPTYR3(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytisEmptyas	cCs6x/|jD]$}|d|kr
|ddkSq
WtS(Nii����R(RR3(R!R*R+((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytisIdgscCs|j||f�S(N(R8(R!teuritenametauriR*((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytisIdNSms(RRR N(
t__name__t
__module__t	__slots__tNoneR#R$R&R-R0R5R7R8R<(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR>s			
				cCs|j||�S(N(t_intern_setdefault(tbuilderts((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt_internqscCs�|jd�}|j}t|�dkry|\}}}|||�}d||f}|||�}|||�}n%|\}}t}|||�}}|||�|||fS(Nt is%s:%s(tsplitRAtlenR(RBtnametpartstinternturit	localnametprefixtqname((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt_parse_ns_namets	tExpatBuildercBs
eZdZdd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(sPDocument builder that uses Expat to build a ParsedXML.DOM document
    instance.cCsw|dkrtj�}n||_|jjdk	rNt|jj�|_nd|_t|_d|_	|j
�dS(N(R@RtOptionst_optionstfiltertFilterVisibilityControllert_filterRt_finish_start_elementt_parsertreset(R!toptions((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#�s				cCs
tj�S(sCreate a new parser object.(RtParserCreate(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytcreateParser�scCsh|jsa|j�|_|jjj|_t|j_t|j_t|j_|j	|j�n|jS(s7Return the parser object, creating a new one if needed.(
RWR[RJt
setdefaultRAtTruetbuffer_texttordered_attributestspecified_attributestinstall(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt	getParser�s	cCs@tjtdd�|_|j|_|jj|_t|_dS(s6Free all data structures used during DOM construction.N(	ttheDOMImplementationtcreateDocumentRR@tdocumenttcurNodet
_elem_infoR3t_cdata(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRX�s
cCs�|j|_|j|_|j|_|j|_|jj	rK|j
|_n|j|_
|jjrr|j|_n|jjr�|j|_|j|_|j|_n|j|_|j|_|j|_|j|_|j|_ dS(s>Install the callbacks needed to build the DOM into the parser.N(!tstart_doctype_decl_handlertStartDoctypeDeclHandlertfirst_element_handlertStartElementHandlertend_element_handlertEndElementHandlert
pi_handlertProcessingInstructionHandlerRRRtentity_decl_handlertEntityDeclHandlertnotation_decl_handlertNotationDeclHandlertcommentstcomment_handlertCommentHandlertcdata_sectionststart_cdata_section_handlertStartCdataSectionHandlertend_cdata_section_handlertEndCdataSectionHandlertcharacter_data_handler_cdatatCharacterDataHandlertcharacter_data_handlertexternal_entity_ref_handlertExternalEntityRefHandlertxml_decl_handlertXmlDeclHandlertelement_decl_handlertElementDeclHandlertattlist_decl_handlertAttlistDeclHandler(R!tparser((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRa�s$cCs�|j�}t}ylxU|jd�}|s1Pn|j|d�|rc|jjrc|j|�nt}qW|jdt�Wntk
r�nX|j}|j	�d|_|S(sIParse a document from a file object, returning the document
        node.iiiti@N(RbR]treadtParseRetdocumentElementt
_setup_subsetR3tParseEscapeRXR@RW(R!tfileR�tfirst_buffertbuffertdoc((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt	parseFile�s$

	
	cCsa|j�}y!|j|t�|j|�Wntk
r@nX|j}|j�d|_|S(s<Parse a document from a string, returning the document node.N(	RbR�R]R�R�ReRXR@RW(R!tstringR�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytparseString�s
	
	cCsD|jjr@t�}|j|�|j�}||jj_ndS(s/Load the internal subset if there might be one.N(RetdoctypetInternalSubsetExtractorR�t	getSubsettinternalSubset(R!R�t	extractortsubset((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s
	
cCs�|jjj|||�}|j|_t|j|�||j_|jr�|jj|�tkr�d|j_|jj
d=d}d|j_d|j_
n|r�|dk	r�g|j_g|j_nd|j_d|j_|j|j_ndS(Ni����(RetimplementationtcreateDocumentTypet
ownerDocumentRR�RUt
acceptNodet
FILTER_REJECTR@t
childNodesRWRrRtRt_seqt	notationsRwRptend_doctype_decl_handlertEndDoctypeDeclHandler(R!tdoctypeNametsystemIdtpublicIdthas_internal_subsetR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRi�s$!
cCsO|jjr|j|j_n|j|j_|jp<|jsKt	|_
ndS(N(RRRuRvRWRwRoRpRgRURt_finish_end_element(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�s
cCs]|jj||�}t|j|�|jrY|jj|�tkrY|jj|�ndS(N(RetcreateProcessingInstructionRRfRUR�R�tremoveChild(R!ttargettdatatnode((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRos!cCs�|jj}|jrd|jrF|djtkrF|dj|�dS|jj|�}t	|_n�|r�|djt
kr�|d}|j|}|j}||d<|d<dSt
j�}|j}||d<|d<|j|d<t|j|�dS(Ni����R�t	nodeValueR�(RfR�Rht_cdata_continuetnodeTypetCDATA_SECTION_NODEt
appendDataRetcreateCDATASectionR]t	TEXT_NODER�t__dict__RtTextR(R!R�R�R�tvaluetd((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR}s&		

		
cCs�|jj}|rU|djtkrU|d}|j}|j||d<|d<dStj�}|j}|j||d<|d<|j|d<t	|j|�dS(Ni����R�R�R�(
RfR�R�R�R�R�RR�ReR(R!R�R�R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR(s
		
c
Cs�|r
dS|jjsdS|jj||||�}|dk	rf|jj|�}	|jj|	�n|jjjj	j|�|j
r�|j
j|�tkr�|jjjj	d=ndS(Ni����(
RRRRet_create_entityR@tcreateTextNodeR�tappendR�R�RUR�R�(
R!t
entityNametis_parameter_entityR�tbaseR�R�tnotationNameR�tchild((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRq5s!cCsl|jj|||�}|jjjjj|�|jrh|jj|�tkrh|jjjjd=ndS(Ni����(	Ret_create_notationR�R�R�R�RUR�t
FILTER_ACCEPT(R!R�R�R�R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRsGs!cCsZ|jj|�}t|j|�|jrV|jj|�tkrV|jj|�ndS(N(Ret
createCommentRRfRUR�R�R�(R!R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRvMs!cCst|_t|_dS(N(R]RhR3R�(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRySs	cCst|_t|_dS(N(R3RhR�(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR{Ws	cCsdS(Ni((R!tcontextR�R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�[scCsK|jdkr%|jr%t|_n|j|j�_|j||�dS(N(RUR@RgRR�tstart_element_handlerRbRl(R!RHt
attributes((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRk^scCs�|jj|�}t|j|�||_|r�x�tdt|�d�D]�}tj||tdt
�}||d}|jdj}||d<|d<|j}||d<|d<|j|d<t
||�qJWn||jjk	r�|j|�ndS(NiiiR�R�R�R�(Ret
createElementRRftrangeRGRtAttrRR@RR�R�RR�RV(R!RHR�R�titaR�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�ds 		
cCs�|jr�||jjkrdS|jj|�}|tkrJt|�n|tkrct|�ndS|j|_	|jj
|�|j�ndS(N(RUReR�tstartContainerR�tRejectertFILTER_SKIPtSkippert
parentNodeRfR�tunlink(R!R�tfilt((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRVxs	

cCs&|j}|j|_|j|�dS(N(RfR�R�(R!RHRf((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRm�s	cCs�|jj|j�}|r.|j||�n|jr�||jjkrMdS|jj|�tkr�|j	j
|�|j�q�ndS(N(RgtgetR t_handle_white_text_nodesRUReR�R�R�RfR�R�(R!RfR+((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s	cCs�|jjs|j�rdSg}x@|jD]5}|jtkr-|jj�r-|j|�q-q-Wx|D]}|j	|�qmWdS(N(
RRtwhitespace_in_element_contentR5R�R�R�R�tstripR�R�(R!R�R+tLR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s

cCsD|jj|�}|dkr7t||�|j|<n	||_dS(N(RgR�R@RR(R!RHR"R+((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��sc	Csf|jj|�}|dkr:t|�}||j|<n|jjd|dd|d||g�dS(Ni(RgR�R@RRR�(R!telemRHR4tdefaulttrequiredR+((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s	cCsL||j_||j_|dkrH|r9t|j_qHt|j_ndS(Ni(RetversiontencodingR]t
standaloneR3(R!R�R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��sN( R=R>t__doc__R@R#R[RbRXRaR�R�R�RiR�RoR}RRqRsRvRyR{R�RkR�RVRmR�R�R�R�R�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRP�s:						
						
														RTcBs�eZdZdZd�Zd�Zd�Zieje	j
6eje	j6ej
e	j6eje	j6eje	j6eje	j6eje	j6eje	j6eje	j6eje	j6eje	j6eje	j 6Z!RS(soWrapper around a DOMBuilderFilter which implements the checks
    to make the whatToShow filter attribute work.RScCs
||_dS(N(RS(R!RS((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#�scCsu|j|j}|jj|@rm|jj|�}|tkrGt�n|tkritdt	|��n|St
SdS(Ns)startContainer() returned illegal value: (t_nodetype_maskR�RSt
whatToShowR�tFILTER_INTERRUPTR�t_ALLOWED_FILTER_RETURNSt
ValueErrortreprR�(R!R�tmasktval((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s	cCs�|j|j}|jj|@r�|jj|�}|tkrGt�n|tkr�|j}x|j	D]}|j
|�qgWtS|tkr�t
dt|��n|StSdS(Ns%acceptNode() returned illegal value: (R�R�RSR�R�R�R�R�R�R�tappendChildR�R�R�R�R�(R!R�R�R�tparentR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s		(RS("R=R>R�R?R#R�R�R	tSHOW_ELEMENTRtELEMENT_NODEtSHOW_ATTRIBUTEtATTRIBUTE_NODEt	SHOW_TEXTR�tSHOW_CDATA_SECTIONR�tSHOW_ENTITY_REFERENCEtENTITY_REFERENCE_NODEtSHOW_ENTITYtENTITY_NODEtSHOW_PROCESSING_INSTRUCTIONtPROCESSING_INSTRUCTION_NODEtSHOW_COMMENTtCOMMENT_NODEt
SHOW_DOCUMENTt
DOCUMENT_NODEtSHOW_DOCUMENT_TYPEtDOCUMENT_TYPE_NODEtSHOW_DOCUMENT_FRAGMENTtDOCUMENT_FRAGMENT_NODEt
SHOW_NOTATIONt
NOTATION_NODER�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRT�s$		
	










tFilterCrutchcBseZdZd�ZRS(t_buildert_levelt
_old_startt_old_endcCsOd|_||_|j}|j|_|j|_|j|_|j|_dS(Ni(	RRRWRlRRnRR�Rm(R!RBR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#s			(RRRR(R=R>R?R#(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR	sR�cBs)eZdZd�Zd�Zd�ZRS(cCs>tj||�|j}xdD]}t||d�q WdS(NRpRwR~RzR|R�(RpRwR~RzR|R�(RR#RWtsetattrR@(R!RBR�RH((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#s	
cGs|jd|_dS(Ni(R(R!targs((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�$scGsZ|jdkrF|jj}|jj|�|j|_|j|_n|jd|_dS(Nii(RRRWRaRRlRRn(R!RR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRm's((R=R>R?R#R�Rm(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�s		R�cBs eZdZd�Zd�ZRS(cGsB|jj}|j|�|jj|k	r>|jd|_ndS(Ni(RRfRR(R!RR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�4s
cGs`|jdkr?|j|jj_|j|jj_d|_n|jd|_|j|�dS(Nii(RRRRWRlRRnR@(R!R((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRm:s((R=R>R?R�Rm(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�1s	s8http://xml.python.org/entities/fragment-builder/internals�<!DOCTYPE wrapper
  %%s [
  <!ENTITY fragment-builder-internal
    SYSTEM "%s">
%%s
]>
<wrapper %%s
>&fragment-builder-internal;</wrapper>tFragmentBuildercBsPeZdZdd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
RS(	s�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.
    cCsM|jtkr$||_||_n|j|_||_tj||�dS(N(R�R�toriginalDocumentR�R�RPR#(R!R�RY((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#bs		cCstj|�d|_dS(N(RPRXR@tfragment(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRXks
cCs|j|j��S(sRParse a document fragment from a file object, returning the
        fragment node.(R�R�(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�osc	Cs�||_|j�}|jj}d}|r�|jp?|j�}|jrdd|j|jf}q�|jr�d|j}q�nd}|j�}t	|||f}y|j
|d�Wn|j��nX|j}|j�|S(sMParse a document fragment from a string, returning the
        fragment node.R�sPUBLIC "%s" "%s"sSYSTEM "%s"i(
t_sourceRbR	R�R�t_getDeclarationsR�R�t_getNSattrst_FRAGMENT_BUILDER_TEMPLATER�RXR
(	R!R�R�R�tidentR�tnsattrsReR
((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�ts,			
	
cCs�|jjj}d}|r�x�t|jj�D]v}|jj|�}|rY|d}nd||jf}|jr�d||j|j	f}q.d||j	f}q.Wx�t|j
j�D]�}|j
j|�}|r�|d}nd||jf}|jrd||j|j	f}n5|j	r=d||j	f}nd	||jjf}|j
rrd
||j
f}n|d}q�Wn|S(s�Re-create the internal subset from the DocumentType node.

        This is only needed if we don't already have the
        internalSubset as a string.
        R�s
  s%s<!NOTATION %ss!%s PUBLIC "%s"
             "%s">s%s SYSTEM "%s">s
%s<!ENTITY %ss %s PUBLIC "%s"
             "%s"s%s SYSTEM "%s"s%s "%s"s%s NOTATION %st>(R�R�R�R�R�tlengthtitemtnodeNameR�R�Rt
firstChildR�R�(R!R�RCR�tnotationR((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�s6
	
			cCsdS(NR�((R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR
�scCs�|tkr�|j}|j}|jj|�}|j|_|jj�|_|j|_z|j|j	d�Wd||_||_d|_	XdStj|||||�SdS(Nii����(
t$_FRAGMENT_BUILDER_INTERNAL_SYSTEM_IDReRfRWtExternalEntityParserCreateR	tcreateDocumentFragmentR
R�RR@RPR�(R!R�R�R�R�told_documenttold_cur_nodeR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s				
N(R=R>R�R@R#RXR�R�RR
R�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRYs					$	t
NamespacescBs;eZdZd�Zd�Zd�Zd�Zd�ZRS(s7Mix-in class for builders; adds support for namespaces.cCs
g|_dS(N(t_ns_ordered_prefixes(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt_initNamespaces�scCstjdd�}t|_|S(s'Create a new namespace-handling parser.tnamespace_separatorRE(RRZR]tnamespace_prefixes(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR[�s	cCs/tj||�|jjr+|j|_ndS(s.Insert the namespace-handlers onto the parser.N(RPRaRRtnamespace_declarationststart_namespace_decl_handlertStartNamespaceDeclHandler(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRa�scCs|jj||f�dS(s/Push this namespace declaration on our storage.N(RR�(R!RMRK((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR"�scCs�d|kr*t||�\}}}}nt}|}d}t}tj||||�}|j|_t|j	|�||_	|j
rIx�|j
D]�\}}|r�tjt|d|�t
|d�}ntjdt
dt�}|jdj}	||	d<|	d<|j}	||	d<|	d<|j|	d<t||�q�W|j
2n|r�|j}
|j}xtdt|�d	�D]}||}
||d
}d|
kr�t||
�\}}}}tj||||�}||
|<||||f<n2tj|
t|
t�}||
|
<||t|
f<|jdj}	||	d<|	d<|j}	|j|	d<||	d<|	d<||	d<qzWndS(NREsxmlns:txmlnsiR�R�R�R�iitownerElement(RORR@RRtElementReR�RRfRR�RDRR�R�Rt_attrst_attrsNSR�RG(R!RHR�RKRLRMRNR�R�R�R'R(R�R*R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��sZ			

		


	
(R=R>R�RR[RaR"R�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�s					4tExpatBuilderNScBseZdZd�ZRS(s*Document builder that supports namespaces.cCstj|�|j�dS(N(RPRXR(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRX5s
(R=R>R�RX(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR)2stFragmentBuilderNScBs eZdZd�Zd�ZRS(s*Fragment builder that supports namespaces.cCstj|�|j�dS(N(RRXR(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRX=s
cCs�d}|j}g}x�|r�t|d�r�x�|jj�D]p\}}||kr[q=n|j|�|r{d|}nd}|r�d|||f}q=d||f}q=Wn|j}qW|S(sNReturn string of namespace attributes from this element and
        ancestors.R�t_ns_prefix_urisxmlns:R$s%s
    %s='%s's %s='%s'(R�thasattrR+titemsR�R�(R!tattrsR�R�RMRKtdeclname((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR
As"		


(R=R>R�RXR
(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR*:s	R�cBseZdZRS(sEException raised to short-circuit parsing in InternalSubsetExtractor.(R=R>R�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�_sR�cBsSeZdZdZd�Zd�Zd�Zd�Zd�Z	d�Z
d�ZRS(	sBXML processor which can rip out the internal document type subset.cCs|jS(s'Return the internal subset as a string.(R�(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�hscCs,ytj||�Wntk
r'nXdS(N(RPR�R�(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�ls
cCs,ytj||�Wntk
r'nXdS(N(RPR�R�(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�rs
cCs|j|_|j|_dS(N(RiRjR�Rl(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRaxscCsF|r9|j�}g|_|jj|_|j|_n	t��dS(N(RbR�R�tDefaultHandlerR�R�R�(R!RHR�R�R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRi|s	cCs@dj|j�jdd�jdd�}||_t��dS(NR�s
s
s
(tjoinR�treplaceR�(R!RC((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s*	cCs
t��dS(N(R�(R!RHR.((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��sN(R=R>R�R@R�R�R�R�RaRiR�R�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�cs					
	cCsp|rt�}n	t�}t|t�r]t|d�}z|j|�}Wd|j�Xn|j|�}|S(s{Parse a document, returning the resulting Document node.

    'file' may be either a file name or an open file object.
    trbN(R)RPt
isinstancetStringTypestopenR�tclose(R�t
namespacesRBtfptresult((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytparse�s	cCs(|rt�}n	t�}|j|�S(sOParse a document from a string, returning the resulting
    Document node.
    (R)RPR�(R�R8RB((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s	cCsv|rt|�}nt|�}t|t�rct|d�}z|j|�}Wd|j�Xn|j|�}|S(s�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.
    R3N(R*RR4R5R6R�R7(R�R�R8RBR9R:((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt
parseFragment�scCs.|rt|�}nt|�}|j|�S(s�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*RR�(R�R�R8RB((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytparseFragmentString�scCs!|jrt|�St|�SdS(s,Create a builder based on an Options object.N(R8R)RP(RY((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytmakeBuilder�s	
N(6R�txml.domRRRRRRtxml.parsersRtxml.dom.minidomRRtxml.dom.NodeFilterR	txml.dom.minicompatR�R�R�tDOMBuilderFilterR�R�R�R�tgetDOMImplementationRctTypeInfoR@R(tobjectRRDRORPR�RTRR�R�RRRRR)R*t	ExceptionR�R�R]R;R�R<R=R>(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt<module>s`
			3		�I:ud%,PK�"["��i����dom/minidom.pyonu�[����
{fc@sdZddlZddlmZmZmZmZddlTddlm	Z	m
Z
ejjj
ejjjfZdejjfd��YZeedd	d
�eedd	d�eed
d	d�d�Zd�Zd�Zd�Zd�Zdefd��YZdefd��YZeedd	d�eed
d	d�eedd	d�defd��YZeedd	d �eZd!efd"��YZeee�Zd#efd$��YZeed%d	d&�eed
d	d'�d(�Zd)fd*��YZ d+e efd,��YZ!d-e efd.��YZ"ee"dd	d/�d0e"fd1��YZ#ee#d2d	d3�ee#d4d	d5�d6�Z$d7�Z%d8e e"fd9��YZ&d:e#fd;��YZ'd<efd=��YZ(ee(dd	d>�d?fd@��YZ)dAe)e efdB��YZ*dCe)efdD��YZ+dEe)e efdF��YZ,dGe	fdH��YZ-dIefdJ��YZ.dK�Z/dLee
fdM��YZ0ee0dNd	dO�dP�Z1dQ�Z2dR�Z3dS�Z4eedT�Z5edU�Z6edV�Z7dS(WscSimple 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
i����N(tEMPTY_NAMESPACEtEMPTY_PREFIXtXMLNS_NAMESPACEtdomreg(t*(tDOMImplementationLSt
DocumentLStNodecBs�eZdZdZdZdZdZeZ	d�Z
dd�Zdddd�Zd�Z
d�Zd�Zd�Zd	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(cCstS(N(tTrue(tself((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__nonzero__*scCs|jdd|�S(Nt(ttoprettyxml(R	tencoding((s'/usr/lib64/python2.7/xml/dom/minidom.pyttoxml-ss	s
cCs�t�}|dk	r=ddl}|j|�d|�}n|jtjkrk|j|d|||�n|j|d||�|j�S(Ni����iR(	t
_get_StringIOtNonetcodecstlookuptnodeTypeRt
DOCUMENT_NODEtwritexmltgetvalue(R	tindenttnewlR
twriterR((s'/usr/lib64/python2.7/xml/dom/minidom.pyR0s	cCs|jr
tStSdS(N(t
childNodesRtFalse(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
hasChildNodes?s	cCs|jS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_childNodesEscCs|jr|jdSdS(Ni(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_firstChildHs	cCs|jr|jdSdS(Ni����(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_lastChildLs	cCsw|j|jkr@x't|j�D]}|j||�q"W|S|j|jkr}tjjdt	|�t	|�f��n|j
dk	r�|j
j|�n|dkr�|j
|�n�y|jj|�}Wn tk
r�tjj��nX|jtkrt|�n|jj||�||_||_|ra|j|d}||_||_n	d|_||_
|S(Ns%s cannot be child of %si(RtDOCUMENT_FRAGMENT_NODEttupleRtinsertBeforet_child_node_typestxmltdomtHierarchyRequestErrtreprt
parentNodeRtremoveChildtappendChildtindext
ValueErrortNotFoundErrt_nodeTypes_with_childrent_clear_id_cachetinserttnextSiblingtpreviousSibling(R	tnewChildtrefChildtcR+tnode((s'/usr/lib64/python2.7/xml/dom/minidom.pyR"Ps6	"

					cCs�|j|jkr=x$t|j�D]}|j|�q"W|S|j|jkrztjjdt	|�t	|�f��n|jt
kr�t|�n|jdk	r�|jj|�nt||�d|_|S(Ns%s cannot be child of %s(RR R!RR*R#R$R%R&R'R.R/R(RR)t
_append_childR1(R	R6R5((s'/usr/lib64/python2.7/xml/dom/minidom.pyR*ps	"

	cCs�|j|jkr8|j}|j|�|j||�S|j|jkrutjjdt	|�t	|�f��n||kr�dS|j
dk	r�|j
j|�ny|jj
|�}Wn tk
r�tjj��nX||j|<||_
d|_
|jtks|jtkr*t|�n|j|_|j|_d|_d|_|jrl||j_n|jr�||j_n|S(Ns%s cannot be child of %s(RR R1R)R"R#R$R%R&R'R(RRR+R,R-R.R/R2(R	R3toldChildR4R+((s'/usr/lib64/python2.7/xml/dom/minidom.pytreplaceChild�s<	
	"

		
				cCs�y|jj|�Wn tk
r6tjj��nX|jdk	rX|j|j_n|jdk	ry|j|j_nd|_|_|j	t
kr�t|�nd|_|S(N(
RtremoveR,R$R%R-R1RR2RR.R/R((R	R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR)�s

	cCs*g}x|jD]}|jtjkr�|jsr|rJ|j|d_n|jre|j|j_n|j�q|r�|dj|jkr�|d}|j|j|_|j|_|jr�||j_n|j�q|j|�q|j|�|jtj	kr|j
�qqW||j(dS(Ni����(RRRt	TEXT_NODEtdataR1R2tunlinktappendtELEMENT_NODEt	normalize(R	tLtchildR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR@�s*		

	

cCst|||jp|�S(N(t_clone_nodet
ownerDocument(R	tdeep((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	cloneNode�scCs|jjj||�S(N(RDtimplementationt
hasFeature(R	tfeaturetversion((s'/usr/lib64/python2.7/xml/dom/minidom.pytisSupported�scCsdS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_localName�scCs
||kS(N((R	tother((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
isSameNode�scCs|j|d�r|SdSdS(N(RKR(R	RI((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetInterface�scCs2y|j|dSWnttfk
r-dSXdS(Ni(t
_user_datatAttributeErrortKeyErrorR(R	tkey((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetUserData�scCs�d}y
|j}Wn tk
r5i}||_nX||krS||d}n|dkr~d}|dk	r�||=q�n||f||<|S(Ni(RRPRQ(R	RSR<thandlertoldtd((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetUserData�s



cCsdt|d�r`xN|jj�D]:\}\}}|dk	r|j|||||�qqWndS(NRP(thasattrRPtitemsRthandle(R	t	operationtsrctdstRSR<RU((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_call_user_data_handler�s"cCs\d|_|_|jrFx|jD]}|j�q#Wt�|_nd|_d|_dS(N(RR(RDRR=tNodeListR2R1(R	RB((s'/usr/lib64/python2.7/xml/dom/minidom.pyR=s		N(t__name__t
__module__RtnamespaceURIR(RDR1R2RtprefixR
RRRRRRR"R*R9R)R@RFRKRLRNRORTRXR_R=(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR!s6						 		 							
			t
firstChildtdocsFirst child node, or None.t	lastChildsLast child node, or None.t	localNames"Namespace-local name of this node.cCsT|j}|r6|d}||jd<||jd<n|j|�||jd<dS(Ni����R2R1R((Rt__dict__R>(R	R6Rtlast((s'/usr/lib64/python2.7/xml/dom/minidom.pyR7s	


cCs6x/|dk	r1|jtjkr%tS|j}qWtS(N(RRRRRR(R(R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_in_documents

cCsP|rL|jdd�jdd�jdd�jdd�}|j|�nd	S(
sWrites datachars to writer.t&s&amp;t<s&lt;s"s&quot;t>s&gt;N(treplacetwrite(RR<((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_write_data%scCsex^|jD]S}|jtjkrM|dks=|j|krM|j|�nt|||�q
W|S(NR(RRRR?ttagNameR>t_get_elements_by_tagName_helper(tparenttnametrcR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyRs,scCs�x|jD]t}|jtjkr
|dks=|j|krh|dksX|j|krh|j|�nt||||�q
q
W|S(NR(RRRR?RhRcR>t"_get_elements_by_tagName_ns_helper(RttnsURIRhRvR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyRw4stDocumentFragmentcBsbeZejZdZdZdZdZ	ej
ejejej
ejejejfZd�ZRS(s#document-fragmentcCst�|_dS(N(R`R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__init__KsN(RaRbRR RtnodeNameRt	nodeValuet
attributesR(R?R;tCDATA_SECTION_NODEtENTITY_REFERENCE_NODEtPROCESSING_INSTRUCTION_NODEtCOMMENT_NODEt
NOTATION_NODER#Rz(((s'/usr/lib64/python2.7/xml/dom/minidom.pyRy=s	tAttrcBs�eZejZd	Zd	ZeZ	eZ
ejejfZ
ed	d	d�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(
cCsS|j}||d<|d<||d<||d<t�|d<|jjt��dS(NR{RuRcRdR(RiR`RR>tText(R	tqNameRcRhRdRW((s'/usr/lib64/python2.7/xml/dom/minidom.pyRzXs	


cCs|jjdd�dS(Nt:ii����(R{tsplit(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRLfscCs|jS(N(t	specified(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_specifiediscCs�|j}|dkrk||d<|d<|jdj}||d<|d<|jdk	r�t|j�q�nJ|dkr�||d<|d<|jdk	r�t|j�q�n
|||<dS(	NtvalueR|iR<RuR{(R�R|(RuR{(RiRtownerElementRR/(R	RuR�RWtd2((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__setattr__ls	cCs�|j}|dkr?|r?|tkr?tjjd��q?n|j}||d<|dkrj|j}nd||jf}|jr�t	|j�n||d<|d<dS(Ntxmlnss5illegal use of 'xmlns' prefix for the wrong namespaceRds%s:%sR{Ru(
RcRR$R%tNamespaceErrRiRRhR�R/(R	RdtnsuriRWtnewName((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_set_prefix{s			
	cCsH|j}||d<|d<|jr4t|j�n||jd_dS(NR�R|i(RiR�R/RR<(R	R�RW((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
_set_value�s
		cCs�|j}|dk	rq|j|j=|j|j|jf=|jrqt|_|j	d8_	|j
jd8_qqnx|jD]}|j
�q{W|j2dS(Ni(R�Rt_attrsR{t_attrsNSRcRht_is_idRt_magic_id_nodesRDt_magic_id_countRR=(R	telemRB((s'/usr/lib64/python2.7/xml/dom/minidom.pyR=�s	
		cCs�|jr
tS|j}|j}|dks7|dkr;tS|j|�}|dkrZtS|jry|j|j|j	�S|j
|j�SdS(N(R�RRDR�RRt_get_elem_infoRctisIdNSRhtisIdR{(R	RfR�tinfo((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	_get_isId�s				cCs�|j}|j}|dks*|dkr.tS|j|�}|dkrMtS|jrl|j|j|j�S|j|j	�SdS(N(
RDR�Rt_no_typeR�RctgetAttributeTypeNSRhtgetAttributeTypeR{(R	RfR�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_schemaType�s			N(RaRbRtATTRIBUTE_NODERRR}R�RR�R�R;RR#RRzRLR�R�R�R�R=R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�Os 	
							R�s True if this attribute is an ID.s'Namespace-local name of this attribute.t
schemaTypesSchema type for this attribute.tNamedNodeMapcBs�eZdZdZd�Zd�Zd�Zd�Zd�Zd	�Z	d
�Z
d�Zd�Zdd
�ZeZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(sThe 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�t
_ownerElementcCs||_||_||_dS(N(R�R�R�(R	tattrstattrsNSR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�s		cCs
t|j�S(N(tlenR�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_length�scCs2y||jj�|SWntk
r-dSXdS(N(R�tkeyst
IndexErrorR(R	R+((s'/usr/lib64/python2.7/xml/dom/minidom.pytitem�s
cCs=g}x0|jj�D]}|j|j|jf�qW|S(N(R�tvaluesR>R{R�(R	RAR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyRZ�scCsFg}x9|jj�D](}|j|j|jf|jf�qW|S(N(R�R�R>RcRhR�(R	RAR6((s'/usr/lib64/python2.7/xml/dom/minidom.pytitemsNS�s&cCs-t|t�r||jkS||jkSdS(N(t
isinstancetStringTypesR�R�(R	RS((s'/usr/lib64/python2.7/xml/dom/minidom.pythas_key�s
cCs
|jj�S(N(R�R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs
|jj�S(N(R�R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pytkeysNS�scCs
|jj�S(N(R�R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|jj||�S(N(R�tget(R	RuR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs<|jt|dd�krdStt|�t|��SdS(NR�i(R�tgetattrRtcmptid(R	RM((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__cmp__scCs)t|t�r|j|S|j|SdS(N(R�R!R�R�(R	tattname_or_tuple((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__getitem__scCs�t|t�rhy|j|}Wn9tk
r[t|�}|jj|_|j|�nX||_n.t|t�s�t	d�n|}|j|�dS(Ns%value must be a string or Attr object(
R�R�R�RRR�R�RDtsetNamedItemR�t	TypeError(R	tattnameR�R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__setitem__
s
cCs(y|j|SWntk
r#dSXdS(N(R�RRR(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetNamedItems
cCs.y|j||fSWntk
r)dSXdS(N(R�RRR(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetNamedItemNS"s
cCs�|j|�}|dk	rnt|j�|j|j=|j|j|jf=d|j	krjd|j	d<n|St
jj��dS(NR�(
R�RR/R�R�R{R�RcRhRiR$R%R-(R	Rutn((s'/usr/lib64/python2.7/xml/dom/minidom.pytremoveNamedItem(s

cCs�|j||�}|dk	rqt|j�|j|j|jf=|j|j=d|j	krmd|j	d<n|St
jj��dS(NR�(
R�RR/R�R�RcRhR�R{RiR$R%R-(R	RcRhR�((s'/usr/lib64/python2.7/xml/dom/minidom.pytremoveNamedItemNS4s

cCs�t|t�s:tjjdt|�t|�f��n|jj|j�}|rb|j	�n||j|j<||j
|j|jf<|j
|_t|j�|S(Ns%s cannot be child of %s(R�R�R$R%R&R'R�R�RuR=R�RcRhR�R�R/(R	R6RV((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�@s	"

cCs
|j|�S(N(R�(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetNamedItemNSMscCs%||}t|j�|j�dS(N(R/R�R=(R	R�R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__delitem__Ps

cCs|j|j|jfS(N(R�R�R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__getstate__UscCs|\|_|_|_dS(N(R�R�R�(R	tstate((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__setstate__Xs(R�R�R�N(RaRbt__doc__t	__slots__RzR�R�RZR�R�R�R�R�RR�t__len__t__hash__R�R�R�R�R�R�R�R�R�R�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s4																	
			tlengths$Number of nodes in the NamedNodeMap.tTypeInfocBs2eZdZd�Zd�Zd�Zd�ZRS(t	namespaceRucCs||_||_dS(N(R�Ru(R	R�Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pyRzds	cCs,|jrd|j|jfSd|jSdS(Ns<TypeInfo %r (from %r)>s
<TypeInfo %r>(R�Ru(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__repr__hs	cCs|jS(N(Ru(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	_get_namenscCs|jS(N(R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_namespaceqs(R�Ru(RaRbR�RzR�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�as
			tElementcBsLeZejZdZeZdZ	ejej
ejejej
ejfZeddd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd	�Zd
�Zd�ZeZd�Zd
�Zd�ZeZ d�Z!d�Z"d�Z#d�Z$d�Z%dddd�Z&d�Z'd�Z(d�Z)d�Z*d�Z+RS(icCsD||_|_||_||_t�|_i|_i|_dS(N(RrR{RdRcR`RR�R�(R	RrRcRdRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�s			cCs|jjdd�dS(NR�ii����(RrR�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRL�scCs|jS(N(Rr(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_tagName�scCsGx!|jj�D]}|j�qWd|_d|_tj|�dS(N(R�R�R=RR�R(R	tattr((s'/usr/lib64/python2.7/xml/dom/minidom.pyR=�s
		cCs+y|j|jSWntk
r&dSXdS(NR(R�R�RR(R	R�((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetAttribute�s
cCs1y|j||fjSWntk
r,dSXdS(NR(R�R�RR(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetAttributeNS�s
cCs�|j|�}|dkr_t|�}|j}||d<|d<|j|d<|j|�nC||jkr�|j}||d<|d<|jr�t|�q�ndS(NR�R|RD(	tgetAttributeNodeRR�RiRDtsetAttributeNodeR�R�R/(R	R�R�R�RW((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetAttribute�s	
		cCs�t|�\}}|j||�}|dkr�t||||�}|j}||d<||d<||d<|d<|j|d<|j|�ni|j}||jkr�||d<|d<|jr�t	|�q�n|j
|kr�||d<||d<ndS(NRdR{R�R|RD(t_nssplittgetAttributeNodeNSRR�RiRDR�R�R�R/Rd(R	Rct
qualifiedNameR�Rdt	localnameR�RW((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetAttributeNS�s$	


		
cCs|jj|�S(N(R�R�(R	tattrname((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|jj||f�S(N(R�R�(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs�|jd|fkr*tjjd��n|jj|jd�}|dk	r^|j|�n|j	j|j
|jfd�}|dk	r�||k	r�|j|�nt||�||k	r�|S||k	r�|SdS(Nsattribute node already owned(
R�RR$R%tInuseAttributeErrR�R�RutremoveAttributeNodeR�RcRht_set_attribute_node(R	R�told1told2((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s!
cCsEy|j|}Wn tk
r3tjj��nX|j|�dS(N(R�RRR$R%R-R�(R	RuR�((s'/usr/lib64/python2.7/xml/dom/minidom.pytremoveAttribute�s

cCsKy|j||f}Wn tk
r9tjj��nX|j|�dS(N(R�RRR$R%R-R�(R	RcRhR�((s'/usr/lib64/python2.7/xml/dom/minidom.pytremoveAttributeNS�s

cCsw|dkrtjj��ny|j|jWn tk
rRtjj��nXt|�|j�|j	|_	dS(N(
RR$R%R-R�RuRRR/R=RD(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s


cCs
||jkS(N(R�(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pythasAttributescCs||f|jkS(N(R�(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pythasAttributeNSscCst||t��S(N(RsR`(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetElementsByTagNamescCst|||t��S(N(RwR`(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetElementsByTagNameNSscCsd|jt|�fS(Ns<DOM Element: %s at %#x>(RrR�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�sRc	Cs[|j|d|j�|j�}|j�}|j�x@|D]8}|jd|�t|||j�|jd�qAW|jrF|jd�t|j�dkr�|jdj	t
jkr�|jdj|ddd�nH|j|�x+|jD] }|j|||||�q�W|j|�|jd|j|f�n|jd	|�dS(
NRms %s="s"RniiRs</%s>%ss/>%s(
RpRrt_get_attributesR�tsortRqR�RR�RRR;R(	R	RRt	addindentRR�ta_namesta_nameR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyRs&

	
 

cCst|j|j|�S(N(R�R�R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�4scCs|jr
tStSdS(N(R�RR(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
hasAttributes7s	cCs |j|�}|j|�dS(N(R�tsetIdAttributeNode(R	RutidAttr((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetIdAttribute?scCs#|j||�}|j|�dS(N(R�R�(R	RcRhR�((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetIdAttributeNSCscCs�|dks|j|j�r1tjj��nt|�dk	rUtjj��n|js�t	|j
d<|jd7_|jj
d7_
t|�ndS(NR�i(RRNR�R$R%R-t_get_containing_entreftNoModificationAllowedErrR�RRiR�RDR�R/(R	R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�Gs	
N(,RaRbRR?RRR|R�R�R�R�R�R;R~RR#RRzRLR�R=R�R�R�R�R�R�R�tsetAttributeNodeNSR�R�R�tremoveAttributeNodeNSR�R�R�R�R�RR�R�R�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�vsL														
									R}s*NamedNodeMap of attributes on the element.s%Namespace-local name of this element.cCsDt|�||j|j<||j|j|jf<||jd<dS(NR�(R/R�RuR�RcRhRi(telementR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�Xs
t	ChildlesscBsqeZdZd	Ze�Zd	Zd	Zd�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd�ZRS(
s�Mixin that makes childless-ness easy to implement and avoids
    the complexity of the Node methods that deal with children.
    cCsdS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRmscCsdS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRpscCstjj|jd��dS(Ns nodes cannot have children(R$R%R&R{(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR*ss	cCstS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRwscCstjj|jd��dS(Ns nodes do not have children(R$R%R&R{(R	R3R4((s'/usr/lib64/python2.7/xml/dom/minidom.pyR"zs	cCstjj|jd��dS(Ns nodes do not have children(R$R%R-R{(R	R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR)~s	cCsdS(N((R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR@�scCstjj|jd��dS(Ns nodes do not have children(R$R%R&R{(R	R3R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR9�s	N(RaRbR�RR}t
EmptyNodeListRReRgRRR*RR"R)R@R9(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�cs								tProcessingInstructioncBsYeZejZd�Zd�Zd�Zd�Zd�Z	d�Z
dddd�ZRS(cCs$||_|_||_|_dS(N(ttargetR{R<R|(R	R�R<((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�scCs|jS(N(R<(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	_get_data�scCs|j}||d<|d<dS(NR<R|(Ri(R	R�RW((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	_set_data�s	cCs|jS(N(R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_target�scCs|j}||d<|d<dS(NR�R{(Ri(R	R�RW((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_set_target�s	cCsw|dks|dkr3||jd<|jd<n@|dksK|dkrf||jd<|jd<n
||j|<dS(NR<R|R�R{(Ri(R	RuR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s
RcCs'|jd||j|j|f�dS(Ns
%s<?%s %s?>%s(RpR�R<(R	RRR�R((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�s(RaRbRR�RRzR�RRRR�R(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s							t
CharacterDatacBsteZd�ZeZd�Zd�ZeZeZd�Zd�Z	d�Z
d�Zd�Zd�Z
d	�ZRS(
cCs
t|j�S(N(R�R<(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|jdS(NR<(Ri(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|j}||d<|d<dS(NR<R|(Ri(R	R<RW((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�s	cCsD|dks|dkr3||jd<|jd<n
||j|<dS(NR<R|(Ri(R	RuR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCsH|j}t|�dkr$d}nd}d|jj|dd!|fS(Ni
s...Rs<DOM %s node "%r%s">i(R<R�t	__class__Ra(R	R<t	dotdotdot((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s		cCs~|dkr!tjjd��n|t|j�krKtjjd��n|dkrltjjd��n|j|||!S(Nisoffset cannot be negatives#offset cannot be beyond end of datascount cannot be negative(R$R%tIndexSizeErrR�R<(R	toffsettcount((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
substringData�scCs|j||_dS(N(R<(R	targ((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
appendData�scCs||dkr!tjjd��n|t|j�krKtjjd��n|rxd|j| ||j|f|_ndS(Nisoffset cannot be negatives#offset cannot be beyond end of datas%s%s%s(R$R%RR�R<(R	RR
((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
insertData�scCs�|dkr!tjjd��n|t|j�krKtjjd��n|dkrltjjd��n|r�|j| |j|||_ndS(Nisoffset cannot be negatives#offset cannot be beyond end of datascount cannot be negative(R$R%RR�R<(R	RR((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
deleteData�scCs�|dkr!tjjd��n|t|j�krKtjjd��n|dkrltjjd��n|r�d|j| ||j||f|_ndS(Nisoffset cannot be negatives#offset cannot be beyond end of datascount cannot be negatives%s%s%s(R$R%RR�R<(R	RRR
((s'/usr/lib64/python2.7/xml/dom/minidom.pytreplaceData�s(RaRbR�R�R�Rt_get_nodeValuet_set_nodeValueR�R�R	RRR
R(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�s												
sLength of the string data.R�cBsSeZejZdZdZd�Zdddd�Z	d�Z
d�Zd�ZRS(s#textcCs�|dks!|t|j�kr6tjjd��n|j�}|j||_|j|_|j}|jr�||jj	kr�|dkr�|jj|�q�|jj||�n|j| |_|S(Nisillegal offset value(
R�R<R$R%RRRDR1R(RRR*R"(R	RtnewTexttnext((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	splitText�s!	RcCs!t|d||j|f�dS(Ns%s%s%s(RqR<(R	RRR�R((s'/usr/lib64/python2.7/xml/dom/minidom.pyR
scCs�|jg}|j}xK|dk	rb|jtjtjfkr^|jd|j�|j}qPqW|j}xH|dk	r�|jtjtjfkr�|j	|j�|j}qoPqoWdj
|�S(NiR(R<R2RRRR;R~R0R1R>tjoin(R	RAR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_wholeTexts		cCs�|j}|j}xK|dk	r_|jtjtjfkr[|j}|j|�|}qPqW|j}|s|j|�nxK|dk	r�|jtjtjfkr�|j}|j|�|}q�Pq�W|r�|j	}||d<||d<|SdSdS(NR<R|(
R(R2RRRR;R~R)R1Ri(R	tcontentRtR�RRW((s'/usr/lib64/python2.7/xml/dom/minidom.pytreplaceWholeText$s.			
			
		

cCs_|jj�rtSt|�}|dkr/tS|jj|�}|dkrQtS|j�SdS(N(R<tstripRt_get_containing_elementRRDR�tisElementContent(R	R�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyt!_get_isWhitespaceInElementContentBsN(
RaRbRR;RR{RR}RRRRR(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s				tisWhitespaceInElementContentsKTrue iff this text node contains only whitespace and is in element content.t	wholeTexts.The text of all logically-adjacent text nodes.cCs?|j}x/|dk	r:|jtjkr.|S|j}qWdS(N(R(RRRR?(R6R5((s'/usr/lib64/python2.7/xml/dom/minidom.pyRUs	
cCs?|j}x/|dk	r:|jtjkr.|S|j}qWdS(N(R(RRRR(R6R5((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�]s	
tCommentcBs2eZejZdZd�Zdddd�ZRS(s#commentcCs||_|_dS(N(R<R|(R	R<((s'/usr/lib64/python2.7/xml/dom/minidom.pyRzjsRcCs?d|jkrtd��n|jd||j|f�dS(Ns--s%'--' is not allowed in a comment nodes
%s<!--%s-->%s(R<R,Rp(R	RRR�R((s'/usr/lib64/python2.7/xml/dom/minidom.pyRms(RaRbRR�RR{RzR(((s'/usr/lib64/python2.7/xml/dom/minidom.pyRfs		tCDATASectioncBs)eZejZdZdddd�ZRS(s#cdata-sectionRcCs?|jjd�dkr'td��n|jd|j�dS(Ns]]>is$']]>' not allowed in a CDATA sections<![CDATA[%s]]>(R<tfindR,Rp(R	RRR�R((s'/usr/lib64/python2.7/xml/dom/minidom.pyR|s(RaRbRR~RR{R(((s'/usr/lib64/python2.7/xml/dom/minidom.pyRss	tReadOnlySequentialNamedNodeMapcBs�eZdZdd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�ZRS(t_seqcCs
||_dS(N(R"(R	tseq((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�scCs
t|j�S(N(R�R"(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs
t|j�S(N(R�R"(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs+x$|jD]}|j|kr
|Sq
WdS(N(R"R{(R	RuR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs:x3|jD](}|j|kr
|j|kr
|Sq
WdS(N(R"RcRh(R	RcRhR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCsLt|t�r!|j|�}n|j|�}|dkrHt|�n|S(N(R�R!R�R�RRR(R	t
name_or_tupleR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs8|dkrdSy|j|SWntk
r3dSXdS(Ni(RR"R�(R	R+((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s
cCstjjd��dS(Ns"NamedNodeMap instance is read-only(R$R%R�(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s	cCstjjd��dS(Ns"NamedNodeMap instance is read-only(R$R%R�(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s	cCstjjd��dS(Ns"NamedNodeMap instance is read-only(R$R%R�(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s	cCstjjd��dS(Ns"NamedNodeMap instance is read-only(R$R%R�(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s	cCs
|jgS(N(R"(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|d|_dS(Ni(R"(R	R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s(R"((RaRbR�RzR�R�R�R�R�R�R�R�R�R�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR!�s												s&Number of entries in the NamedNodeMap.t
IdentifiedcBs)eZdZd�Zd�Zd�ZRS(s@Mix-in class that supports the publicId and systemId attributes.cCs||_||_dS(N(tpublicIdtsystemId(R	R&R'((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_identified_mixin_init�s	cCs|jS(N(R&(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
_get_publicId�scCs|jS(N(R'(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
_get_systemId�s(RaRbR�R(R)R*(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR%�s		tDocumentTypecBs\eZejZdZdZdZdZ	dZ
d�Zd�Zd�Z
dddd�ZRS(cCsLt�|_t�|_|r<t|�\}}||_n|j|_dS(N(R!tentitiest	notationsR�RuR{(R	R�RdR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�scCs|jS(N(tinternalSubset(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_internalSubset�scCs\|jdkrTtd�}|j|_|j|_tjjj}|r=g|j	_
g|j_
xU|jj
D]G}t|j|j
|j�}|jj
j|�|j|||�qmWx�|j	j
D]q}t|j|j
|j|j�}|j|_|j|_|j|_|j	j
j|�|j|||�q�Wn|j|||�|SdSdS(N(RDRR+RuR{R$R%tUserDataHandlertNODE_CLONEDR,R"R-tNotationR&R'R>R_tEntitytnotationNametactualEncodingR
RJ(R	REtcloneR\R�tnotationtetentity((s'/usr/lib64/python2.7/xml/dom/minidom.pyRF�s.RcCs�|jd�|j|j�|jrL|jd||j||jf�n&|jrr|jd||jf�n|jdk	r�|jd�|j|j�|jd�n|jd|�dS(Ns
<!DOCTYPE s%s  PUBLIC '%s'%s  '%s's%s  SYSTEM '%s's [t]Rn(RpRuR&R'R.R(R	RRR�R((s'/usr/lib64/python2.7/xml/dom/minidom.pyRs
			
N(RaRbRtDOCUMENT_TYPE_NODERRR|RuR&R'R.RzR/RFR(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR+�s				R3cBsweZdZejZdZdZdZ	dZ
d�Zd�Zd�Z
d�Zd�Zd�Zd�Zd�ZRS(	cCs2||_||_t�|_|j||�dS(N(R{R4R`RR((R	RuR&R'R7((s'/usr/lib64/python2.7/xml/dom/minidom.pyRzs		cCs|jS(N(R5(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_actualEncodingscCs|jS(N(R
(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
_get_encoding"scCs|jS(N(RJ(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_version%scCstjjd��dS(Ns(cannot append children to an entity node(R$R%R&(R	R3((s'/usr/lib64/python2.7/xml/dom/minidom.pyR*(s	cCstjjd��dS(Ns+cannot insert children below an entity node(R$R%R&(R	R3R4((s'/usr/lib64/python2.7/xml/dom/minidom.pyR",s	cCstjjd��dS(Ns*cannot remove children from an entity node(R$R%R&(R	R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR)0s	cCstjjd��dS(Ns)cannot replace children of an entity node(R$R%R&(R	R3R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR94s	N(RaRbRR}RtENTITY_NODERR|R5R
RJRzR<R=R>R*R"R)R9(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR3s								R2cBs eZejZdZd�ZRS(cCs||_|j||�dS(N(R{R((R	RuR&R'((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz<s	N(RaRbRR�RRR|Rz(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR28s	tDOMImplementationc	BsSeZddddddddgZd�Zd�Zd�Zd	�Zd
�ZRS(tcores1.0s2.0R$sls-loads3.0cCs.|dkrd}n|j�|f|jkS(NR(Rtlowert	_features(R	RIRJ((s'/usr/lib64/python2.7/xml/dom/minidom.pyRHLs	c	CsK|r*|jdk	r*tjjd��n|j�}|dkoW|dkoW|dk}|r}|r}tjjd��n|rt|�\}}|dkr�|dkr�tjjd��n|r�|r�tjjd��n|j	||�}|r|j
|�n|j
|�n|r5||_|_n||_||_
|S(Ns(doctype object owned by another DOM treesElement with no nameR$s$http://www.w3.org/XML/1998/namespacesillegal use of 'xml' prefixs(illegal use of prefix without namespaces(R(RR$R%tWrongDocumentErrt_create_documenttInvalidCharacterErrR�R�tcreateElementNSR*RDtdoctypeRG(	R	RcR�RHRftadd_root_elementRdR�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateDocumentQs4	



			cCs"t|�}||_||_|S(N(R+R&R'(R	R�R&R'RH((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateDocumentType~s		cCs|j|d�r|SdSdS(N(RHR(R	RI((s'/usr/lib64/python2.7/xml/dom/minidom.pyRO�scCst�S(N(tDocument(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRE�s(RAs1.0(RAs2.0N(RAN(R$s1.0(R$s2.0(R$N(sls-loads3.0(sls-loadN(	RaRbRRCRHRJRKRORE(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR@As			-		tElementInfocBseeZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�ZRS(s�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.

    RrcCs
||_dS(N(Rr(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�scCstS(N(R�(R	taname((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCstS(N(R�(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCstS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�scCstS(sQReturns true iff this element is declared to have an EMPTY
        content model.(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pytisEmpty�scCstS(s7Returns true iff the named attribute is a DTD-style ID.(R(R	RN((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCstS(s<Returns true iff the identified attribute is a DTD-style ID.(R(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|jS(N(Rr(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs
||_dS(N(Rr(R	R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s(Rr(
RaRbR�R�RzR�R�RROR�R�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyRM�s								cCsZ|jtjkr+|jj�d|_n+t|�rV|jjj�d|j_ndS(N(	RRRt	_id_cachetclearRt_id_search_stackRkRD(R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR/�s
RLcBs�eZejejejejfZejZ	dZ
d$Zd$Z
d$Zd$Zd$ZZe�Zd$Zd$Zd$Zd$ZeZd$Zd$ZdZd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#d	�Z$d
�Z%d�Z&d�Z'd
�Z(d�Z)d�Z*d�Z+d�Z,d�Z-d�Z.d�Z/d�Z0d�Z1d�Z2d�Z3d�Z4d�Z5d�Z6d�Z7d�Z8d�Z9d�Z:d �Z;d!d!d!d$d"�Z<d#�Z=RS(%s	#documenticCs+t�|_i|_i|_d|_dS(N(R`Rt
_elem_infoRPRRR(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�s		cCs7|jr|j|jf}n	|j}|jj|�S(N(RcRhRrRSR�(R	R�RS((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s		cCs|jS(N(R5(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR<�scCs|jS(N(RH(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_doctype�scCs|jS(N(tdocumentURI(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_documentURI�scCs|jS(N(R
(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR=�scCs|jS(N(terrorHandler(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_errorHandler�scCs|jS(N(t
standalone(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_standalone�scCs|jS(N(tstrictErrorChecking(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_strictErrorChecking�scCs|jS(N(RJ(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR>scCs�|j|jkr=tjjdt|�t|�f��n|jdk	r_|jj|�n|jt	j
kr�|j�r�tjjd��nt	j||�S(Ns%s cannot be child of %ss two document elements disallowed(
RR#R$R%R&R'R(RR)RR?t_get_documentElementR*(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR*s	"	cCsoy|jj|�Wn tk
r6tjj��nXd|_|_d|_	|j
|krkd|_
n|S(N(RR:R,R$R%R-RR1R2R(tdocumentElement(R	R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR)s
	cCs.x'|jD]}|jtjkr
|Sq
WdS(N(RRRR?(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR]scCs9|jdk	r(|jj�d|_ntj|�dS(N(RHRR=R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR=$s
cCs�|s
dS|jjddd�}|j|_|j|_|j|_xo|jD]d}t|||�}|jj|�|j	t
jkr�n|j	t
jkr�||_
n||_qPW|jtjjj||�|S(N(RRGRJR
RYRJRRCR>RRRR;RHR(R_R$R%R0R1(R	RER6R�t
childclone((s'/usr/lib64/python2.7/xml/dom/minidom.pyRF*s"

cCst�}||_|S(N(RyRD(R	RW((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateDocumentFragment?s		cCst|�}||_|S(N(R�RD(R	RrR8((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
createElementDs	cCs:t|t�std�nt�}||_||_|S(Nsnode contents must be a string(R�R�R�R�R<RD(R	R<tt((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateTextNodeIs			cCs:t|t�std�nt�}||_||_|S(Nsnode contents must be a string(R�R�R�RR<RD(R	R<R5((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateCDATASectionQs			cCst|�}||_|S(N(RRD(R	R<R5((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
createCommentYs	cCst||�}||_|S(N(R�RD(R	R�R<tp((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateProcessingInstruction^s	cCs"t|�}||_d|_|S(NR(R�RDR�(R	R�ta((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateAttributecs		cCs1t|�\}}t|||�}||_|S(N(R�R�RD(R	RcR�RdRhR8((s'/usr/lib64/python2.7/xml/dom/minidom.pyRGis	cCs=t|�\}}t||||�}||_d|_|S(NR(R�R�RDR�(R	RcR�RdRhRh((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateAttributeNSos
		cCs"t||||�}||_|S(N(R3RD(R	RuR&R'R4R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_create_entityys	cCst|||�}||_|S(N(R2RD(R	RuR&R'R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_create_notation~s	cCsE||jkr|j|S|jp)|js0dS|j}|dkr]|jg}||_n
|sgdSd}x�|r@|j�}|jg|jD]}|j	t
kr�|^q��|j|�}|r�xa|jj
�D]�}|jr;|j|j|j�r�||j|j<|j|kr(|}q8|js8Pq8q�q�|j|j�r�||j|j<|j|kru|}q�|js�Pq�q�|jr�||j|j<|j|kr�|}q�|jdkr�Pq�q�q�WnZ|jr-xN|jj
�D]:}|jr�||j|j<|j|kr&|}q&q�q�Wn|dk	rpPqpqpW|S(Ni(RPRSR�RRRR^tpoptextendRRR.R�R}R�RcR�RhR�R�R�RuR�(R	R�tstacktresultR6RBR�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetElementById�s\					
						cCst||t��S(N(RsR`(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCst|||t��S(N(RwR`(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|jj||�S(N(RGRH(R	RIRJ((s'/usr/lib64/python2.7/xml/dom/minidom.pyRK�scCs^|jtjkr'tjjd��n'|jtjkrNtjjd��nt|||�S(Nscannot import document nodess!cannot import document type nodes(RRRR$R%tNotSupportedErrR;RC(R	R6RE((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
importNode�s
RcCse|dkr |jd|�n|jd||f�x'|jD]}|j||||�qAWdS(Ns<?xml version="1.0" ?>s%<?xml version="1.0" encoding="%s"?>%s(RRpRR(R	RRR�RR
R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�s
c	Cs|j|k	r1tjjd||jf��n|jtjtjfkratjjd��n|t	krd|kr�|j
dd�\}}|dkr|tjjkrtjjd��qq'|dkr|tjjkr|jtjkrtjjd��nd}|}nd}d}|jtjkrj|j}|dk	rp|j}|j|�qpnd}|j}||d<||d	<||d
<||d<|jtjkr�||d<n<||d
<|dk	r�|j|�|r�|j|�q�n|S(Ns?cannot rename nodes from other documents;
expected %s,
found %ss8renameNode() only applies to element and attribute nodesR�iR�sillegal use of 'xmlns' prefixs$illegal use of the 'xmlns' attributeRdRhRcR{RrRu(RDR$R%RDRRR?R�RrRR�RR�RR�R�R�RiR�R�(	R	R�RcRuRdRhR�tis_idRW((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
renameNode�sT								






N(>RaRbRR?R�R�R;R#RRR{RR|R}RHR(R2R1R@RGR5R
RYRJRR[RWRUR�RzR�R<RTRVR=RXRZR\R>R*R)R]R=RFR`RaRcRdReRgRiRGRjRkRlRqR�R�RKRsRRu(((s'/usr/lib64/python2.7/xml/dom/minidom.pyRL�sh	
																									
			:					
R^s#Top-level element of this document.c
Cs�|jj|�r$tjjj}ntjjj}|jtj	kr�|j
|j|j�}xW|j
j�D]F}|j|j|j|j�|j|j|j�}|j|_qmW|r�x3|jD]%}t|||�}|j|�q�Wq�n�|jtjkrS|j�}|r�x3|jD]%}t|||�}|j|�q$Wq�n|jtjkrz|j|j�}nX|jtjkr�|j|j�}n1|jtjkr�|j|j |j�}n|jtj!kr�|j"|j�}n�|jtj#kr7|j$|j|j�}t%|_|j|_n�|jtj&kr�tjjj}|j'j(|j)|j*|j+�}||_|r�g|j,_-g|j._-xp|j.j-D]b}	t/|	j|	j*|	j+�}
||
_|j.j-j0|
�t1|	d�r�|	j2||	|
�q�q�Wx�|j,j-D]�}t3|j|j*|j+|j4�}|j5|_5|j6|_6|j7|_7||_|j,j-j0|�t1|d�r |j2|||�q q Wq�ntjj8dt9|���t1|d�r�|j2|||�n|S(so
    Clone a node and give it the new owner document.
    Called by Node.cloneNode and Document.importNode
    R_sCannot clone node %s(:RDRNR$R%R0R1t
NODE_IMPORTEDRRR?RGRcR{R}R�R�R�R�RhR�RRCR*R R`R;RcR<R~RdR�RgR�R�ReR�RjRR;RGRKRuR&R'R,R"R-R2R>RYR_R3R4R5R
RJRrR'(
R6REtnewOwnerDocumentR\R6R�RhRBR5R�R7R8R9((s'/usr/lib64/python2.7/xml/dom/minidom.pyRCs|					 cCs:|jdd�}t|�dkr(|Sd|dfSdS(NR�iii(R�R�R(R�tfields((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�fscCsddlm}|�S(Ni����(tStringIO(Ry(Ry((s'/usr/lib64/python2.7/xml/dom/minidom.pyRnscCs<|||�}|j�\}}|j|�|j�|S(N(tgetEventt
expandNodeRQ(tfunctargstkwargsteventsttoktypetrootNode((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_do_pulldom_parsess


cCsh|dkr0|r0ddlm}|j|�Sddlm}t|j|fi|d6|d6�SdS(s3Parse a file into a DOM by filename or file object.i����(texpatbuilder(tpulldomtparsertbufsizeN(Rtxml.domR�tparseR�R�(tfileR�R�R�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�zs
cCsZ|dkr)ddlm}|j|�Sddlm}t|j|fi|d6�SdS(s&Parse a file into a DOM from a string.i����(R�(R�R�N(RR�R�tparseStringR�R�(tstringR�R�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s
cCsa|rZt|t�r'tj|�}nx0|D]%\}}tjj||�s.dSq.WntjS(N(R�R�Rt_parse_feature_stringRLRGRHR(tfeaturestftv((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetDOMImplementation�s(8R�R�R$RRRRtxml.dom.minicompattxml.dom.xmlbuilderRRR%RR?RR.tdefpropertyR7RkRqRsRwRyR�tobjectR�t
AttributeListR�RR�R�R�R�R�RR�RR�RRR!R%R+R3R2R@RMR/RLRCR�RR�R�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyt<module>s�"
�	
					r��	(GZ			
><(	O*	�O	R			

PK�"[#@���dom/minicompat.pyonu�[����
{fc@s�dZddddgZddlZyeWn ek
rNed�fZnXed�eed��fZdefd��YZ	de
fd	��YZd
�ZdS(s1Python version compatibility support for minidom.tNodeListt
EmptyNodeListtStringTypestdefpropertyi����NtcBsGeZdZd�Zd�Zd�Zeeedd�Zd�ZRS(cCs.d|kot|�knr*||SdS(Ni(tlen(tselftindex((s*/usr/lib64/python2.7/xml/dom/minicompat.pytitem6s"cCs
t|�S(N(R(R((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt_get_length:scCstjjd��dS(Ns.attempt to modify read-only attribute 'length'(txmltdomtNoModificationAllowedErr(Rtvalue((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt_set_length=s	tdocs$The number of nodes in the NodeList.cCs |dkrg}n||(dS(N(tNone(Rtstate((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt__setstate__Es	((	t__name__t
__module__t	__slots__RR	RtpropertytlengthR(((s*/usr/lib64/python2.7/xml/dom/minicompat.pyR3s				cBsPeZdZd�Zd�Zd�Zd�Zd�Zeeedd�Z	RS(cCst�}|j|�|S(N(Rtextend(RtothertNL((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt__add__Ns	
cCst�}|j|�|S(N(RR(RRR((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt__radd__Ss	
cCsdS(N(R(RR((s*/usr/lib64/python2.7/xml/dom/minicompat.pyRXscCsdS(Ni((R((s*/usr/lib64/python2.7/xml/dom/minicompat.pyR	[scCstjjd��dS(Ns.attempt to modify read-only attribute 'length'(R
RR(RR
((s*/usr/lib64/python2.7/xml/dom/minicompat.pyR^s	Rs$The number of nodes in the NodeList.((
RRRRRRR	RRR(((s*/usr/lib64/python2.7/xml/dom/minicompat.pyRKs					cCsKt|d|�j}|d�}t||d|�}t|||�dS(Nt_get_cSs tjjdt|���dS(Ns&attempt to modify read-only attribute (R
RRtrepr(RR
tname((s*/usr/lib64/python2.7/xml/dom/minicompat.pytseths	R(tgetattrtim_funcRtsetattr(tklassRRtgetR tprop((s*/usr/lib64/python2.7/xml/dom/minicompat.pyRfs(
t__doc__t__all__txml.domR
tunicodet	NameErrorttypeRtlistRttupleRR(((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt<module>s&
PK�"[���}ffdom/NodeFilter.pyonu�[����
{fc@sddd��YZdS(t
NodeFiltercBsweZdZdZdZdZdZdZdZdZ	dZ
dZdZd	Z
d
ZdZdZd
ZdZd�ZRS(sL
    This is the DOM2 NodeFilter interface. It contains only constants.
    iiil��iiii i@i�iiiicCs
t�dS(N(tNotImplementedError(tselftnode((s*/usr/lib64/python2.7/xml/dom/NodeFilter.pyt
acceptNodes(t__name__t
__module__t__doc__t
FILTER_ACCEPTt
FILTER_REJECTtFILTER_SKIPtSHOW_ALLtSHOW_ELEMENTtSHOW_ATTRIBUTEt	SHOW_TEXTtSHOW_CDATA_SECTIONtSHOW_ENTITY_REFERENCEtSHOW_ENTITYtSHOW_PROCESSING_INSTRUCTIONtSHOW_COMMENTt
SHOW_DOCUMENTtSHOW_DOCUMENT_TYPEtSHOW_DOCUMENT_FRAGMENTt
SHOW_NOTATIONR(((s*/usr/lib64/python2.7/xml/dom/NodeFilter.pyRs$N((R(((s*/usr/lib64/python2.7/xml/dom/NodeFilter.pyt<module>tPK�"[�H�J8
8
dom/domreg.pycnu�[����
{fc@sddZddlTddlZidd6dd6ZiZd�Zd	�Zddd
�Zd�Z	dS(
s�Registration facilities for DOM. This module should not be used
directly. Instead, the functions getDOMImplementation and
registerDOMImplementation should be imported from xml.dom.i����(t*Nsxml.dom.minidomtminidomsxml.dom.DOMImplementationt4DOMcCs|t|<dS(sIregisterDOMImplementation(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(t
registered(tnametfactory((s&/usr/lib64/python2.7/xml/dom/domreg.pytregisterDOMImplementations	cCs1x*|D]"\}}|j||�sdSqWdS(sF_good_enough(dom, features) -> Return 1 if the dom offers the featuresii(t
hasFeature(tdomtfeaturestftv((s&/usr/lib64/python2.7/xml/dom/domreg.pyt_good_enough"scCs<ddl}d}tj|�}|rIt|iidg�}|j�S|rZt|�Stjj	r�d|j
kr�td|j
d�St|t�r�t
|�}nx0tj�D]"}|�}t||�r�|Sq�WxQtj�D]C}ytd|�}Wntk
rq�nXt||�r�|Sq�Wtd�dS(sSgetDOMImplementation(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.i����NtgetDOMImplementationt
PYTHON_DOMRs$no suitable DOM implementation found(tostNonetwell_known_implementationstgett
__import__R
Rtsystflagstignore_environmenttenviront
isinstancetStringTypest_parse_feature_stringtvaluesRtkeyst
StandardErrortImportError(RR	RtcreatortmodR((s&/usr/lib64/python2.7/xml/dom/domreg.pyR
)s0

	
cCs�g}|j�}d}t|�}x�||kr�||}|ddkr`td|f�n|d}d}||kr�||}|ddkr�|d}|}q�n|j||f�q'Wt|�S(Nit
0123456789sbad feature name: %ri(tsplittlent
ValueErrorRtappendttuple(tsR	tpartstitlengthtfeaturetversionR((s&/usr/lib64/python2.7/xml/dom/domreg.pyRTs"



((
t__doc__txml.dom.minicompatRRRRRRR
R(((s&/usr/lib64/python2.7/xml/dom/domreg.pyt<module>s

		+PK�"[[s#33dom/pulldom.pycnu�[����
{fc@sddlZddlZddlZyejejgZWnek
rYejgZnXdZdZ	dZ
dZdZdZ
dZd	Zd
ejjfd��YZddd
��YZddd��YZdefd��YZdZddd�Zdd�ZdS(i����Nt
START_ELEMENTtEND_ELEMENTtCOMMENTtSTART_DOCUMENTtEND_DOCUMENTtPROCESSING_INSTRUCTIONtIGNORABLE_WHITESPACEt
CHARACTERStPullDOMcBs�eZdZdZdd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd�Zd�Z
d	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�ZRS(cCs�ddlm}||_ddg|_|j|_g|_|jj|_y|jj	|_	Wnt
k
rrnXid|6g|_|jd|_g|_
dS(Ni����(t
XML_NAMESPACEtxml(txml.domR	tdocumentFactorytNonet
firstEventt	lastEventtelementStacktappendtpushtpoptAttributeErrort_ns_contextst_current_contexttpending_events(tselfRR	((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt__init__s		
cCs|jd}|jd=|S(Ni����(R(Rtresult((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR's

cCs
||_dS(N(t_locator(Rtlocator((s'/usr/lib64/python2.7/xml/dom/pulldom.pytsetDocumentLocator,scCsgt|d�sg|_n|jj|p-d|f�|jj|jj��|pYd|j|<dS(Nt_xmlns_attrstxmlns(thasattrRRRRtcopyR
(Rtprefixturi((s'/usr/lib64/python2.7/xml/dom/pulldom.pytstartPrefixMapping/s
cCs|jj�|_dS(N(RRR(RR"((s'/usr/lib64/python2.7/xml/dom/pulldom.pytendPrefixMapping6scCs;d}t|dd�}|dk	rZx'|D]\}}||j||f<q+Wg|_n|\}}	|r�|dkr�|j|}
|
r�|
d|	}q�|	}n|jr�|jj||�}q|j||�}n0|jr�|jj|	�}n|jd|	�}x�|j	�D]�\}}|\}}
||kr�|
dkrQ|
}n
d|
}|jj
||�}|j|�nt|r�|j|}
|
r�|
d|
}n|
}|jj
||�}|j|�n|jj|
�}|j
|�||_qWt|fdg|jd<|jd|_|j|�dS(Nshttp://www.w3.org/2000/xmlns/Rt:Rsxmlns:i(tgetattrR
t_attrsRRtdocumenttcreateElementNSt
buildDocumentt
createElementtitemstcreateAttributeNStsetAttributeNodeNStcreateAttributetsetAttributeNodetvalueRRR(RtnamettagNametattrst	xmlns_uritxmlns_attrstanameR2R#t	localnameR"tnodeta_urita_localnametqnametattr((s'/usr/lib64/python2.7/xml/dom/pulldom.pytstartElementNS9sP
				



cCs3t|j�fdg|jd<|jd|_dS(Ni(RRR
R(RR3R4((s'/usr/lib64/python2.7/xml/dom/pulldom.pytendElementNSrscCs�|jr|jj|�}n|jd|�}xB|j�D]4\}}|jj|�}||_|j|�q=Wt|fdg|j	d<|j	d|_	|j
|�dS(Ni(R)R,R+R
R-R0R2R1RRR(RR3R5R:R8R2R>((s'/usr/lib64/python2.7/xml/dom/pulldom.pytstartElementvs		cCs3t|j�fdg|jd<|jd|_dS(Ni(RRR
R(RR3((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt
endElement�scCsm|jrG|jj|�}t|fdg|jd<|jd|_n"t|fdg}|jj|�dS(Ni(R)t
createCommentRR
RRR(RtsR:tevent((s'/usr/lib64/python2.7/xml/dom/pulldom.pytcomment�s	cCss|jrJ|jj||�}t|fdg|jd<|jd|_n%t||fdg}|jj|�dS(Ni(R)tcreateProcessingInstructionRR
RRR(RttargettdataR:RE((s'/usr/lib64/python2.7/xml/dom/pulldom.pytprocessingInstruction�s	cCs?|jj|�}t|fdg|jd<|jd|_dS(Ni(R)tcreateTextNodeRR
R(RtcharsR:((s'/usr/lib64/python2.7/xml/dom/pulldom.pytignorableWhitespace�scCs?|jj|�}t|fdg|jd<|jd|_dS(Ni(R)RKRR
R(RRLR:((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt
characters�scCs7|jdkr3ddl}|jjjj|_ndS(Ni����(RR
txml.dom.minidomtdomtminidomtDocumenttimplementation(RR
((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt
startDocument�sc	Cs8|jj||d�}||_t|fdg|jd<|jd|_|j|�x�|jD]�}|ddtkr�|d\}}}|jj	||�}t|f|d<nX|ddt
kr�|jj|dd�}t
|f|d<ntd|dd��||jd<||_qaWd|_|j
S(NiisUnknown pending event (RtcreateDocumentR
R)RRRRRRGRRCtAssertionErrort
firstChild(	RR#ttagnameR:tet_RHRItn((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR+�s$	


	cCs*t|jfdg|jd<|j�dS(Ni(RR)R
RR(R((s'/usr/lib64/python2.7/xml/dom/pulldom.pytendDocument�scCs
d|_dS(s.clear(): Explicitly release parsing structuresN(R
R)(R((s'/usr/lib64/python2.7/xml/dom/pulldom.pytclear�sN(t__name__t
__module__R
RR)RRRR$R%R?R@RARBRFRJRMRNRTR+R\R](((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRs&					9												tErrorHandlercBs#eZd�Zd�Zd�ZRS(cCs	|GHdS(N((Rt	exception((s'/usr/lib64/python2.7/xml/dom/pulldom.pytwarning�scCs
|�dS(N((RRa((s'/usr/lib64/python2.7/xml/dom/pulldom.pyterror�scCs
|�dS(N((RRa((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt
fatalError�s(R^R_RbRcRd(((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR`�s		tDOMEventStreamcBsbeZd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�ZRS(
cCsJ||_||_||_t|jd�s<|j|_n|j�dS(Ntfeed(tstreamtparsertbufsizeR t_slurptgetEventtreset(RRgRhRi((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR�s			cCs?t�|_|jjtjjjd�|jj|j�dS(Ni(	RtpulldomRht
setFeatureR
tsaxthandlertfeature_namespacestsetContentHandler(R((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRl�scCs |j�}|r|St�dS(N(Rkt
IndexError(Rtpostrc((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt__getitem__�scCs |j�}|r|St�dS(N(Rkt
StopIteration(RRu((s'/usr/lib64/python2.7/xml/dom/pulldom.pytnext�scCs|S(N((R((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt__iter__�scCs�|j�}|g}x�|r�|\}}||kr:dS|tkrZ|dj|�n|tkrv|j|�n|tkr�|d=n|j�}qWdS(Ni����(RkRtappendChildRR(RR:REtparentsttokentcur_node((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt
expandNode�s		
cCs�|jjds%|jj|j_nxP|jjdsw|jj|j�}|sd|jj�dS|jj	|�q(W|jjdd}|jjdd|jjd<|S(Nii(
RmRRRgtreadRiRhtcloseR
Rf(RtbufRu((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRk�s
cCs)|jj|j�|j|_|j�S(s� 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).
        (RhtparseRgt_emitRk(R((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRjscCs6|jjdd}|jjdd|jjd<|S(sn Fallback replacement for getEvent() that emits
            the events that _slurp() read previously.
        ii(RmR(RRu((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR�scCs)|jj�|`d|_d|_dS(s+clear(): Explicitly release parsing objectsN(RmR]R
RhRg(R((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR] s
	(R^R_RRlRvRxRyR~RkRjR�R](((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRe�s								
	tSAX2DOMcBs5eZd�Zd�Zd�Zd�Zd�ZRS(cCsAtj||||�|jd}|jd}|j|�dS(Ni����i����(RR?RRz(RR3R4R5tcurNodet
parentNode((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR?)s

cCs>tj|||�|jd}|jd}|j|�dS(Ni����i����(RRARRz(RR3R5R�R�((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRA/s

cCsBtj|||�|jdd}|jd}|j|�dS(Niii����(RRJRRRz(RRHRIR:R�((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRJ5s
cCs?tj||�|jdd}|jd}|j|�dS(Niii����(RRMRRRz(RRLR:R�((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRM;s
cCs?tj||�|jdd}|jd}|j|�dS(Niii����(RRNRRRz(RRLR:R�((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRNAs
(R^R_R?RARJRMRN(((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR�'s
				iiicCsd|dkrt}nt|�tkr6t|�}n|}|sTtjj�}nt|||�S(N(	R
tdefault_bufsizettypet_StringTypestopenR
Rotmake_parserRe(tstream_or_stringRhRiRg((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR�Js	cCsxyddlm}Wn!tk
r7ddlm}nXt|�}||�}|shtjj�}nt|||�S(Ni����(tStringIO(t	cStringIOR�tImportErrortlenR
RoR�Re(tstringRhR�RiR�((s'/usr/lib64/python2.7/xml/dom/pulldom.pytparseStringUs
((i@i�?(txml.saxR
txml.sax.handlerttypest
StringTypetUnicodeTypeR�RRRRRRRRRRotContentHandlerRR`ReR�R�R
R�R�(((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt<module>s*
�U!PK�"[sk�EEdom/minidom.pycnu�[����
{fc@sdZddlZddlmZmZmZmZddlTddlm	Z	m
Z
ejjj
ejjjfZdejjfd��YZeedd	d
�eedd	d�eed
d	d�d�Zd�Zd�Zd�Zd�Zdefd��YZdefd��YZeedd	d�eed
d	d�eedd	d�defd��YZeedd	d �eZd!efd"��YZeee�Zd#efd$��YZeed%d	d&�eed
d	d'�d(�Zd)fd*��YZ d+e efd,��YZ!d-e efd.��YZ"ee"dd	d/�d0e"fd1��YZ#ee#d2d	d3�ee#d4d	d5�d6�Z$d7�Z%d8e e"fd9��YZ&d:e#fd;��YZ'd<efd=��YZ(ee(dd	d>�d?fd@��YZ)dAe)e efdB��YZ*dCe)efdD��YZ+dEe)e efdF��YZ,dGe	fdH��YZ-dIefdJ��YZ.dK�Z/dLee
fdM��YZ0ee0dNd	dO�dP�Z1dQ�Z2dR�Z3dS�Z4eedT�Z5edU�Z6edV�Z7dS(WscSimple 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
i����N(tEMPTY_NAMESPACEtEMPTY_PREFIXtXMLNS_NAMESPACEtdomreg(t*(tDOMImplementationLSt
DocumentLStNodecBs�eZdZdZdZdZdZeZ	d�Z
dd�Zdddd�Zd�Z
d�Zd�Zd�Zd	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(cCstS(N(tTrue(tself((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__nonzero__*scCs|jdd|�S(Nt(ttoprettyxml(R	tencoding((s'/usr/lib64/python2.7/xml/dom/minidom.pyttoxml-ss	s
cCs�t�}|dk	r=ddl}|j|�d|�}n|jtjkrk|j|d|||�n|j|d||�|j�S(Ni����iR(	t
_get_StringIOtNonetcodecstlookuptnodeTypeRt
DOCUMENT_NODEtwritexmltgetvalue(R	tindenttnewlR
twriterR((s'/usr/lib64/python2.7/xml/dom/minidom.pyR0s	cCs|jr
tStSdS(N(t
childNodesRtFalse(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
hasChildNodes?s	cCs|jS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_childNodesEscCs|jr|jdSdS(Ni(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_firstChildHs	cCs|jr|jdSdS(Ni����(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_lastChildLs	cCsw|j|jkr@x't|j�D]}|j||�q"W|S|j|jkr}tjjdt	|�t	|�f��n|j
dk	r�|j
j|�n|dkr�|j
|�n�y|jj|�}Wn tk
r�tjj��nX|jtkrt|�n|jj||�||_||_|ra|j|d}||_||_n	d|_||_
|S(Ns%s cannot be child of %si(RtDOCUMENT_FRAGMENT_NODEttupleRtinsertBeforet_child_node_typestxmltdomtHierarchyRequestErrtreprt
parentNodeRtremoveChildtappendChildtindext
ValueErrortNotFoundErrt_nodeTypes_with_childrent_clear_id_cachetinserttnextSiblingtpreviousSibling(R	tnewChildtrefChildtcR+tnode((s'/usr/lib64/python2.7/xml/dom/minidom.pyR"Ps6	"

					cCs�|j|jkr=x$t|j�D]}|j|�q"W|S|j|jkrztjjdt	|�t	|�f��n|jt
kr�t|�n|jdk	r�|jj|�nt||�d|_|S(Ns%s cannot be child of %s(RR R!RR*R#R$R%R&R'R.R/R(RR)t
_append_childR1(R	R6R5((s'/usr/lib64/python2.7/xml/dom/minidom.pyR*ps	"

	cCs�|j|jkr8|j}|j|�|j||�S|j|jkrutjjdt	|�t	|�f��n||kr�dS|j
dk	r�|j
j|�ny|jj
|�}Wn tk
r�tjj��nX||j|<||_
d|_
|jtks|jtkr*t|�n|j|_|j|_d|_d|_|jrl||j_n|jr�||j_n|S(Ns%s cannot be child of %s(RR R1R)R"R#R$R%R&R'R(RRR+R,R-R.R/R2(R	R3toldChildR4R+((s'/usr/lib64/python2.7/xml/dom/minidom.pytreplaceChild�s<	
	"

		
				cCs�y|jj|�Wn tk
r6tjj��nX|jdk	rX|j|j_n|jdk	ry|j|j_nd|_|_|j	t
kr�t|�nd|_|S(N(
RtremoveR,R$R%R-R1RR2RR.R/R((R	R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR)�s

	cCs*g}x|jD]}|jtjkr�|jsr|rJ|j|d_n|jre|j|j_n|j�q|r�|dj|jkr�|d}|j|j|_|j|_|jr�||j_n|j�q|j|�q|j|�|jtj	kr|j
�qqW||j(dS(Ni����(RRRt	TEXT_NODEtdataR1R2tunlinktappendtELEMENT_NODEt	normalize(R	tLtchildR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR@�s*		

	

cCst|||jp|�S(N(t_clone_nodet
ownerDocument(R	tdeep((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	cloneNode�scCs|jjj||�S(N(RDtimplementationt
hasFeature(R	tfeaturetversion((s'/usr/lib64/python2.7/xml/dom/minidom.pytisSupported�scCsdS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_localName�scCs
||kS(N((R	tother((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
isSameNode�scCs|j|d�r|SdSdS(N(RKR(R	RI((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetInterface�scCs2y|j|dSWnttfk
r-dSXdS(Ni(t
_user_datatAttributeErrortKeyErrorR(R	tkey((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetUserData�scCs�d}y
|j}Wn tk
r5i}||_nX||krS||d}n|dkr~d}|dk	r�||=q�n||f||<|S(Ni(RRPRQ(R	RSR<thandlertoldtd((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetUserData�s



cCsdt|d�r`xN|jj�D]:\}\}}|dk	r|j|||||�qqWndS(NRP(thasattrRPtitemsRthandle(R	t	operationtsrctdstRSR<RU((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_call_user_data_handler�s"cCs\d|_|_|jrFx|jD]}|j�q#Wt�|_nd|_d|_dS(N(RR(RDRR=tNodeListR2R1(R	RB((s'/usr/lib64/python2.7/xml/dom/minidom.pyR=s		N(t__name__t
__module__RtnamespaceURIR(RDR1R2RtprefixR
RRRRRRR"R*R9R)R@RFRKRLRNRORTRXR_R=(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR!s6						 		 							
			t
firstChildtdocsFirst child node, or None.t	lastChildsLast child node, or None.t	localNames"Namespace-local name of this node.cCsT|j}|r6|d}||jd<||jd<n|j|�||jd<dS(Ni����R2R1R((Rt__dict__R>(R	R6Rtlast((s'/usr/lib64/python2.7/xml/dom/minidom.pyR7s	


cCs6x/|dk	r1|jtjkr%tS|j}qWtS(N(RRRRRR(R(R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_in_documents

cCsP|rL|jdd�jdd�jdd�jdd�}|j|�nd	S(
sWrites datachars to writer.t&s&amp;t<s&lt;s"s&quot;t>s&gt;N(treplacetwrite(RR<((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_write_data%scCsex^|jD]S}|jtjkrM|dks=|j|krM|j|�nt|||�q
W|S(NR(RRRR?ttagNameR>t_get_elements_by_tagName_helper(tparenttnametrcR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyRs,scCs�x|jD]t}|jtjkr
|dks=|j|krh|dksX|j|krh|j|�nt||||�q
q
W|S(NR(RRRR?RhRcR>t"_get_elements_by_tagName_ns_helper(RttnsURIRhRvR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyRw4stDocumentFragmentcBsbeZejZdZdZdZdZ	ej
ejejej
ejejejfZd�ZRS(s#document-fragmentcCst�|_dS(N(R`R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__init__KsN(RaRbRR RtnodeNameRt	nodeValuet
attributesR(R?R;tCDATA_SECTION_NODEtENTITY_REFERENCE_NODEtPROCESSING_INSTRUCTION_NODEtCOMMENT_NODEt
NOTATION_NODER#Rz(((s'/usr/lib64/python2.7/xml/dom/minidom.pyRy=s	tAttrcBs�eZejZd	Zd	ZeZ	eZ
ejejfZ
ed	d	d�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(
cCsS|j}||d<|d<||d<||d<t�|d<|jjt��dS(NR{RuRcRdR(RiR`RR>tText(R	tqNameRcRhRdRW((s'/usr/lib64/python2.7/xml/dom/minidom.pyRzXs	


cCs|jjdd�dS(Nt:ii����(R{tsplit(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRLfscCs|jS(N(t	specified(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_specifiediscCs�|j}|dkrk||d<|d<|jdj}||d<|d<|jdk	r�t|j�q�nJ|dkr�||d<|d<|jdk	r�t|j�q�n
|||<dS(	NtvalueR|iR<RuR{(R�R|(RuR{(RiRtownerElementRR/(R	RuR�RWtd2((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__setattr__ls	cCs�|j}|dkr?|r?|tkr?tjjd��q?n|j}||d<|dkrj|j}nd||jf}|jr�t	|j�n||d<|d<dS(Ntxmlnss5illegal use of 'xmlns' prefix for the wrong namespaceRds%s:%sR{Ru(
RcRR$R%tNamespaceErrRiRRhR�R/(R	RdtnsuriRWtnewName((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_set_prefix{s			
	cCsH|j}||d<|d<|jr4t|j�n||jd_dS(NR�R|i(RiR�R/RR<(R	R�RW((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
_set_value�s
		cCs�|j}|dk	rq|j|j=|j|j|jf=|jrqt|_|j	d8_	|j
jd8_qqnx|jD]}|j
�q{W|j2dS(Ni(R�Rt_attrsR{t_attrsNSRcRht_is_idRt_magic_id_nodesRDt_magic_id_countRR=(R	telemRB((s'/usr/lib64/python2.7/xml/dom/minidom.pyR=�s	
		cCs�|jr
tS|j}|j}|dks7|dkr;tS|j|�}|dkrZtS|jry|j|j|j	�S|j
|j�SdS(N(R�RRDR�RRt_get_elem_infoRctisIdNSRhtisIdR{(R	RfR�tinfo((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	_get_isId�s				cCs�|j}|j}|dks*|dkr.tS|j|�}|dkrMtS|jrl|j|j|j�S|j|j	�SdS(N(
RDR�Rt_no_typeR�RctgetAttributeTypeNSRhtgetAttributeTypeR{(R	RfR�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_schemaType�s			N(RaRbRtATTRIBUTE_NODERRR}R�RR�R�R;RR#RRzRLR�R�R�R�R=R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�Os 	
							R�s True if this attribute is an ID.s'Namespace-local name of this attribute.t
schemaTypesSchema type for this attribute.tNamedNodeMapcBs�eZdZdZd�Zd�Zd�Zd�Zd�Zd	�Z	d
�Z
d�Zd�Zdd
�ZeZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(sThe 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�t
_ownerElementcCs||_||_||_dS(N(R�R�R�(R	tattrstattrsNSR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�s		cCs
t|j�S(N(tlenR�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_length�scCs2y||jj�|SWntk
r-dSXdS(N(R�tkeyst
IndexErrorR(R	R+((s'/usr/lib64/python2.7/xml/dom/minidom.pytitem�s
cCs=g}x0|jj�D]}|j|j|jf�qW|S(N(R�tvaluesR>R{R�(R	RAR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyRZ�scCsFg}x9|jj�D](}|j|j|jf|jf�qW|S(N(R�R�R>RcRhR�(R	RAR6((s'/usr/lib64/python2.7/xml/dom/minidom.pytitemsNS�s&cCs-t|t�r||jkS||jkSdS(N(t
isinstancetStringTypesR�R�(R	RS((s'/usr/lib64/python2.7/xml/dom/minidom.pythas_key�s
cCs
|jj�S(N(R�R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs
|jj�S(N(R�R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pytkeysNS�scCs
|jj�S(N(R�R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|jj||�S(N(R�tget(R	RuR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs<|jt|dd�krdStt|�t|��SdS(NR�i(R�tgetattrRtcmptid(R	RM((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__cmp__scCs)t|t�r|j|S|j|SdS(N(R�R!R�R�(R	tattname_or_tuple((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__getitem__scCs�t|t�rhy|j|}Wn9tk
r[t|�}|jj|_|j|�nX||_n.t|t�s�t	d�n|}|j|�dS(Ns%value must be a string or Attr object(
R�R�R�RRR�R�RDtsetNamedItemR�t	TypeError(R	tattnameR�R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__setitem__
s
cCs(y|j|SWntk
r#dSXdS(N(R�RRR(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetNamedItems
cCs.y|j||fSWntk
r)dSXdS(N(R�RRR(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetNamedItemNS"s
cCs�|j|�}|dk	rnt|j�|j|j=|j|j|jf=d|j	krjd|j	d<n|St
jj��dS(NR�(
R�RR/R�R�R{R�RcRhRiR$R%R-(R	Rutn((s'/usr/lib64/python2.7/xml/dom/minidom.pytremoveNamedItem(s

cCs�|j||�}|dk	rqt|j�|j|j|jf=|j|j=d|j	krmd|j	d<n|St
jj��dS(NR�(
R�RR/R�R�RcRhR�R{RiR$R%R-(R	RcRhR�((s'/usr/lib64/python2.7/xml/dom/minidom.pytremoveNamedItemNS4s

cCs�t|t�s:tjjdt|�t|�f��n|jj|j�}|rb|j	�n||j|j<||j
|j|jf<|j
|_t|j�|S(Ns%s cannot be child of %s(R�R�R$R%R&R'R�R�RuR=R�RcRhR�R�R/(R	R6RV((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�@s	"

cCs
|j|�S(N(R�(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetNamedItemNSMscCs%||}t|j�|j�dS(N(R/R�R=(R	R�R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__delitem__Ps

cCs|j|j|jfS(N(R�R�R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__getstate__UscCs|\|_|_|_dS(N(R�R�R�(R	tstate((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__setstate__Xs(R�R�R�N(RaRbt__doc__t	__slots__RzR�R�RZR�R�R�R�R�RR�t__len__t__hash__R�R�R�R�R�R�R�R�R�R�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s4																	
			tlengths$Number of nodes in the NamedNodeMap.tTypeInfocBs2eZdZd�Zd�Zd�Zd�ZRS(t	namespaceRucCs||_||_dS(N(R�Ru(R	R�Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pyRzds	cCs,|jrd|j|jfSd|jSdS(Ns<TypeInfo %r (from %r)>s
<TypeInfo %r>(R�Ru(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt__repr__hs	cCs|jS(N(Ru(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	_get_namenscCs|jS(N(R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_namespaceqs(R�Ru(RaRbR�RzR�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�as
			tElementcBsLeZejZdZeZdZ	ejej
ejejej
ejfZeddd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd	�Zd
�Zd�ZeZd�Zd
�Zd�ZeZ d�Z!d�Z"d�Z#d�Z$d�Z%dddd�Z&d�Z'd�Z(d�Z)d�Z*d�Z+RS(icCsD||_|_||_||_t�|_i|_i|_dS(N(RrR{RdRcR`RR�R�(R	RrRcRdRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�s			cCs|jjdd�dS(NR�ii����(RrR�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRL�scCs|jS(N(Rr(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_tagName�scCsGx!|jj�D]}|j�qWd|_d|_tj|�dS(N(R�R�R=RR�R(R	tattr((s'/usr/lib64/python2.7/xml/dom/minidom.pyR=�s
		cCs+y|j|jSWntk
r&dSXdS(NR(R�R�RR(R	R�((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetAttribute�s
cCs1y|j||fjSWntk
r,dSXdS(NR(R�R�RR(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetAttributeNS�s
cCs�|j|�}|dkr_t|�}|j}||d<|d<|j|d<|j|�nC||jkr�|j}||d<|d<|jr�t|�q�ndS(NR�R|RD(	tgetAttributeNodeRR�RiRDtsetAttributeNodeR�R�R/(R	R�R�R�RW((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetAttribute�s	
		cCs�t|�\}}|j||�}|dkr�t||||�}|j}||d<||d<||d<|d<|j|d<|j|�ni|j}||jkr�||d<|d<|jr�t	|�q�n|j
|kr�||d<||d<ndS(NRdR{R�R|RD(t_nssplittgetAttributeNodeNSRR�RiRDR�R�R�R/Rd(R	Rct
qualifiedNameR�Rdt	localnameR�RW((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetAttributeNS�s$	


		
cCs|jj|�S(N(R�R�(R	tattrname((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|jj||f�S(N(R�R�(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs�|jd|fkr*tjjd��n|jj|jd�}|dk	r^|j|�n|j	j|j
|jfd�}|dk	r�||k	r�|j|�nt||�||k	r�|S||k	r�|SdS(Nsattribute node already owned(
R�RR$R%tInuseAttributeErrR�R�RutremoveAttributeNodeR�RcRht_set_attribute_node(R	R�told1told2((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s!
cCsEy|j|}Wn tk
r3tjj��nX|j|�dS(N(R�RRR$R%R-R�(R	RuR�((s'/usr/lib64/python2.7/xml/dom/minidom.pytremoveAttribute�s

cCsKy|j||f}Wn tk
r9tjj��nX|j|�dS(N(R�RRR$R%R-R�(R	RcRhR�((s'/usr/lib64/python2.7/xml/dom/minidom.pytremoveAttributeNS�s

cCsw|dkrtjj��ny|j|jWn tk
rRtjj��nXt|�|j�|j	|_	dS(N(
RR$R%R-R�RuRRR/R=RD(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s


cCs
||jkS(N(R�(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pythasAttributescCs||f|jkS(N(R�(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pythasAttributeNSscCst||t��S(N(RsR`(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetElementsByTagNamescCst|||t��S(N(RwR`(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetElementsByTagNameNSscCsd|jt|�fS(Ns<DOM Element: %s at %#x>(RrR�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�sRc	Cs[|j|d|j�|j�}|j�}|j�x@|D]8}|jd|�t|||j�|jd�qAW|jrF|jd�t|j�dkr�|jdj	t
jkr�|jdj|ddd�nH|j|�x+|jD] }|j|||||�q�W|j|�|jd|j|f�n|jd	|�dS(
NRms %s="s"RniiRs</%s>%ss/>%s(
RpRrt_get_attributesR�tsortRqR�RR�RRR;R(	R	RRt	addindentRR�ta_namesta_nameR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyRs&

	
 

cCst|j|j|�S(N(R�R�R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�4scCs|jr
tStSdS(N(R�RR(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
hasAttributes7s	cCs |j|�}|j|�dS(N(R�tsetIdAttributeNode(R	RutidAttr((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetIdAttribute?scCs#|j||�}|j|�dS(N(R�R�(R	RcRhR�((s'/usr/lib64/python2.7/xml/dom/minidom.pytsetIdAttributeNSCscCs�|dks|j|j�r1tjj��nt|�dk	rUtjj��n|js�t	|j
d<|jd7_|jj
d7_
t|�ndS(NR�i(RRNR�R$R%R-t_get_containing_entreftNoModificationAllowedErrR�RRiR�RDR�R/(R	R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�Gs	
N(,RaRbRR?RRR|R�R�R�R�R�R;R~RR#RRzRLR�R=R�R�R�R�R�R�R�tsetAttributeNodeNSR�R�R�tremoveAttributeNodeNSR�R�R�R�R�RR�R�R�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�vsL														
									R}s*NamedNodeMap of attributes on the element.s%Namespace-local name of this element.cCsDt|�||j|j<||j|j|jf<||jd<dS(NR�(R/R�RuR�RcRhRi(telementR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�Xs
t	ChildlesscBsqeZdZd	Ze�Zd	Zd	Zd�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd�ZRS(
s�Mixin that makes childless-ness easy to implement and avoids
    the complexity of the Node methods that deal with children.
    cCsdS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRmscCsdS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRpscCstjj|jd��dS(Ns nodes cannot have children(R$R%R&R{(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR*ss	cCstS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRwscCstjj|jd��dS(Ns nodes do not have children(R$R%R&R{(R	R3R4((s'/usr/lib64/python2.7/xml/dom/minidom.pyR"zs	cCstjj|jd��dS(Ns nodes do not have children(R$R%R-R{(R	R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR)~s	cCsdS(N((R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR@�scCstjj|jd��dS(Ns nodes do not have children(R$R%R&R{(R	R3R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR9�s	N(RaRbR�RR}t
EmptyNodeListRReRgRRR*RR"R)R@R9(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�cs								tProcessingInstructioncBsYeZejZd�Zd�Zd�Zd�Zd�Z	d�Z
dddd�ZRS(cCs$||_|_||_|_dS(N(ttargetR{R<R|(R	R�R<((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�scCs|jS(N(R<(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	_get_data�scCs|j}||d<|d<dS(NR<R|(Ri(R	R�RW((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	_set_data�s	cCs|jS(N(R�(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_target�scCs|j}||d<|d<dS(NR�R{(Ri(R	R�RW((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_set_target�s	cCsw|dks|dkr3||jd<|jd<n@|dksK|dkrf||jd<|jd<n
||j|<dS(NR<R|R�R{(Ri(R	RuR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s
RcCs'|jd||j|j|f�dS(Ns
%s<?%s %s?>%s(RpR�R<(R	RRR�R((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�s(RaRbRR�RRzR�RRRR�R(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s							t
CharacterDatacBsteZd�ZeZd�Zd�ZeZeZd�Zd�Z	d�Z
d�Zd�Zd�Z
d	�ZRS(
cCs
t|j�S(N(R�R<(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|jdS(NR<(Ri(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|j}||d<|d<dS(NR<R|(Ri(R	R<RW((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�s	cCsD|dks|dkr3||jd<|jd<n
||j|<dS(NR<R|(Ri(R	RuR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCsH|j}t|�dkr$d}nd}d|jj|dd!|fS(Ni
s...Rs<DOM %s node "%r%s">i(R<R�t	__class__Ra(R	R<t	dotdotdot((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s		cCs~|dkr!tjjd��n|t|j�krKtjjd��n|dkrltjjd��n|j|||!S(Nisoffset cannot be negatives#offset cannot be beyond end of datascount cannot be negative(R$R%tIndexSizeErrR�R<(R	toffsettcount((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
substringData�scCs|j||_dS(N(R<(R	targ((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
appendData�scCs||dkr!tjjd��n|t|j�krKtjjd��n|rxd|j| ||j|f|_ndS(Nisoffset cannot be negatives#offset cannot be beyond end of datas%s%s%s(R$R%RR�R<(R	RR
((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
insertData�scCs�|dkr!tjjd��n|t|j�krKtjjd��n|dkrltjjd��n|r�|j| |j|||_ndS(Nisoffset cannot be negatives#offset cannot be beyond end of datascount cannot be negative(R$R%RR�R<(R	RR((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
deleteData�scCs�|dkr!tjjd��n|t|j�krKtjjd��n|dkrltjjd��n|r�d|j| ||j||f|_ndS(Nisoffset cannot be negatives#offset cannot be beyond end of datascount cannot be negatives%s%s%s(R$R%RR�R<(R	RRR
((s'/usr/lib64/python2.7/xml/dom/minidom.pytreplaceData�s(RaRbR�R�R�Rt_get_nodeValuet_set_nodeValueR�R�R	RRR
R(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�s												
sLength of the string data.R�cBsSeZejZdZdZd�Zdddd�Z	d�Z
d�Zd�ZRS(s#textcCs�|dks!|t|j�kr6tjjd��n|j�}|j||_|j|_|j}|jr�||jj	kr�|dkr�|jj|�q�|jj||�n|j| |_|S(Nisillegal offset value(
R�R<R$R%RRRDR1R(RRR*R"(R	RtnewTexttnext((s'/usr/lib64/python2.7/xml/dom/minidom.pyt	splitText�s!	RcCs!t|d||j|f�dS(Ns%s%s%s(RqR<(R	RRR�R((s'/usr/lib64/python2.7/xml/dom/minidom.pyR
scCs�|jg}|j}xK|dk	rb|jtjtjfkr^|jd|j�|j}qPqW|j}xH|dk	r�|jtjtjfkr�|j	|j�|j}qoPqoWdj
|�S(NiR(R<R2RRRR;R~R0R1R>tjoin(R	RAR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_wholeTexts		cCs�|j}|j}xK|dk	r_|jtjtjfkr[|j}|j|�|}qPqW|j}|s|j|�nxK|dk	r�|jtjtjfkr�|j}|j|�|}q�Pq�W|r�|j	}||d<||d<|SdSdS(NR<R|(
R(R2RRRR;R~R)R1Ri(R	tcontentRtR�RRW((s'/usr/lib64/python2.7/xml/dom/minidom.pytreplaceWholeText$s.			
			
		

cCs_|jj�rtSt|�}|dkr/tS|jj|�}|dkrQtS|j�SdS(N(R<tstripRt_get_containing_elementRRDR�tisElementContent(R	R�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyt!_get_isWhitespaceInElementContentBsN(
RaRbRR;RR{RR}RRRRR(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s				tisWhitespaceInElementContentsKTrue iff this text node contains only whitespace and is in element content.t	wholeTexts.The text of all logically-adjacent text nodes.cCs?|j}x/|dk	r:|jtjkr.|S|j}qWdS(N(R(RRRR?(R6R5((s'/usr/lib64/python2.7/xml/dom/minidom.pyRUs	
cCs?|j}x/|dk	r:|jtjkr.|S|j}qWdS(N(R(RRRR(R6R5((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�]s	
tCommentcBs2eZejZdZd�Zdddd�ZRS(s#commentcCs||_|_dS(N(R<R|(R	R<((s'/usr/lib64/python2.7/xml/dom/minidom.pyRzjsRcCs?d|jkrtd��n|jd||j|f�dS(Ns--s%'--' is not allowed in a comment nodes
%s<!--%s-->%s(R<R,Rp(R	RRR�R((s'/usr/lib64/python2.7/xml/dom/minidom.pyRms(RaRbRR�RR{RzR(((s'/usr/lib64/python2.7/xml/dom/minidom.pyRfs		tCDATASectioncBs)eZejZdZdddd�ZRS(s#cdata-sectionRcCs?|jjd�dkr'td��n|jd|j�dS(Ns]]>is$']]>' not allowed in a CDATA sections<![CDATA[%s]]>(R<tfindR,Rp(R	RRR�R((s'/usr/lib64/python2.7/xml/dom/minidom.pyR|s(RaRbRR~RR{R(((s'/usr/lib64/python2.7/xml/dom/minidom.pyRss	tReadOnlySequentialNamedNodeMapcBs�eZdZdd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�ZRS(t_seqcCs
||_dS(N(R"(R	tseq((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�scCs
t|j�S(N(R�R"(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs
t|j�S(N(R�R"(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs+x$|jD]}|j|kr
|Sq
WdS(N(R"R{(R	RuR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs:x3|jD](}|j|kr
|j|kr
|Sq
WdS(N(R"RcRh(R	RcRhR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCsLt|t�r!|j|�}n|j|�}|dkrHt|�n|S(N(R�R!R�R�RRR(R	t
name_or_tupleR6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs8|dkrdSy|j|SWntk
r3dSXdS(Ni(RR"R�(R	R+((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s
cCstjjd��dS(Ns"NamedNodeMap instance is read-only(R$R%R�(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s	cCstjjd��dS(Ns"NamedNodeMap instance is read-only(R$R%R�(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s	cCstjjd��dS(Ns"NamedNodeMap instance is read-only(R$R%R�(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s	cCstjjd��dS(Ns"NamedNodeMap instance is read-only(R$R%R�(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s	cCs
|jgS(N(R"(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|d|_dS(Ni(R"(R	R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s(R"((RaRbR�RzR�R�R�R�R�R�R�R�R�R�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR!�s												s&Number of entries in the NamedNodeMap.t
IdentifiedcBs)eZdZd�Zd�Zd�ZRS(s@Mix-in class that supports the publicId and systemId attributes.cCs||_||_dS(N(tpublicIdtsystemId(R	R&R'((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_identified_mixin_init�s	cCs|jS(N(R&(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
_get_publicId�scCs|jS(N(R'(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
_get_systemId�s(RaRbR�R(R)R*(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR%�s		tDocumentTypecBs\eZejZdZdZdZdZ	dZ
d�Zd�Zd�Z
dddd�ZRS(cCsLt�|_t�|_|r<t|�\}}||_n|j|_dS(N(R!tentitiest	notationsR�RuR{(R	R�RdR�((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�scCs|jS(N(tinternalSubset(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_internalSubset�scCs\|jdkrTtd�}|j|_|j|_tjjj}|r=g|j	_
g|j_
xU|jj
D]G}t|j|j
|j�}|jj
j|�|j|||�qmWx�|j	j
D]q}t|j|j
|j|j�}|j|_|j|_|j|_|j	j
j|�|j|||�q�Wn|j|||�|SdSdS(N(RDRR+RuR{R$R%tUserDataHandlertNODE_CLONEDR,R"R-tNotationR&R'R>R_tEntitytnotationNametactualEncodingR
RJ(R	REtcloneR\R�tnotationtetentity((s'/usr/lib64/python2.7/xml/dom/minidom.pyRF�s.RcCs�|jd�|j|j�|jrL|jd||j||jf�n&|jrr|jd||jf�n|jdk	r�|jd�|j|j�|jd�n|jd|�dS(Ns
<!DOCTYPE s%s  PUBLIC '%s'%s  '%s's%s  SYSTEM '%s's [t]Rn(RpRuR&R'R.R(R	RRR�R((s'/usr/lib64/python2.7/xml/dom/minidom.pyRs
			
N(RaRbRtDOCUMENT_TYPE_NODERRR|RuR&R'R.RzR/RFR(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR+�s				R3cBsweZdZejZdZdZdZ	dZ
d�Zd�Zd�Z
d�Zd�Zd�Zd�Zd�ZRS(	cCs2||_||_t�|_|j||�dS(N(R{R4R`RR((R	RuR&R'R7((s'/usr/lib64/python2.7/xml/dom/minidom.pyRzs		cCs|jS(N(R5(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_actualEncodingscCs|jS(N(R
(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
_get_encoding"scCs|jS(N(RJ(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_version%scCstjjd��dS(Ns(cannot append children to an entity node(R$R%R&(R	R3((s'/usr/lib64/python2.7/xml/dom/minidom.pyR*(s	cCstjjd��dS(Ns+cannot insert children below an entity node(R$R%R&(R	R3R4((s'/usr/lib64/python2.7/xml/dom/minidom.pyR",s	cCstjjd��dS(Ns*cannot remove children from an entity node(R$R%R&(R	R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR)0s	cCstjjd��dS(Ns)cannot replace children of an entity node(R$R%R&(R	R3R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR94s	N(RaRbRR}RtENTITY_NODERR|R5R
RJRzR<R=R>R*R"R)R9(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR3s								R2cBs eZejZdZd�ZRS(cCs||_|j||�dS(N(R{R((R	RuR&R'((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz<s	N(RaRbRR�RRR|Rz(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR28s	tDOMImplementationc	BsSeZddddddddgZd�Zd�Zd�Zd	�Zd
�ZRS(tcores1.0s2.0R$sls-loads3.0cCs.|dkrd}n|j�|f|jkS(NR(Rtlowert	_features(R	RIRJ((s'/usr/lib64/python2.7/xml/dom/minidom.pyRHLs	c	CsK|r*|jdk	r*tjjd��n|j�}|dkoW|dkoW|dk}|r}|r}tjjd��n|rt|�\}}|dkr�|dkr�tjjd��n|r�|r�tjjd��n|j	||�}|r|j
|�n|j
|�n|r5||_|_n||_||_
|S(Ns(doctype object owned by another DOM treesElement with no nameR$s$http://www.w3.org/XML/1998/namespacesillegal use of 'xml' prefixs(illegal use of prefix without namespaces(R(RR$R%tWrongDocumentErrt_create_documenttInvalidCharacterErrR�R�tcreateElementNSR*RDtdoctypeRG(	R	RcR�RHRftadd_root_elementRdR�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateDocumentQs4	



			cCs"t|�}||_||_|S(N(R+R&R'(R	R�R&R'RH((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateDocumentType~s		cCs|j|d�r|SdSdS(N(RHR(R	RI((s'/usr/lib64/python2.7/xml/dom/minidom.pyRO�scCst�S(N(tDocument(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRE�s(RAs1.0(RAs2.0N(RAN(R$s1.0(R$s2.0(R$N(sls-loads3.0(sls-loadN(	RaRbRRCRHRJRKRORE(((s'/usr/lib64/python2.7/xml/dom/minidom.pyR@As			-		tElementInfocBseeZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�ZRS(s�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.

    RrcCs
||_dS(N(Rr(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�scCstS(N(R�(R	taname((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCstS(N(R�(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCstS(N(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�scCstS(sQReturns true iff this element is declared to have an EMPTY
        content model.(R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pytisEmpty�scCstS(s7Returns true iff the named attribute is a DTD-style ID.(R(R	RN((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCstS(s<Returns true iff the identified attribute is a DTD-style ID.(R(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|jS(N(Rr(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs
||_dS(N(Rr(R	R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s(Rr(
RaRbR�R�RzR�R�RROR�R�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyRM�s								cCsZ|jtjkr+|jj�d|_n+t|�rV|jjj�d|j_ndS(N(	RRRt	_id_cachetclearRt_id_search_stackRkRD(R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR/�s
RLcBs�eZejejejejfZejZ	dZ
d$Zd$Z
d$Zd$Zd$ZZe�Zd$Zd$Zd$Zd$ZeZd$Zd$ZdZd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#d	�Z$d
�Z%d�Z&d�Z'd
�Z(d�Z)d�Z*d�Z+d�Z,d�Z-d�Z.d�Z/d�Z0d�Z1d�Z2d�Z3d�Z4d�Z5d�Z6d�Z7d�Z8d�Z9d�Z:d �Z;d!d!d!d$d"�Z<d#�Z=RS(%s	#documenticCs+t�|_i|_i|_d|_dS(N(R`Rt
_elem_infoRPRRR(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyRz�s		cCs7|jr|j|jf}n	|j}|jj|�S(N(RcRhRrRSR�(R	R�RS((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s		cCs|jS(N(R5(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR<�scCs|jS(N(RH(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_doctype�scCs|jS(N(tdocumentURI(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_documentURI�scCs|jS(N(R
(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR=�scCs|jS(N(terrorHandler(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_errorHandler�scCs|jS(N(t
standalone(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_standalone�scCs|jS(N(tstrictErrorChecking(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_get_strictErrorChecking�scCs|jS(N(RJ(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR>scCs�|j|jkr=tjjdt|�t|�f��n|jdk	r_|jj|�n|jt	j
kr�|j�r�tjjd��nt	j||�S(Ns%s cannot be child of %ss two document elements disallowed(
RR#R$R%R&R'R(RR)RR?t_get_documentElementR*(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR*s	"	cCsoy|jj|�Wn tk
r6tjj��nXd|_|_d|_	|j
|krkd|_
n|S(N(RR:R,R$R%R-RR1R2R(tdocumentElement(R	R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyR)s
	cCs.x'|jD]}|jtjkr
|Sq
WdS(N(RRRR?(R	R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR]scCs9|jdk	r(|jj�d|_ntj|�dS(N(RHRR=R(R	((s'/usr/lib64/python2.7/xml/dom/minidom.pyR=$s
cCs|s
dS|jjddd�}|j|_|j|_|j|_x�|jD]�}t|||�}|jj	|�s�t
�|jj|�|jt
jkr�|jdks�t
�n3|jt
jkr�|jdks�t
�||_n||_qPW|jtjjj||�|S(N(RRGRJR
RYRJRRCRDRNtAssertionErrorR>RRRR^R;RHR(R_R$R%R0R1(R	RER6R�t
childclone((s'/usr/lib64/python2.7/xml/dom/minidom.pyRF*s&

cCst�}||_|S(N(RyRD(R	RW((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateDocumentFragment?s		cCst|�}||_|S(N(R�RD(R	RrR8((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
createElementDs	cCs:t|t�std�nt�}||_||_|S(Nsnode contents must be a string(R�R�R�R�R<RD(R	R<tt((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateTextNodeIs			cCs:t|t�std�nt�}||_||_|S(Nsnode contents must be a string(R�R�R�RR<RD(R	R<R5((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateCDATASectionQs			cCst|�}||_|S(N(RRD(R	R<R5((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
createCommentYs	cCst||�}||_|S(N(R�RD(R	R�R<tp((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateProcessingInstruction^s	cCs"t|�}||_d|_|S(NR(R�RDR�(R	R�ta((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateAttributecs		cCs1t|�\}}t|||�}||_|S(N(R�R�RD(R	RcR�RdRhR8((s'/usr/lib64/python2.7/xml/dom/minidom.pyRGis	cCs=t|�\}}t||||�}||_d|_|S(NR(R�R�RDR�(R	RcR�RdRhRi((s'/usr/lib64/python2.7/xml/dom/minidom.pytcreateAttributeNSos
		cCs"t||||�}||_|S(N(R3RD(R	RuR&R'R4R8((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_create_entityys	cCst|||�}||_|S(N(R2RD(R	RuR&R'R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_create_notation~s	cCsE||jkr|j|S|jp)|js0dS|j}|dkr]|jg}||_n
|sgdSd}x�|r@|j�}|jg|jD]}|j	t
kr�|^q��|j|�}|r�xa|jj
�D]�}|jr;|j|j|j�r�||j|j<|j|kr(|}q8|js8Pq8q�q�|j|j�r�||j|j<|j|kru|}q�|js�Pq�q�|jr�||j|j<|j|kr�|}q�|jdkr�Pq�q�q�WnZ|jr-xN|jj
�D]:}|jr�||j|j<|j|kr&|}q&q�q�Wn|dk	rpPqpqpW|S(Ni(RPRSR�RRRR^tpoptextendRRR.R�R}R�RcR�RhR�R�R�RuR�(R	R�tstacktresultR6RBR�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetElementById�s\					
						cCst||t��S(N(RsR`(R	Ru((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCst|||t��S(N(RwR`(R	RcRh((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��scCs|jj||�S(N(RGRH(R	RIRJ((s'/usr/lib64/python2.7/xml/dom/minidom.pyRK�scCs^|jtjkr'tjjd��n'|jtjkrNtjjd��nt|||�S(Nscannot import document nodess!cannot import document type nodes(RRRR$R%tNotSupportedErrR;RC(R	R6RE((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
importNode�s
RcCse|dkr |jd|�n|jd||f�x'|jD]}|j||||�qAWdS(Ns<?xml version="1.0" ?>s%<?xml version="1.0" encoding="%s"?>%s(RRpRR(R	RRR�RR
R6((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�s
c	Cs|j|k	r1tjjd||jf��n|jtjtjfkratjjd��n|t	krd|kr�|j
dd�\}}|dkr|tjjkrtjjd��qq'|dkr|tjjkr|jtjkrtjjd��nd}|}nd}d}|jtjkrj|j}|dk	rp|j}|j|�qpnd}|j}||d<||d	<||d
<||d<|jtjkr�||d<n<||d
<|dk	r�|j|�|r�|j|�q�n|S(Ns?cannot rename nodes from other documents;
expected %s,
found %ss8renameNode() only applies to element and attribute nodesR�iR�sillegal use of 'xmlns' prefixs$illegal use of the 'xmlns' attributeRdRhRcR{RrRu(RDR$R%RDRRR?R�RsRR�RR�RR�R�R�RiR�R�(	R	R�RcRuRdRhR�tis_idRW((s'/usr/lib64/python2.7/xml/dom/minidom.pyt
renameNode�sT								






N(>RaRbRR?R�R�R;R#RRR{RR|R}RHR(R2R1R@RGR5R
RYRJRR[RWRUR�RzR�R<RTRVR=RXRZR\R>R*R)R]R=RFRaRbRdReRfRhRjRGRkRlRmRrR�R�RKRtRRv(((s'/usr/lib64/python2.7/xml/dom/minidom.pyRL�sh	
																									
			:					
R^s#Top-level element of this document.c
Cs|jj|�r$tjjj}ntjjj}|jtj	kr�|j
|j|j�}xW|j
j�D]F}|j|j|j|j�|j|j|j�}|j|_qmW|r�x3|jD]%}t|||�}|j|�q�Wq�n�|jtjkrS|j�}|r�x3|jD]%}t|||�}|j|�q$Wq�n�|jtjkrz|j|j�}nm|jtjkr�|j|j�}nF|jtjkr�|j|j |j�}n|jtj!kr�|j"|j�}n�|jtj#kr7|j$|j|j�}t%|_|j|_n�|jtj&kr�|j|k	s^t'�tjjj}|j(j)|j*|j+|j,�}||_|r�g|j-_.g|j/_.xp|j/j.D]b}	t0|	j|	j+|	j,�}
||
_|j/j.j1|
�t2|	d�r�|	j3||	|
�q�q�Wx�|j-j.D]�}t4|j|j+|j,|j5�}|j6|_6|j7|_7|j8|_8||_|j-j.j1|�t2|d�r5|j3|||�q5q5Wq�ntjj9dt:|���t2|d�r|j3|||�n|S(so
    Clone a node and give it the new owner document.
    Called by Node.cloneNode and Document.importNode
    R_sCannot clone node %s(;RDRNR$R%R0R1t
NODE_IMPORTEDRRR?RGRcR{R}R�R�R�R�RhR�RRCR*R RaR;RdR<R~ReR�RhR�R�RfR�RkRR;R_RGRKRuR&R'R,R"R-R2R>RYR_R3R4R5R
RJRsR'(
R6REtnewOwnerDocumentR\R6R�RiRBR5R�R7R8R9((s'/usr/lib64/python2.7/xml/dom/minidom.pyRCs~					 cCs:|jdd�}t|�dkr(|Sd|dfSdS(NR�iii(R�R�R(R�tfields((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�fscCsddlm}|�S(Ni����(tStringIO(Rz(Rz((s'/usr/lib64/python2.7/xml/dom/minidom.pyRnscCs<|||�}|j�\}}|j|�|j�|S(N(tgetEventt
expandNodeRQ(tfunctargstkwargsteventsttoktypetrootNode((s'/usr/lib64/python2.7/xml/dom/minidom.pyt_do_pulldom_parsess


cCsh|dkr0|r0ddlm}|j|�Sddlm}t|j|fi|d6|d6�SdS(s3Parse a file into a DOM by filename or file object.i����(texpatbuilder(tpulldomtparsertbufsizeN(Rtxml.domR�tparseR�R�(tfileR�R�R�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR�zs
cCsZ|dkr)ddlm}|j|�Sddlm}t|j|fi|d6�SdS(s&Parse a file into a DOM from a string.i����(R�(R�R�N(RR�R�tparseStringR�R�(tstringR�R�R�((s'/usr/lib64/python2.7/xml/dom/minidom.pyR��s
cCsa|rZt|t�r'tj|�}nx0|D]%\}}tjj||�s.dSq.WntjS(N(R�R�Rt_parse_feature_stringRLRGRHR(tfeaturestftv((s'/usr/lib64/python2.7/xml/dom/minidom.pytgetDOMImplementation�s(8R�R�R$RRRRtxml.dom.minicompattxml.dom.xmlbuilderRRR%RR?RR.tdefpropertyR7RkRqRsRwRyR�tobjectR�t
AttributeListR�RR�R�R�R�R�RR�RR�RRR!R%R+R3R2R@RMR/RLRCR�RR�R�R�R�(((s'/usr/lib64/python2.7/xml/dom/minidom.pyt<module>s�"
�	
					r��	(GZ			
><(	O*	�O	R			

PK�"[o���;�;dom/xmlbuilder.pyonu�[����
{fc@s�dZddlZddlZddlmZdddgZddd��YZddd	��YZd
�Z	de
fd��YZde
fd��YZd
dd��YZ
[ddd��YZddd��YZdS(s4Implementation of the DOM Level 3 'LS-Load' feature.i����N(t
NodeFiltert
DOMBuildertDOMEntityResolvertDOMInputSourcetOptionscBs�eZdZdZeZeZeZeZ	eZ
eZeZeZ
eZeZeZeZeZeZeZeZdZdZRS(s�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.
    iN(t__name__t
__module__t__doc__t
namespacestTruetnamespace_declarationstFalset
validationtexternal_parameter_entitiestexternal_general_entitiestexternal_dtd_subsettvalidate_if_schematvalidatetdatatype_normalizationtcreate_entity_ref_nodestentitiestwhitespace_in_element_contenttcdata_sectionstcommentstcharset_overrides_xml_encodingtinfosettsupported_mediatypes_onlytNoneterrorHandlertfilter(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRs(cBs�eZd#Zd#Zd#ZdZdZdZdZ	eeee	fZ
d�Zd�Zd�Z
d�Zd�Zd	�Zd
�Zd�Zd�Zd
�Zid$gd%6d&gd'6d(gd)6d*gd+6d,gd-6d.gd/6d0gd16d2gd36d4gd56d6gd76d8d9gd:6d;gd<6d=gd>6d?gd@6dAgdB6dCgdD6dEgdF6dGgdH6dIgdJ6dKgdL6gdM6dNdOdPdQdRdSdTdUdVg	dW6dXgdY6dZgd[6d\gd]6Zd�Zd�Zd �Zd!�Zd"�ZRS(^iiiicCst�|_dS(N(Rt_options(tself((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt__init__9scCs|jS(N(tentityResolver(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_entityResolver<scCs
||_dS(N(R!(RR!((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_entityResolver>scCs|jS(N(R(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_errorHandlerAscCs
||_dS(N(R(RR((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_errorHandlerCscCs|jS(N(R(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_filterFscCs
||_dS(N(R(RR((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_filterHscCs�|j|�r�|rdpd}y|jt|�|f}Wn*tk
rjtjjd|f��q�XxF|D]\}}t|j||�qrWntjj	dt
|���dS(Niisunsupported feature: %rsunknown feature: (tsupportsFeaturet	_settingst_name_xformtKeyErrortxmltdomtNotSupportedErrtsetattrRtNotFoundErrtrepr(Rtnametstatetsettingstvalue((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
setFeatureKs
	cCst|jt|��S(N(thasattrRR*(RR2((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR(YscCs+t|�|rdpdf}||jkS(Nii(R*R)(RR2R3tkey((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
canSetFeature\sR
iRRR
RRRRRRRRRRRcCs�t|�}yt|j|�SWn�tk
r�|dkr�|j}|jo�|jo�|jo�|jo�|jp�|j	p�|j
p�|jp�|jSt
jjdt|���nXdS(NRsfeature %s not known(R*tgetattrRtAttributeErrorRRRRR
RRRRR,R-R0R1(RR2txnametoptions((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
getFeature�s 
									cCsC|jr!|jjd|�}nt�jd|�}|j|�S(N(R!t
resolveEntityRRtparse(Rturitinput((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytparseURI�s	cCsytj|j�}|j|_|j|_|j}|dkri|jriddl}|j|j�}n|j	||�S(Ni����(
tcopyRRRt
byteStreamRtsystemIdturllib2turlopent_parse_bytestream(RRBR=tfpRG((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR@�s	cCs.||jkrtd��ntd��dS(Nsnot a legal actionsHaven't written this yet...(t_legal_actionst
ValueErrortNotImplementedError(RRBtcnodetaction((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytparseWithContext�scCs.ddl}|jjj|�}|j|�S(Ni����(txml.dom.expatbuilderR-texpatbuildertmakeBuildert	parseFile(RtstreamR=R,tbuilder((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRI�sN(R
i(R
i(R
i(R
i(Ri(Ri(Ri(Ri(Ri(Ri(R
i(R
i(R
i(R
i(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(R
i(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(RRRR!RRtACTION_REPLACEtACTION_APPEND_AS_CHILDRENtACTION_INSERT_AFTERtACTION_INSERT_BEFORERKR R"R#R$R%R&R'R6R(R9R)R>RCR@RPRI(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR,sv											























			
	cCs|j�jdd�S(Nt-t_(tlowertreplace(R2((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR*�scBs2eZdZd�Zd�Zd�Zd�ZRS(t_openerc
Cs�t�}||_||_|j�j|�|_|j|�|_ddl}ddl	}|j	|�}|\}}}	}
}}|	r�|	j
d�r�|j|	�d}	|||	|
||f}|j|�|_
n|S(Ni����t/(RtpublicIdRFt_get_openertopenREt_guess_media_encodingtencodingt	posixpathturlparsetendswithtdirnamet
urlunparsetbaseURI(
RRaRFtsourceRfRgtpartstschemetnetloctpathtparamstquerytfragment((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR?�s			cCs6y|jSWn$tk
r1|j�|_|jSXdS(N(R_R;t_create_opener(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRb�s

cCsddl}|j�S(Ni����(RGtbuild_opener(RRG((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRt�scCsb|jj�}d|kr^x@|j�D]/}|jd�r(|jdd�dj�Sq(WndS(NsContent-Typescharset=t=i(REtinfotgetplistt
startswithtsplitR](RRlRwtparam((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRd�s
(R_(RRt	__slots__R?RbRtRd(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR�s
			cBs�eZdZd�Zd�Zd	�Zd
�Zd�Zd�Zd
�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd�Zd�ZRS(REtcharacterStreamt
stringDataReRaRFRkcCsCd|_d|_d|_d|_d|_d|_d|_dS(N(RRER}R~ReRaRFRk(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR s						cCs|jS(N(RE(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_byteStream
scCs
||_dS(N(RE(RRE((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_byteStreamscCs|jS(N(R}(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_characterStreamscCs
||_dS(N(R}(RR}((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_characterStreamscCs|jS(N(R~(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_stringDatascCs
||_dS(N(R~(Rtdata((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_stringDatascCs|jS(N(Re(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_get_encodingscCs
||_dS(N(Re(RRe((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_set_encodingscCs|jS(N(Ra(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_get_publicId!scCs
||_dS(N(Ra(RRa((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_set_publicId#scCs|jS(N(RF(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_get_systemId&scCs
||_dS(N(RF(RRF((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_set_systemId(scCs|jS(N(Rk(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_baseURI+scCs
||_dS(N(Rk(RRA((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_baseURI-s(RER}R~ReRaRFRk(RRR|R RR�R�R�R�R�R�R�R�R�R�R�R�R�(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRs"															tDOMBuilderFiltercBsJeZdZdZdZdZdZejZ	d�Z
d�Zd�ZRS(sSElement filter which can be used to tailor construction of
    a DOM instance.
    iiiicCs|jS(N(t
whatToShow(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_whatToShowBscCs|jS(N(t
FILTER_ACCEPT(Rtelement((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
acceptNodeEscCs|jS(N(R�(RR�((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytstartContainerHs(
RRRR�t
FILTER_REJECTtFILTER_SKIPtFILTER_INTERRUPTRtSHOW_ALLR�R�R�R�(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR�1s			t
DocumentLScBsJeZdZeZd�Zd�Zd�Zd�Zd�Z	d�Z
RS(s=Mixin to create documents that conform to the load/save spec.cCstS(N(R(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_get_asyncSscCs|rtjjd��ndS(Ns.asynchronous document loading is not supported(R,R-R.(Rtasync((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_set_asyncUs	cCstd��dS(Ns'haven't figured out what this means yet(RM(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytabortZscCstd��dS(Nshaven't written this yet(RM(RRA((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytload`scCstd��dS(Nshaven't written this yet(RM(RRl((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytloadXMLcscCs@|dkr|}n!|j|k	r6tjj��n|j�S(N(Rt
ownerDocumentR,R-tWrongDocumentErrttoxml(Rtsnode((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytsaveXMLfs
	(RRRRR�R�R�R�R�R�R�(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR�Ns					tDOMImplementationLScBs/eZdZdZd�Zd�Zd�ZRS(iicCsk|dk	r!tjjd��n||jkr7t�S||jkr[tjjd��ntd��dS(NsschemaType not yet supporteds'asynchronous builders are not supportedsunknown value for mode(RR,R-R.tMODE_SYNCHRONOUSRtMODE_ASYNCHRONOUSRL(Rtmodet
schemaType((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytcreateDOMBuilderrs		cCstd��dS(Ns-the writer interface hasn't been written yet!(RM(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytcreateDOMWriter}scCst�S(N(R(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytcreateDOMInputSource�s(RRR�R�R�R�R�(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR�ns
		((((((RRDtxml.domR,txml.dom.NodeFilterRt__all__RRR*tobjectRRR�R�R�(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt<module>s �	,1 PK�"[�VY�f
f
dom/minicompat.pycnu�[����
{fc@s�dZddddgZddlZyeWn ek
rNed�fZnXed�eed��fZdefd��YZ	de
fd	��YZd
�ZdS(s1Python version compatibility support for minidom.tNodeListt
EmptyNodeListtStringTypestdefpropertyi����NtcBsGeZdZd�Zd�Zd�Zeeedd�Zd�ZRS(cCs.d|kot|�knr*||SdS(Ni(tlen(tselftindex((s*/usr/lib64/python2.7/xml/dom/minicompat.pytitem6s"cCs
t|�S(N(R(R((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt_get_length:scCstjjd��dS(Ns.attempt to modify read-only attribute 'length'(txmltdomtNoModificationAllowedErr(Rtvalue((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt_set_length=s	tdocs$The number of nodes in the NodeList.cCs |dkrg}n||(dS(N(tNone(Rtstate((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt__setstate__Es	((	t__name__t
__module__t	__slots__RR	RtpropertytlengthR(((s*/usr/lib64/python2.7/xml/dom/minicompat.pyR3s				cBsPeZdZd�Zd�Zd�Zd�Zd�Zeeedd�Z	RS(cCst�}|j|�|S(N(Rtextend(RtothertNL((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt__add__Ns	
cCst�}|j|�|S(N(RR(RRR((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt__radd__Ss	
cCsdS(N(R(RR((s*/usr/lib64/python2.7/xml/dom/minicompat.pyRXscCsdS(Ni((R((s*/usr/lib64/python2.7/xml/dom/minicompat.pyR	[scCstjjd��dS(Ns.attempt to modify read-only attribute 'length'(R
RR(RR
((s*/usr/lib64/python2.7/xml/dom/minicompat.pyR^s	Rs$The number of nodes in the NodeList.((
RRRRRRR	RRR(((s*/usr/lib64/python2.7/xml/dom/minicompat.pyRKs					cCsot|d|�j}|d�}t|d|�sFtd|��t||d|�}t|||�dS(Nt_get_cSs tjjdt|���dS(Ns&attempt to modify read-only attribute (R
RRtrepr(RR
tname((s*/usr/lib64/python2.7/xml/dom/minicompat.pytseths	t_set_sexpected not to find _set_R(tgetattrtim_functhasattrtAssertionErrorRtsetattr(tklassRRtgetR tprop((s*/usr/lib64/python2.7/xml/dom/minicompat.pyRfs
(
t__doc__t__all__txml.domR
tunicodet	NameErrorttypeRtlistRttupleRR(((s*/usr/lib64/python2.7/xml/dom/minicompat.pyt<module>s&
PK�"[��iOOdom/__init__.pyonu�[����
{fc@s:dZdd=d��YZdZdZdZdZdZdZd	Zd
Z	dZ
dZd
ZdZ
dZdZdZdZdefd��YZdefd��YZdefd��YZdefd��YZdefd��YZdefd��YZdefd ��YZd!efd"��YZd#efd$��YZd%efd&��YZd'efd(��YZd)efd*��YZd+efd,��YZd-efd.��YZ d/efd0��YZ!d1efd2��YZ"d3efd4��YZ#d5d>d6��YZ$d7Z%d8Z&d9Z'd<Z)d<Z*d:d;l+m,Z,m-Z-d<S(?s
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.

tNodecBsVeZdZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZ
dZRS(
s$Class giving the NodeType constants.iiiiiiiii	i
ii(t__name__t
__module__t__doc__tELEMENT_NODEtATTRIBUTE_NODEt	TEXT_NODEtCDATA_SECTION_NODEtENTITY_REFERENCE_NODEtENTITY_NODEtPROCESSING_INSTRUCTION_NODEtCOMMENT_NODEt
DOCUMENT_NODEtDOCUMENT_TYPE_NODEtDOCUMENT_FRAGMENT_NODEt
NOTATION_NODE(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRs	iiiiiiiii	i
iii
iiitDOMExceptioncBs eZdZd�Zd�ZRS(smAbstract base class for DOM exceptions.
    Exceptions with specific codes are specializations of this class.cOs5|jtkrtd��ntj|||�dS(Ns0DOMException should not be instantiated directly(t	__class__RtRuntimeErrort	Exceptiont__init__(tselftargstkw((s(/usr/lib64/python2.7/xml/dom/__init__.pyRAscCs|jS(N(tcode(R((s(/usr/lib64/python2.7/xml/dom/__init__.pyt	_get_codeGs(RRRRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR=s	tIndexSizeErrcBseZeZRS((RRtINDEX_SIZE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRKstDomstringSizeErrcBseZeZRS((RRtDOMSTRING_SIZE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRNstHierarchyRequestErrcBseZeZRS((RRtHIERARCHY_REQUEST_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRQstWrongDocumentErrcBseZeZRS((RRtWRONG_DOCUMENT_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR TstInvalidCharacterErrcBseZeZRS((RRtINVALID_CHARACTER_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR"WstNoDataAllowedErrcBseZeZRS((RRtNO_DATA_ALLOWED_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR$ZstNoModificationAllowedErrcBseZeZRS((RRtNO_MODIFICATION_ALLOWED_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR&]stNotFoundErrcBseZeZRS((RRt
NOT_FOUND_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR(`stNotSupportedErrcBseZeZRS((RRtNOT_SUPPORTED_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR*cstInuseAttributeErrcBseZeZRS((RRtINUSE_ATTRIBUTE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR,fstInvalidStateErrcBseZeZRS((RRtINVALID_STATE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR.ist	SyntaxErrcBseZeZRS((RRt
SYNTAX_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR0lstInvalidModificationErrcBseZeZRS((RRtINVALID_MODIFICATION_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR2ostNamespaceErrcBseZeZRS((RRt
NAMESPACE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR4rstInvalidAccessErrcBseZeZRS((RRtINVALID_ACCESS_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR6ust
ValidationErrcBseZeZRS((RRtVALIDATION_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR8xstUserDataHandlercBs&eZdZdZdZdZdZRS(sBClass giving the operation constants for UserDataHandler.handle().iiii(RRRtNODE_CLONEDt
NODE_IMPORTEDtNODE_DELETEDtNODE_RENAMED(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR:{s
s$http://www.w3.org/XML/1998/namespaceshttp://www.w3.org/2000/xmlns/shttp://www.w3.org/1999/xhtmli����(tgetDOMImplementationtregisterDOMImplementationN(((.RRRRRR!R#R%R'R)R+R-R/R1R3R5R7R9RRRRRR R"R$R&R(R*R,R.R0R2R4R6R8R:t
XML_NAMESPACEtXMLNS_NAMESPACEtXHTML_NAMESPACEtNonetEMPTY_NAMESPACEtEMPTY_PREFIXtdomregR?R@(((s(/usr/lib64/python2.7/xml/dom/__init__.pyt<module>sR
PK�"[���}ffdom/NodeFilter.pycnu�[����
{fc@sddd��YZdS(t
NodeFiltercBsweZdZdZdZdZdZdZdZdZ	dZ
dZdZd	Z
d
ZdZdZd
ZdZd�ZRS(sL
    This is the DOM2 NodeFilter interface. It contains only constants.
    iiil��iiii i@i�iiiicCs
t�dS(N(tNotImplementedError(tselftnode((s*/usr/lib64/python2.7/xml/dom/NodeFilter.pyt
acceptNodes(t__name__t
__module__t__doc__t
FILTER_ACCEPTt
FILTER_REJECTtFILTER_SKIPtSHOW_ALLtSHOW_ELEMENTtSHOW_ATTRIBUTEt	SHOW_TEXTtSHOW_CDATA_SECTIONtSHOW_ENTITY_REFERENCEtSHOW_ENTITYtSHOW_PROCESSING_INSTRUCTIONtSHOW_COMMENTt
SHOW_DOCUMENTtSHOW_DOCUMENT_TYPEtSHOW_DOCUMENT_FRAGMENTt
SHOW_NOTATIONR(((s*/usr/lib64/python2.7/xml/dom/NodeFilter.pyRs$N((R(((s*/usr/lib64/python2.7/xml/dom/NodeFilter.pyt<module>tPK�"[�H�J8
8
dom/domreg.pyonu�[����
{fc@sddZddlTddlZidd6dd6ZiZd�Zd	�Zddd
�Zd�Z	dS(
s�Registration facilities for DOM. This module should not be used
directly. Instead, the functions getDOMImplementation and
registerDOMImplementation should be imported from xml.dom.i����(t*Nsxml.dom.minidomtminidomsxml.dom.DOMImplementationt4DOMcCs|t|<dS(sIregisterDOMImplementation(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(t
registered(tnametfactory((s&/usr/lib64/python2.7/xml/dom/domreg.pytregisterDOMImplementations	cCs1x*|D]"\}}|j||�sdSqWdS(sF_good_enough(dom, features) -> Return 1 if the dom offers the featuresii(t
hasFeature(tdomtfeaturestftv((s&/usr/lib64/python2.7/xml/dom/domreg.pyt_good_enough"scCs<ddl}d}tj|�}|rIt|iidg�}|j�S|rZt|�Stjj	r�d|j
kr�td|j
d�St|t�r�t
|�}nx0tj�D]"}|�}t||�r�|Sq�WxQtj�D]C}ytd|�}Wntk
rq�nXt||�r�|Sq�Wtd�dS(sSgetDOMImplementation(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.i����NtgetDOMImplementationt
PYTHON_DOMRs$no suitable DOM implementation found(tostNonetwell_known_implementationstgett
__import__R
Rtsystflagstignore_environmenttenviront
isinstancetStringTypest_parse_feature_stringtvaluesRtkeyst
StandardErrortImportError(RR	RtcreatortmodR((s&/usr/lib64/python2.7/xml/dom/domreg.pyR
)s0

	
cCs�g}|j�}d}t|�}x�||kr�||}|ddkr`td|f�n|d}d}||kr�||}|ddkr�|d}|}q�n|j||f�q'Wt|�S(Nit
0123456789sbad feature name: %ri(tsplittlent
ValueErrorRtappendttuple(tsR	tpartstitlengthtfeaturetversionR((s&/usr/lib64/python2.7/xml/dom/domreg.pyRTs"



((
t__doc__txml.dom.minicompatRRRRRRR
R(((s&/usr/lib64/python2.7/xml/dom/domreg.pyt<module>s

		+PK�"[ �.���dom/expatbuilder.pycnu�[����
{fc@s�dZddlmZmZmZddlmZmZmZddlm	Z	ddl
mZmZddl
mZddlTejZejZejZejjZejjZejjZejjZej�Zi	ejed�d	6ejed
�d6ejed�d
6ejed�d6ejed�d6ejed�d6ejed�d6ejed�d6ejed�d6Zdefd��YZd�Zd�Z dfd��YZ!eeefZ"d efd!��YZ#d"efd#��YZ$d$e$fd%��YZ%d&e$fd'��YZ&d(Z'd)e'Z(d*e!fd+��YZ)d,fd-��YZ*d.e*e!fd/��YZ+d0e*e)fd1��YZ,d2e-fd3��YZ.d4e!fd5��YZ/e0d6�Z1e0d7�Z2e0d8�Z3e0d9�Z4d:�Z5d;S(<s�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.
i����(t
xmlbuildertminidomtNode(tEMPTY_NAMESPACEtEMPTY_PREFIXtXMLNS_NAMESPACE(texpat(t
_append_childt_set_attribute_node(t
NodeFilter(t*tcdatatCDATAtenumerationtENUMtentitytENTITYtentitiestENTITIEStidtIDtidreftIDREFtidrefstIDREFStnmtokentNMTOKENtnmtokenstNMTOKENStElementInfocBsbeZdZd
d�Zd�Zd�Zd�Zd�Zd�Z	d	�Z
d
�Zd�ZRS(t
_attr_infot_modelttagNamecCs||_g|_||_dS(N(R RR(tselfR tmodel((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt__init__As		cCs|j|j|jfS(N(RRR (R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt__getstate__FscCs|\|_|_|_dS(N(RRR (R!tstate((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt__setstate__IscCs\xR|jD]G}|d|kr
|d}|ddkrBtdSt|dSq
q
WtjS(Nii����it(R(Rt
_typeinfo_mapRt_no_type(R!tanametinfott((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytgetAttributeTypeLs
cCstjS(N(RR)(R!tnamespaceURIt	localName((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytgetAttributeTypeNSVscCs:|jr2|jd}|tjjtjjfkStSdS(Ni(RRR"t
XML_CTYPE_ANYtXML_CTYPE_MIXEDtFalse(R!ttype((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytisElementContentYs
	
cCs(|jr |jdtjjkStSdS(Ni(RRR"tXML_CTYPE_EMPTYR3(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytisEmptyas	cCs6x/|jD]$}|d|kr
|ddkSq
WtS(Nii����R(RR3(R!R*R+((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytisIdgscCs|j||f�S(N(R8(R!teuritenametauriR*((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytisIdNSms(RRR N(
t__name__t
__module__t	__slots__tNoneR#R$R&R-R0R5R7R8R<(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR>s			
				cCs|j||�S(N(t_intern_setdefault(tbuilderts((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt_internqscCs�d|kst�|jd�}|j}t|�dkr�|\}}}|||�}d||f}|||�}|||�}n%|\}}t}|||�}}|||�|||fS(Nt is%s:%s(tAssertionErrortsplitRAtlenR(RBtnametpartstinternturit	localnametprefixtqname((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt_parse_ns_namets	tExpatBuildercBs
eZdZdd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(sPDocument builder that uses Expat to build a ParsedXML.DOM document
    instance.cCsw|dkrtj�}n||_|jjdk	rNt|jj�|_nd|_t|_d|_	|j
�dS(N(R@RtOptionst_optionstfiltertFilterVisibilityControllert_filterRt_finish_start_elementt_parsertreset(R!toptions((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#�s				cCs
tj�S(sCreate a new parser object.(RtParserCreate(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytcreateParser�scCsh|jsa|j�|_|jjj|_t|j_t|j_t|j_|j	|j�n|jS(s7Return the parser object, creating a new one if needed.(
RXR\RKt
setdefaultRAtTruetbuffer_texttordered_attributestspecified_attributestinstall(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt	getParser�s	cCs@tjtdd�|_|j|_|jj|_t|_dS(s6Free all data structures used during DOM construction.N(	ttheDOMImplementationtcreateDocumentRR@tdocumenttcurNodet
_elem_infoR3t_cdata(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRY�s
cCs�|j|_|j|_|j|_|j|_|jj	rK|j
|_n|j|_
|jjrr|j|_n|jjr�|j|_|j|_|j|_n|j|_|j|_|j|_|j|_|j|_ dS(s>Install the callbacks needed to build the DOM into the parser.N(!tstart_doctype_decl_handlertStartDoctypeDeclHandlertfirst_element_handlertStartElementHandlertend_element_handlertEndElementHandlert
pi_handlertProcessingInstructionHandlerRSRtentity_decl_handlertEntityDeclHandlertnotation_decl_handlertNotationDeclHandlertcommentstcomment_handlertCommentHandlertcdata_sectionststart_cdata_section_handlertStartCdataSectionHandlertend_cdata_section_handlertEndCdataSectionHandlertcharacter_data_handler_cdatatCharacterDataHandlertcharacter_data_handlertexternal_entity_ref_handlertExternalEntityRefHandlertxml_decl_handlertXmlDeclHandlertelement_decl_handlertElementDeclHandlertattlist_decl_handlertAttlistDeclHandler(R!tparser((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRb�s$cCs�|j�}t}ylxU|jd�}|s1Pn|j|d�|rc|jjrc|j|�nt}qW|jdt�Wntk
r�nX|j}|j	�d|_|S(sIParse a document from a file object, returning the document
        node.iiiti@N(RcR^treadtParseRftdocumentElementt
_setup_subsetR3tParseEscapeRYR@RX(R!tfileR�tfirst_buffertbuffertdoc((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt	parseFile�s$

	
	cCsa|j�}y!|j|t�|j|�Wntk
r@nX|j}|j�d|_|S(s<Parse a document from a string, returning the document node.N(	RcR�R^R�R�RfRYR@RX(R!tstringR�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytparseString�s
	
	cCsD|jjr@t�}|j|�|j�}||jj_ndS(s/Load the internal subset if there might be one.N(RftdoctypetInternalSubsetExtractorR�t	getSubsettinternalSubset(R!R�t	extractortsubset((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s
	
cCs�|jjj|||�}|j|_t|j|�||j_|jr�|jj|�tkr�d|j_|jj
d=d}d|j_d|j_
n|r�|dk	r�g|j_g|j_nd|j_d|j_|j|j_ndS(Ni����(RftimplementationtcreateDocumentTypet
ownerDocumentRR�RVt
acceptNodet
FILTER_REJECTR@t
childNodesRXRsRuRt_seqt	notationsRxRqtend_doctype_decl_handlertEndDoctypeDeclHandler(R!tdoctypeNametsystemIdtpublicIdthas_internal_subsetR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRj�s$!
cCsO|jjr|j|j_n|j|j_|jp<|jsKt	|_
ndS(N(RSRvRwRXRxRpRqRhRVRt_finish_end_element(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�s
cCs]|jj||�}t|j|�|jrY|jj|�tkrY|jj|�ndS(N(RftcreateProcessingInstructionRRgRVR�R�tremoveChild(R!ttargettdatatnode((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRps!cCs�|jj}|jrd|jrF|djtkrF|dj|�dS|jj|�}t	|_n�|r�|djt
kr�|d}|j|}|j}||d<|d<dSt
j�}|j}||d<|d<|j|d<t|j|�dS(Ni����R�t	nodeValueR�(RgR�Rit_cdata_continuetnodeTypetCDATA_SECTION_NODEt
appendDataRftcreateCDATASectionR^t	TEXT_NODER�t__dict__RtTextR(R!R�R�R�tvaluetd((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR~s&		

		
cCs�|jj}|rU|djtkrU|d}|j}|j||d<|d<dStj�}|j}|j||d<|d<|j|d<t	|j|�dS(Ni����R�R�R�(
RgR�R�R�R�R�RR�RfR(R!R�R�R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�(s
		
c
Cs�|r
dS|jjsdS|jj||||�}|dk	rf|jj|�}	|jj|	�n|jjjj	j|�|j
r�|j
j|�tkr�|jjjj	d=ndS(Ni����(
RSRRft_create_entityR@tcreateTextNodeR�tappendR�R�RVR�R�(
R!t
entityNametis_parameter_entityR�tbaseR�R�tnotationNameR�tchild((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRr5s!cCsl|jj|||�}|jjjjj|�|jrh|jj|�tkrh|jjjjd=ndS(Ni����(	Rft_create_notationR�R�R�R�RVR�t
FILTER_ACCEPT(R!R�R�R�R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRtGs!cCsZ|jj|�}t|j|�|jrV|jj|�tkrV|jj|�ndS(N(Rft
createCommentRRgRVR�R�R�(R!R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRwMs!cCst|_t|_dS(N(R^RiR3R�(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRzSs	cCst|_t|_dS(N(R3RiR�(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR|Ws	cCsdS(Ni((R!tcontextR�R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�[scCsK|jdkr%|jr%t|_n|j|j�_|j||�dS(N(RVR@RhRR�tstart_element_handlerRcRm(R!RIt
attributes((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRl^scCs�|jj|�}t|j|�||_|r�x�tdt|�d�D]�}tj||tdt
�}||d}|jdj}||d<|d<|j}||d<|d<|j|d<t
||�qJWn||jjk	r�|j|�ndS(NiiiR�R�R�R�(Rft
createElementRRgtrangeRHRtAttrRR@RR�R�RR�RW(R!RIR�R�titaR�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�ds 		
cCs�|jr�||jjkrdS|jj|�}|tkrJt|�n|tkrct|�ndS|j|_	|jj
|�|j�ndS(N(RVRfR�tstartContainerR�tRejectertFILTER_SKIPtSkippert
parentNodeRgR�tunlink(R!R�tfilt((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRWxs	

cCs&|j}|j|_|j|�dS(N(RgR�R�(R!RIRg((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRn�s	cCs�|jj|j�}|r.|j||�n|jr�||jjkrMdS|jj|�tkr�|j	j
|�|j�q�ndS(N(RhtgetR t_handle_white_text_nodesRVRfR�R�R�RgR�R�(R!RgR+((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s	cCs�|jjs|j�rdSg}x@|jD]5}|jtkr-|jj�r-|j|�q-q-Wx|D]}|j	|�qmWdS(N(
RStwhitespace_in_element_contentR5R�R�R�R�tstripR�R�(R!R�R+tLR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s

cCsY|jj|�}|dkr7t||�|j|<n|jdksLt�||_dS(N(RhR�R@RRRF(R!RIR"R+((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s
c	Csf|jj|�}|dkr:t|�}||j|<n|jjd|dd|d||g�dS(Ni(RhR�R@RRR�(R!telemRIR4tdefaulttrequiredR+((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s	cCsL||j_||j_|dkrH|r9t|j_qHt|j_ndS(Ni(RftversiontencodingR^t
standaloneR3(R!R�R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��sN( R=R>t__doc__R@R#R\RcRYRbR�R�R�RjR�RpR~R�RrRtRwRzR|R�RlR�RWRnR�R�R�R�R�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRQ�s:						
						
														RUcBs�eZdZdZd�Zd�Zd�Zieje	j
6eje	j6ej
e	j6eje	j6eje	j6eje	j6eje	j6eje	j6eje	j6eje	j6eje	j6eje	j 6Z!RS(soWrapper around a DOMBuilderFilter which implements the checks
    to make the whatToShow filter attribute work.RTcCs
||_dS(N(RT(R!RT((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#�scCsu|j|j}|jj|@rm|jj|�}|tkrGt�n|tkritdt	|��n|St
SdS(Ns)startContainer() returned illegal value: (t_nodetype_maskR�RTt
whatToShowR�tFILTER_INTERRUPTR�t_ALLOWED_FILTER_RETURNSt
ValueErrortreprR�(R!R�tmasktval((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s	cCs�|j|j}|jj|@r�|jj|�}|tkrGt�n|tkr�|j}x|j	D]}|j
|�qgWtS|tkr�t
dt|��n|StSdS(Ns%acceptNode() returned illegal value: (R�R�RTR�R�R�R�R�R�R�tappendChildR�R�R�R�R�(R!R�R�R�tparentR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s		(RT("R=R>R�R?R#R�R�R	tSHOW_ELEMENTRtELEMENT_NODEtSHOW_ATTRIBUTEtATTRIBUTE_NODEt	SHOW_TEXTR�tSHOW_CDATA_SECTIONR�tSHOW_ENTITY_REFERENCEtENTITY_REFERENCE_NODEtSHOW_ENTITYtENTITY_NODEtSHOW_PROCESSING_INSTRUCTIONtPROCESSING_INSTRUCTION_NODEtSHOW_COMMENTtCOMMENT_NODEt
SHOW_DOCUMENTt
DOCUMENT_NODEtSHOW_DOCUMENT_TYPEtDOCUMENT_TYPE_NODEtSHOW_DOCUMENT_FRAGMENTtDOCUMENT_FRAGMENT_NODEt
SHOW_NOTATIONt
NOTATION_NODER�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRU�s$		
	










tFilterCrutchcBseZdZd�ZRS(t_buildert_levelt
_old_startt_old_endcCsOd|_||_|j}|j|_|j|_|j|_|j|_dS(Ni(	RRRXRmRRoRR�Rn(R!RBR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#s			(RRRR(R=R>R?R#(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR	sR�cBs)eZdZd�Zd�Zd�ZRS(cCs>tj||�|j}xdD]}t||d�q WdS(NRqRxRR{R}R�(RqRxRR{R}R�(RR#RXtsetattrR@(R!RBR�RI((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#s	
cGs|jd|_dS(Ni(R(R!targs((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�$scGsZ|jdkrF|jj}|jj|�|j|_|j|_n|jd|_dS(Nii(RRRXRbRRmRRo(R!RR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRn's((R=R>R?R#R�Rn(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�s		R�cBs eZdZd�Zd�ZRS(cGsB|jj}|j|�|jj|k	r>|jd|_ndS(Ni(RRgRR(R!RR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�4s
cGs`|jdkr?|j|jj_|j|jj_d|_n|jd|_|j|�dS(Nii(RRRRXRmRRoR@(R!R((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRn:s((R=R>R?R�Rn(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�1s	s8http://xml.python.org/entities/fragment-builder/internals�<!DOCTYPE wrapper
  %%s [
  <!ENTITY fragment-builder-internal
    SYSTEM "%s">
%%s
]>
<wrapper %%s
>&fragment-builder-internal;</wrapper>tFragmentBuildercBsPeZdZdd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
RS(	s�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.
    cCsM|jtkr$||_||_n|j|_||_tj||�dS(N(R�R�toriginalDocumentR�R�RQR#(R!R�RZ((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#bs		cCstj|�d|_dS(N(RQRYR@tfragment(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRYks
cCs|j|j��S(sRParse a document fragment from a file object, returning the
        fragment node.(R�R�(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�osc	Cs�||_|j�}|jj}d}|r�|jp?|j�}|jrdd|j|jf}q�|jr�d|j}q�nd}|j�}t	|||f}y|j
|d�Wn|j��nX|j}|j�|S(sMParse a document fragment from a string, returning the
        fragment node.R�sPUBLIC "%s" "%s"sSYSTEM "%s"i(
t_sourceRcR
R�R�t_getDeclarationsR�R�t_getNSattrst_FRAGMENT_BUILDER_TEMPLATER�RYR(	R!R�R�R�tidentR�tnsattrsRfR((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�ts,			
	
cCs�|jjj}d}|r�x�t|jj�D]v}|jj|�}|rY|d}nd||jf}|jr�d||j|j	f}q.d||j	f}q.Wx�t|j
j�D]�}|j
j|�}|r�|d}nd||jf}|jrd||j|j	f}n5|j	r=d||j	f}nd	||jjf}|j
rrd
||j
f}n|d}q�Wn|S(s�Re-create the internal subset from the DocumentType node.

        This is only needed if we don't already have the
        internalSubset as a string.
        R�s
  s%s<!NOTATION %ss!%s PUBLIC "%s"
             "%s">s%s SYSTEM "%s">s
%s<!ENTITY %ss %s PUBLIC "%s"
             "%s"s%s SYSTEM "%s"s%s "%s"s%s NOTATION %st>(R�R�R�R�R�tlengthtitemtnodeNameR�R�Rt
firstChildR�R�(R!R�RCR�tnotationR((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR
�s6
	
			cCsdS(NR�((R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�scCs�|tkr�|j}|j}|jj|�}|j|_|jj�|_|j|_z|j|j	d�Wd||_||_d|_	XdStj|||||�SdS(Nii����(
t$_FRAGMENT_BUILDER_INTERNAL_SYSTEM_IDRfRgRXtExternalEntityParserCreateR
tcreateDocumentFragmentRR�RR@RQR�(R!R�R�R�R�told_documenttold_cur_nodeR�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s				
N(R=R>R�R@R#RYR�R�R
RR�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR	Ys					$	t
NamespacescBsDeZdZd�Zd�Zd�Zd�Zd�Zd�ZRS(s7Mix-in class for builders; adds support for namespaces.cCs
g|_dS(N(t_ns_ordered_prefixes(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt_initNamespaces�scCstjdd�}t|_|S(s'Create a new namespace-handling parser.tnamespace_separatorRE(RR[R^tnamespace_prefixes(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR\�s	cCs/tj||�|jjr+|j|_ndS(s.Insert the namespace-handlers onto the parser.N(RQRbRStnamespace_declarationststart_namespace_decl_handlertStartNamespaceDeclHandler(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRb�scCs|jj||f�dS(s/Push this namespace declaration on our storage.N(RR�(R!RNRL((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR#�scCs�d|kr*t||�\}}}}nt}|}d}t}tj||||�}|j|_t|j	|�||_	|j
rIx�|j
D]�\}}|r�tjt|d|�t
|d�}ntjdt
dt�}|jdj}	||	d<|	d<|j}	||	d<|	d<|j|	d<t||�q�W|j
2n|r�|j}
|j}xtdt|�d	�D]}||}
||d
}d|
kr�t||
�\}}}}tj||||�}||
|<||||f<n2tj|
t|
t�}||
|
<||t|
f<|jdj}	||	d<|	d<|j}	|j|	d<||	d<|	d<||	d<qzWndS(NREsxmlns:txmlnsiR�R�R�R�iitownerElement(RPRR@RRtElementRfR�RRgRR�RDRR�R�Rt_attrst_attrsNSR�RH(R!RIR�RLRMRNROR�R�R�R(R)R�R*R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��sZ			

		


	
cCs�|j}d|krlt||�\}}}}|j|kr]|j|kr]|j|ks�td��n6|j|ks�td��|jtks�td��|j|_|j	|�dS(NREs$element stack messed up! (namespace)s&element stack messed up - bad nodeNames*element stack messed up - bad namespaceURI(
RgRPR.R/RNRFRRR�R�(R!RIRgRLRMRNRO((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRn!s			(	R=R>R�RR\RbR#R�Rn(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�s					:tExpatBuilderNScBseZdZd�ZRS(s*Document builder that supports namespaces.cCstj|�|j�dS(N(RQRYR(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRY5s
(R=R>R�RY(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR*2stFragmentBuilderNScBs eZdZd�Zd�ZRS(s*Fragment builder that supports namespaces.cCstj|�|j�dS(N(R	RYR(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRY=s
cCs�d}|j}g}x�|r�t|d�r�x�|jj�D]p\}}||kr[q=n|j|�|r{d|}nd}|r�d|||f}q=d||f}q=Wn|j}qW|S(sNReturn string of namespace attributes from this element and
        ancestors.R�t_ns_prefix_urisxmlns:R%s%s
    %s='%s's %s='%s'(R�thasattrR,titemsR�R�(R!tattrsR�R�RNRLtdeclname((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRAs"		


(R=R>R�RYR(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR+:s	R�cBseZdZRS(sEException raised to short-circuit parsing in InternalSubsetExtractor.(R=R>R�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�_sR�cBsSeZdZdZd�Zd�Zd�Zd�Zd�Z	d�Z
d�ZRS(	sBXML processor which can rip out the internal document type subset.cCs|jS(s'Return the internal subset as a string.(R�(R!((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�hscCs,ytj||�Wntk
r'nXdS(N(RQR�R�(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�ls
cCs,ytj||�Wntk
r'nXdS(N(RQR�R�(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�rs
cCs|j|_|j|_dS(N(RjRkR�Rm(R!R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRbxscCsF|r9|j�}g|_|jj|_|j|_n	t��dS(N(RcR�R�tDefaultHandlerR�R�R�(R!RIR�R�R�R�((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyRj|s	cCs@dj|j�jdd�jdd�}||_t��dS(NR�s
s
s
(tjoinR�treplaceR�(R!RC((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s*	cCs
t��dS(N(R�(R!RIR/((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��sN(R=R>R�R@R�R�R�R�RbRjR�R�(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR�cs					
	cCsp|rt�}n	t�}t|t�r]t|d�}z|j|�}Wd|j�Xn|j|�}|S(s{Parse a document, returning the resulting Document node.

    'file' may be either a file name or an open file object.
    trbN(R*RQt
isinstancetStringTypestopenR�tclose(R�t
namespacesRBtfptresult((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytparse�s	cCs(|rt�}n	t�}|j|�S(sOParse a document from a string, returning the resulting
    Document node.
    (R*RQR�(R�R9RB((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyR��s	cCsv|rt|�}nt|�}t|t�rct|d�}z|j|�}Wd|j�Xn|j|�}|S(s�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.
    R4N(R+R	R5R6R7R�R8(R�R�R9RBR:R;((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt
parseFragment�scCs.|rt|�}nt|�}|j|�S(s�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�R9RB((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytparseFragmentString�scCs!|jrt|�St|�SdS(s,Create a builder based on an Options object.N(R9R*RQ(RZ((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pytmakeBuilder�s	
N(6R�txml.domRRRRRRtxml.parsersRtxml.dom.minidomRRtxml.dom.NodeFilterR	txml.dom.minicompatR�R�R�tDOMBuilderFilterR�R�R�R�tgetDOMImplementationRdtTypeInfoR@R(tobjectRRDRPRQR�RURR�R�RRR	RR*R+t	ExceptionR�R�R^R<R�R=R>R?(((s,/usr/lib64/python2.7/xml/dom/expatbuilder.pyt<module>s`
			3		�I:ud%,PK�"[��iOOdom/__init__.pycnu�[����
{fc@s:dZdd=d��YZdZdZdZdZdZdZd	Zd
Z	dZ
dZd
ZdZ
dZdZdZdZdefd��YZdefd��YZdefd��YZdefd��YZdefd��YZdefd��YZdefd ��YZd!efd"��YZd#efd$��YZd%efd&��YZd'efd(��YZd)efd*��YZd+efd,��YZd-efd.��YZ d/efd0��YZ!d1efd2��YZ"d3efd4��YZ#d5d>d6��YZ$d7Z%d8Z&d9Z'd<Z)d<Z*d:d;l+m,Z,m-Z-d<S(?s
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.

tNodecBsVeZdZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZ
dZRS(
s$Class giving the NodeType constants.iiiiiiiii	i
ii(t__name__t
__module__t__doc__tELEMENT_NODEtATTRIBUTE_NODEt	TEXT_NODEtCDATA_SECTION_NODEtENTITY_REFERENCE_NODEtENTITY_NODEtPROCESSING_INSTRUCTION_NODEtCOMMENT_NODEt
DOCUMENT_NODEtDOCUMENT_TYPE_NODEtDOCUMENT_FRAGMENT_NODEt
NOTATION_NODE(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRs	iiiiiiiii	i
iii
iiitDOMExceptioncBs eZdZd�Zd�ZRS(smAbstract base class for DOM exceptions.
    Exceptions with specific codes are specializations of this class.cOs5|jtkrtd��ntj|||�dS(Ns0DOMException should not be instantiated directly(t	__class__RtRuntimeErrort	Exceptiont__init__(tselftargstkw((s(/usr/lib64/python2.7/xml/dom/__init__.pyRAscCs|jS(N(tcode(R((s(/usr/lib64/python2.7/xml/dom/__init__.pyt	_get_codeGs(RRRRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR=s	tIndexSizeErrcBseZeZRS((RRtINDEX_SIZE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRKstDomstringSizeErrcBseZeZRS((RRtDOMSTRING_SIZE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRNstHierarchyRequestErrcBseZeZRS((RRtHIERARCHY_REQUEST_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRQstWrongDocumentErrcBseZeZRS((RRtWRONG_DOCUMENT_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR TstInvalidCharacterErrcBseZeZRS((RRtINVALID_CHARACTER_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR"WstNoDataAllowedErrcBseZeZRS((RRtNO_DATA_ALLOWED_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR$ZstNoModificationAllowedErrcBseZeZRS((RRtNO_MODIFICATION_ALLOWED_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR&]stNotFoundErrcBseZeZRS((RRt
NOT_FOUND_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR(`stNotSupportedErrcBseZeZRS((RRtNOT_SUPPORTED_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR*cstInuseAttributeErrcBseZeZRS((RRtINUSE_ATTRIBUTE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR,fstInvalidStateErrcBseZeZRS((RRtINVALID_STATE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR.ist	SyntaxErrcBseZeZRS((RRt
SYNTAX_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR0lstInvalidModificationErrcBseZeZRS((RRtINVALID_MODIFICATION_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR2ostNamespaceErrcBseZeZRS((RRt
NAMESPACE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR4rstInvalidAccessErrcBseZeZRS((RRtINVALID_ACCESS_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR6ust
ValidationErrcBseZeZRS((RRtVALIDATION_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR8xstUserDataHandlercBs&eZdZdZdZdZdZRS(sBClass giving the operation constants for UserDataHandler.handle().iiii(RRRtNODE_CLONEDt
NODE_IMPORTEDtNODE_DELETEDtNODE_RENAMED(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR:{s
s$http://www.w3.org/XML/1998/namespaceshttp://www.w3.org/2000/xmlns/shttp://www.w3.org/1999/xhtmli����(tgetDOMImplementationtregisterDOMImplementationN(((.RRRRRR!R#R%R'R)R+R-R/R1R3R5R7R9RRRRRR R"R$R&R(R*R,R.R0R2R4R6R8R:t
XML_NAMESPACEtXMLNS_NAMESPACEtXHTML_NAMESPACEtNonetEMPTY_NAMESPACEtEMPTY_PREFIXtdomregR?R@(((s(/usr/lib64/python2.7/xml/dom/__init__.pyt<module>sR
PK�"[S�p�;�;dom/xmlbuilder.pycnu�[����
{fc@s�dZddlZddlZddlmZdddgZddd��YZddd	��YZd
�Z	de
fd��YZde
fd��YZd
dd��YZ
[ddd��YZddd��YZdS(s4Implementation of the DOM Level 3 'LS-Load' feature.i����N(t
NodeFiltert
DOMBuildertDOMEntityResolvertDOMInputSourcetOptionscBs�eZdZdZeZeZeZeZ	eZ
eZeZeZ
eZeZeZeZeZeZeZeZdZdZRS(s�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.
    iN(t__name__t
__module__t__doc__t
namespacestTruetnamespace_declarationstFalset
validationtexternal_parameter_entitiestexternal_general_entitiestexternal_dtd_subsettvalidate_if_schematvalidatetdatatype_normalizationtcreate_entity_ref_nodestentitiestwhitespace_in_element_contenttcdata_sectionstcommentstcharset_overrides_xml_encodingtinfosettsupported_mediatypes_onlytNoneterrorHandlertfilter(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRs(cBs�eZd#Zd#Zd#ZdZdZdZdZ	eeee	fZ
d�Zd�Zd�Z
d�Zd�Zd	�Zd
�Zd�Zd�Zd
�Zid$gd%6d&gd'6d(gd)6d*gd+6d,gd-6d.gd/6d0gd16d2gd36d4gd56d6gd76d8d9gd:6d;gd<6d=gd>6d?gd@6dAgdB6dCgdD6dEgdF6dGgdH6dIgdJ6dKgdL6gdM6dNdOdPdQdRdSdTdUdVg	dW6dXgdY6dZgd[6d\gd]6Zd�Zd�Zd �Zd!�Zd"�ZRS(^iiiicCst�|_dS(N(Rt_options(tself((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt__init__9scCs|jS(N(tentityResolver(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_entityResolver<scCs
||_dS(N(R!(RR!((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_entityResolver>scCs|jS(N(R(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_errorHandlerAscCs
||_dS(N(R(RR((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_errorHandlerCscCs|jS(N(R(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_filterFscCs
||_dS(N(R(RR((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_filterHscCs�|j|�r�|rdpd}y|jt|�|f}Wn*tk
rjtjjd|f��q�XxF|D]\}}t|j||�qrWntjj	dt
|���dS(Niisunsupported feature: %rsunknown feature: (tsupportsFeaturet	_settingst_name_xformtKeyErrortxmltdomtNotSupportedErrtsetattrRtNotFoundErrtrepr(Rtnametstatetsettingstvalue((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
setFeatureKs
	cCst|jt|��S(N(thasattrRR*(RR2((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR(YscCs+t|�|rdpdf}||jkS(Nii(R*R)(RR2R3tkey((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
canSetFeature\sR
iRRR
RRRRRRRRRRRcCs�t|�}yt|j|�SWn�tk
r�|dkr�|j}|jo�|jo�|jo�|jo�|jp�|j	p�|j
p�|jp�|jSt
jjdt|���nXdS(NRsfeature %s not known(R*tgetattrRtAttributeErrorRRRRR
RRRRR,R-R0R1(RR2txnametoptions((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
getFeature�s 
									cCsC|jr!|jjd|�}nt�jd|�}|j|�S(N(R!t
resolveEntityRRtparse(Rturitinput((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytparseURI�s	cCsytj|j�}|j|_|j|_|j}|dkri|jriddl}|j|j�}n|j	||�S(Ni����(
tcopyRRRt
byteStreamRtsystemIdturllib2turlopent_parse_bytestream(RRBR=tfpRG((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR@�s	cCs.||jkrtd��ntd��dS(Nsnot a legal actionsHaven't written this yet...(t_legal_actionst
ValueErrortNotImplementedError(RRBtcnodetaction((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytparseWithContext�scCs.ddl}|jjj|�}|j|�S(Ni����(txml.dom.expatbuilderR-texpatbuildertmakeBuildert	parseFile(RtstreamR=R,tbuilder((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRI�sN(R
i(R
i(R
i(R
i(Ri(Ri(Ri(Ri(Ri(Ri(R
i(R
i(R
i(R
i(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(R
i(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(Ri(RRRR!RRtACTION_REPLACEtACTION_APPEND_AS_CHILDRENtACTION_INSERT_AFTERtACTION_INSERT_BEFORERKR R"R#R$R%R&R'R6R(R9R)R>RCR@RPRI(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR,sv											























			
	cCs|j�jdd�S(Nt-t_(tlowertreplace(R2((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR*�scBs2eZdZd�Zd�Zd�Zd�ZRS(t_openerc
Cs�|dk	st�t�}||_||_|j�j|�|_|j|�|_	ddl
}ddl}|j|�}|\}}}	}
}}|	r�|	jd�r�|j
|	�d}	|||	|
||f}|j|�|_n|S(Ni����t/(RtAssertionErrorRtpublicIdRFt_get_openertopenREt_guess_media_encodingtencodingt	posixpathturlparsetendswithtdirnamet
urlunparsetbaseURI(
RRbRFtsourceRgRhtpartstschemetnetloctpathtparamstquerytfragment((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR?�s			cCs6y|jSWn$tk
r1|j�|_|jSXdS(N(R_R;t_create_opener(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRc�s

cCsddl}|j�S(Ni����(RGtbuild_opener(RRG((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRu�scCsb|jj�}d|kr^x@|j�D]/}|jd�r(|jdd�dj�Sq(WndS(NsContent-Typescharset=t=i(REtinfotgetplistt
startswithtsplitR](RRmRxtparam((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRe�s
(R_(RRt	__slots__R?RcRuRe(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR�s
			cBs�eZdZd�Zd�Zd	�Zd
�Zd�Zd�Zd
�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd�Zd�ZRS(REtcharacterStreamt
stringDataRfRbRFRlcCsCd|_d|_d|_d|_d|_d|_d|_dS(N(RRER~RRfRbRFRl(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR s						cCs|jS(N(RE(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_byteStream
scCs
||_dS(N(RE(RRE((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_byteStreamscCs|jS(N(R~(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_characterStreamscCs
||_dS(N(R~(RR~((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_characterStreamscCs|jS(N(R(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_stringDatascCs
||_dS(N(R(Rtdata((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_stringDatascCs|jS(N(Rf(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_get_encodingscCs
||_dS(N(Rf(RRf((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_set_encodingscCs|jS(N(Rb(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_get_publicId!scCs
||_dS(N(Rb(RRb((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_set_publicId#scCs|jS(N(RF(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_get_systemId&scCs
||_dS(N(RF(RRF((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_set_systemId(scCs|jS(N(Rl(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_baseURI+scCs
||_dS(N(Rl(RRA((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_set_baseURI-s(RER~RRfRbRFRl(RRR}R R�R�R�R�R�R�R�R�R�R�R�R�R�R�(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyRs"															tDOMBuilderFiltercBsJeZdZdZdZdZdZejZ	d�Z
d�Zd�ZRS(sSElement filter which can be used to tailor construction of
    a DOM instance.
    iiiicCs|jS(N(t
whatToShow(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt_get_whatToShowBscCs|jS(N(t
FILTER_ACCEPT(Rtelement((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
acceptNodeEscCs|jS(N(R�(RR�((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytstartContainerHs(
RRRR�t
FILTER_REJECTtFILTER_SKIPtFILTER_INTERRUPTRtSHOW_ALLR�R�R�R�(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR�1s			t
DocumentLScBsJeZdZeZd�Zd�Zd�Zd�Zd�Z	d�Z
RS(s=Mixin to create documents that conform to the load/save spec.cCstS(N(R(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_get_asyncSscCs|rtjjd��ndS(Ns.asynchronous document loading is not supported(R,R-R.(Rtasync((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt
_set_asyncUs	cCstd��dS(Ns'haven't figured out what this means yet(RM(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytabortZscCstd��dS(Nshaven't written this yet(RM(RRA((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytload`scCstd��dS(Nshaven't written this yet(RM(RRm((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytloadXMLcscCs@|dkr|}n!|j|k	r6tjj��n|j�S(N(Rt
ownerDocumentR,R-tWrongDocumentErrttoxml(Rtsnode((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytsaveXMLfs
	(RRRRR�R�R�R�R�R�R�(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR�Ns					tDOMImplementationLScBs/eZdZdZd�Zd�Zd�ZRS(iicCsk|dk	r!tjjd��n||jkr7t�S||jkr[tjjd��ntd��dS(NsschemaType not yet supporteds'asynchronous builders are not supportedsunknown value for mode(RR,R-R.tMODE_SYNCHRONOUSRtMODE_ASYNCHRONOUSRL(Rtmodet
schemaType((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytcreateDOMBuilderrs		cCstd��dS(Ns-the writer interface hasn't been written yet!(RM(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytcreateDOMWriter}scCst�S(N(R(R((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pytcreateDOMInputSource�s(RRR�R�R�R�R�(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyR�ns
		((((((RRDtxml.domR,txml.dom.NodeFilterRt__all__RRR*tobjectRRR�R�R�(((s*/usr/lib64/python2.7/xml/dom/xmlbuilder.pyt<module>s �	,1 PK�"[[s#33dom/pulldom.pyonu�[����
{fc@sddlZddlZddlZyejejgZWnek
rYejgZnXdZdZ	dZ
dZdZdZ
dZd	Zd
ejjfd��YZddd
��YZddd��YZdefd��YZdZddd�Zdd�ZdS(i����Nt
START_ELEMENTtEND_ELEMENTtCOMMENTtSTART_DOCUMENTtEND_DOCUMENTtPROCESSING_INSTRUCTIONtIGNORABLE_WHITESPACEt
CHARACTERStPullDOMcBs�eZdZdZdd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd�Zd�Z
d	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�ZRS(cCs�ddlm}||_ddg|_|j|_g|_|jj|_y|jj	|_	Wnt
k
rrnXid|6g|_|jd|_g|_
dS(Ni����(t
XML_NAMESPACEtxml(txml.domR	tdocumentFactorytNonet
firstEventt	lastEventtelementStacktappendtpushtpoptAttributeErrort_ns_contextst_current_contexttpending_events(tselfRR	((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt__init__s		
cCs|jd}|jd=|S(Ni����(R(Rtresult((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR's

cCs
||_dS(N(t_locator(Rtlocator((s'/usr/lib64/python2.7/xml/dom/pulldom.pytsetDocumentLocator,scCsgt|d�sg|_n|jj|p-d|f�|jj|jj��|pYd|j|<dS(Nt_xmlns_attrstxmlns(thasattrRRRRtcopyR
(Rtprefixturi((s'/usr/lib64/python2.7/xml/dom/pulldom.pytstartPrefixMapping/s
cCs|jj�|_dS(N(RRR(RR"((s'/usr/lib64/python2.7/xml/dom/pulldom.pytendPrefixMapping6scCs;d}t|dd�}|dk	rZx'|D]\}}||j||f<q+Wg|_n|\}}	|r�|dkr�|j|}
|
r�|
d|	}q�|	}n|jr�|jj||�}q|j||�}n0|jr�|jj|	�}n|jd|	�}x�|j	�D]�\}}|\}}
||kr�|
dkrQ|
}n
d|
}|jj
||�}|j|�nt|r�|j|}
|
r�|
d|
}n|
}|jj
||�}|j|�n|jj|
�}|j
|�||_qWt|fdg|jd<|jd|_|j|�dS(Nshttp://www.w3.org/2000/xmlns/Rt:Rsxmlns:i(tgetattrR
t_attrsRRtdocumenttcreateElementNSt
buildDocumentt
createElementtitemstcreateAttributeNStsetAttributeNodeNStcreateAttributetsetAttributeNodetvalueRRR(RtnamettagNametattrst	xmlns_uritxmlns_attrstanameR2R#t	localnameR"tnodeta_urita_localnametqnametattr((s'/usr/lib64/python2.7/xml/dom/pulldom.pytstartElementNS9sP
				



cCs3t|j�fdg|jd<|jd|_dS(Ni(RRR
R(RR3R4((s'/usr/lib64/python2.7/xml/dom/pulldom.pytendElementNSrscCs�|jr|jj|�}n|jd|�}xB|j�D]4\}}|jj|�}||_|j|�q=Wt|fdg|j	d<|j	d|_	|j
|�dS(Ni(R)R,R+R
R-R0R2R1RRR(RR3R5R:R8R2R>((s'/usr/lib64/python2.7/xml/dom/pulldom.pytstartElementvs		cCs3t|j�fdg|jd<|jd|_dS(Ni(RRR
R(RR3((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt
endElement�scCsm|jrG|jj|�}t|fdg|jd<|jd|_n"t|fdg}|jj|�dS(Ni(R)t
createCommentRR
RRR(RtsR:tevent((s'/usr/lib64/python2.7/xml/dom/pulldom.pytcomment�s	cCss|jrJ|jj||�}t|fdg|jd<|jd|_n%t||fdg}|jj|�dS(Ni(R)tcreateProcessingInstructionRR
RRR(RttargettdataR:RE((s'/usr/lib64/python2.7/xml/dom/pulldom.pytprocessingInstruction�s	cCs?|jj|�}t|fdg|jd<|jd|_dS(Ni(R)tcreateTextNodeRR
R(RtcharsR:((s'/usr/lib64/python2.7/xml/dom/pulldom.pytignorableWhitespace�scCs?|jj|�}t|fdg|jd<|jd|_dS(Ni(R)RKRR
R(RRLR:((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt
characters�scCs7|jdkr3ddl}|jjjj|_ndS(Ni����(RR
txml.dom.minidomtdomtminidomtDocumenttimplementation(RR
((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt
startDocument�sc	Cs8|jj||d�}||_t|fdg|jd<|jd|_|j|�x�|jD]�}|ddtkr�|d\}}}|jj	||�}t|f|d<nX|ddt
kr�|jj|dd�}t
|f|d<ntd|dd��||jd<||_qaWd|_|j
S(NiisUnknown pending event (RtcreateDocumentR
R)RRRRRRGRRCtAssertionErrort
firstChild(	RR#ttagnameR:tet_RHRItn((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR+�s$	


	cCs*t|jfdg|jd<|j�dS(Ni(RR)R
RR(R((s'/usr/lib64/python2.7/xml/dom/pulldom.pytendDocument�scCs
d|_dS(s.clear(): Explicitly release parsing structuresN(R
R)(R((s'/usr/lib64/python2.7/xml/dom/pulldom.pytclear�sN(t__name__t
__module__R
RR)RRRR$R%R?R@RARBRFRJRMRNRTR+R\R](((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRs&					9												tErrorHandlercBs#eZd�Zd�Zd�ZRS(cCs	|GHdS(N((Rt	exception((s'/usr/lib64/python2.7/xml/dom/pulldom.pytwarning�scCs
|�dS(N((RRa((s'/usr/lib64/python2.7/xml/dom/pulldom.pyterror�scCs
|�dS(N((RRa((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt
fatalError�s(R^R_RbRcRd(((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR`�s		tDOMEventStreamcBsbeZd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�ZRS(
cCsJ||_||_||_t|jd�s<|j|_n|j�dS(Ntfeed(tstreamtparsertbufsizeR t_slurptgetEventtreset(RRgRhRi((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR�s			cCs?t�|_|jjtjjjd�|jj|j�dS(Ni(	RtpulldomRht
setFeatureR
tsaxthandlertfeature_namespacestsetContentHandler(R((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRl�scCs |j�}|r|St�dS(N(Rkt
IndexError(Rtpostrc((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt__getitem__�scCs |j�}|r|St�dS(N(Rkt
StopIteration(RRu((s'/usr/lib64/python2.7/xml/dom/pulldom.pytnext�scCs|S(N((R((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt__iter__�scCs�|j�}|g}x�|r�|\}}||kr:dS|tkrZ|dj|�n|tkrv|j|�n|tkr�|d=n|j�}qWdS(Ni����(RkRtappendChildRR(RR:REtparentsttokentcur_node((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt
expandNode�s		
cCs�|jjds%|jj|j_nxP|jjdsw|jj|j�}|sd|jj�dS|jj	|�q(W|jjdd}|jjdd|jjd<|S(Nii(
RmRRRgtreadRiRhtcloseR
Rf(RtbufRu((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRk�s
cCs)|jj|j�|j|_|j�S(s� 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).
        (RhtparseRgt_emitRk(R((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRjscCs6|jjdd}|jjdd|jjd<|S(sn Fallback replacement for getEvent() that emits
            the events that _slurp() read previously.
        ii(RmR(RRu((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR�scCs)|jj�|`d|_d|_dS(s+clear(): Explicitly release parsing objectsN(RmR]R
RhRg(R((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR] s
	(R^R_RRlRvRxRyR~RkRjR�R](((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRe�s								
	tSAX2DOMcBs5eZd�Zd�Zd�Zd�Zd�ZRS(cCsAtj||||�|jd}|jd}|j|�dS(Ni����i����(RR?RRz(RR3R4R5tcurNodet
parentNode((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR?)s

cCs>tj|||�|jd}|jd}|j|�dS(Ni����i����(RRARRz(RR3R5R�R�((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRA/s

cCsBtj|||�|jdd}|jd}|j|�dS(Niii����(RRJRRRz(RRHRIR:R�((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRJ5s
cCs?tj||�|jdd}|jd}|j|�dS(Niii����(RRMRRRz(RRLR:R�((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRM;s
cCs?tj||�|jdd}|jd}|j|�dS(Niii����(RRNRRRz(RRLR:R�((s'/usr/lib64/python2.7/xml/dom/pulldom.pyRNAs
(R^R_R?RARJRMRN(((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR�'s
				iiicCsd|dkrt}nt|�tkr6t|�}n|}|sTtjj�}nt|||�S(N(	R
tdefault_bufsizettypet_StringTypestopenR
Rotmake_parserRe(tstream_or_stringRhRiRg((s'/usr/lib64/python2.7/xml/dom/pulldom.pyR�Js	cCsxyddlm}Wn!tk
r7ddlm}nXt|�}||�}|shtjj�}nt|||�S(Ni����(tStringIO(t	cStringIOR�tImportErrortlenR
RoR�Re(tstringRhR�RiR�((s'/usr/lib64/python2.7/xml/dom/pulldom.pytparseStringUs
((i@i�?(txml.saxR
txml.sax.handlerttypest
StringTypetUnicodeTypeR�RRRRRRRRRRotContentHandlerRR`ReR�R�R
R�R�(((s'/usr/lib64/python2.7/xml/dom/pulldom.pyt<module>s*
�U!PK�"[���G|�|�etree/ElementTree.pycnu�[����
{fc@s>dddddddddd	d
ddd
dddddddgZdZddlZddlZddlZdefd��YZyddlmZWne	k
r�e�ZnXd	e
fd��YZd�Zdefd��YZ
e
ZZid�Zed �Zed!�ZeZdefd"��YZdefd#��YZed$�Zd%�Zd&d'd(d)d*d+d,d-d.d/d0d1d2f
Zyee�ZWnek
r�nXd3�Zd4�Zied56ed66ed76Zd8�Zid5d96d6d:6d;d<6d=d>6d?d@6dAdB6dCdD6Z dE�Z!dF�Z"dG�Z#dH�Z$dI�Z%eedJ�Z&eedK�Z'dL�Z(edM�Z)eedN�Z*dOefdP��YZ+edQ�Z,edR�Z-e,Z.edS�Z/defdT��YZ0dUgZ1defdV��YZ2e2Z3yddWl4m5Z5e5edX<Wne	k
r9nXdS(YtCommenttdumptElementtElementTreet
fromstringtfromstringlistt	iselementt	iterparsetparset
ParseErrortPItProcessingInstructiontQNamet
SubElementttostringttostringlisttTreeBuildertVERSIONtXMLt	XMLParsertXMLTreeBuilders1.3.0i����Nt_SimpleElementPathcBs;eZdd�Zddd�Zdd�Zdd�ZRS(cCs(x!|D]}|j|kr|SqWdS(N(ttagtNone(tselftelementRt
namespacestelem((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytfindjs
cCs/|j||�}|dkr"|S|jp.dS(Nt(RRttext(RRRtdefaultRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytfindtextosccsb|d dkr6x#|j|d�D]}|Vq$Wnx%|D]}|j|kr=|Vq=q=WdS(Nis.//(titerR(RRRRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytiterfindts
cCst|j|||��S(N(tlistR"(RRRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytfindall{sN(t__name__t
__module__RRR R"R$(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRhsi(tElementPathcBseZRS((R%R&(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR	�scCst|t�pt|d�S(NR(t
isinstanceRthasattr(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scBs%eZdZdZdZdZid�Zd�Zd�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd	�Zd
�Zd�Zd�Zd
�Zdd�Zddd�Zdd�Zdd�Zd�Zdd�Zd�Zd�Zd�Zdd�Zdd�Zd�Z RS(cKs8|j�}|j|�||_||_g|_dS(N(tcopytupdateRtattribt	_children(RRR,textra((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__init__�s

		cCsdt|j�t|�fS(Ns<Element %s at 0x%x>(treprRtid(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__repr__�scCs|j||�S(N(t	__class__(RRR,((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytmakeelement�scCs;|j|j|j�}|j|_|j|_||(|S(N(R4RR,Rttail(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR*�s
cCs
t|j�S(N(tlenR-(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__len__�scCs)tjdtdd�t|j�dkS(NsyThe behavior of this method will change in future versions.  Use specific 'len(elem)' or 'elem is not None' test instead.t
stacklevelii(twarningstwarnt
FutureWarningR6R-(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__nonzero__�s
cCs|j|S(N(R-(Rtindex((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__getitem__	scCs||j|<dS(N(R-(RR=R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__setitem__scCs|j|=dS(N(R-(RR=((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__delitem__!scCs|jj|�dS(N(R-tappend(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRA,scCs|jj|�dS(N(R-textend(Rtelements((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRB6scCs|jj||�dS(N(R-tinsert(RR=R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRD@scCs|jj|�dS(N(R-tremove(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyREOscCstjdtdd�|jS(NsaThis method will be removed in future versions.  Use 'list(elem)' or iteration over elem instead.R8i(R9R:tDeprecationWarningR-(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytgetchildrenZs
cCstj|||�S(N(R'R(RtpathR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRjscCstj||||�S(N(R'R (RRHRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR yscCstj|||�S(N(R'R$(RRHR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR$�scCstj|||�S(N(R'R"(RRHR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR"�scCs*|jj�g|_d|_|_dS(N(R,tclearR-RRR5(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRI�s
	cCs|jj||�S(N(R,tget(RtkeyR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRJ�scCs||j|<dS(N(R,(RRKtvalue((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytset�scCs
|jj�S(N(R,tkeys(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRN�scCs
|jj�S(N(R,titems(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRO�sccso|dkrd}n|dks0|j|kr8|Vnx0|jD]%}x|j|�D]}|VqXWqBWdS(Nt*(RRR-R!(RRte((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR!�s	cCs)tjdtdd�t|j|��S(NsbThis method will be removed in future versions.  Use 'elem.iter()' or 'list(elem.iter())' instead.R8i(R9R:tPendingDeprecationWarningR#R!(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytgetiterator�s
ccs�|j}t|t�r)|dk	r)dS|jr=|jVnx>|D]6}x|j�D]}|VqWW|jrD|jVqDqDWdS(N(RR(t
basestringRRtitertextR5(RRRQts((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRU�s		
		N(!R%R&RRR,RR5R/R2R4R*R7R<R>R?R@RARBRDRERGRR R$R"RIRJRMRNROR!RSRU(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s<
	
						
			
	
				
		
	
cKs<|j�}|j|�|j||�}|j|�|S(N(R*R+R4RA(tparentRR,R.R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR
s


cCstt�}||_|S(N(RRR(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR"s	cCs6tt�}||_|r2|jd||_n|S(Nt (RRR(ttargetRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR1s
	cBs/eZdd�Zd�Zd�Zd�ZRS(cCs&|rd||f}n||_dS(Ns{%s}%s(R(Rttext_or_uriR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR/EscCs|jS(N(R(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__str__IscCs
t|j�S(N(thashR(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__hash__KscCs2t|t�r"t|j|j�St|j|�S(N(R(RtcmpR(Rtother((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__cmp__MsN(R%R&RR/R[R]R`(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRDs		cBs�eZddd�Zd�Zd�Zdd�Zdd�Zdd�Zdd�Z	ddd�Z
dd�Zdd	�Zddddd
�Z
d�ZRS(
cCs#||_|r|j|�ndS(N(t_rootR(RRtfile((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR/_s	cCs|jS(N(Ra(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytgetrootkscCs
||_dS(N(Ra(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt_setrootuscCs�t}t|d�s-t|d�}t}nzb|sKtdt��}nx*|jd�}|sgPn|j|�qNW|j�|_	|j	SWd|r�|j�nXdS(NtreadtrbRYi(
tFalseR)topentTrueRRRetfeedtcloseRa(Rtsourcetparsertclose_sourcetdata((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s 	cCs|jj|�S(N(RaR!(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR!�scCs)tjdtdd�t|j|��S(NsbThis method will be removed in future versions.  Use 'tree.iter()' or 'list(tree.iter())' instead.R8i(R9R:RRR#R!(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRS�s
cCsJ|d dkr7d|}tjd|tdd�n|jj||�S(Nit/t.s�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 %rR8i(R9R:R;RaR(RRHR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s
cCsM|d dkr7d|}tjd|tdd�n|jj|||�S(NiRpRqs�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 %rR8i(R9R:R;RaR (RRHRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR �s
cCsJ|d dkr7d|}tjd|tdd�n|jj||�S(NiRpRqs�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 %rR8i(R9R:R;RaR$(RRHR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR$�s
cCsJ|d dkr7d|}tjd|tdd�n|jj||�S(NiRpRqs�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 %rR8i(R9R:R;RaR"(RRHR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR"�s
cCs=|sd}n|tkr.td|��nt|d�rF|}nt|d�}|j}|s�|dkryd}q�d}n>|s�|dkr�|d
kr�|dkr�|d|�q�n|d	kr�t||j|�n>t|j||�\}}	t|}
|
||j|||	�||k	r9|j	�ndS(Ntxmlsunknown method %rtwritetwbtc14nsutf-8sus-asciis$<?xml version='1.0' encoding='%s'?>
R(sutf-8sus-ascii(
t
_serializet
ValueErrorR)RhRsRt_serialize_textRat_namespacesRk(Rtfile_or_filenametencodingtxml_declarationtdefault_namespacetmethodRbRstqnamesRt	serialize((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRss0					
cCs|j|dd�S(NR~Ru(Rs(RRb((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt
write_c14n8sN(R%R&RR/RcRdRR!RSRR R$R"RsR�(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR]s	
	 c	s�idd6�i��r&d��<n�fd������fd�}y
|j}Wntk
rv|j}nXx]|�D]R}|j}t|t�r�|j�kr||j�qn\t|t�r�|�kr||�qn1|dk	r|t	k	r|t
k	rt|�nx||j�D]n\}}t|t�rQ|j}n|�krj||�nt|t�r*|j�kr*||j�q*q*W|j}t|t�r�|j�kr�||j�q�q�W��fS(NRcs
|j��S(N(tencode(R(R{(s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�Jscsy�|d dkr�|djdd�\}}�j|�}|dkr�tj|�}|dkrxdt��}n|dkr�|�|<q�n|r��d||f��|<q��|��|<n%�r�td��n�|��|<Wntk
r
t|�nXdS(Nit{t}sns%dRrs%s:%ss<cannot use non-qualified names with default_namespace option(trsplitRJRt_namespace_mapR6Rwt	TypeErrort_raise_serialization_error(tqnameturiRtprefix(R}R�RR(s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt	add_qnameMs&
(
RR!tAttributeErrorRSRR(RRRTRR
R�RO(	RR{R}R�titerateRRKRLR((R}R�R{RRs-/usr/lib64/python2.7/xml/etree/ElementTree.pyRy?s>




	$

	cCss|j}|j}|tkr8|dt||��n|tkr^|dt||��n�||}|dkr�|r�|t||��nx�|D]}t||||d�q�Wn�|d|�|j�}|s�|r�|rNxet	|j�dd��D]E\}	}
|
r!d|
}
n|d|
j
|�t|	|�f�qWnx~t	|�D]m\}
}	t|
t
�r�|
j}
nt|	t
�r�||	j}	nt|	|�}	|d||
|	f�q[Wn|s�t|�rC|d	�|r|t||��nx$|D]}t||||d�qW|d
|d	�n
|d�|jro|t|j|��ndS(Ns	<!--%s-->s<?%s?>t<RKcSs|dS(Ni((tx((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt<lambda>�Rt:s
 xmlns%s="%s"s %s="%s"t>s</s />(RRRt_encodeRRt
_escape_cdatat_serialize_xmlROtsortedR�t_escape_attribR(RR6R5(RsRR{RRRRRQROtvtk((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��sP		





	tareatbasetbasefonttbrtcoltframethrtimgtinputtisindextlinktmetatparamcCs�|j}|j}|tkr8|dt||��n?|tkr^|dt||��n||}|dkr�|r�|t||��nx�|D]}t||||d�q�Wn�|d|�|j�}|s�|r�|rNxet|j�dd��D]E\}	}
|
r!d|
}
n|d|
j	|�t
|	|�f�qWnx~t|�D]m\}
}	t|
t�r�|
j}
nt|	t�r�||	j}	nt
|	|�}	|d||
|	f�q[Wn|d	�|j�}|r/|d
ks|dkr|t||��q/|t||��nx$|D]}t||||d�q6W|tkrw|d|d	�n|jr�|t|j|��ndS(
Ns	<!--%s-->s<?%s?>R�RKcSs|dS(Ni((R�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��RR�s
 xmlns%s="%s"s %s="%s"R�tscripttstyles</(RRRR�RRt_serialize_htmlROR�R�R�R(Rt_escape_attrib_htmltlowerR�t
HTML_EMPTYR5(RsRR{RRRRRQROR�R�tltag((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��sT		




	cCsPx'|j�D]}||j|��q
W|jrL||jj|��ndS(N(RUR�R5(RsRR{tpart((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRx�s	RrthtmlRcCsntjd|�r!td��nx<tj�D].\}}||ksR||kr.t|=q.q.W|t|<dS(Nsns\d+$s'Prefix format reserved for internal use(tretmatchRwR�RO(R�R�R�R�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytregister_namespacess$http://www.w3.org/XML/1998/namespaceshttp://www.w3.org/1999/xhtmltrdfs+http://www.w3.org/1999/02/22-rdf-syntax-ns#twsdls http://schemas.xmlsoap.org/wsdl/txss http://www.w3.org/2001/XMLSchematxsis)http://www.w3.org/2001/XMLSchema-instancetdcs http://purl.org/dc/elements/1.1/cCs#td|t|�jf��dS(Nscannot serialize %r (type %s)(R�ttypeR%(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scCs<y|j|d�SWn!ttfk
r7t|�nXdS(Ntxmlcharrefreplace(R�R�R�R�(RR{((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scCs�ywd|kr$|jdd�}nd|krE|jdd�}nd|krf|jdd�}n|j|d�SWn!ttfk
r�t|�nXdS(Nt&s&amp;R�s&lt;R�s&gt;R�(treplaceR�R�R�R�(RR{((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�%scCs�y�d|kr$|jdd�}nd|krE|jdd�}nd|krf|jdd�}nd|kr�|jdd�}nd	|kr�|jd	d
�}n|j|d�SWn!ttfk
r�t|�nXdS(NR�s&amp;R�s&lt;R�s&gt;s"s&quot;s
s&#10;R�(R�R�R�R�R�(RR{((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�5scCs�ywd|kr$|jdd�}nd|krE|jdd�}nd|krf|jdd�}n|j|d�SWn!ttfk
r�t|�nXdS(NR�s&amp;R�s&gt;s"s&quot;R�(R�R�R�R�R�(RR{((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�FscCsWddd��Y}g}|�}|j|_t|�j||d|�dj|�S(NtdummycBseZRS((R%R&(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�asR~R((RARsRtjoin(RR{R~R�RoRb((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR`s	cCsNddd��Y}g}|�}|j|_t|�j||d|�|S(NR�cBseZRS((R%R&(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�vsR~((RARsR(RR{R~R�RoRb((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRus	cCskt|t�st|�}n|jtj�|j�j}|sT|ddkrgtjjd�ndS(Ni����s
(R(RRstsyststdoutRcR5(RR5((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scCst�}|j||�|S(N(RR(RlRmttree((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s	cCs�t}t|d�s-t|d�}t}ny2|sKtdt��}nt||||�SWn|rx|j�n�nXdS(NReRfRY(RgR)RhRiRRt_IterParseIteratorRk(RlteventsRmRn((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s	
R�cBs&eZed�Zd�Zd�ZRS(cCs�||_||_g|_d|_d|_d|_|_||_|jj}|jj	}|dkrvdg}nx|D]}|dkr�y7d|_
d|_|||jjd�}||_
Wq�tk
r�|||jjd�}||_
q�Xq}|dkr.|||jjd�}||_q}|dkrU||d	�}||_q}|d
kr|||d�}||_q}td|��q}WdS(
NitendtstarticSs|||||�f�dS(N((Rt	attrib_inteventRAR�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pythandler�scSs|||||�f�dS(N((RR�R�RAR�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��scSs||||�f�dS(N((RR�RAR�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��ssstart-nscSsSy|pdjd�}Wntk
r,nX|||p<d|pEdff�dS(NRtascii(R�tUnicodeError(R�R�R�RA((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��s

send-nscSs||df�dS(N(R(R�R�RA((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��ssunknown event %r(t_filet_close_filet_eventst_indexRt_errortrootRat_parserRAtordered_attributestspecified_attributest_start_listtStartElementHandlerR�t_startt_endtEndElementHandlertStartNamespaceDeclHandlertEndNamespaceDeclHandlerRw(RRlR�RmRnRAR�R�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR/�sD						
		

cCsKyx�y'|j|j}|jd7_|SWntk
r@nX|jre|j}d|_|�n|jdkr�|j|_Pn|j2d|_|jj	d�}|r�y|jj
|�Wq�tk
r�}||_q�Xq|jj�|_d|_qWWn#|j
r!|jj�n�nX|j
rA|jj�nt�dS(Niii@(R�R�t
IndexErrorR�RR�RaR�R�ReRjtSyntaxErrorRkR�t
StopIteration(RtitemRQRotexc((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytnext�s@
							cCs|S(N((R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__iter__s(R%R&RgR/R�R�(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��s/	$cCs2|stdt��}n|j|�|j�S(NRY(RRRjRk(RRm((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRs
cCs}|stdt��}n|j|�|j�}i}x6|j�D](}|jd�}|rG|||<qGqGW||fS(NRYR1(RRRjRkR!RJ(RRmR�tidsRR1((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytXMLID,s
cCsC|stdt��}nx|D]}|j|�q"W|j�S(NRY(RRRjRk(tsequenceRmR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRLs

cBsAeZdd�Zd�Zd�Zd�Zd�Zd�ZRS(cCsFg|_g|_d|_d|_|dkr9t}n||_dS(N(t_datat_elemRt_lastt_tailRt_factory(Rtelement_factory((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR/bs					cCsCt|j�dks!td��|jdk	s<td��|jS(Nismissing end tagssmissing toplevel element(R6R�tAssertionErrorR�R(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRkrs!cCs�|jr�|jdk	r�dj|j�}|jr`|jjdksQtd��||j_q�|jjdks~td��||j_ng|_ndS(NRsinternal error (tail)sinternal error (text)(R�R�RR�R�R5R�R(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt_flushws		cCs|jj|�dS(N(R�RA(RRo((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRo�scCs`|j�|j||�|_}|jrC|jdj|�n|jj|�d|_|S(Ni����i(R�R�R�R�RAR�(RRtattrsR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��s
		cCsZ|j�|jj�|_|jj|ksJtd|jj|f��d|_|jS(Ns&end tag mismatch (expected %s, got %s)i(R�R�tpopR�RR�R�(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��s
	N(	R%R&RR/RkR�RoR�R�(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR`s				tsentinelcBs�eZeddd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd�Zd	�Z
d
�Zd�ZeZd�Zd
�ZRS(cCs�|tk	r%tjdtdd�nyddlm}WnAtk
r|yddl}Wq}tk
rxtd��q}XnX|j|d�}|dkr�t
�}n||_|_||_
|_|j|_i|_|j|_|j|_|j|_|j|_|j|_|j|_yd|j_Wntk
rGnXy(d|j_ d|j_!|j"|_Wntk
r�nXd|_#i|_$yd	|j%|_&Wntk
r�nXdS(
Ns.The html argument of XMLParser() is deprecatedR8ii����(texpats7No module named expat; use SimpleXMLTreeBuilder insteadR�isExpat %d.%d.%d('t	_sentinelR9twarnpy3kRFtxml.parsersR�tImportErrortpyexpattParserCreateRRRmR�RYt_targetterrorR�t_namest_defaulttDefaultHandlerExpandR�R�R�R�R�tCharacterDataHandlert_commenttCommentHandlert_pitProcessingInstructionHandlertbuffer_textR�R�R�R�t_doctypetentitytversion_infotversion(RR�RYR{R�Rm((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR/�sR

	

		
cCs7t|�}|j|_|j|jf|_|�dS(N(R	tcodetlinenotoffsettposition(RRLterr((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt_raiseerror�scCs*y|jd�SWntk
r%|SXdS(NR�(R�R�(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt_fixtext�s
cCsby|j|}WnJtk
r]|}d|kr@d|}n|j|�|j|<}nX|S(NR�R�(R�tKeyErrorR(RRKtname((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt_fixname�s

cCsj|j}|j}||�}i}x0|j�D]"\}}||�|||�<q1W|jj||�S(N(RRRORYR�(RRR�tfixnametfixtextR,RKRL((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s		cCs�|j}|j}||�}i}|rrxEtdt|�d�D](}|||d�||||�<qCWn|jj||�S(Niii(RRtrangeR6RYR�(RRR�RRR,ti((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s		)cCs|jj|j|��S(N(RYRoR(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scCs|jj|j|��S(N(RYR�R(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scCs;y|jj}Wntk
r#nX||j|��SdS(N(RYtcommentR�R(RRoR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR� s

cCsGy|jj}Wntk
r#n X||j|�|j|��SdS(N(RYtpiR�R(RRYRoR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�(s

c
Cs]|d }|dkr�y"|jj|j|dd!�WqYtk
r�ddlm}|jd||jj|jj	f�}d|_
|jj|_|jj	|_|�qYXn�|dkr�|d d	kr�g|_
n}|j
dk	rY|d
krd|_
dS|j�}|sdS|j
j|�t|j
�}|dkrY|j
d}|dkr�|d
kr�|j
\}}}}	n7|dkr�|dkr�|j
\}}}	d}ndS|r�|dd!}nt|jd�r|jj|||	dd!�nI|j|jkrJ|j|||	dd!�|j|||	dd!�nd|_
qYndS(NiR�i����(R�s'undefined entity %s: line %d, column %diR�i	s	<!DOCTYPER�itPUBLICitSYSTEMitdoctype(RYRoRR
R�R�R�R�tErrorLineNumbertErrorColumnNumberRRRRRtstripRAR6R)Rt_XMLParser__doctype(
RRR�R�R
tnR�Rtpubidtsystem((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�0sR
"
	
	
	 cCstjdt�dS(s'This method of XMLParser is deprecated.s[This method of XMLParser is deprecated.  Define doctype() method on the TreeBuilder target.N(R9R:RF(RRRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRgscCsAy|jj|d�Wn#|jk
r<}|j|�nXdS(Ni(R�tParseR�R(RRoR�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRjwscCs\y|jjdd�Wn#|jk
r<}|j|�nX|jj�}|`|`|S(NRi(R�R R�RRYRk(RR�R�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRk�sN(R%R&R�RR/RRRR�R�R�R�R�R�R�RRRjRk(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s1						
					7			(t_serialize_c14nRu(6t__all__RR�R�R9tobjectRRR'R�R�R	RRt_Elementt_ElementInterfaceR
RRRR
RRRyR�R�RMt	NameErrorR�RxRvR�R�R�R�R�R�R�RRRRRR�RR�RRRR�RRtElementC14NR!(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt<module>;s�

		�U
�D	/
	2	
	
						bM	�
PK�"[�Y檯�etree/ElementInclude.pyonu�[����
{fc@shddlZddlmZdZedZedZdefd��YZdd	�Z	dd
�Z
dS(i����Ni(tElementTrees!{http://www.w3.org/2001/XInclude}tincludetfallbacktFatalIncludeErrorcBseZRS((t__name__t
__module__(((s0/usr/lib64/python2.7/xml/etree/ElementInclude.pyR>scCsat|��O}|dkr3tj|�j�}n$|j�}|rW|j|�}nWdQX|S(Ntxml(topenRtparsetgetroottreadtdecode(threfRtencodingtfiletdata((s0/usr/lib64/python2.7/xml/etree/ElementInclude.pytdefault_loaderMscCs�|dkrt}nd}x�|t|�kr�||}|jtkr�|jd�}|jdd�}|dkr�|||�}|dkr�td||f��ntj|�}|jr�|jp�d|j|_n|||<q�|dkr�||||jd��}|dkr7td||f��n|rq||d	}|jpWd||jpgd|_n#|j	p}d||jp�d|_	||=qq�td
|��n2|jt
kr�td|j��n
t||�|d	}qWdS(NiRRRscannot load %r as %rtttextR
is)unknown parse type in xi:include tag (%r)s0xi:fallback tag must be child of xi:include (%r)(tNoneRtlenttagtXINCLUDE_INCLUDEtgetRtcopyttailRtXINCLUDE_FALLBACKR(telemtloadertiteRRtnodeR((s0/usr/lib64/python2.7/xml/etree/ElementInclude.pyRbsF	
	
&#
(RRRtXINCLUDERRtSyntaxErrorRRRR(((s0/usr/lib64/python2.7/xml/etree/ElementInclude.pyt<module>3s

PK�"[hNwW��etree/__init__.pyonu�[����
{fc@sdS(N((((s*/usr/lib64/python2.7/xml/etree/__init__.pyt<module>tPK�"[�Y檯�etree/ElementInclude.pycnu�[����
{fc@shddlZddlmZdZedZedZdefd��YZdd	�Z	dd
�Z
dS(i����Ni(tElementTrees!{http://www.w3.org/2001/XInclude}tincludetfallbacktFatalIncludeErrorcBseZRS((t__name__t
__module__(((s0/usr/lib64/python2.7/xml/etree/ElementInclude.pyR>scCsat|��O}|dkr3tj|�j�}n$|j�}|rW|j|�}nWdQX|S(Ntxml(topenRtparsetgetroottreadtdecode(threfRtencodingtfiletdata((s0/usr/lib64/python2.7/xml/etree/ElementInclude.pytdefault_loaderMscCs�|dkrt}nd}x�|t|�kr�||}|jtkr�|jd�}|jdd�}|dkr�|||�}|dkr�td||f��ntj|�}|jr�|jp�d|j|_n|||<q�|dkr�||||jd��}|dkr7td||f��n|rq||d	}|jpWd||jpgd|_n#|j	p}d||jp�d|_	||=qq�td
|��n2|jt
kr�td|j��n
t||�|d	}qWdS(NiRRRscannot load %r as %rtttextR
is)unknown parse type in xi:include tag (%r)s0xi:fallback tag must be child of xi:include (%r)(tNoneRtlenttagtXINCLUDE_INCLUDEtgetRtcopyttailRtXINCLUDE_FALLBACKR(telemtloadertiteRRtnodeR((s0/usr/lib64/python2.7/xml/etree/ElementInclude.pyRbsF	
	
&#
(RRRtXINCLUDERRtSyntaxErrorRRRR(((s0/usr/lib64/python2.7/xml/etree/ElementInclude.pyt<module>3s

PK�"[P��^��etree/cElementTree.pyonu�[����
{fc@sddlTdS(i����(t*N(t_elementtree(((s./usr/lib64/python2.7/xml/etree/cElementTree.pyt<module>tPK�"[�B�u��etree/ElementPath.pyonu�[����
{fc@s�ddlZejd�Zdd�Zd�Zd�Zd�Zd�Zd�Z	d	�Z
d
�Zied6ed6ed
6e
d6e	d6ed6ZiZ
ddd��YZdd�Zdd�Zdd�Zddd�ZdS(i����NsY('[^']*'|"[^"]*"|::|//?|\.\.|\(\)|[/.*:\[\]\(\)@=])|((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|\s+ccs�x�tj|�D]�}|d}|r�|ddkr�d|kr�yH|jdd�\}}|slt�n|dd|||ffVWq�tk
r�td|��q�Xq|VqWdS(Niit{t:s{%s}%ss!prefix %r not found in prefix map(txpath_tokenizer_retfindalltsplittKeyErrortSyntaxError(tpatternt
namespacesttokenttagtprefixturi((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytxpath_tokenizerIs
"	!
cCs^|j}|dkrZi|_}x5|jj�D]!}x|D]}|||<q?Wq2Wn|S(N(t
parent_maptNonetroottiter(tcontextRtpte((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytget_parent_mapWs	

cs|d��fd�}|S(Nic3s=x6|D].}x%|D]}|j�kr|VqqWqWdS(N(R
(RtresulttelemR(R
(s-/usr/lib64/python2.7/xml/etree/ElementPath.pytselectbs

((tnextR	R((R
s-/usr/lib64/python2.7/xml/etree/ElementPath.pyt
prepare_child`s
cCs
d�}|S(Ncss+x$|D]}x|D]}|VqWqWdS(N((RRRR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyRjs

((RR	R((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytprepare_staris	cCs
d�}|S(Ncssx|D]}|VqWdS(N((RRR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyRqs
((RR	R((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytprepare_selfps	csX|�}|ddkr"d�n#|ds9|d�ntd���fd�}|S(Nit*isinvalid descendantc3sCx<|D]4}x+|j��D]}||k	r|VqqWqWdS(N(R(RRRR(R
(s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR~s
(R(RR	R((R
s-/usr/lib64/python2.7/xml/etree/ElementPath.pytprepare_descendantvs		

cCs
d�}|S(Ncss^t|�}i}xE|D]=}||kr||}||krVd||<|VqVqqWdS(N(RR(RRRt
result_mapRtparent((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s


((RR	R((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytprepare_parent�s	
csag}g}x�|�}|ddkr,Pn|drd|dd dkrdd|ddd!f}n|j|dpwd�|j|d�qWdj|�}|d	kr�|d��fd
�}|S|dkr�|d�|d���fd�}|S|dkr>tjd
|d�r>|d��fd�}|S|dkr�tjd
|d�r�|d�|d���fd�}|S|dks�|dks�|dkrQ|dkr�t|d�d�nl|ddkr�td��n|dkr8yt|d�d�Wq>tk
r4td��q>Xnd��fd�}|Std��dS(Nit]is'"t'i����t-ts@-c3s2x+|D]#}|j��dk	r|VqqWdS(N(tgetR(RRR(tkey(s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s
s@-='c3s2x+|D]#}|j���kr|VqqWdS(N(R&(RRR(R'tvalue(s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s
s\d+$c3s2x+|D]#}|j��dk	r|VqqWdS(N(tfindR(RRR(R
(s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s
s-='c3sSxL|D]D}x;|j��D]*}dj|j���kr|VPqqWqWdS(NR%(Rtjointitertext(RRRR(R
R((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s

s-()s-()-tlastsunsupported functionisunsupported expressionc3syt|�}xf|D]^}y>||}t|j|j��}|�|krV|VnWqttfk
rpqXqWdS(N(RtlistRR
t
IndexErrorR(RRRRR telems(tindex(s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s

sinvalid predicate(tappendR*tretmatchtintRt
ValueError(RR	t	signaturet	predicateR((R0R'R
R(s-/usr/lib64/python2.7/xml/etree/ElementPath.pytprepare_predicate�sV	


#
#

$
R%Rt.s..s//t[t_SelectorContextcBseZdZd�ZRS(cCs
||_dS(N(R(tselfR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyt__init__�sN(t__name__t
__module__RRR=(((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR;�sc	Csn|ddkr|d}nyt|}Wntk
r4tt�dkrZtj�n|d dkrytd��ntt||��j}|�}g}x�y"|jt	|d||��Wnt
k
r�td��nXy)|�}|ddkr
|�}nWq�t
k
r"Pq�Xq�W|t|<nX|g}t|�}x|D]}|||�}qQW|S(	Ni����t/Ridis#cannot use absolute path on elementisinvalid path(t_cacheRtlentclearRRR
RR1topst
StopIterationR;(	RtpathRtselectorRR	RRR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytiterfind�s:


	"
	
		
cCs3yt|||�j�SWntk
r.dSXdS(N(RHRRER(RRFR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR)s
cCstt|||��S(N(R-RH(RRFR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR$scCsBy)t|||�j�}|jp'dSWntk
r=|SXdS(NR%(RHRttextRE(RRFtdefaultR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytfindtext*s

((R2tcompileRRR
RRRRRR!R8RDRAR;RHR)RRK(((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyt<module>;s.									
	P

$	PK�"[hNwW��etree/__init__.pycnu�[����
{fc@sdS(N((((s*/usr/lib64/python2.7/xml/etree/__init__.pyt<module>tPK�"[[��	��etree/ElementTree.pyonu�[����
{fc@s>dddddddddd	d
ddd
dddddddgZdZddlZddlZddlZdefd��YZyddlmZWne	k
r�e�ZnXd	e
fd��YZd�Zdefd��YZ
e
ZZid�Zed �Zed!�ZeZdefd"��YZdefd#��YZed$�Zd%�Zd&d'd(d)d*d+d,d-d.d/d0d1d2f
Zyee�ZWnek
r�nXd3�Zd4�Zied56ed66ed76Zd8�Zid5d96d6d:6d;d<6d=d>6d?d@6dAdB6dCdD6Z dE�Z!dF�Z"dG�Z#dH�Z$dI�Z%eedJ�Z&eedK�Z'dL�Z(edM�Z)eedN�Z*dOefdP��YZ+edQ�Z,edR�Z-e,Z.edS�Z/defdT��YZ0dUgZ1defdV��YZ2e2Z3yddWl4m5Z5e5edX<Wne	k
r9nXdS(YtCommenttdumptElementtElementTreet
fromstringtfromstringlistt	iselementt	iterparsetparset
ParseErrortPItProcessingInstructiontQNamet
SubElementttostringttostringlisttTreeBuildertVERSIONtXMLt	XMLParsertXMLTreeBuilders1.3.0i����Nt_SimpleElementPathcBs;eZdd�Zddd�Zdd�Zdd�ZRS(cCs(x!|D]}|j|kr|SqWdS(N(ttagtNone(tselftelementRt
namespacestelem((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytfindjs
cCs/|j||�}|dkr"|S|jp.dS(Nt(RRttext(RRRtdefaultRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytfindtextosccsb|d dkr6x#|j|d�D]}|Vq$Wnx%|D]}|j|kr=|Vq=q=WdS(Nis.//(titerR(RRRRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytiterfindts
cCst|j|||��S(N(tlistR"(RRRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytfindall{sN(t__name__t
__module__RRR R"R$(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRhsi(tElementPathcBseZRS((R%R&(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR	�scCst|t�pt|d�S(NR(t
isinstanceRthasattr(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scBs%eZdZdZdZdZid�Zd�Zd�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd	�Zd
�Zd�Zd�Zd
�Zdd�Zddd�Zdd�Zdd�Zd�Zdd�Zd�Zd�Zd�Zdd�Zdd�Zd�Z RS(cKs8|j�}|j|�||_||_g|_dS(N(tcopytupdateRtattribt	_children(RRR,textra((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__init__�s

		cCsdt|j�t|�fS(Ns<Element %s at 0x%x>(treprRtid(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__repr__�scCs|j||�S(N(t	__class__(RRR,((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytmakeelement�scCs;|j|j|j�}|j|_|j|_||(|S(N(R4RR,Rttail(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR*�s
cCs
t|j�S(N(tlenR-(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__len__�scCs)tjdtdd�t|j�dkS(NsyThe behavior of this method will change in future versions.  Use specific 'len(elem)' or 'elem is not None' test instead.t
stacklevelii(twarningstwarnt
FutureWarningR6R-(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__nonzero__�s
cCs|j|S(N(R-(Rtindex((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__getitem__	scCs||j|<dS(N(R-(RR=R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__setitem__scCs|j|=dS(N(R-(RR=((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__delitem__!scCs|jj|�dS(N(R-tappend(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRA,scCs|jj|�dS(N(R-textend(Rtelements((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRB6scCs|jj||�dS(N(R-tinsert(RR=R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRD@scCs|jj|�dS(N(R-tremove(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyREOscCstjdtdd�|jS(NsaThis method will be removed in future versions.  Use 'list(elem)' or iteration over elem instead.R8i(R9R:tDeprecationWarningR-(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytgetchildrenZs
cCstj|||�S(N(R'R(RtpathR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRjscCstj||||�S(N(R'R (RRHRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR yscCstj|||�S(N(R'R$(RRHR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR$�scCstj|||�S(N(R'R"(RRHR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR"�scCs*|jj�g|_d|_|_dS(N(R,tclearR-RRR5(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRI�s
	cCs|jj||�S(N(R,tget(RtkeyR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRJ�scCs||j|<dS(N(R,(RRKtvalue((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytset�scCs
|jj�S(N(R,tkeys(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRN�scCs
|jj�S(N(R,titems(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRO�sccso|dkrd}n|dks0|j|kr8|Vnx0|jD]%}x|j|�D]}|VqXWqBWdS(Nt*(RRR-R!(RRte((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR!�s	cCs)tjdtdd�t|j|��S(NsbThis method will be removed in future versions.  Use 'elem.iter()' or 'list(elem.iter())' instead.R8i(R9R:tPendingDeprecationWarningR#R!(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytgetiterator�s
ccs�|j}t|t�r)|dk	r)dS|jr=|jVnx>|D]6}x|j�D]}|VqWW|jrD|jVqDqDWdS(N(RR(t
basestringRRtitertextR5(RRRQts((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRU�s		
		N(!R%R&RRR,RR5R/R2R4R*R7R<R>R?R@RARBRDRERGRR R$R"RIRJRMRNROR!RSRU(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s<
	
						
			
	
				
		
	
cKs<|j�}|j|�|j||�}|j|�|S(N(R*R+R4RA(tparentRR,R.R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR
s


cCstt�}||_|S(N(RRR(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR"s	cCs6tt�}||_|r2|jd||_n|S(Nt (RRR(ttargetRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR1s
	cBs/eZdd�Zd�Zd�Zd�ZRS(cCs&|rd||f}n||_dS(Ns{%s}%s(R(Rttext_or_uriR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR/EscCs|jS(N(R(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__str__IscCs
t|j�S(N(thashR(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__hash__KscCs2t|t�r"t|j|j�St|j|�S(N(R(RtcmpR(Rtother((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__cmp__MsN(R%R&RR/R[R]R`(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRDs		cBs�eZddd�Zd�Zd�Zdd�Zdd�Zdd�Zdd�Z	ddd�Z
dd�Zdd	�Zddddd
�Z
d�ZRS(
cCs#||_|r|j|�ndS(N(t_rootR(RRtfile((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR/_s	cCs|jS(N(Ra(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytgetrootkscCs
||_dS(N(Ra(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt_setrootuscCs�t}t|d�s-t|d�}t}nzb|sKtdt��}nx*|jd�}|sgPn|j|�qNW|j�|_	|j	SWd|r�|j�nXdS(NtreadtrbRYi(
tFalseR)topentTrueRRRetfeedtcloseRa(Rtsourcetparsertclose_sourcetdata((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s 	cCs|jj|�S(N(RaR!(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR!�scCs)tjdtdd�t|j|��S(NsbThis method will be removed in future versions.  Use 'tree.iter()' or 'list(tree.iter())' instead.R8i(R9R:RRR#R!(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRS�s
cCsJ|d dkr7d|}tjd|tdd�n|jj||�S(Nit/t.s�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 %rR8i(R9R:R;RaR(RRHR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s
cCsM|d dkr7d|}tjd|tdd�n|jj|||�S(NiRpRqs�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 %rR8i(R9R:R;RaR (RRHRR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR �s
cCsJ|d dkr7d|}tjd|tdd�n|jj||�S(NiRpRqs�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 %rR8i(R9R:R;RaR$(RRHR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR$�s
cCsJ|d dkr7d|}tjd|tdd�n|jj||�S(NiRpRqs�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 %rR8i(R9R:R;RaR"(RRHR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR"�s
cCs=|sd}n|tkr.td|��nt|d�rF|}nt|d�}|j}|s�|dkryd}q�d}n>|s�|dkr�|d
kr�|dkr�|d|�q�n|d	kr�t||j|�n>t|j||�\}}	t|}
|
||j|||	�||k	r9|j	�ndS(Ntxmlsunknown method %rtwritetwbtc14nsutf-8sus-asciis$<?xml version='1.0' encoding='%s'?>
R(sutf-8sus-ascii(
t
_serializet
ValueErrorR)RhRsRt_serialize_textRat_namespacesRk(Rtfile_or_filenametencodingtxml_declarationtdefault_namespacetmethodRbRstqnamesRt	serialize((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRss0					
cCs|j|dd�S(NR~Ru(Rs(RRb((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt
write_c14n8sN(R%R&RR/RcRdRR!RSRR R$R"RsR�(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR]s	
	 c	s�idd6�i��r&d��<n�fd������fd�}y
|j}Wntk
rv|j}nXx]|�D]R}|j}t|t�r�|j�kr||j�qn\t|t�r�|�kr||�qn1|dk	r|t	k	r|t
k	rt|�nx||j�D]n\}}t|t�rQ|j}n|�krj||�nt|t�r*|j�kr*||j�q*q*W|j}t|t�r�|j�kr�||j�q�q�W��fS(NRcs
|j��S(N(tencode(R(R{(s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�Jscsy�|d dkr�|djdd�\}}�j|�}|dkr�tj|�}|dkrxdt��}n|dkr�|�|<q�n|r��d||f��|<q��|��|<n%�r�td��n�|��|<Wntk
r
t|�nXdS(Nit{t}sns%dRrs%s:%ss<cannot use non-qualified names with default_namespace option(trsplitRJRt_namespace_mapR6Rwt	TypeErrort_raise_serialization_error(tqnameturiRtprefix(R}R�RR(s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt	add_qnameMs&
(
RR!tAttributeErrorRSRR(RRRTRR
R�RO(	RR{R}R�titerateRRKRLR((R}R�R{RRs-/usr/lib64/python2.7/xml/etree/ElementTree.pyRy?s>




	$

	cCss|j}|j}|tkr8|dt||��n|tkr^|dt||��n�||}|dkr�|r�|t||��nx�|D]}t||||d�q�Wn�|d|�|j�}|s�|r�|rNxet	|j�dd��D]E\}	}
|
r!d|
}
n|d|
j
|�t|	|�f�qWnx~t	|�D]m\}
}	t|
t
�r�|
j}
nt|	t
�r�||	j}	nt|	|�}	|d||
|	f�q[Wn|s�t|�rC|d	�|r|t||��nx$|D]}t||||d�qW|d
|d	�n
|d�|jro|t|j|��ndS(Ns	<!--%s-->s<?%s?>t<RKcSs|dS(Ni((tx((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt<lambda>�Rt:s
 xmlns%s="%s"s %s="%s"t>s</s />(RRRt_encodeRRt
_escape_cdatat_serialize_xmlROtsortedR�t_escape_attribR(RR6R5(RsRR{RRRRRQROtvtk((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��sP		





	tareatbasetbasefonttbrtcoltframethrtimgtinputtisindextlinktmetatparamcCs�|j}|j}|tkr8|dt||��n?|tkr^|dt||��n||}|dkr�|r�|t||��nx�|D]}t||||d�q�Wn�|d|�|j�}|s�|r�|rNxet|j�dd��D]E\}	}
|
r!d|
}
n|d|
j	|�t
|	|�f�qWnx~t|�D]m\}
}	t|
t�r�|
j}
nt|	t�r�||	j}	nt
|	|�}	|d||
|	f�q[Wn|d	�|j�}|r/|d
ks|dkr|t||��q/|t||��nx$|D]}t||||d�q6W|tkrw|d|d	�n|jr�|t|j|��ndS(
Ns	<!--%s-->s<?%s?>R�RKcSs|dS(Ni((R�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��RR�s
 xmlns%s="%s"s %s="%s"R�tscripttstyles</(RRRR�RRt_serialize_htmlROR�R�R�R(Rt_escape_attrib_htmltlowerR�t
HTML_EMPTYR5(RsRR{RRRRRQROR�R�tltag((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��sT		




	cCsPx'|j�D]}||j|��q
W|jrL||jj|��ndS(N(RUR�R5(RsRR{tpart((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRx�s	RrthtmlRcCsntjd|�r!td��nx<tj�D].\}}||ksR||kr.t|=q.q.W|t|<dS(Nsns\d+$s'Prefix format reserved for internal use(tretmatchRwR�RO(R�R�R�R�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytregister_namespacess$http://www.w3.org/XML/1998/namespaceshttp://www.w3.org/1999/xhtmltrdfs+http://www.w3.org/1999/02/22-rdf-syntax-ns#twsdls http://schemas.xmlsoap.org/wsdl/txss http://www.w3.org/2001/XMLSchematxsis)http://www.w3.org/2001/XMLSchema-instancetdcs http://purl.org/dc/elements/1.1/cCs#td|t|�jf��dS(Nscannot serialize %r (type %s)(R�ttypeR%(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scCs<y|j|d�SWn!ttfk
r7t|�nXdS(Ntxmlcharrefreplace(R�R�R�R�(RR{((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scCs�ywd|kr$|jdd�}nd|krE|jdd�}nd|krf|jdd�}n|j|d�SWn!ttfk
r�t|�nXdS(Nt&s&amp;R�s&lt;R�s&gt;R�(treplaceR�R�R�R�(RR{((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�%scCs�y�d|kr$|jdd�}nd|krE|jdd�}nd|krf|jdd�}nd|kr�|jdd�}nd	|kr�|jd	d
�}n|j|d�SWn!ttfk
r�t|�nXdS(NR�s&amp;R�s&lt;R�s&gt;s"s&quot;s
s&#10;R�(R�R�R�R�R�(RR{((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�5scCs�ywd|kr$|jdd�}nd|krE|jdd�}nd|krf|jdd�}n|j|d�SWn!ttfk
r�t|�nXdS(NR�s&amp;R�s&gt;s"s&quot;R�(R�R�R�R�R�(RR{((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�FscCsWddd��Y}g}|�}|j|_t|�j||d|�dj|�S(NtdummycBseZRS((R%R&(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�asR~R((RARsRtjoin(RR{R~R�RoRb((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR`s	cCsNddd��Y}g}|�}|j|_t|�j||d|�|S(NR�cBseZRS((R%R&(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�vsR~((RARsR(RR{R~R�RoRb((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRus	cCskt|t�st|�}n|jtj�|j�j}|sT|ddkrgtjjd�ndS(Ni����s
(R(RRstsyststdoutRcR5(RR5((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scCst�}|j||�|S(N(RR(RlRmttree((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s	cCs�t}t|d�s-t|d�}t}ny2|sKtdt��}nt||||�SWn|rx|j�n�nXdS(NReRfRY(RgR)RhRiRRt_IterParseIteratorRk(RlteventsRmRn((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s	
R�cBs&eZed�Zd�Zd�ZRS(cCs�||_||_g|_d|_d|_d|_|_||_|jj}|jj	}|dkrvdg}nx|D]}|dkr�y7d|_
d|_|||jjd�}||_
Wq�tk
r�|||jjd�}||_
q�Xq}|dkr.|||jjd�}||_q}|dkrU||d	�}||_q}|d
kr|||d�}||_q}td|��q}WdS(
NitendtstarticSs|||||�f�dS(N((Rt	attrib_inteventRAR�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pythandler�scSs|||||�f�dS(N((RR�R�RAR�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��scSs||||�f�dS(N((RR�RAR�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��ssstart-nscSsSy|pdjd�}Wntk
r,nX|||p<d|pEdff�dS(NRtascii(R�tUnicodeError(R�R�R�RA((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��s

send-nscSs||df�dS(N(R(R�R�RA((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��ssunknown event %r(t_filet_close_filet_eventst_indexRt_errortrootRat_parserRAtordered_attributestspecified_attributest_start_listtStartElementHandlerR�t_startt_endtEndElementHandlertStartNamespaceDeclHandlertEndNamespaceDeclHandlerRw(RRlR�RmRnRAR�R�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR/�sD						
		

cCsKyx�y'|j|j}|jd7_|SWntk
r@nX|jre|j}d|_|�n|jdkr�|j|_Pn|j2d|_|jj	d�}|r�y|jj
|�Wq�tk
r�}||_q�Xq|jj�|_d|_qWWn#|j
r!|jj�n�nX|j
rA|jj�nt�dS(Niii@(R�R�t
IndexErrorR�RR�RaR�R�ReRjtSyntaxErrorRkR�t
StopIteration(RtitemRQRotexc((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytnext�s@
							cCs|S(N((R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt__iter__s(R%R&RgR/R�R�(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��s/	$cCs2|stdt��}n|j|�|j�S(NRY(RRRjRk(RRm((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRs
cCs}|stdt��}n|j|�|j�}i}x6|j�D](}|jd�}|rG|||<qGqGW||fS(NRYR1(RRRjRkR!RJ(RRmR�tidsRR1((s-/usr/lib64/python2.7/xml/etree/ElementTree.pytXMLID,s
cCsC|stdt��}nx|D]}|j|�q"W|j�S(NRY(RRRjRk(tsequenceRmR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRLs

cBsAeZdd�Zd�Zd�Zd�Zd�Zd�ZRS(cCsFg|_g|_d|_d|_|dkr9t}n||_dS(N(t_datat_elemRt_lastt_tailRt_factory(Rtelement_factory((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR/bs					cCs|jS(N(R�(R((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRkrscCsa|jr]|jdk	rQdj|j�}|jrB||j_qQ||j_ng|_ndS(NR(R�R�RR�R�R5R(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt_flushws		cCs|jj|�dS(N(R�RA(RRo((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRo�scCs`|j�|j||�|_}|jrC|jdj|�n|jj|�d|_|S(Ni����i(R�R�R�R�RAR�(RRtattrsR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��s
		cCs,|j�|jj�|_d|_|jS(Ni(R�R�tpopR�R�(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR��s
	N(	R%R&RR/RkR�RoR�R�(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR`s				tsentinelcBs�eZeddd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd�Zd	�Z
d
�Zd�ZeZd�Zd
�ZRS(cCs�|tk	r%tjdtdd�nyddlm}WnAtk
r|yddl}Wq}tk
rxtd��q}XnX|j|d�}|dkr�t
�}n||_|_||_
|_|j|_i|_|j|_|j|_|j|_|j|_|j|_|j|_yd|j_Wntk
rGnXy(d|j_ d|j_!|j"|_Wntk
r�nXd|_#i|_$yd	|j%|_&Wntk
r�nXdS(
Ns.The html argument of XMLParser() is deprecatedR8ii����(texpats7No module named expat; use SimpleXMLTreeBuilder insteadR�isExpat %d.%d.%d('t	_sentinelR9twarnpy3kRFtxml.parsersR�tImportErrortpyexpattParserCreateRRRmR�RYt_targetterrorR�t_namest_defaulttDefaultHandlerExpandR�R�R�R�R�tCharacterDataHandlert_commenttCommentHandlert_pitProcessingInstructionHandlertbuffer_textR�R�R�R�t_doctypetentitytversion_infotversion(RR�RYR{R�Rm((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR/�sR

	

		
cCs7t|�}|j|_|j|jf|_|�dS(N(R	tcodetlinenotoffsettposition(RRLterr((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt_raiseerror�scCs*y|jd�SWntk
r%|SXdS(NR�(R�R�(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt_fixtext�s
cCsby|j|}WnJtk
r]|}d|kr@d|}n|j|�|j|<}nX|S(NR�R�(R�tKeyErrorR(RRKtname((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt_fixname�s

cCsj|j}|j}||�}i}x0|j�D]"\}}||�|||�<q1W|jj||�S(N(RRRORYR�(RRR�tfixnametfixtextR,RKRL((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s		cCs�|j}|j}||�}i}|rrxEtdt|�d�D](}|||d�||||�<qCWn|jj||�S(Niii(RRtrangeR6RYR�(RRR�RRR,ti((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s		)cCs|jj|j|��S(N(RYRoR(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scCs|jj|j|��S(N(RYR�R(RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�scCs;y|jj}Wntk
r#nX||j|��SdS(N(RYtcommentR�R(RRoR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR� s

cCsGy|jj}Wntk
r#n X||j|�|j|��SdS(N(RYtpiR�R(RRYRoR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�(s

c
Cs]|d }|dkr�y"|jj|j|dd!�WqYtk
r�ddlm}|jd||jj|jj	f�}d|_
|jj|_|jj	|_|�qYXn�|dkr�|d d	kr�g|_
n}|j
dk	rY|d
krd|_
dS|j�}|sdS|j
j|�t|j
�}|dkrY|j
d}|dkr�|d
kr�|j
\}}}}	n7|dkr�|dkr�|j
\}}}	d}ndS|r�|dd!}nt|jd�r|jj|||	dd!�nI|j|jkrJ|j|||	dd!�|j|||	dd!�nd|_
qYndS(NiR�i����(R�s'undefined entity %s: line %d, column %diR�i	s	<!DOCTYPER�itPUBLICitSYSTEMitdoctype(RYRoRRR�R�R�R�tErrorLineNumbertErrorColumnNumberRRRRRtstripRAR6R)Rt_XMLParser__doctype(
RRR�R�R	tnR�R
tpubidtsystem((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�0sR
"
	
	
	 cCstjdt�dS(s'This method of XMLParser is deprecated.s[This method of XMLParser is deprecated.  Define doctype() method on the TreeBuilder target.N(R9R:RF(RR
RR((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRgscCsAy|jj|d�Wn#|jk
r<}|j|�nXdS(Ni(R�tParseR�R
(RRoR�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRjwscCs\y|jjdd�Wn#|jk
r<}|j|�nX|jj�}|`|`|S(NRi(R�RR�R
RYRk(RR�R�((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyRk�sN(R%R&R�RR/R
RRR�R�R�R�R�R�R�RRRjRk(((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyR�s1						
					7			(t_serialize_c14nRu(6t__all__RR�R�R9tobjectRRR'R�R�R	RRt_Elementt_ElementInterfaceR
RRRR
RRRyR�R�RMt	NameErrorR�RxRvR�R�R�R�R�R�R�RRRRRR�RR�RRRR�RRtElementC14NR (((s-/usr/lib64/python2.7/xml/etree/ElementTree.pyt<module>;s�

		�U
�D	/
	2	
	
						bM	�
PK�"[�B�u��etree/ElementPath.pycnu�[����
{fc@s�ddlZejd�Zdd�Zd�Zd�Zd�Zd�Zd�Z	d	�Z
d
�Zied6ed6ed
6e
d6e	d6ed6ZiZ
ddd��YZdd�Zdd�Zdd�Zddd�ZdS(i����NsY('[^']*'|"[^"]*"|::|//?|\.\.|\(\)|[/.*:\[\]\(\)@=])|((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|\s+ccs�x�tj|�D]�}|d}|r�|ddkr�d|kr�yH|jdd�\}}|slt�n|dd|||ffVWq�tk
r�td|��q�Xq|VqWdS(Niit{t:s{%s}%ss!prefix %r not found in prefix map(txpath_tokenizer_retfindalltsplittKeyErrortSyntaxError(tpatternt
namespacesttokenttagtprefixturi((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytxpath_tokenizerIs
"	!
cCs^|j}|dkrZi|_}x5|jj�D]!}x|D]}|||<q?Wq2Wn|S(N(t
parent_maptNonetroottiter(tcontextRtpte((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytget_parent_mapWs	

cs|d��fd�}|S(Nic3s=x6|D].}x%|D]}|j�kr|VqqWqWdS(N(R
(RtresulttelemR(R
(s-/usr/lib64/python2.7/xml/etree/ElementPath.pytselectbs

((tnextR	R((R
s-/usr/lib64/python2.7/xml/etree/ElementPath.pyt
prepare_child`s
cCs
d�}|S(Ncss+x$|D]}x|D]}|VqWqWdS(N((RRRR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyRjs

((RR	R((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytprepare_staris	cCs
d�}|S(Ncssx|D]}|VqWdS(N((RRR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyRqs
((RR	R((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytprepare_selfps	csX|�}|ddkr"d�n#|ds9|d�ntd���fd�}|S(Nit*isinvalid descendantc3sCx<|D]4}x+|j��D]}||k	r|VqqWqWdS(N(R(RRRR(R
(s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR~s
(R(RR	R((R
s-/usr/lib64/python2.7/xml/etree/ElementPath.pytprepare_descendantvs		

cCs
d�}|S(Ncss^t|�}i}xE|D]=}||kr||}||krVd||<|VqVqqWdS(N(RR(RRRt
result_mapRtparent((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s


((RR	R((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytprepare_parent�s	
csag}g}x�|�}|ddkr,Pn|drd|dd dkrdd|ddd!f}n|j|dpwd�|j|d�qWdj|�}|d	kr�|d��fd
�}|S|dkr�|d�|d���fd�}|S|dkr>tjd
|d�r>|d��fd�}|S|dkr�tjd
|d�r�|d�|d���fd�}|S|dks�|dks�|dkrQ|dkr�t|d�d�nl|ddkr�td��n|dkr8yt|d�d�Wq>tk
r4td��q>Xnd��fd�}|Std��dS(Nit]is'"t'i����t-ts@-c3s2x+|D]#}|j��dk	r|VqqWdS(N(tgetR(RRR(tkey(s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s
s@-='c3s2x+|D]#}|j���kr|VqqWdS(N(R&(RRR(R'tvalue(s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s
s\d+$c3s2x+|D]#}|j��dk	r|VqqWdS(N(tfindR(RRR(R
(s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s
s-='c3sSxL|D]D}x;|j��D]*}dj|j���kr|VPqqWqWdS(NR%(Rtjointitertext(RRRR(R
R((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s

s-()s-()-tlastsunsupported functionisunsupported expressionc3syt|�}xf|D]^}y>||}t|j|j��}|�|krV|VnWqttfk
rpqXqWdS(N(RtlistRR
t
IndexErrorR(RRRRR telems(tindex(s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR�s

sinvalid predicate(tappendR*tretmatchtintRt
ValueError(RR	t	signaturet	predicateR((R0R'R
R(s-/usr/lib64/python2.7/xml/etree/ElementPath.pytprepare_predicate�sV	


#
#

$
R%Rt.s..s//t[t_SelectorContextcBseZdZd�ZRS(cCs
||_dS(N(R(tselfR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyt__init__�sN(t__name__t
__module__RRR=(((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR;�sc	Csn|ddkr|d}nyt|}Wntk
r4tt�dkrZtj�n|d dkrytd��ntt||��j}|�}g}x�y"|jt	|d||��Wnt
k
r�td��nXy)|�}|ddkr
|�}nWq�t
k
r"Pq�Xq�W|t|<nX|g}t|�}x|D]}|||�}qQW|S(	Ni����t/Ridis#cannot use absolute path on elementisinvalid path(t_cacheRtlentclearRRR
RR1topst
StopIterationR;(	RtpathRtselectorRR	RRR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytiterfind�s:


	"
	
		
cCs3yt|||�j�SWntk
r.dSXdS(N(RHRRER(RRFR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR)s
cCstt|||��S(N(R-RH(RRFR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyR$scCsBy)t|||�j�}|jp'dSWntk
r=|SXdS(NR%(RHRttextRE(RRFtdefaultR((s-/usr/lib64/python2.7/xml/etree/ElementPath.pytfindtext*s

((R2tcompileRRR
RRRRRR!R8RDRAR;RHR)RRK(((s-/usr/lib64/python2.7/xml/etree/ElementPath.pyt<module>;s.									
	P

$	PK�"[P��^��etree/cElementTree.pycnu�[����
{fc@sddlTdS(i����(t*N(t_elementtree(((s./usr/lib64/python2.7/xml/etree/cElementTree.pyt<module>tPK�"[=p�66__init__.pyonu�[����
{fc@s�dZddddgZd
Zydd	lZWnek
rAn]Xy
ejZWnek
rbn<Xeekr�dd	lZej	j
e	�eeje<n[d	S(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.

tdomtparserstsaxtetreeiiii����N(iii(
t__doc__t__all__t_MINIMUM_XMLPLUS_VERSIONt_xmlplustImportErrortversion_infotvtAttributeErrortsyst__path__textendtmodulest__name__(((s$/usr/lib64/python2.7/xml/__init__.pyt<module>s


PK�"[=p�66__init__.pycnu�[����
{fc@s�dZddddgZd
Zydd	lZWnek
rAn]Xy
ejZWnek
rbn<Xeekr�dd	lZej	j
e	�eeje<n[d	S(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.

tdomtparserstsaxtetreeiiii����N(iii(
t__doc__t__all__t_MINIMUM_XMLPLUS_VERSIONt_xmlplustImportErrortversion_infotvtAttributeErrortsyst__path__textendtmodulest__name__(((s$/usr/lib64/python2.7/xml/__init__.pyt<module>s


PK�"[�'�ZE;E;sax/expatreader.pyonu�[����
{fc@s3dZdZddlTddlmZmZddlmZddlmZmZddlm	Z	ddlm
Z
mZdd	lZej
d
 dkr�ede��n[ydd
lmZWn ek
r�ede��n#Xeed�rede��nddlmZmZmZejZejZydd	lZWnek
r_d�ZnXdd	lZejZ[[dfd��YZdejfd��YZ dej!ejfd��YZ"d�Z#e$dkr/dd	l%Z&e#�Z'e'j(e&j)jj*��e'j+e&j)j,��e'j-d�nd	S(s]
SAX driver for the pyexpat C module.  This driver works with
pyexpat.__version__ == '2.22'.
s0.20i����(t*(tfeature_validationtfeature_namespaces(tfeature_namespace_prefixes(tfeature_external_gestfeature_external_pes(tfeature_string_interning(tproperty_xml_stringtproperty_interning_dictNitjavasexpat not available in Java(texpatsexpat not supportedtParserCreate(t	xmlreadertsaxutilsthandlercCs|S(N((to((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt_mkproxy'st
_ClosedParsercBseZRS((t__name__t
__module__(((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR.stExpatLocatorcBs;eZdZd�Zd�Zd�Zd�Zd�ZRS(s�Locator for use with the ExpatParser class.

    This uses a weak reference to the parser object to avoid creating
    a circular reference between the parser and the content handler.
    cCst|�|_dS(N(Rt_ref(tselftparser((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt__init__9scCs&|j}|jdkrdS|jjS(N(Rt_parsertNonetErrorColumnNumber(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pytgetColumnNumber<s	cCs&|j}|jdkrdS|jjS(Ni(RRRtErrorLineNumber(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt
getLineNumberBs	cCs&|j}|dkrdS|jj�S(N(RRt_sourcetgetPublicId(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR Hs	cCs&|j}|dkrdS|jj�S(N(RRRtgetSystemId(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR!Ns	(RRt__doc__RRRR R!(((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR3s				tExpatParsercBs.eZdZdd%d�Zd�Zd�Zd�Zd	�Zd
�Zd�Z	d�Z
dd
�Zd�Zd�Z
d�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd �Zd!�Zd"�Z d#�Z!RS(&s$SAX driver for the pyexpat C module.iiiicCsetjj||�tj�|_d|_||_d|_d|_	g|_
d|_d|_dS(Nii(
RtIncrementalParserRtInputSourceRRRt_namespacest_lex_handler_propt_parsingt
_entity_stackt
_external_gest
_interning(RtnamespaceHandlingtbufsize((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRZs						cCsjtj|�}||_y7|j�|jjt|��tjj	||�Wn|j
��nXdS(s3Parse an XML document from a URL or an InputSource.N(R
tprepare_input_sourceRtresett
_cont_handlertsetDocumentLocatorRRR$tparset
_close_source(Rtsource((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR2gs	

cCsV|j�dk	rR|j�}t|t�r?|jd�}n|jj|�ndS(Nsutf-8(R!Rt
isinstancetunicodetencodeRtSetBase(RR4tbase((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt
prepareParserws
cCs-tjj||�|jr)|j�ndS(N(RR$tsetContentHandlerR(t_reset_cont_handler(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR;�s	cCsl|tkr|jS|tkr,|jdk	S|tttfkrEdS|tkrX|j	St
d|��dS(NisFeature '%s' not recognized(RR&RR+RRRRRR*tSAXNotRecognizedException(Rtname((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt
getFeature�s
	cCs|jrtd��n|tkr0||_n�|tkrH||_n�|tkr�|rx|jdkr�i|_q�qd|_n||t	kr�|rtd��qnX|t
kr�|rtd��qn4|tkr�|rtd��qntd|��dS(Ns!Cannot set features while parsings!expat does not support validations/expat does not read external parameter entitiess(expat does not report namespace prefixessFeature '%s' not recognized(
R(tSAXNotSupportedExceptionRR&RR*RR+RRRRR=(RR>tstate((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt
setFeature�s2	cCs�|tjkr|jS|tkr)|jS|tkr{|jrlt|jd�r]|jj�St	d��q{t
d��nt	d|��dS(NtGetInputContexts=This version of expat does not support getting the XML strings.XML string cannot be returned when not parsingsProperty '%s' not recognized(Rtproperty_lexical_handlerR'RR+RRthasattrRCR=R@(RR>((s+/usr/lib64/python2.7/xml/sax/expatreader.pytgetProperty�s	
cCs||tjkr1||_|jrx|j�qxnG|tkrI||_n/|tkrhtd|��nt	d|��dS(NsProperty '%s' cannot be setsProperty '%s' not recognized(
RRDR'R(t_reset_lex_handler_propRR+RR@R=(RR>tvalue((s+/usr/lib64/python2.7/xml/sax/expatreader.pytsetProperty�s		
cCs�|js,|j�d|_|jj�ny|jj||�WnDtjk
r�}ttj	|j
�||�}|jj|�nXdS(Ni(
R(R/R0t
startDocumentRtParseR
terrortSAXParseExceptiontErrorStringtcodet_err_handlert
fatalError(RtdatatisFinaltetexc((s+/usr/lib64/python2.7/xml/sax/expatreader.pytfeed�s	
	cCs_|j}z)|j�}|dk	r1|j�nWd|j�}|dk	rZ|j�nXdS(N(RtgetCharacterStreamRtcloset
getByteStream(RR4tfile((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR3�s	cCs�|js*|jdks*t|jt�r.dSz6|jddd�|jj�d|_d|_Wdd|_|jdk	r�t�}|jj	|_	|jj
|_
||_n|j�XdS(NtRSii(R)RRR5RRVR0tendDocumentR(RRR3(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRX�s
	
		cCs(|jj|j_|jj|j_dS(N(R0tprocessingInstructionRtProcessingInstructionHandlert
characterstCharacterDataHandler(R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR<scCs�|j}|j}|dkrNd|_d|_d|_d|_d|_n<|j|_|j	|_|j
|_|j|_|j|_dS(N(
R'RRtCommentHandlertStartCdataSectionHandlertEndCdataSectionHandlertStartDoctypeDeclHandlertEndDoctypeDeclHandlertcommentt
startCDATAtendCDATAtstart_doctype_decltendDTD(RtlexR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRGs						cCsc|jr]tj|jj�dd|j�|_d|j_|j|j_	|j
|j_nBtj|jj�d|j�|_|j|j_	|j
|j_|j�|j|j_|j|j_|j|j_|j|j_d|_|jr|j�n|j|j_y|j|j_Wntk
r9nX|jj tj!�d|_"g|_#dS(Nt tinternii($R&R
RRtgetEncodingR+Rtnamespace_prefixeststart_element_nstStartElementHandlertend_element_nstEndElementHandlert
start_elementtend_elementR<tunparsed_entity_decltUnparsedEntityDeclHandlert
notation_decltNotationDeclHandlertstart_namespace_decltStartNamespaceDeclHandlertend_namespace_decltEndNamespaceDeclHandlerRt_decl_handler_propR'RGtexternal_entity_reftExternalEntityRefHandlertskipped_entity_handlertSkippedEntityHandlertAttributeErrortSetParamEntityParsingt*XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONER(R)(R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR/s6	
		

	
	cCs|jdkrdS|jjS(N(RRR(R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR>scCs|jdkrdS|jjS(Ni(RRR(R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRCscCs
|jj�S(N(RR (R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR HscCs
|jj�S(N(RR!(R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR!KscCs|jj|t|��dS(N(R0tstartElementtAttributesImpl(RR>tattrs((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRtOscCs|jj|�dS(N(R0t
endElement(RR>((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRuRscCsL|j�}t|�dkr-d|f}n5t|�dkrV|d|df}nt|�}i}i}x�|j�D]�\}}|j�}t|�}	|	dkr�|}
d|f}nQ|	dkr�d|d|df}
|d|df}n|d}
t|�}|||<|
||<q{W|jj|dt||��dS(Niiis%s:%si(tsplittlenRttupletitemsR0tstartElementNStAttributesNSImpl(RR>R�tpairtnewattrstqnamestanameRHtpartstlengthtqnametapair((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRpUs.

cCsy|j�}t|�dkr-d|f}n5t|�dkrV|d|df}nt|�}|jj|d�dS(Niii(R�R�RR�R0tendElementNS(RR>R�((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRrwscCs|jj||�dS(N(R0R](RttargetRR((s+/usr/lib64/python2.7/xml/sax/expatreader.pytprocessing_instruction�scCs|jj|�dS(N(R0R_(RRR((s+/usr/lib64/python2.7/xml/sax/expatreader.pytcharacter_data�scCs|jj||�dS(N(R0tstartPrefixMapping(Rtprefixturi((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRz�scCs|jj|�dS(N(R0tendPrefixMapping(RR�((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR|�scCs|jj|||�dS(N(R'tstartDTD(RR>tsysidtpubidthas_internal_subset((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRi�scCs|jj||||�dS(N(t_dtd_handlertunparsedEntityDecl(RR>R9R�R�t
notation_name((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRv�scCs|jj|||�dS(N(R�tnotationDecl(RR>R9R�R�((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRx�scCs�|js
dS|jj||�}tj||jj�p=d�}|jj|j	|jf�|j	j
|�|_	||_ytjj
||�WndSX|jd\|_	|_|jd=dS(NiR[ii����(R*t_ent_handlert
resolveEntityR
R.RR!R)tappendRtExternalEntityParserCreateRR$R2(RtcontextR9R�R�R4((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR�s 				
cCs'|rd|}n|jj|�dS(Nt%(R0t
skippedEntity(RR>tis_pe((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR��s
ii�("RRR"RR2R:R;R?RBRFRIRVR3RXR<RGR/RRR R!RtRuRpRrR�R�RzR|RiRvRxRR�(((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR#Ws@
													'							"									cOs
t||�S(N(R#(targstkwargs((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt
create_parser�st__main__s:http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml(.R"tversiontxml.sax._exceptionstxml.sax.handlerRRRRRRRRtsystplatformtSAXReaderNotAvailableRtxml.parsersR
tImportErrorREtxml.saxRR
RR�R�t_weakrefRtweakreftproxyRtLocatorRR$R#R�Rtxml.sax.saxutilstxmltpR;tsaxtXMLGeneratortsetErrorHandlertErrorHandlerR2(((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt<module>sL

		

	$�a		PK�"[����9�9sax/saxutils.pyonu�[����
{fc@s-dZddlZddlZddlZddlZddlZddlZddlZddlZyej	ej
gZWnek
r�ej	gZnXd�Z
id�Zid�Zid�Zd�Zdejfd	��YZd
ejfd��YZdejfd
��YZdd�ZdS(snA library of useful helper classes to the SAX classes, for the
convenience of application and driver writers.
i����NcCs3x,|j�D]\}}|j||�}q
W|S(s2Replace substrings of a string using a dictionary.(titemstreplace(tstdtkeytvalue((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt__dict_replacescCsR|jdd�}|jdd�}|jdd�}|rNt||�}n|S(s�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.
    t&s&amp;t>s&gt;t<s&lt;(RR(tdatatentities((s(/usr/lib64/python2.7/xml/sax/saxutils.pytescapes	cCsL|jdd�}|jdd�}|r<t||�}n|jdd�S(s
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.
    s&lt;R	s&gt;Rs&amp;R(RR(R
R((s(/usr/lib64/python2.7/xml/sax/saxutils.pytunescape's
cCs�|j�}|jidd6dd6dd6�t||�}d|kr{d|krnd	|jdd
�}q�d|}n
d	|}|S(s�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.
    s&#10;s
s&#13;s
s&#9;s	t"t's"%s"s&quot;s'%s'(tcopytupdateRR(R
R((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt	quoteattr5s"

cCs�|dkr$ddl}|j}nt|tj�rTtj|�}d�|_nTtj�}d�|_|j	|_	y|j
|_
|j|_Wntk
r�nXt
|d|dddd�S(	Ni����cSsdS(N(tNone(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt<lambda>VtcSstS(N(tTrue(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR[Rtencodingterrorstxmlcharrefreplacetnewlines
(Rtsyststdoutt
isinstancetiot	RawIOBasetBufferedIOBasetclosetwritabletwritetseekablettelltAttributeErrort_UnbufferedTextIOWrapper(toutRRtbuffer((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt_gettextwriterMs"
R'cBseZd�ZRS(cCs$tt|�j|�|j�dS(N(tsuperR'R#tflush(tselfR((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR#ks(t__name__t
__module__R#(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR'jstXMLGeneratorcBs�eZddd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�ZRS(s
iso-8859-1cCsitjj|�t||�}|j|_|j|_ig|_|jd|_	g|_
||_dS(Ni����(thandlertContentHandlert__init__R*R#t_writeR,t_flusht_ns_contextst_current_contextt_undeclared_ns_mapst	_encoding(R-R(R((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR3rs	cCsX|drPd|dkr&d|dS|j|d}|rP|d|dSn|dS(s7Builds a qualified name from a (ns_url, localname) pairis$http://www.w3.org/XML/1998/namespacesxml:it:(R7(R-tnametprefix((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt_qname|s
cCs|jd|j�dS(Nu$<?xml version="1.0" encoding="%s"?>
(R4R9(R-((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt
startDocument�s	cCs|j�dS(N(R5(R-((s(/usr/lib64/python2.7/xml/sax/saxutils.pytendDocument�scCs@|jj|jj��||j|<|jj||f�dS(N(R6tappendR7RR8(R-R<turi((s(/usr/lib64/python2.7/xml/sax/saxutils.pytstartPrefixMapping�s
cCs|jd|_|jd=dS(Ni����(R6R7(R-R<((s(/usr/lib64/python2.7/xml/sax/saxutils.pytendPrefixMapping�scCs\|jd|�x7|j�D])\}}|jd|t|�f�qW|jd�dS(Nu<u %s=%su>(R4RR(R-R;tattrsR((s(/usr/lib64/python2.7/xml/sax/saxutils.pytstartElement�s!cCs|jd|�dS(Nu</%s>(R4(R-R;((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt
endElement�scCs�|jd|j|��xH|jD]=\}}|rP|jd||f�q$|jd|�q$Wg|_x@|j�D]2\}}|jd|j|�t|�f�q{W|jd�dS(Nu<u xmlns:%s="%s"u xmlns="%s"u %s=%su>(R4R=R8RR(R-R;tqnameRDR<RAR((s(/usr/lib64/python2.7/xml/sax/saxutils.pytstartElementNS�s	*cCs|jd|j|��dS(Nu</%s>(R4R=(R-R;RG((s(/usr/lib64/python2.7/xml/sax/saxutils.pytendElementNS�scCs;t|t�s$t||j�}n|jt|��dS(N(RtunicodeR9R4R(R-tcontent((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt
characters�scCs5t|t�s$t||j�}n|j|�dS(N(RRJR9R4(R-RK((s(/usr/lib64/python2.7/xml/sax/saxutils.pytignorableWhitespace�scCs|jd||f�dS(Nu	<?%s %s?>(R4(R-ttargetR
((s(/usr/lib64/python2.7/xml/sax/saxutils.pytprocessingInstruction�sN(R.R/RR3R=R>R?RBRCRERFRHRIRLRMRO(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR0ps
											t
XMLFilterBasecBs
eZdZdd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(sYThis 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.cCstjj|�||_dS(N(t	xmlreadert	XMLReaderR3t_parent(R-tparent((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR3�scCs|jj|�dS(N(t_err_handlerterror(R-t	exception((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRV�scCs|jj|�dS(N(RUt
fatalError(R-RW((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRX�scCs|jj|�dS(N(RUtwarning(R-RW((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRY�scCs|jj|�dS(N(t
_cont_handlertsetDocumentLocator(R-tlocator((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR[�scCs|jj�dS(N(RZR>(R-((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR>�scCs|jj�dS(N(RZR?(R-((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR?�scCs|jj||�dS(N(RZRB(R-R<RA((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRB�scCs|jj|�dS(N(RZRC(R-R<((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRC�scCs|jj||�dS(N(RZRE(R-R;RD((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRE�scCs|jj|�dS(N(RZRF(R-R;((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRF�scCs|jj|||�dS(N(RZRH(R-R;RGRD((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRH�scCs|jj||�dS(N(RZRI(R-R;RG((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRI�scCs|jj|�dS(N(RZRL(R-RK((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRL�scCs|jj|�dS(N(RZRM(R-tchars((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRM�scCs|jj||�dS(N(RZRO(R-RNR
((s(/usr/lib64/python2.7/xml/sax/saxutils.pyROscCs|jj|�dS(N(RZt
skippedEntity(R-R;((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR^scCs|jj|||�dS(N(t_dtd_handlertnotationDecl(R-R;tpublicIdtsystemId((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR`	scCs|jj||||�dS(N(R_tunparsedEntityDecl(R-R;RaRbtndata((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRcscCs|jj||�S(N(t_ent_handlert
resolveEntity(R-RaRb((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRfscCsT|jj|�|jj|�|jj|�|jj|�|jj|�dS(N(RStsetContentHandlertsetErrorHandlertsetEntityResolvert
setDTDHandlertparse(R-tsource((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRks
cCs|jj|�dS(N(RSt	setLocale(R-tlocale((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRmscCs|jj|�S(N(RSt
getFeature(R-R;((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRo scCs|jj||�dS(N(RSt
setFeature(R-R;tstate((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRp#scCs|jj|�S(N(RStgetProperty(R-R;((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRr&scCs|jj||�dS(N(RStsetProperty(R-R;R((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRs)scCs|jS(N(RS(R-((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt	getParent.scCs
||_dS(N(RS(R-RT((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt	setParent1sN( R.R/t__doc__RR3RVRXRYR[R>R?RBRCRERFRHRIRLRMROR^R`RcRfRkRmRoRpRrRsRtRu(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRP�s:																										RcCst|�tkr$tj|�}nSt|d�rw|}tj�}|j|�t|d�rw|j|j�qwn|j�dkry|j
�}tjj
tjj|��}tj�}t|t�rt|t�sdy|j|�}Wqtk
r|j|�}qXqdnHt|t�rdy|j|�}Wqdtk
r`|j|�}qdXntjj||�}tjj|�}Wntk
r�t}nX|r�|j|�t|d�}n4|jtj||j
���tj|j
��}|j|�n|S(s�This function takes an InputSource and an optional base URL and
    returns a fully resolved InputSource object ready for reading.treadR;trbN(ttypet_StringTypesRQtInputSourcethasattrt
setByteStreamtsetSystemIdR;t
getByteStreamRtgetSystemIdtostpathtdirnametnormpathRtgetfilesystemencodingRRJtdecodetUnicodeDecodeErrortencodetjointisfiletUnicodeErrortFalsetopenturlparseturljointurllibturlopen(RltbasetftsysidtbaseheadRt
sysidfilenameR�((s(/usr/lib64/python2.7/xml/sax/saxutils.pytprepare_input_source6sF





(RvR�R�R�ttypesRRR1RQt
StringTypetUnicodeTypeRzR&RRR
RR*t
TextIOWrapperR'R2R0RRRPR�(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt<module>s$0
		WoPK�"[�'�ZE;E;sax/expatreader.pycnu�[����
{fc@s3dZdZddlTddlmZmZddlmZddlmZmZddlm	Z	ddlm
Z
mZdd	lZej
d
 dkr�ede��n[ydd
lmZWn ek
r�ede��n#Xeed�rede��nddlmZmZmZejZejZydd	lZWnek
r_d�ZnXdd	lZejZ[[dfd��YZdejfd��YZ dej!ejfd��YZ"d�Z#e$dkr/dd	l%Z&e#�Z'e'j(e&j)jj*��e'j+e&j)j,��e'j-d�nd	S(s]
SAX driver for the pyexpat C module.  This driver works with
pyexpat.__version__ == '2.22'.
s0.20i����(t*(tfeature_validationtfeature_namespaces(tfeature_namespace_prefixes(tfeature_external_gestfeature_external_pes(tfeature_string_interning(tproperty_xml_stringtproperty_interning_dictNitjavasexpat not available in Java(texpatsexpat not supportedtParserCreate(t	xmlreadertsaxutilsthandlercCs|S(N((to((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt_mkproxy'st
_ClosedParsercBseZRS((t__name__t
__module__(((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR.stExpatLocatorcBs;eZdZd�Zd�Zd�Zd�Zd�ZRS(s�Locator for use with the ExpatParser class.

    This uses a weak reference to the parser object to avoid creating
    a circular reference between the parser and the content handler.
    cCst|�|_dS(N(Rt_ref(tselftparser((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt__init__9scCs&|j}|jdkrdS|jjS(N(Rt_parsertNonetErrorColumnNumber(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pytgetColumnNumber<s	cCs&|j}|jdkrdS|jjS(Ni(RRRtErrorLineNumber(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt
getLineNumberBs	cCs&|j}|dkrdS|jj�S(N(RRt_sourcetgetPublicId(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR Hs	cCs&|j}|dkrdS|jj�S(N(RRRtgetSystemId(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR!Ns	(RRt__doc__RRRR R!(((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR3s				tExpatParsercBs.eZdZdd%d�Zd�Zd�Zd�Zd	�Zd
�Zd�Z	d�Z
dd
�Zd�Zd�Z
d�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd �Zd!�Zd"�Z d#�Z!RS(&s$SAX driver for the pyexpat C module.iiiicCsetjj||�tj�|_d|_||_d|_d|_	g|_
d|_d|_dS(Nii(
RtIncrementalParserRtInputSourceRRRt_namespacest_lex_handler_propt_parsingt
_entity_stackt
_external_gest
_interning(RtnamespaceHandlingtbufsize((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRZs						cCsjtj|�}||_y7|j�|jjt|��tjj	||�Wn|j
��nXdS(s3Parse an XML document from a URL or an InputSource.N(R
tprepare_input_sourceRtresett
_cont_handlertsetDocumentLocatorRRR$tparset
_close_source(Rtsource((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR2gs	

cCsV|j�dk	rR|j�}t|t�r?|jd�}n|jj|�ndS(Nsutf-8(R!Rt
isinstancetunicodetencodeRtSetBase(RR4tbase((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt
prepareParserws
cCs-tjj||�|jr)|j�ndS(N(RR$tsetContentHandlerR(t_reset_cont_handler(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR;�s	cCsl|tkr|jS|tkr,|jdk	S|tttfkrEdS|tkrX|j	St
d|��dS(NisFeature '%s' not recognized(RR&RR+RRRRRR*tSAXNotRecognizedException(Rtname((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt
getFeature�s
	cCs|jrtd��n|tkr0||_n�|tkrH||_n�|tkr�|rx|jdkr�i|_q�qd|_n||t	kr�|rtd��qnX|t
kr�|rtd��qn4|tkr�|rtd��qntd|��dS(Ns!Cannot set features while parsings!expat does not support validations/expat does not read external parameter entitiess(expat does not report namespace prefixessFeature '%s' not recognized(
R(tSAXNotSupportedExceptionRR&RR*RR+RRRRR=(RR>tstate((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt
setFeature�s2	cCs�|tjkr|jS|tkr)|jS|tkr{|jrlt|jd�r]|jj�St	d��q{t
d��nt	d|��dS(NtGetInputContexts=This version of expat does not support getting the XML strings.XML string cannot be returned when not parsingsProperty '%s' not recognized(Rtproperty_lexical_handlerR'RR+RRthasattrRCR=R@(RR>((s+/usr/lib64/python2.7/xml/sax/expatreader.pytgetProperty�s	
cCs||tjkr1||_|jrx|j�qxnG|tkrI||_n/|tkrhtd|��nt	d|��dS(NsProperty '%s' cannot be setsProperty '%s' not recognized(
RRDR'R(t_reset_lex_handler_propRR+RR@R=(RR>tvalue((s+/usr/lib64/python2.7/xml/sax/expatreader.pytsetProperty�s		
cCs�|js,|j�d|_|jj�ny|jj||�WnDtjk
r�}ttj	|j
�||�}|jj|�nXdS(Ni(
R(R/R0t
startDocumentRtParseR
terrortSAXParseExceptiontErrorStringtcodet_err_handlert
fatalError(RtdatatisFinaltetexc((s+/usr/lib64/python2.7/xml/sax/expatreader.pytfeed�s	
	cCs_|j}z)|j�}|dk	r1|j�nWd|j�}|dk	rZ|j�nXdS(N(RtgetCharacterStreamRtcloset
getByteStream(RR4tfile((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR3�s	cCs�|js*|jdks*t|jt�r.dSz6|jddd�|jj�d|_d|_Wdd|_|jdk	r�t�}|jj	|_	|jj
|_
||_n|j�XdS(NtRSii(R)RRR5RRVR0tendDocumentR(RRR3(RR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRX�s
	
		cCs(|jj|j_|jj|j_dS(N(R0tprocessingInstructionRtProcessingInstructionHandlert
characterstCharacterDataHandler(R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR<scCs�|j}|j}|dkrNd|_d|_d|_d|_d|_n<|j|_|j	|_|j
|_|j|_|j|_dS(N(
R'RRtCommentHandlertStartCdataSectionHandlertEndCdataSectionHandlertStartDoctypeDeclHandlertEndDoctypeDeclHandlertcommentt
startCDATAtendCDATAtstart_doctype_decltendDTD(RtlexR((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRGs						cCsc|jr]tj|jj�dd|j�|_d|j_|j|j_	|j
|j_nBtj|jj�d|j�|_|j|j_	|j
|j_|j�|j|j_|j|j_|j|j_|j|j_d|_|jr|j�n|j|j_y|j|j_Wntk
r9nX|jj tj!�d|_"g|_#dS(Nt tinternii($R&R
RRtgetEncodingR+Rtnamespace_prefixeststart_element_nstStartElementHandlertend_element_nstEndElementHandlert
start_elementtend_elementR<tunparsed_entity_decltUnparsedEntityDeclHandlert
notation_decltNotationDeclHandlertstart_namespace_decltStartNamespaceDeclHandlertend_namespace_decltEndNamespaceDeclHandlerRt_decl_handler_propR'RGtexternal_entity_reftExternalEntityRefHandlertskipped_entity_handlertSkippedEntityHandlertAttributeErrortSetParamEntityParsingt*XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONER(R)(R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR/s6	
		

	
	cCs|jdkrdS|jjS(N(RRR(R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR>scCs|jdkrdS|jjS(Ni(RRR(R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRCscCs
|jj�S(N(RR (R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR HscCs
|jj�S(N(RR!(R((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR!KscCs|jj|t|��dS(N(R0tstartElementtAttributesImpl(RR>tattrs((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRtOscCs|jj|�dS(N(R0t
endElement(RR>((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRuRscCsL|j�}t|�dkr-d|f}n5t|�dkrV|d|df}nt|�}i}i}x�|j�D]�\}}|j�}t|�}	|	dkr�|}
d|f}nQ|	dkr�d|d|df}
|d|df}n|d}
t|�}|||<|
||<q{W|jj|dt||��dS(Niiis%s:%si(tsplittlenRttupletitemsR0tstartElementNStAttributesNSImpl(RR>R�tpairtnewattrstqnamestanameRHtpartstlengthtqnametapair((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRpUs.

cCsy|j�}t|�dkr-d|f}n5t|�dkrV|d|df}nt|�}|jj|d�dS(Niii(R�R�RR�R0tendElementNS(RR>R�((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRrwscCs|jj||�dS(N(R0R](RttargetRR((s+/usr/lib64/python2.7/xml/sax/expatreader.pytprocessing_instruction�scCs|jj|�dS(N(R0R_(RRR((s+/usr/lib64/python2.7/xml/sax/expatreader.pytcharacter_data�scCs|jj||�dS(N(R0tstartPrefixMapping(Rtprefixturi((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRz�scCs|jj|�dS(N(R0tendPrefixMapping(RR�((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR|�scCs|jj|||�dS(N(R'tstartDTD(RR>tsysidtpubidthas_internal_subset((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRi�scCs|jj||||�dS(N(t_dtd_handlertunparsedEntityDecl(RR>R9R�R�t
notation_name((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRv�scCs|jj|||�dS(N(R�tnotationDecl(RR>R9R�R�((s+/usr/lib64/python2.7/xml/sax/expatreader.pyRx�scCs�|js
dS|jj||�}tj||jj�p=d�}|jj|j	|jf�|j	j
|�|_	||_ytjj
||�WndSX|jd\|_	|_|jd=dS(NiR[ii����(R*t_ent_handlert
resolveEntityR
R.RR!R)tappendRtExternalEntityParserCreateRR$R2(RtcontextR9R�R�R4((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR�s 				
cCs'|rd|}n|jj|�dS(Nt%(R0t
skippedEntity(RR>tis_pe((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR��s
ii�("RRR"RR2R:R;R?RBRFRIRVR3RXR<RGR/RRR R!RtRuRpRrR�R�RzR|RiRvRxRR�(((s+/usr/lib64/python2.7/xml/sax/expatreader.pyR#Ws@
													'							"									cOs
t||�S(N(R#(targstkwargs((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt
create_parser�st__main__s:http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml(.R"tversiontxml.sax._exceptionstxml.sax.handlerRRRRRRRRtsystplatformtSAXReaderNotAvailableRtxml.parsersR
tImportErrorREtxml.saxRR
RR�R�t_weakrefRtweakreftproxyRtLocatorRR$R#R�Rtxml.sax.saxutilstxmltpR;tsaxtXMLGeneratortsetErrorHandlertErrorHandlerR2(((s+/usr/lib64/python2.7/xml/sax/expatreader.pyt<module>sL

		

	$�a		PK�"[�hj��sax/__init__.pyonu�[����
{fc@sjdZddlmZddlmZmZddlmZmZm	Z	m
Z
mZe�d�Ze�d�Z
dgZdZer�dd	lZndd	lZdd	lZejjr�d
ejkr�ejd
jd�Zn[dZejd
 dkr/ejje�r/ejje�jd�Zngd�Zejd
 dkrZd�Zn	d�Z[d	S(s�Simple API for XML (SAX) implementation for Python.

This module provides an implementation of the SAX 2 interface;
information about the Java version of the interface can be found at
http://www.megginson.com/SAX/.  The Python version of the interface is
documented at <...>.

This package contains the following modules:

handler -- Base classes and constants which define the SAX 2 API for
           the 'client-side' of SAX for Python.

saxutils -- Implementation of the convenience classes commonly used to
            work with SAX.

xmlreader -- Base classes and constants which define the SAX 2 API for
             the parsers used with SAX for Python.

expatreader -- Driver that allows use of the Expat parser with SAX.
i����(tInputSource(tContentHandlertErrorHandler(tSAXExceptiontSAXNotRecognizedExceptiontSAXParseExceptiontSAXNotSupportedExceptiontSAXReaderNotAvailablecCs4t�}|j|�|j|�|j|�dS(N(tmake_parsertsetContentHandlertsetErrorHandlertparse(tsourcethandlerterrorHandlertparser((s(/usr/lib64/python2.7/xml/sax/__init__.pyRs	

cCs�yddlm}Wn!tk
r7ddlm}nX|dkrPt�}nt�}|j|�|j|�t�}|j	||��|j
|�dS(Ni����(tStringIO(t	cStringIORtImportErrortNoneRRR	R
Rt
setByteStreamR(tstringR
RRRtinpsrc((s(/usr/lib64/python2.7/xml/sax/__init__.pytparseString#s
	

	sxml.sax.expatreaderiNt
PY_SAX_PARSERt,spython.xml.sax.parseritjavacCs}xg|tD][}yt|�SWqtk
rU}ddl}||jkrf�qfqtk
reqXqWtdd��dS(s&Creates and returns a SAX parser.

    Creates the first parser it is able to instantiate of the ones
    given in the list created by doing parser_list +
    default_parser_list.  The lists must contain the names of Python
    modules containing both a SAX parser and a create_parser function.i����NsNo parsers found(tdefault_parser_listt_create_parserRtsystmodulesRR(tparser_listtparser_nameteR((s(/usr/lib64/python2.7/xml/sax/__init__.pyRGs	
cCs2ddlm}|j|dt��}|j�S(Ni����(timpi(torg.python.coreR"t
importNametglobalst
create_parser(R R"t
drv_module((s(/usr/lib64/python2.7/xml/sax/__init__.pyRbscCs"t|iidg�}|j�S(NR&(t
__import__R&(R R'((s(/usr/lib64/python2.7/xml/sax/__init__.pyRhs(t__doc__t	xmlreaderRR
RRt_exceptionsRRRRRRRRt_falsetxml.sax.expatreadertxmltosRtflagstignore_environmenttenvirontsplitt_keytplatformtregistrytcontainsKeytgetPropertyRR(((s(/usr/lib64/python2.7/xml/sax/__init__.pyt<module>s*(	%	PK�"[deq�2�2sax/handler.pycnu�[����
{fc@s�dZdZddd��YZddd��YZddd��YZddd	��YZd
ZdZdZd
Z	dZ
dZeeee	e
egZdZ
dZdZdZdZdZe
eeeeegZdS(s0
This module contains the core classes of version 2.0 of SAX for Python.
This file provides only default classes with absolutely minimum
functionality, from which drivers and applications can be subclassed.

Many of these classes are empty and are included only as documentation
of the interfaces.

$Id$
s2.0betatErrorHandlercBs)eZdZd�Zd�Zd�ZRS(s�Basic interface for SAX error handlers.

    If you create an object that implements this interface, then
    register the object with your XMLReader, the parser will call the
    methods in your object to report all warnings and errors. There
    are three levels of errors available: warnings, (possibly)
    recoverable errors, and unrecoverable errors. All methods take a
    SAXParseException as the only parameter.cCs
|�dS(sHandle a recoverable error.N((tselft	exception((s'/usr/lib64/python2.7/xml/sax/handler.pyterror scCs
|�dS(sHandle a non-recoverable error.N((RR((s'/usr/lib64/python2.7/xml/sax/handler.pyt
fatalError$scCs	|GHdS(sHandle a warning.N((RR((s'/usr/lib64/python2.7/xml/sax/handler.pytwarning(s(t__name__t
__module__t__doc__RRR(((s'/usr/lib64/python2.7/xml/sax/handler.pyRs		tContentHandlercBs�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�ZRS(s�Interface for receiving logical document content events.

    This is the main callback interface in SAX, and the one most
    important to applications. The order of events in this interface
    mirrors the order of the information in the document.cCs
d|_dS(N(tNonet_locator(R((s'/usr/lib64/python2.7/xml/sax/handler.pyt__init__6scCs
||_dS(s#Called by the parser to give the application a locator for
        locating the origin of document events.

        SAX parsers are strongly encouraged (though not absolutely
        required) to supply a locator: if it does so, it must supply
        the locator to the application by invoking this method before
        invoking any of the other methods in the DocumentHandler
        interface.

        The locator allows the application to determine the end
        position of any document-related event, even if the parser is
        not reporting an error. Typically, the application will use
        this information for reporting its own errors (such as
        character content that does not match an application's
        business rules). The information returned by the locator is
        probably not sufficient for use with a search engine.

        Note that the locator will return correct information only
        during the invocation of the events in this interface. The
        application should not attempt to use it at any other time.N(R(Rtlocator((s'/usr/lib64/python2.7/xml/sax/handler.pytsetDocumentLocator9scCsdS(s�Receive notification of the beginning of a document.

        The SAX parser will invoke this method only once, before any
        other methods in this interface or in DTDHandler (except for
        setDocumentLocator).N((R((s'/usr/lib64/python2.7/xml/sax/handler.pyt
startDocumentPtcCsdS(sQReceive notification of the end of a document.

        The SAX parser will invoke this method only once, and it will
        be the last method invoked during the parse. The parser shall
        not invoke this method until it has either abandoned parsing
        (because of an unrecoverable error) or reached the end of
        input.N((R((s'/usr/lib64/python2.7/xml/sax/handler.pytendDocumentWRcCsdS(sBegin the scope of a prefix-URI Namespace mapping.

        The information from this event is not necessary for normal
        Namespace processing: the SAX XML reader will automatically
        replace prefixes for element and attribute names when the
        http://xml.org/sax/features/namespaces feature is true (the
        default).

        There are cases, however, when applications need to use
        prefixes in character data or in attribute values, where they
        cannot safely be expanded automatically; the
        start/endPrefixMapping event supplies the information to the
        application to expand prefixes in those contexts itself, if
        necessary.

        Note that start/endPrefixMapping events are not guaranteed to
        be properly nested relative to each-other: all
        startPrefixMapping events will occur before the corresponding
        startElement event, and all endPrefixMapping events will occur
        after the corresponding endElement event, but their order is
        not guaranteed.N((Rtprefixturi((s'/usr/lib64/python2.7/xml/sax/handler.pytstartPrefixMapping`RcCsdS(s�End the scope of a prefix-URI mapping.

        See startPrefixMapping for details. This event will always
        occur after the corresponding endElement event, but the order
        of endPrefixMapping events is not otherwise guaranteed.N((RR((s'/usr/lib64/python2.7/xml/sax/handler.pytendPrefixMappingwRcCsdS(sSignals the start of an element in non-namespace mode.

        The name parameter contains the raw XML 1.0 name of the
        element type as a string and the attrs parameter holds an
        instance of the Attributes class containing the attributes of
        the element.N((Rtnametattrs((s'/usr/lib64/python2.7/xml/sax/handler.pytstartElement~RcCsdS(s�Signals the end of an element in non-namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElement event.N((RR((s'/usr/lib64/python2.7/xml/sax/handler.pyt
endElement�RcCsdS(s�Signals the start of an element in namespace mode.

        The name parameter contains the name of the element type as a
        (uri, localname) tuple, the qname parameter the raw XML 1.0
        name used in the source document, and the attrs parameter
        holds an instance of the Attributes class containing the
        attributes of the element.

        The uri part of the name tuple is None for elements which have
        no namespace.N((RRtqnameR((s'/usr/lib64/python2.7/xml/sax/handler.pytstartElementNS�RcCsdS(s�Signals the end of an element in namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElementNS event.N((RRR((s'/usr/lib64/python2.7/xml/sax/handler.pytendElementNS�RcCsdS(s�Receive notification of character data.

        The Parser will call this method to report each chunk of
        character data. SAX parsers may return all contiguous
        character data in a single chunk, or they may split it into
        several chunks; however, all of the characters in any single
        event must come from the same external entity so that the
        Locator provides useful information.N((Rtcontent((s'/usr/lib64/python2.7/xml/sax/handler.pyt
characters�RcCsdS(swReceive notification of ignorable whitespace in element content.

        Validating Parsers must use this method to report each chunk
        of ignorable whitespace (see the W3C XML 1.0 recommendation,
        section 2.10): non-validating parsers may also use this method
        if they are capable of parsing and using content models.

        SAX parsers may return all contiguous whitespace in a single
        chunk, or they may split it into several chunks; however, all
        of the characters in any single event must come from the same
        external entity, so that the Locator provides useful
        information.N((Rt
whitespace((s'/usr/lib64/python2.7/xml/sax/handler.pytignorableWhitespace�RcCsdS(s�Receive notification of a processing instruction.

        The Parser will invoke this method once for each processing
        instruction found: note that processing instructions may occur
        before or after the main document element.

        A SAX parser should never report an XML declaration (XML 1.0,
        section 2.8) or a text declaration (XML 1.0, section 4.3.1)
        using this method.N((Rttargettdata((s'/usr/lib64/python2.7/xml/sax/handler.pytprocessingInstruction�RcCsdS(sReceive notification of a skipped entity.

        The Parser will invoke this method once for each entity
        skipped. Non-validating processors may skip entities if they
        have not seen the declarations (because, for example, the
        entity was declared in an external DTD subset). All processors
        may skip external entities, depending on the values of the
        http://xml.org/sax/features/external-general-entities and the
        http://xml.org/sax/features/external-parameter-entities
        properties.N((RR((s'/usr/lib64/python2.7/xml/sax/handler.pyt
skippedEntity�R(RRRRRRRRRRRRRRR R#R$(((s'/usr/lib64/python2.7/xml/sax/handler.pyR	/s												
		t
DTDHandlercBs eZdZd�Zd�ZRS(s�Handle DTD events.

    This interface specifies only those DTD events required for basic
    parsing (unparsed entities and attributes).cCsdS(s$Handle a notation declaration event.N((RRtpublicIdtsystemId((s'/usr/lib64/python2.7/xml/sax/handler.pytnotationDecl�RcCsdS(s,Handle an unparsed entity declaration event.N((RRR&R'tndata((s'/usr/lib64/python2.7/xml/sax/handler.pytunparsedEntityDecl�R(RRRR(R*(((s'/usr/lib64/python2.7/xml/sax/handler.pyR%�s	tEntityResolvercBseZdZd�ZRS(s7Basic interface for resolving entities. If you create an object
    implementing this interface, then register the object with your
    Parser, the parser will call the method in your object to
    resolve all external entities. Note that DefaultHandler implements
    this interface with the default behaviour.cCs|S(s�Resolve the system identifier of an entity and return either
        the system identifier to read from as a string, or an InputSource
        to read from.((RR&R'((s'/usr/lib64/python2.7/xml/sax/handler.pyt
resolveEntity�s(RRRR,(((s'/usr/lib64/python2.7/xml/sax/handler.pyR+�ss&http://xml.org/sax/features/namespacess.http://xml.org/sax/features/namespace-prefixess,http://xml.org/sax/features/string-internings&http://xml.org/sax/features/validations5http://xml.org/sax/features/external-general-entitiess7http://xml.org/sax/features/external-parameter-entitiess-http://xml.org/sax/properties/lexical-handlers1http://xml.org/sax/properties/declaration-handlers&http://xml.org/sax/properties/dom-nodes(http://xml.org/sax/properties/xml-strings-http://www.python.org/sax/properties/encodings3http://www.python.org/sax/properties/interning-dictN(((((RtversionRR	R%R+tfeature_namespacestfeature_namespace_prefixestfeature_string_interningtfeature_validationtfeature_external_gestfeature_external_pestall_featurestproperty_lexical_handlertproperty_declaration_handlertproperty_dom_nodetproperty_xml_stringtproperty_encodingtproperty_interning_dicttall_properties(((s'/usr/lib64/python2.7/xml/sax/handler.pyt<module>
s:
�		PK�"[��/�sax/_exceptions.pyonu�[����
{fc@s�dZddlZejd dkr8ddlmZn[defd��YZdefd	��YZd
efd��YZdefd
��YZdefd��YZ	dS(s!Different kinds of SAX Exceptionsi����Nitjava(t	ExceptiontSAXExceptioncBs>eZdZdd�Zd�Zd�Zd�Zd�ZRS(s�Encapsulate an XML error or warning. This class can contain
    basic error or warning information from either the XML parser or
    the application: you can subclass it to provide additional
    functionality, or to add localization. Note that although you will
    receive a SAXException as the argument to the handlers in the
    ErrorHandler interface, you are not actually required to raise
    the exception; instead, you can simply read the information in
    it.cCs&||_||_tj||�dS(sUCreates an exception. The message is required, but the exception
        is optional.N(t_msgt
_exceptionRt__init__(tselftmsgt	exception((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRs		cCs|jS(s$Return a message for this exception.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyt
getMessagescCs|jS(s9Return the embedded exception, or None if there was none.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pytgetExceptionscCs|jS(s0Create a string representation of the exception.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyt__str__"scCstd��dS(svAvoids weird error messages if someone does exception[ix] by
        mistake, since Exception has __getitem__ defined.t__getitem__N(tAttributeError(Rtix((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR&sN(	t__name__t
__module__t__doc__tNoneRR	R
RR(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR	s			tSAXParseExceptioncBsDeZdZd�Zd�Zd�Zd�Zd�Zd�ZRS(s#Encapsulate an XML parse error or warning.

    This exception will include information for locating the error in
    the original XML document. Note that although the application will
    receive a SAXParseException as the argument to the handlers in the
    ErrorHandler interface, the application is not actually required
    to raise the exception; instead, it can simply read the
    information in it and take a different action.

    Since this exception is a subclass of SAXException, it inherits
    the ability to wrap another exception.cCsVtj|||�||_|jj�|_|jj�|_|jj�|_dS(sECreates the exception. The exception parameter is allowed to be None.N(	RRt_locatortgetSystemIdt	_systemIdtgetColumnNumbert_colnumt
getLineNumbert_linenum(RRRtlocator((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR;s
	cCs|jS(sNThe column number of the end of the text where the exception
        occurred.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRHscCs|jS(sDThe line number of the end of the text where the exception occurred.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRMscCs
|jj�S(sEGet the public identifier of the entity where the exception occurred.(RtgetPublicId(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRQscCs|jS(sEGet the system identifier of the entity where the exception occurred.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRUscCsz|j�}|dkr!d}n|j�}|dkrBd}n|j�}|dkrcd}nd||||jfS(s0Create a string representation of the exception.s	<unknown>t?s%s:%s:%s: %sN(RRRRR(Rtsysidtlinenumtcolnum((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRYs			(	RRRRRRRRR(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR.s	
				tSAXNotRecognizedExceptioncBseZdZRS(s�Exception class for an unrecognized identifier.

    An XMLReader will raise this exception when it is confronted with an
    unrecognized feature or property. SAX applications and extensions may
    use this class for similar purposes.(RRR(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR!istSAXNotSupportedExceptioncBseZdZRS(sException class for an unsupported operation.

    An XMLReader will raise this exception when a service it cannot
    perform is requested (specifically setting a state or value). SAX
    applications and extensions may use this class for similar
    purposes.(RRR(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR"sstSAXReaderNotAvailablecBseZdZRS(sException class for a missing driver.

    An XMLReader module (driver) should raise this exception when it
    is first imported, e.g. when a support module cannot be imported.
    It also may be raised during parsing, e.g. if executing an external
    program is not permitted.(RRR(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR#}s(
Rtsystplatformt	java.langRRRR!R"R#(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyt<module>s%;

PK�"[deq�2�2sax/handler.pyonu�[����
{fc@s�dZdZddd��YZddd��YZddd��YZddd	��YZd
ZdZdZd
Z	dZ
dZeeee	e
egZdZ
dZdZdZdZdZe
eeeeegZdS(s0
This module contains the core classes of version 2.0 of SAX for Python.
This file provides only default classes with absolutely minimum
functionality, from which drivers and applications can be subclassed.

Many of these classes are empty and are included only as documentation
of the interfaces.

$Id$
s2.0betatErrorHandlercBs)eZdZd�Zd�Zd�ZRS(s�Basic interface for SAX error handlers.

    If you create an object that implements this interface, then
    register the object with your XMLReader, the parser will call the
    methods in your object to report all warnings and errors. There
    are three levels of errors available: warnings, (possibly)
    recoverable errors, and unrecoverable errors. All methods take a
    SAXParseException as the only parameter.cCs
|�dS(sHandle a recoverable error.N((tselft	exception((s'/usr/lib64/python2.7/xml/sax/handler.pyterror scCs
|�dS(sHandle a non-recoverable error.N((RR((s'/usr/lib64/python2.7/xml/sax/handler.pyt
fatalError$scCs	|GHdS(sHandle a warning.N((RR((s'/usr/lib64/python2.7/xml/sax/handler.pytwarning(s(t__name__t
__module__t__doc__RRR(((s'/usr/lib64/python2.7/xml/sax/handler.pyRs		tContentHandlercBs�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�ZRS(s�Interface for receiving logical document content events.

    This is the main callback interface in SAX, and the one most
    important to applications. The order of events in this interface
    mirrors the order of the information in the document.cCs
d|_dS(N(tNonet_locator(R((s'/usr/lib64/python2.7/xml/sax/handler.pyt__init__6scCs
||_dS(s#Called by the parser to give the application a locator for
        locating the origin of document events.

        SAX parsers are strongly encouraged (though not absolutely
        required) to supply a locator: if it does so, it must supply
        the locator to the application by invoking this method before
        invoking any of the other methods in the DocumentHandler
        interface.

        The locator allows the application to determine the end
        position of any document-related event, even if the parser is
        not reporting an error. Typically, the application will use
        this information for reporting its own errors (such as
        character content that does not match an application's
        business rules). The information returned by the locator is
        probably not sufficient for use with a search engine.

        Note that the locator will return correct information only
        during the invocation of the events in this interface. The
        application should not attempt to use it at any other time.N(R(Rtlocator((s'/usr/lib64/python2.7/xml/sax/handler.pytsetDocumentLocator9scCsdS(s�Receive notification of the beginning of a document.

        The SAX parser will invoke this method only once, before any
        other methods in this interface or in DTDHandler (except for
        setDocumentLocator).N((R((s'/usr/lib64/python2.7/xml/sax/handler.pyt
startDocumentPtcCsdS(sQReceive notification of the end of a document.

        The SAX parser will invoke this method only once, and it will
        be the last method invoked during the parse. The parser shall
        not invoke this method until it has either abandoned parsing
        (because of an unrecoverable error) or reached the end of
        input.N((R((s'/usr/lib64/python2.7/xml/sax/handler.pytendDocumentWRcCsdS(sBegin the scope of a prefix-URI Namespace mapping.

        The information from this event is not necessary for normal
        Namespace processing: the SAX XML reader will automatically
        replace prefixes for element and attribute names when the
        http://xml.org/sax/features/namespaces feature is true (the
        default).

        There are cases, however, when applications need to use
        prefixes in character data or in attribute values, where they
        cannot safely be expanded automatically; the
        start/endPrefixMapping event supplies the information to the
        application to expand prefixes in those contexts itself, if
        necessary.

        Note that start/endPrefixMapping events are not guaranteed to
        be properly nested relative to each-other: all
        startPrefixMapping events will occur before the corresponding
        startElement event, and all endPrefixMapping events will occur
        after the corresponding endElement event, but their order is
        not guaranteed.N((Rtprefixturi((s'/usr/lib64/python2.7/xml/sax/handler.pytstartPrefixMapping`RcCsdS(s�End the scope of a prefix-URI mapping.

        See startPrefixMapping for details. This event will always
        occur after the corresponding endElement event, but the order
        of endPrefixMapping events is not otherwise guaranteed.N((RR((s'/usr/lib64/python2.7/xml/sax/handler.pytendPrefixMappingwRcCsdS(sSignals the start of an element in non-namespace mode.

        The name parameter contains the raw XML 1.0 name of the
        element type as a string and the attrs parameter holds an
        instance of the Attributes class containing the attributes of
        the element.N((Rtnametattrs((s'/usr/lib64/python2.7/xml/sax/handler.pytstartElement~RcCsdS(s�Signals the end of an element in non-namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElement event.N((RR((s'/usr/lib64/python2.7/xml/sax/handler.pyt
endElement�RcCsdS(s�Signals the start of an element in namespace mode.

        The name parameter contains the name of the element type as a
        (uri, localname) tuple, the qname parameter the raw XML 1.0
        name used in the source document, and the attrs parameter
        holds an instance of the Attributes class containing the
        attributes of the element.

        The uri part of the name tuple is None for elements which have
        no namespace.N((RRtqnameR((s'/usr/lib64/python2.7/xml/sax/handler.pytstartElementNS�RcCsdS(s�Signals the end of an element in namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElementNS event.N((RRR((s'/usr/lib64/python2.7/xml/sax/handler.pytendElementNS�RcCsdS(s�Receive notification of character data.

        The Parser will call this method to report each chunk of
        character data. SAX parsers may return all contiguous
        character data in a single chunk, or they may split it into
        several chunks; however, all of the characters in any single
        event must come from the same external entity so that the
        Locator provides useful information.N((Rtcontent((s'/usr/lib64/python2.7/xml/sax/handler.pyt
characters�RcCsdS(swReceive notification of ignorable whitespace in element content.

        Validating Parsers must use this method to report each chunk
        of ignorable whitespace (see the W3C XML 1.0 recommendation,
        section 2.10): non-validating parsers may also use this method
        if they are capable of parsing and using content models.

        SAX parsers may return all contiguous whitespace in a single
        chunk, or they may split it into several chunks; however, all
        of the characters in any single event must come from the same
        external entity, so that the Locator provides useful
        information.N((Rt
whitespace((s'/usr/lib64/python2.7/xml/sax/handler.pytignorableWhitespace�RcCsdS(s�Receive notification of a processing instruction.

        The Parser will invoke this method once for each processing
        instruction found: note that processing instructions may occur
        before or after the main document element.

        A SAX parser should never report an XML declaration (XML 1.0,
        section 2.8) or a text declaration (XML 1.0, section 4.3.1)
        using this method.N((Rttargettdata((s'/usr/lib64/python2.7/xml/sax/handler.pytprocessingInstruction�RcCsdS(sReceive notification of a skipped entity.

        The Parser will invoke this method once for each entity
        skipped. Non-validating processors may skip entities if they
        have not seen the declarations (because, for example, the
        entity was declared in an external DTD subset). All processors
        may skip external entities, depending on the values of the
        http://xml.org/sax/features/external-general-entities and the
        http://xml.org/sax/features/external-parameter-entities
        properties.N((RR((s'/usr/lib64/python2.7/xml/sax/handler.pyt
skippedEntity�R(RRRRRRRRRRRRRRR R#R$(((s'/usr/lib64/python2.7/xml/sax/handler.pyR	/s												
		t
DTDHandlercBs eZdZd�Zd�ZRS(s�Handle DTD events.

    This interface specifies only those DTD events required for basic
    parsing (unparsed entities and attributes).cCsdS(s$Handle a notation declaration event.N((RRtpublicIdtsystemId((s'/usr/lib64/python2.7/xml/sax/handler.pytnotationDecl�RcCsdS(s,Handle an unparsed entity declaration event.N((RRR&R'tndata((s'/usr/lib64/python2.7/xml/sax/handler.pytunparsedEntityDecl�R(RRRR(R*(((s'/usr/lib64/python2.7/xml/sax/handler.pyR%�s	tEntityResolvercBseZdZd�ZRS(s7Basic interface for resolving entities. If you create an object
    implementing this interface, then register the object with your
    Parser, the parser will call the method in your object to
    resolve all external entities. Note that DefaultHandler implements
    this interface with the default behaviour.cCs|S(s�Resolve the system identifier of an entity and return either
        the system identifier to read from as a string, or an InputSource
        to read from.((RR&R'((s'/usr/lib64/python2.7/xml/sax/handler.pyt
resolveEntity�s(RRRR,(((s'/usr/lib64/python2.7/xml/sax/handler.pyR+�ss&http://xml.org/sax/features/namespacess.http://xml.org/sax/features/namespace-prefixess,http://xml.org/sax/features/string-internings&http://xml.org/sax/features/validations5http://xml.org/sax/features/external-general-entitiess7http://xml.org/sax/features/external-parameter-entitiess-http://xml.org/sax/properties/lexical-handlers1http://xml.org/sax/properties/declaration-handlers&http://xml.org/sax/properties/dom-nodes(http://xml.org/sax/properties/xml-strings-http://www.python.org/sax/properties/encodings3http://www.python.org/sax/properties/interning-dictN(((((RtversionRR	R%R+tfeature_namespacestfeature_namespace_prefixestfeature_string_interningtfeature_validationtfeature_external_gestfeature_external_pestall_featurestproperty_lexical_handlertproperty_declaration_handlertproperty_dom_nodetproperty_xml_stringtproperty_encodingtproperty_interning_dicttall_properties(((s'/usr/lib64/python2.7/xml/sax/handler.pyt<module>
s:
�		PK�"[ȳ�KKsax/xmlreader.pyonu�[����
{fc@s�dZddlZddlmZmZddd��YZdefd��YZddd	��YZd
dd��YZddd
��YZ	de	fd��YZ
d�Zedkr�e�ndS(s]An XML Reader is the SAX 2 name for an XML parser. XML Parsers
should be based on this code. i����N(tSAXNotSupportedExceptiontSAXNotRecognizedExceptiont	XMLReadercBs�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�ZRS(s%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.cCs@tj�|_tj�|_tj�|_tj�|_dS(N(	thandlertContentHandlert
_cont_handlert
DTDHandlert_dtd_handlertEntityResolvert_ent_handlertErrorHandlert_err_handler(tself((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt__init__scCstd��dS(sAParse an XML document from a system identifier or an InputSource.s This method must be implemented!N(tNotImplementedError(Rtsource((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytparsescCs|jS(s#Returns the current ContentHandler.(R(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetContentHandler"scCs
||_dS(s:Registers a new object to receive document content events.N(R(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetContentHandler&scCs|jS(s Returns the current DTD handler.(R(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
getDTDHandler*scCs
||_dS(s7Register an object to receive basic DTD-related events.N(R(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
setDTDHandler.scCs|jS(s#Returns the current EntityResolver.(R	(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetEntityResolver2scCs
||_dS(s0Register an object to resolve external entities.N(R	(Rtresolver((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetEntityResolver6scCs|jS(s!Returns the current ErrorHandler.(R(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetErrorHandler:scCs
||_dS(s3Register an object to receive error-message events.N(R(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetErrorHandler>scCstd��dS(sHAllow 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.sLocale support not implementedN(R(Rtlocale((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt	setLocaleBscCstd|��dS(s1Looks up and returns the state of a SAX2 feature.sFeature '%s' not recognizedN(R(Rtname((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
getFeatureKscCstd|��dS(s!Sets the state of a SAX2 feature.sFeature '%s' not recognizedN(R(RRtstate((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
setFeatureOscCstd|��dS(s2Looks up and returns the value of a SAX2 property.sProperty '%s' not recognizedN(R(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetPropertySscCstd|��dS(s"Sets the value of a SAX2 property.sProperty '%s' not recognizedN(R(RRtvalue((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetPropertyWs(t__name__t
__module__t__doc__R
RRRRRRRRRRRRR R"(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRs 															tIncrementalParsercBsGeZdZd	d�Zd�Zd�Zd�Zd�Zd�ZRS(
ssThis 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.iicCs||_tj|�dS(N(t_bufsizeRR
(Rtbufsize((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR
os	cCs�ddl}|j|�}|j|�|j�}|j|j�}x/|dkrw|j|�|j|j�}qIW|j�dS(Ni����t(tsaxutilstprepare_input_sourcet
prepareParsert
getByteStreamtreadR'tfeedtclose(RRR*tfiletbuffer((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRss

cCstd��dS(sThis 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.s This method must be implemented!N(R(Rtdata((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR/scCstd��dS(stThis method is called by the parse implementation to allow
        the SAX 2.0 driver to prepare itself for parsing.s!prepareParser must be overridden!N(R(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR,�scCstd��dS(s�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.s This method must be implemented!N(R(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR0�scCstd��dS(s�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.s This method must be implemented!N(R(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytreset�si(	R#R$R%R
RR/R,R0R4(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR&[s					
tLocatorcBs2eZdZd�Zd�Zd�Zd�ZRS(s�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.cCsdS(s6Return the column number where the current event ends.i����((R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetColumnNumber�scCsdS(s4Return the line number where the current event ends.i����((R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
getLineNumber�scCsdS(s3Return the public identifier for the current event.N(tNone(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetPublicId�scCsdS(s3Return the system identifier for the current event.N(R8(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetSystemId�s(R#R$R%R6R7R9R:(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR5�s
			tInputSourcecBsteZdZdd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�ZRS(
snEncapsulation 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.cCs1||_d|_d|_d|_d|_dS(N(t_InputSource__system_idR8t_InputSource__public_idt_InputSource__encodingt_InputSource__bytefilet_InputSource__charfile(Rt	system_id((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR
�s
				cCs
||_dS(s/Sets the public identifier of this InputSource.N(R=(Rt	public_id((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetPublicId�scCs|jS(s2Returns the public identifier of this InputSource.(R=(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR9�scCs
||_dS(s/Sets the system identifier of this InputSource.N(R<(RRA((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetSystemId�scCs|jS(s2Returns the system identifier of this InputSource.(R<(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR:�scCs
||_dS(s4Sets 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.N(R>(Rtencoding((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetEncoding�scCs|jS(s/Get the character encoding of this InputSource.(R>(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetEncoding�scCs
||_dS(s�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.N(R?(Rtbytefile((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
setByteStream�scCs|jS(s�Get the byte stream for this input source.

        The getEncoding method will return the character encoding for
        this byte stream, or None if unknown.(R?(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR-�scCs
||_dS(s^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.N(R@(Rtcharfile((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetCharacterStreamscCs|jS(s/Get the character stream for this input source.(R@(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetCharacterStreamsN(R#R$R%R8R
RCR9RDR:RFRGRIR-RKRL(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR;�s					
		
		
tAttributesImplcBs�eZd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zdd�Zd�Zd�Zd�ZRS(cCs
||_dS(sQNon-NS-aware implementation.

        attrs should be of the form {name : value}.N(t_attrs(Rtattrs((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR
scCs
t|j�S(N(tlenRN(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt	getLengthscCsdS(NtCDATA((RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetTypescCs|j|S(N(RN(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetValue"scCs|j|S(N(RN(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetValueByQName%scCs||jkrt|�n|S(N(RNtKeyError(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetNameByQName(scCs||jkrt|�n|S(N(RNRV(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetQNameByName-scCs
|jj�S(N(RNtkeys(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetNames2scCs
|jj�S(N(RNRY(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt	getQNames5scCs
t|j�S(N(RPRN(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt__len__8scCs|j|S(N(RN(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt__getitem__;scCs
|jj�S(N(RNRY(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRY>scCs
||jkS(N(RN(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pythas_keyAscCs
||jkS(N(RN(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt__contains__DscCs|jj||�S(N(RNtget(RRtalternative((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR`GscCs|j|j�S(N(t	__class__RN(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytcopyJscCs
|jj�S(N(RNtitems(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRdMscCs
|jj�S(N(RNtvalues(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRePsN(R#R$R
RQRSRTRURWRXRZR[R\R]RYR^R_R8R`RcRdRe(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRMs$																tAttributesNSImplcBs>eZd�Zd�Zd�Zd�Zd�Zd�ZRS(cCs||_||_dS(s�NS-aware implementation.

        attrs should be of the form {(ns_uri, lname): value, ...}.
        qnames of the form {(ns_uri, lname): qname, ...}.N(RNt_qnames(RROtqnames((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR
Ws	cCsDx4|jj�D]#\}}||kr|j|SqWt|�dS(N(RgRdRNRV(RRtnsnametqname((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRU_scCs=x-|jj�D]\}}||kr|SqWt|�dS(N(RgRdRV(RRRiRj((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRWfscCs|j|S(N(Rg(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRXmscCs
|jj�S(N(RgRe(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR[pscCs|j|j|j�S(N(RbRNRg(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRcss(R#R$R
RURWRXR[Rc(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRfUs					cCst�t�t�dS(N(RR&R5(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt_testwst__main__(((((
R%Rt_exceptionsRRRR&R5R;RMRfRkR#(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt<module>sPHYA"	PK�"[�hj��sax/__init__.pycnu�[����
{fc@sjdZddlmZddlmZmZddlmZmZm	Z	m
Z
mZe�d�Ze�d�Z
dgZdZer�dd	lZndd	lZdd	lZejjr�d
ejkr�ejd
jd�Zn[dZejd
 dkr/ejje�r/ejje�jd�Zngd�Zejd
 dkrZd�Zn	d�Z[d	S(s�Simple API for XML (SAX) implementation for Python.

This module provides an implementation of the SAX 2 interface;
information about the Java version of the interface can be found at
http://www.megginson.com/SAX/.  The Python version of the interface is
documented at <...>.

This package contains the following modules:

handler -- Base classes and constants which define the SAX 2 API for
           the 'client-side' of SAX for Python.

saxutils -- Implementation of the convenience classes commonly used to
            work with SAX.

xmlreader -- Base classes and constants which define the SAX 2 API for
             the parsers used with SAX for Python.

expatreader -- Driver that allows use of the Expat parser with SAX.
i����(tInputSource(tContentHandlertErrorHandler(tSAXExceptiontSAXNotRecognizedExceptiontSAXParseExceptiontSAXNotSupportedExceptiontSAXReaderNotAvailablecCs4t�}|j|�|j|�|j|�dS(N(tmake_parsertsetContentHandlertsetErrorHandlertparse(tsourcethandlerterrorHandlertparser((s(/usr/lib64/python2.7/xml/sax/__init__.pyRs	

cCs�yddlm}Wn!tk
r7ddlm}nX|dkrPt�}nt�}|j|�|j|�t�}|j	||��|j
|�dS(Ni����(tStringIO(t	cStringIORtImportErrortNoneRRR	R
Rt
setByteStreamR(tstringR
RRRtinpsrc((s(/usr/lib64/python2.7/xml/sax/__init__.pytparseString#s
	

	sxml.sax.expatreaderiNt
PY_SAX_PARSERt,spython.xml.sax.parseritjavacCs}xg|tD][}yt|�SWqtk
rU}ddl}||jkrf�qfqtk
reqXqWtdd��dS(s&Creates and returns a SAX parser.

    Creates the first parser it is able to instantiate of the ones
    given in the list created by doing parser_list +
    default_parser_list.  The lists must contain the names of Python
    modules containing both a SAX parser and a create_parser function.i����NsNo parsers found(tdefault_parser_listt_create_parserRtsystmodulesRR(tparser_listtparser_nameteR((s(/usr/lib64/python2.7/xml/sax/__init__.pyRGs	
cCs2ddlm}|j|dt��}|j�S(Ni����(timpi(torg.python.coreR"t
importNametglobalst
create_parser(R R"t
drv_module((s(/usr/lib64/python2.7/xml/sax/__init__.pyRbscCs"t|iidg�}|j�S(NR&(t
__import__R&(R R'((s(/usr/lib64/python2.7/xml/sax/__init__.pyRhs(t__doc__t	xmlreaderRR
RRt_exceptionsRRRRRRRRt_falsetxml.sax.expatreadertxmltosRtflagstignore_environmenttenvirontsplitt_keytplatformtregistrytcontainsKeytgetPropertyRR(((s(/usr/lib64/python2.7/xml/sax/__init__.pyt<module>s*(	%	PK�"[ȳ�KKsax/xmlreader.pycnu�[����
{fc@s�dZddlZddlmZmZddd��YZdefd��YZddd	��YZd
dd��YZddd
��YZ	de	fd��YZ
d�Zedkr�e�ndS(s]An XML Reader is the SAX 2 name for an XML parser. XML Parsers
should be based on this code. i����N(tSAXNotSupportedExceptiontSAXNotRecognizedExceptiont	XMLReadercBs�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�ZRS(s%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.cCs@tj�|_tj�|_tj�|_tj�|_dS(N(	thandlertContentHandlert
_cont_handlert
DTDHandlert_dtd_handlertEntityResolvert_ent_handlertErrorHandlert_err_handler(tself((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt__init__scCstd��dS(sAParse an XML document from a system identifier or an InputSource.s This method must be implemented!N(tNotImplementedError(Rtsource((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytparsescCs|jS(s#Returns the current ContentHandler.(R(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetContentHandler"scCs
||_dS(s:Registers a new object to receive document content events.N(R(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetContentHandler&scCs|jS(s Returns the current DTD handler.(R(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
getDTDHandler*scCs
||_dS(s7Register an object to receive basic DTD-related events.N(R(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
setDTDHandler.scCs|jS(s#Returns the current EntityResolver.(R	(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetEntityResolver2scCs
||_dS(s0Register an object to resolve external entities.N(R	(Rtresolver((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetEntityResolver6scCs|jS(s!Returns the current ErrorHandler.(R(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetErrorHandler:scCs
||_dS(s3Register an object to receive error-message events.N(R(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetErrorHandler>scCstd��dS(sHAllow 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.sLocale support not implementedN(R(Rtlocale((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt	setLocaleBscCstd|��dS(s1Looks up and returns the state of a SAX2 feature.sFeature '%s' not recognizedN(R(Rtname((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
getFeatureKscCstd|��dS(s!Sets the state of a SAX2 feature.sFeature '%s' not recognizedN(R(RRtstate((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
setFeatureOscCstd|��dS(s2Looks up and returns the value of a SAX2 property.sProperty '%s' not recognizedN(R(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetPropertySscCstd|��dS(s"Sets the value of a SAX2 property.sProperty '%s' not recognizedN(R(RRtvalue((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetPropertyWs(t__name__t
__module__t__doc__R
RRRRRRRRRRRRR R"(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRs 															tIncrementalParsercBsGeZdZd	d�Zd�Zd�Zd�Zd�Zd�ZRS(
ssThis 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.iicCs||_tj|�dS(N(t_bufsizeRR
(Rtbufsize((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR
os	cCs�ddl}|j|�}|j|�|j�}|j|j�}x/|dkrw|j|�|j|j�}qIW|j�dS(Ni����t(tsaxutilstprepare_input_sourcet
prepareParsert
getByteStreamtreadR'tfeedtclose(RRR*tfiletbuffer((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRss

cCstd��dS(sThis 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.s This method must be implemented!N(R(Rtdata((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR/scCstd��dS(stThis method is called by the parse implementation to allow
        the SAX 2.0 driver to prepare itself for parsing.s!prepareParser must be overridden!N(R(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR,�scCstd��dS(s�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.s This method must be implemented!N(R(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR0�scCstd��dS(s�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.s This method must be implemented!N(R(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytreset�si(	R#R$R%R
RR/R,R0R4(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR&[s					
tLocatorcBs2eZdZd�Zd�Zd�Zd�ZRS(s�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.cCsdS(s6Return the column number where the current event ends.i����((R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetColumnNumber�scCsdS(s4Return the line number where the current event ends.i����((R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
getLineNumber�scCsdS(s3Return the public identifier for the current event.N(tNone(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetPublicId�scCsdS(s3Return the system identifier for the current event.N(R8(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetSystemId�s(R#R$R%R6R7R9R:(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR5�s
			tInputSourcecBsteZdZdd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�ZRS(
snEncapsulation 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.cCs1||_d|_d|_d|_d|_dS(N(t_InputSource__system_idR8t_InputSource__public_idt_InputSource__encodingt_InputSource__bytefilet_InputSource__charfile(Rt	system_id((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR
�s
				cCs
||_dS(s/Sets the public identifier of this InputSource.N(R=(Rt	public_id((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetPublicId�scCs|jS(s2Returns the public identifier of this InputSource.(R=(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR9�scCs
||_dS(s/Sets the system identifier of this InputSource.N(R<(RRA((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetSystemId�scCs|jS(s2Returns the system identifier of this InputSource.(R<(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR:�scCs
||_dS(s4Sets 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.N(R>(Rtencoding((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetEncoding�scCs|jS(s/Get the character encoding of this InputSource.(R>(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetEncoding�scCs
||_dS(s�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.N(R?(Rtbytefile((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt
setByteStream�scCs|jS(s�Get the byte stream for this input source.

        The getEncoding method will return the character encoding for
        this byte stream, or None if unknown.(R?(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR-�scCs
||_dS(s^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.N(R@(Rtcharfile((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytsetCharacterStreamscCs|jS(s/Get the character stream for this input source.(R@(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetCharacterStreamsN(R#R$R%R8R
RCR9RDR:RFRGRIR-RKRL(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR;�s					
		
		
tAttributesImplcBs�eZd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zdd�Zd�Zd�Zd�ZRS(cCs
||_dS(sQNon-NS-aware implementation.

        attrs should be of the form {name : value}.N(t_attrs(Rtattrs((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR
scCs
t|j�S(N(tlenRN(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt	getLengthscCsdS(NtCDATA((RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetTypescCs|j|S(N(RN(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetValue"scCs|j|S(N(RN(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetValueByQName%scCs||jkrt|�n|S(N(RNtKeyError(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetNameByQName(scCs||jkrt|�n|S(N(RNRV(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetQNameByName-scCs
|jj�S(N(RNtkeys(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytgetNames2scCs
|jj�S(N(RNRY(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt	getQNames5scCs
t|j�S(N(RPRN(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt__len__8scCs|j|S(N(RN(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt__getitem__;scCs
|jj�S(N(RNRY(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRY>scCs
||jkS(N(RN(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pythas_keyAscCs
||jkS(N(RN(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt__contains__DscCs|jj||�S(N(RNtget(RRtalternative((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR`GscCs|j|j�S(N(t	__class__RN(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pytcopyJscCs
|jj�S(N(RNtitems(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRdMscCs
|jj�S(N(RNtvalues(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRePsN(R#R$R
RQRSRTRURWRXRZR[R\R]RYR^R_R8R`RcRdRe(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRMs$																tAttributesNSImplcBs>eZd�Zd�Zd�Zd�Zd�Zd�ZRS(cCs||_||_dS(s�NS-aware implementation.

        attrs should be of the form {(ns_uri, lname): value, ...}.
        qnames of the form {(ns_uri, lname): qname, ...}.N(RNt_qnames(RROtqnames((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR
Ws	cCsDx4|jj�D]#\}}||kr|j|SqWt|�dS(N(RgRdRNRV(RRtnsnametqname((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRU_scCs=x-|jj�D]\}}||kr|SqWt|�dS(N(RgRdRV(RRRiRj((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRWfscCs|j|S(N(Rg(RR((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRXmscCs
|jj�S(N(RgRe(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyR[pscCs|j|j|j�S(N(RbRNRg(R((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRcss(R#R$R
RURWRXR[Rc(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyRfUs					cCst�t�t�dS(N(RR&R5(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt_testwst__main__(((((
R%Rt_exceptionsRRRR&R5R;RMRfRkR#(((s)/usr/lib64/python2.7/xml/sax/xmlreader.pyt<module>sPHYA"	PK�"[��/�sax/_exceptions.pycnu�[����
{fc@s�dZddlZejd dkr8ddlmZn[defd��YZdefd	��YZd
efd��YZdefd
��YZdefd��YZ	dS(s!Different kinds of SAX Exceptionsi����Nitjava(t	ExceptiontSAXExceptioncBs>eZdZdd�Zd�Zd�Zd�Zd�ZRS(s�Encapsulate an XML error or warning. This class can contain
    basic error or warning information from either the XML parser or
    the application: you can subclass it to provide additional
    functionality, or to add localization. Note that although you will
    receive a SAXException as the argument to the handlers in the
    ErrorHandler interface, you are not actually required to raise
    the exception; instead, you can simply read the information in
    it.cCs&||_||_tj||�dS(sUCreates an exception. The message is required, but the exception
        is optional.N(t_msgt
_exceptionRt__init__(tselftmsgt	exception((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRs		cCs|jS(s$Return a message for this exception.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyt
getMessagescCs|jS(s9Return the embedded exception, or None if there was none.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pytgetExceptionscCs|jS(s0Create a string representation of the exception.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyt__str__"scCstd��dS(svAvoids weird error messages if someone does exception[ix] by
        mistake, since Exception has __getitem__ defined.t__getitem__N(tAttributeError(Rtix((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR&sN(	t__name__t
__module__t__doc__tNoneRR	R
RR(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR	s			tSAXParseExceptioncBsDeZdZd�Zd�Zd�Zd�Zd�Zd�ZRS(s#Encapsulate an XML parse error or warning.

    This exception will include information for locating the error in
    the original XML document. Note that although the application will
    receive a SAXParseException as the argument to the handlers in the
    ErrorHandler interface, the application is not actually required
    to raise the exception; instead, it can simply read the
    information in it and take a different action.

    Since this exception is a subclass of SAXException, it inherits
    the ability to wrap another exception.cCsVtj|||�||_|jj�|_|jj�|_|jj�|_dS(sECreates the exception. The exception parameter is allowed to be None.N(	RRt_locatortgetSystemIdt	_systemIdtgetColumnNumbert_colnumt
getLineNumbert_linenum(RRRtlocator((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR;s
	cCs|jS(sNThe column number of the end of the text where the exception
        occurred.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRHscCs|jS(sDThe line number of the end of the text where the exception occurred.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRMscCs
|jj�S(sEGet the public identifier of the entity where the exception occurred.(RtgetPublicId(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRQscCs|jS(sEGet the system identifier of the entity where the exception occurred.(R(R((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRUscCsz|j�}|dkr!d}n|j�}|dkrBd}n|j�}|dkrcd}nd||||jfS(s0Create a string representation of the exception.s	<unknown>t?s%s:%s:%s: %sN(RRRRR(Rtsysidtlinenumtcolnum((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyRYs			(	RRRRRRRRR(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR.s	
				tSAXNotRecognizedExceptioncBseZdZRS(s�Exception class for an unrecognized identifier.

    An XMLReader will raise this exception when it is confronted with an
    unrecognized feature or property. SAX applications and extensions may
    use this class for similar purposes.(RRR(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR!istSAXNotSupportedExceptioncBseZdZRS(sException class for an unsupported operation.

    An XMLReader will raise this exception when a service it cannot
    perform is requested (specifically setting a state or value). SAX
    applications and extensions may use this class for similar
    purposes.(RRR(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR"sstSAXReaderNotAvailablecBseZdZRS(sException class for a missing driver.

    An XMLReader module (driver) should raise this exception when it
    is first imported, e.g. when a support module cannot be imported.
    It also may be raised during parsing, e.g. if executing an external
    program is not permitted.(RRR(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyR#}s(
Rtsystplatformt	java.langRRRR!R"R#(((s+/usr/lib64/python2.7/xml/sax/_exceptions.pyt<module>s%;

PK�"[����9�9sax/saxutils.pycnu�[����
{fc@s-dZddlZddlZddlZddlZddlZddlZddlZddlZyej	ej
gZWnek
r�ej	gZnXd�Z
id�Zid�Zid�Zd�Zdejfd	��YZd
ejfd��YZdejfd
��YZdd�ZdS(snA library of useful helper classes to the SAX classes, for the
convenience of application and driver writers.
i����NcCs3x,|j�D]\}}|j||�}q
W|S(s2Replace substrings of a string using a dictionary.(titemstreplace(tstdtkeytvalue((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt__dict_replacescCsR|jdd�}|jdd�}|jdd�}|rNt||�}n|S(s�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.
    t&s&amp;t>s&gt;t<s&lt;(RR(tdatatentities((s(/usr/lib64/python2.7/xml/sax/saxutils.pytescapes	cCsL|jdd�}|jdd�}|r<t||�}n|jdd�S(s
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.
    s&lt;R	s&gt;Rs&amp;R(RR(R
R((s(/usr/lib64/python2.7/xml/sax/saxutils.pytunescape's
cCs�|j�}|jidd6dd6dd6�t||�}d|kr{d|krnd	|jdd
�}q�d|}n
d	|}|S(s�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.
    s&#10;s
s&#13;s
s&#9;s	t"t's"%s"s&quot;s'%s'(tcopytupdateRR(R
R((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt	quoteattr5s"

cCs�|dkr$ddl}|j}nt|tj�rTtj|�}d�|_nTtj�}d�|_|j	|_	y|j
|_
|j|_Wntk
r�nXt
|d|dddd�S(	Ni����cSsdS(N(tNone(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt<lambda>VtcSstS(N(tTrue(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR[Rtencodingterrorstxmlcharrefreplacetnewlines
(Rtsyststdoutt
isinstancetiot	RawIOBasetBufferedIOBasetclosetwritabletwritetseekablettelltAttributeErrort_UnbufferedTextIOWrapper(toutRRtbuffer((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt_gettextwriterMs"
R'cBseZd�ZRS(cCs$tt|�j|�|j�dS(N(tsuperR'R#tflush(tselfR((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR#ks(t__name__t
__module__R#(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR'jstXMLGeneratorcBs�eZddd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�ZRS(s
iso-8859-1cCsitjj|�t||�}|j|_|j|_ig|_|jd|_	g|_
||_dS(Ni����(thandlertContentHandlert__init__R*R#t_writeR,t_flusht_ns_contextst_current_contextt_undeclared_ns_mapst	_encoding(R-R(R((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR3rs	cCsX|drPd|dkr&d|dS|j|d}|rP|d|dSn|dS(s7Builds a qualified name from a (ns_url, localname) pairis$http://www.w3.org/XML/1998/namespacesxml:it:(R7(R-tnametprefix((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt_qname|s
cCs|jd|j�dS(Nu$<?xml version="1.0" encoding="%s"?>
(R4R9(R-((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt
startDocument�s	cCs|j�dS(N(R5(R-((s(/usr/lib64/python2.7/xml/sax/saxutils.pytendDocument�scCs@|jj|jj��||j|<|jj||f�dS(N(R6tappendR7RR8(R-R<turi((s(/usr/lib64/python2.7/xml/sax/saxutils.pytstartPrefixMapping�s
cCs|jd|_|jd=dS(Ni����(R6R7(R-R<((s(/usr/lib64/python2.7/xml/sax/saxutils.pytendPrefixMapping�scCs\|jd|�x7|j�D])\}}|jd|t|�f�qW|jd�dS(Nu<u %s=%su>(R4RR(R-R;tattrsR((s(/usr/lib64/python2.7/xml/sax/saxutils.pytstartElement�s!cCs|jd|�dS(Nu</%s>(R4(R-R;((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt
endElement�scCs�|jd|j|��xH|jD]=\}}|rP|jd||f�q$|jd|�q$Wg|_x@|j�D]2\}}|jd|j|�t|�f�q{W|jd�dS(Nu<u xmlns:%s="%s"u xmlns="%s"u %s=%su>(R4R=R8RR(R-R;tqnameRDR<RAR((s(/usr/lib64/python2.7/xml/sax/saxutils.pytstartElementNS�s	*cCs|jd|j|��dS(Nu</%s>(R4R=(R-R;RG((s(/usr/lib64/python2.7/xml/sax/saxutils.pytendElementNS�scCs;t|t�s$t||j�}n|jt|��dS(N(RtunicodeR9R4R(R-tcontent((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt
characters�scCs5t|t�s$t||j�}n|j|�dS(N(RRJR9R4(R-RK((s(/usr/lib64/python2.7/xml/sax/saxutils.pytignorableWhitespace�scCs|jd||f�dS(Nu	<?%s %s?>(R4(R-ttargetR
((s(/usr/lib64/python2.7/xml/sax/saxutils.pytprocessingInstruction�sN(R.R/RR3R=R>R?RBRCRERFRHRIRLRMRO(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR0ps
											t
XMLFilterBasecBs
eZdZdd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZRS(sYThis 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.cCstjj|�||_dS(N(t	xmlreadert	XMLReaderR3t_parent(R-tparent((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR3�scCs|jj|�dS(N(t_err_handlerterror(R-t	exception((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRV�scCs|jj|�dS(N(RUt
fatalError(R-RW((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRX�scCs|jj|�dS(N(RUtwarning(R-RW((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRY�scCs|jj|�dS(N(t
_cont_handlertsetDocumentLocator(R-tlocator((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR[�scCs|jj�dS(N(RZR>(R-((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR>�scCs|jj�dS(N(RZR?(R-((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR?�scCs|jj||�dS(N(RZRB(R-R<RA((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRB�scCs|jj|�dS(N(RZRC(R-R<((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRC�scCs|jj||�dS(N(RZRE(R-R;RD((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRE�scCs|jj|�dS(N(RZRF(R-R;((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRF�scCs|jj|||�dS(N(RZRH(R-R;RGRD((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRH�scCs|jj||�dS(N(RZRI(R-R;RG((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRI�scCs|jj|�dS(N(RZRL(R-RK((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRL�scCs|jj|�dS(N(RZRM(R-tchars((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRM�scCs|jj||�dS(N(RZRO(R-RNR
((s(/usr/lib64/python2.7/xml/sax/saxutils.pyROscCs|jj|�dS(N(RZt
skippedEntity(R-R;((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR^scCs|jj|||�dS(N(t_dtd_handlertnotationDecl(R-R;tpublicIdtsystemId((s(/usr/lib64/python2.7/xml/sax/saxutils.pyR`	scCs|jj||||�dS(N(R_tunparsedEntityDecl(R-R;RaRbtndata((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRcscCs|jj||�S(N(t_ent_handlert
resolveEntity(R-RaRb((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRfscCsT|jj|�|jj|�|jj|�|jj|�|jj|�dS(N(RStsetContentHandlertsetErrorHandlertsetEntityResolvert
setDTDHandlertparse(R-tsource((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRks
cCs|jj|�dS(N(RSt	setLocale(R-tlocale((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRmscCs|jj|�S(N(RSt
getFeature(R-R;((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRo scCs|jj||�dS(N(RSt
setFeature(R-R;tstate((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRp#scCs|jj|�S(N(RStgetProperty(R-R;((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRr&scCs|jj||�dS(N(RStsetProperty(R-R;R((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRs)scCs|jS(N(RS(R-((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt	getParent.scCs
||_dS(N(RS(R-RT((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt	setParent1sN( R.R/t__doc__RR3RVRXRYR[R>R?RBRCRERFRHRIRLRMROR^R`RcRfRkRmRoRpRrRsRtRu(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyRP�s:																										RcCst|�tkr$tj|�}nSt|d�rw|}tj�}|j|�t|d�rw|j|j�qwn|j�dkry|j
�}tjj
tjj|��}tj�}t|t�rt|t�sdy|j|�}Wqtk
r|j|�}qXqdnHt|t�rdy|j|�}Wqdtk
r`|j|�}qdXntjj||�}tjj|�}Wntk
r�t}nX|r�|j|�t|d�}n4|jtj||j
���tj|j
��}|j|�n|S(s�This function takes an InputSource and an optional base URL and
    returns a fully resolved InputSource object ready for reading.treadR;trbN(ttypet_StringTypesRQtInputSourcethasattrt
setByteStreamtsetSystemIdR;t
getByteStreamRtgetSystemIdtostpathtdirnametnormpathRtgetfilesystemencodingRRJtdecodetUnicodeDecodeErrortencodetjointisfiletUnicodeErrortFalsetopenturlparseturljointurllibturlopen(RltbasetftsysidtbaseheadRt
sysidfilenameR�((s(/usr/lib64/python2.7/xml/sax/saxutils.pytprepare_input_source6sF





(RvR�R�R�ttypesRRR1RQt
StringTypetUnicodeTypeRzR&RRR
RR*t
TextIOWrapperR'R2R0RRRPR�(((s(/usr/lib64/python2.7/xml/sax/saxutils.pyt<module>s$0
		WoPK�"[��@s++1parsers/__pycache__/__init__.cpython-36.opt-1.pycnu�[���3


 \��@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.6/xml/parsers/__init__.py�<module>sPK�"[d��GHH(parsers/__pycache__/expat.cpython-36.pycnu�[���3


 \��@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.6/xml/parsers/expat.py�<module>s
PK�"[P\}(��1parsers/__pycache__/__init__.cpython-36.opt-2.pycnu�[���3


 \��@sdS)N�rrr�,/usr/lib64/python3.6/xml/parsers/__init__.py�<module>sPK�"[��@s+++parsers/__pycache__/__init__.cpython-36.pycnu�[���3


 \��@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.6/xml/parsers/__init__.py�<module>sPK�"[d��GHH.parsers/__pycache__/expat.cpython-36.opt-1.pycnu�[���3


 \��@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.6/xml/parsers/expat.py�<module>s
PK�"[��9:.parsers/__pycache__/expat.cpython-36.opt-2.pycnu�[���3


 \��@s(ddlZddlTeejd<eejd<dS)�N)�*zxml.parsers.expat.modelzxml.parsers.expat.errors)�sysZpyexpatZmodel�modules�errors�rr�)/usr/lib64/python3.6/xml/parsers/expat.py�<module>s
PK�"[����99-dom/__pycache__/__init__.cpython-36.opt-1.pycnu�[���3


 \��@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@sDeZdZdZfZdZdZdZdZdZ	dZ
dZd	Zd
Z
dZdZd
ZdS)�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_NODE�rr�(/usr/lib64/python3.6/xml/dom/__init__.pyrs	rrrrrrrrr	r
rr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
PK�"[qm3(�(�&dom/__pycache__/minidom.cpython-36.pycnu�[���3


 \�@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.6/xml/dom/minidom.py�__bool__+sz
Node.__bool__cCs|jdd|�S)N�)�toprettyxml)r�encodingr
r
r�toxml.sz
Node.toxml�	�
cCsx|dkrtj�}ntjtj�|ddd�}|jtjkrH|j|d|||�n|j|d||�|dkrh|j�S|j	�j�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�
childNodes)rr
r
r�
hasChildNodesCszNode.hasChildNodescCs|jS)N)r$)rr
r
r�_get_childNodesFszNode._get_childNodescCs|jr|jdSdS)Nr)r$)rr
r
r�_get_firstChildIszNode._get_firstChildcCs|jr|jdSdS)N����)r$)rr
r
r�_get_lastChildMszNode._get_lastChildcCs|j|jkr0xt|j�D]}|j||�qW|S|j|jkrXtjjdt	|�t	|�f��|j
dk	rn|j
j|�|dkr�|j|�n�y|jj
|�}Wntk
r�tjj��YnX|jtkr�t|�|jj||�||_||_|r�|j|d}||_||_nd|_||_
|S)Nz%s cannot be child of %sr()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�cr6�noder
r
rr-Qs6

zNode.insertBeforecCs�|j|jkr.xt|j�D]}|j|�qW|S|j|jkrXtjjdt	|�t	|�f��n|jt
krjt|�|jdk	r�|jj
|�t||�d|_|S)Nz%s cannot be child of %s)rr+r,r$r5r.r/r0r1r2r9r:r3r4�
_append_childr<)rrAr@r
r
rr5qs


zNode.appendChildcCs|j|jkr(|j}|j|�|j||�S|j|jkrPtjjdt	|�t	|�f��||kr\dS|j
dk	rr|j
j|�y|jj|�}Wnt
k
r�tjj��YnX||j|<||_
d|_
|jtks�|jtkr�t|�|j|_|j|_d|_d|_|jr�||j_|j�r||j_|S)Nz%s cannot be child of %s)rr+r<r4r-r.r/r0r1r2r3r$r6r7r8r9r:r=)rr>�oldChildr?r6r
r
r�replaceChild�s<




zNode.replaceChildcCs�y|jj|�Wntk
r.tjj��YnX|jdk	rD|j|j_|jdk	rX|j|j_d|_|_|jt	krvt
|�d|_|S)N)r$�remover7r/r0r8r<r=rr9r:r3)rrCr
r
rr4�s




zNode.removeChildcCs�g}x�|jD]�}|jtjkr�|jsL|r2|j|d_|jrB|j|j_|j�q�|r�|dj|jkr�|d}|j|j|_|j|_|jr�||j_|j�q�|j|�q|j|�|jtj	kr|j
�qW||jdd�<dS)Nr(r)r)r))r$rr	�	TEXT_NODE�datar<r=�unlink�append�ELEMENT_NODE�	normalize)r�L�childrAr
r
rrK�s*



zNode.normalizecCst|||jp|�S)N)�_clone_node�
ownerDocument)r�deepr
r
r�	cloneNode�szNode.cloneNodecCs|jjj||�S)N)rO�implementation�
hasFeature)r�feature�versionr
r
r�isSupported�szNode.isSupportedcCsdS)Nr
)rr
r
r�_get_localName�szNode._get_localNamecCs||kS)Nr
)r�otherr
r
r�
isSameNode�szNode.isSameNodecCs|j|d�r|SdSdS)N)rV)rrTr
r
r�getInterface�szNode.getInterfacecCs,y|j|dSttfk
r&dSXdS)Nr)�
_user_data�AttributeError�KeyError)r�keyr
r
r�getUserData�szNode.getUserDatacCsnd}y
|j}Wntk
r,i}||_YnX||krB||d}|dkr^d}|dk	rj||=n||f||<|S)Nr)r[r\)rr^rG�handler�old�dr
r
r�setUserData�s
zNode.setUserDatacCsHt|d�rDx8t|jj��D]&\}\}}|dk	r|j|||||�qWdS)Nr[)�hasattr�listr[�itemsZhandle)r�	operation�src�dstr^rGr`r
r
r�_call_user_data_handler�s
zNode._call_user_data_handlercCsBd|_|_|jr2x|jD]}|j�qWt�|_d|_d|_dS)N)r3rOr$rH�NodeListr=r<)rrMr
r
rrHszNode.unlinkcCs|S)Nr
)rr
r
r�	__enter__szNode.__enter__cCs|j�dS)N)rH)rZetZev�tbr
r
r�__exit__sz
Node.__exit__)N)rrN)!�__name__�
__module__�__qualname__�namespaceURIr3rOr<r=r�prefixr
rrr%r&r'r*r-r5rDr4rKrQrVrWrYrZr_rcrjrHrlrnr
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}||_||_|j|�||_dS)Nr(r))r$r=r<rIr3)rrAr$Zlastr
r
rrBs
rBcCs(x"|dk	r"|jtjkrdS|j}qWdS)NTF)rr	rr3)rAr
r
r�_in_document&s


rxcCs6|r2|jdd�jdd�jdd�jdd�}|j|�d	S)
zWrites datachars to writer.�&z&amp;�<z&lt;�"z&quot;�>z&gt;N)�replace�write)r"rGr
r
r�_write_data.srcCsHxB|jD]8}|jtjkr4|dks*|j|kr4|j|�t|||�qW|S)Nr)r$rr	rJ�tagNamerI�_get_elements_by_tagName_helper)�parent�name�rcrAr
r
rr�5s
r�cCs\xV|jD]L}|jtjkr|dks*|j|krF|dks<|j|krF|j|�t||||�qW|S)Nr)r$rr	rJrwrrrI�"_get_elements_by_tagName_ns_helper)r�ZnsURIrwr�rAr
r
rr�=s
r�c@sJeZdZejZdZdZdZdZ	ej
ejejej
ejejejfZdd�ZdS)�DocumentFragmentz#document-fragmentNcCst�|_dS)N)rkr$)rr
r
r�__init__TszDocumentFragment.__init__)rorprqr	r+r�nodeName�	nodeValue�
attributesr3rJrF�CDATA_SECTION_NODE�ENTITY_REFERENCE_NODE�PROCESSING_INSTRUCTION_NODE�COMMENT_NODE�
NOTATION_NODEr.r�r
r
r
rr�Fsr�c@s�eZdZd#ZejZd	Zd
Zd
Z	ej
ejfZe
d	d	fdd�Zd
d�Zdd�Zdd�Zdd�Zeee�ZZdd�Zdd�Zeee�ZZdd�Zdd�Zeee�Zdd�Zdd �Zd!d"�Zd	S)$�Attr�_name�_valuerr�_prefixr$�
_localNamerO�ownerElementNFcCs2d|_||_||_||_t�|_|jjt��dS)N)r�r�rrr�rkr$rI�Text)r�qNamerrrwrsr
r
rr�bsz
Attr.__init__cCs.y|jStk
r(|jjdd�dSXdS)N�:r(r))r�r\r��split)rr
r
rrWoszAttr._get_localNamecCs|jS)N)�	specified)rr
r
r�_get_specifieduszAttr._get_specifiedcCs|jS)N)r�)rr
r
r�	_get_namexszAttr._get_namecCs||_|jdk	rt|j�dS)N)r�r�r:)r�valuer
r
r�	_set_name{s
zAttr._set_namecCs|jS)N)r�)rr
r
r�
_get_value�szAttr._get_valuecCs6||_||jd_|jdk	r&t|j�||jd_dS)Nr)r�r$rGr�r:)rr�r
r
r�
_set_value�s


zAttr._set_valuecCs|jS)N)r�)rr
r
r�_get_prefix�szAttr._get_prefixcCsd|j}|dkr&|r&|tkr&tjjd��||_|dkr<|j}nd||jf}|jrZt|j�||_	dS)N�xmlnsz5illegal use of 'xmlns' prefix for the wrong namespacez%s:%s)
rrrr/r0�NamespaceErrr�rwr�r:r�)rrsZnsuriZnewNamer
r
r�_set_prefix�s
zAttr._set_prefixcCsz|j}|dk	rR|j|j=|j|j|jf=|jrRd|_|jd8_|jj	d8_	x|j
D]}|j�qZW|j
dd�=dS)NFr()r��_attrsr��_attrsNSrrrw�_is_id�_magic_id_nodesrO�_magic_id_countr$rH)r�elemrMr
r
rrH�s
zAttr.unlinkcCsf|jr
dS|j}|j}|dks&|dkr*dS|j|�}|dkr@dS|jrV|j|j|j�S|j|j�SdS)NTF)	r�rOr��_get_elem_inforr�isIdNSrw�isIdr�)rrur��infor
r
r�	_get_isId�s
zAttr._get_isIdcCs\|j}|j}|dks|dkr tS|j|�}|dkr6tS|jrL|j|j|j�S|j|j�SdS)N)	rOr��_no_typer�rr�getAttributeTypeNSrw�getAttributeTyper�)rrur�r�r
r
r�_get_schemaType�s
zAttr._get_schemaType)r�r�rrr�r$r�rOr�) rorprq�	__slots__r	�ATTRIBUTE_NODErr�r�r�rFr�r.rr�rWr�r�r��propertyr�r�r�r�r�r�r�r�rsrHr�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�eZdZdZd<Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
d=dd�ZeZdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Zd:d;�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||_||_||_dS)N)r�r�r�)r�attrsZattrsNSr�r
r
rr��szNamedNodeMap.__init__cCs
t|j�S)N)�lenr�)rr
r
r�_get_length�szNamedNodeMap._get_lengthcCs0y|t|jj��|Stk
r*dSXdS)N)rer��keys�
IndexError)rr6r
r
r�item�szNamedNodeMap.itemcCs.g}x$|jj�D]}|j|j|jf�qW|S)N)r��valuesrIr�r�)rrLrAr
r
rrf�szNamedNodeMap.itemscCs4g}x*|jj�D]}|j|j|jf|jf�qW|S)N)r�r�rIrrrwr�)rrLrAr
r
r�itemsNS�szNamedNodeMap.itemsNScCs"t|t�r||jkS||jkSdS)N)�
isinstance�strr�r�)rr^r
r
r�__contains__�s

zNamedNodeMap.__contains__cCs
|jj�S)N)r�r�)rr
r
rr�szNamedNodeMap.keyscCs
|jj�S)N)r�r�)rr
r
r�keysNSszNamedNodeMap.keysNScCs
|jj�S)N)r�r�)rr
r
rr�szNamedNodeMap.valuesNcCs|jj||�S)N)r��get)rr�r�r
r
rr�
szNamedNodeMap.getcCs:|jt|dd�krdSt|�t|�kt|�t|�kSdS)Nr�r)r��getattr�id)rrXr
r
r�_cmpszNamedNodeMap._cmpcCs|j|�dkS)Nr)r�)rrXr
r
r�__eq__szNamedNodeMap.__eq__cCs|j|�dkS)Nr)r�)rrXr
r
r�__ge__szNamedNodeMap.__ge__cCs|j|�dkS)Nr)r�)rrXr
r
r�__gt__szNamedNodeMap.__gt__cCs|j|�dkS)Nr)r�)rrXr
r
r�__le__szNamedNodeMap.__le__cCs|j|�dkS)Nr)r�)rrXr
r
r�__lt__!szNamedNodeMap.__lt__cCs"t|t�r|j|S|j|SdS)N)r�r,r�r�)r�attname_or_tupler
r
r�__getitem__$s

zNamedNodeMap.__getitem__cCsvt|t�rRy|j|}Wn0tk
rHt|�}|jj|_|j|�YnX||_n t|t�sdt	d��|}|j|�dS)Nz%value must be a string or Attr object)
r�r�r�r]r�r�rO�setNamedItemr��	TypeError)r�attnamer�rAr
r
r�__setitem__+s


zNamedNodeMap.__setitem__cCs$y
|j|Stk
rdSXdS)N)r�r])rr�r
r
r�getNamedItem:s
zNamedNodeMap.getNamedItemcCs(y|j||fStk
r"dSXdS)N)r�r])rrrrwr
r
r�getNamedItemNS@szNamedNodeMap.getNamedItemNScCsX|j|�}|dk	rJt|j�|j|j=|j|j|jf=t|d�rFd|_	|St
jj��dS)Nr�)
r�r:r�r�r�r�rrrwrdr�r/r0r8)rr��nr
r
r�removeNamedItemFs



zNamedNodeMap.removeNamedItemcCsZ|j||�}|dk	rLt|j�|j|j|jf=|j|j=t|d�rHd|_	|St
jj��dS)Nr�)
r�r:r�r�rrrwr�r�rdr�r/r0r8)rrrrwr�r
r
r�removeNamedItemNSRs


zNamedNodeMap.removeNamedItemNScCstt|t�s&tjjdt|�t|�f��|jj|j�}|r@|j	�||j|j<||j
|j|jf<|j
|_t|j�|S)Nz%s cannot be child of %s)r�r�r/r0r1r2r�r�r�rHr�rrrwr�r�r:)rrArar
r
rr�^s

zNamedNodeMap.setNamedItemcCs
|j|�S)N)r�)rrAr
r
r�setNamedItemNSkszNamedNodeMap.setNamedItemNScCs||}t|j�|j�dS)N)r:r�rH)rr�rAr
r
r�__delitem__ns
zNamedNodeMap.__delitem__cCs|j|j|jfS)N)r�r�r�)rr
r
r�__getstate__sszNamedNodeMap.__getstate__cCs|\|_|_|_dS)N)r�r�r�)r�stater
r
r�__setstate__vszNamedNodeMap.__setstate__)r�r�r�)N)!rorprq�__doc__r�r�r�r�rfr�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@s0eZdZdZdd�Zdd�Zdd�Zd	d
�ZdS)
�TypeInfo�	namespacer�cCs||_||_dS)N)r�r�)rr�r�r
r
rr��szTypeInfo.__init__cCs2|jrd|jj|j|jfSd|jj|jfSdS)Nz<%s %r (from %r)>z<%s %r>)r��	__class__ror�)rr
r
r�__repr__�s
zTypeInfo.__repr__cCs|jS)N)r�)rr
r
rr��szTypeInfo._get_namecCs|jS)N)r�)rr
r
r�_get_namespace�szTypeInfo._get_namespaceN)r�r�)rorprqr�r�r�r�r�r
r
r
rr�s
r�c@s eZdZdDZejZd
ZeZ	dZ
ejejejej
ejejfZed
d
fdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�ZeZd'd(�Zd)d*�Z d+d,�Z!e!Z"d-d.�Z#d/d0�Z$d1d2�Z%d3d4�Z&d5d6�Z'dEd8d9�Z(d:d;�Z)d<d=�Z*d>d?�Z+d@dA�Z,dBdC�Z-d
S)F�ElementrOr3r�r�rsrrr�r$r�r�r<r=NrcCsBd|_||_|_||_||_t�|_d|_|_d|_	d|_
dS)N)r3r�r�rsrrrkr$r<r=r�r�)rr�rrrsrwr
r
rr��s
zElement.__init__cCs|jdkri|_i|_dS)N)r�r�)rr
r
r�_ensure_attributes�s
zElement._ensure_attributescCs.y|jStk
r(|jjdd�dSXdS)Nr�r(r))r�r\r�r�)rr
r
rrW�szElement._get_localNamecCs|jS)N)r�)rr
r
r�_get_tagName�szElement._get_tagNamecCsD|jdk	r*xt|jj��D]}|j�qWd|_d|_tj|�dS)N)r�rer�rHr�r	)r�attrr
r
rrH�s
zElement.unlinkcCs4|jdkrdSy|j|jStk
r.dSXdS)Nr)r�r�r])rr�r
r
r�getAttribute�s
zElement.getAttributecCs8|jdkrdSy|j||fjStk
r2dSXdS)Nr)r�r�r])rrrrwr
r
r�getAttributeNS�s
zElement.getAttributeNScCsV|j|�}|dkr4t|�}||_|j|_|j|�n||jkrR||_|jrRt|�dS)N)�getAttributeNoder�r�rO�setAttributeNoder�r:)rr�r�r�r
r
r�setAttribute�s

zElement.setAttributecCs�t|�\}}|j||�}|dkrHt||||�}||_|j|_|j|�n4||jkrf||_|jrft|�|j|kr|||_||_	dS)N)
�_nssplit�getAttributeNodeNSr�r�rOr�r�r:rsr�)rrr�
qualifiedNamer�rs�	localnamer�r
r
r�setAttributeNS�s

zElement.setAttributeNScCs|jdkrdS|jj|�S)N)r�r�)rZattrnamer
r
rr��s
zElement.getAttributeNodecCs|jdkrdS|jj||f�S)N)r�r�)rrrrwr
r
rr�s
zElement.getAttributeNodeNScCs�|jd|fkrtjjd��|j�|jj|jd�}|dk	rD|j|�|j	j|j
|jfd�}|dk	rt||k	rt|j|�t||�||k	r�|S||k	r�|SdS)Nzattribute node already owned)
r�r/r0ZInuseAttributeErrr�r�r�r��removeAttributeNoder�rrrw�_set_attribute_node)rr�Zold1Zold2r
r
rr�s


zElement.setAttributeNodecCsP|jdkrtjj��y|j|}Wntk
r@tjj��YnX|j|�dS)N)r�r/r0r8r�r]r�)rr�r�r
r
r�removeAttributes

zElement.removeAttributecCsT|jdkrtjj��y|j||f}Wntk
rDtjj��YnX|j|�dS)N)r�r/r0r8r]r�)rrrrwr�r
r
r�removeAttributeNS%s

zElement.removeAttributeNScCs^|dkrtjj��y|j|jWntk
r@tjj��YnXt|�|j�|j|_dS)N)	r/r0r8r�r�r]r:rHrO)rrAr
r
rr�.s
zElement.removeAttributeNodecCs|jdkrdS||jkS)NF)r�)rr�r
r
r�hasAttribute=s
zElement.hasAttributecCs|jdkrdS||f|jkS)NF)r�)rrrrwr
r
r�hasAttributeNSBs
zElement.hasAttributeNScCst||t��S)N)r�rk)rr�r
r
r�getElementsByTagNameGszElement.getElementsByTagNamecCst|||t��S)N)r�rk)rrrrwr
r
r�getElementsByTagNameNSJszElement.getElementsByTagNameNScCsd|jt|�fS)Nz<DOM Element: %s at %#x>)r�r�)rr
r
rr�NszElement.__repr__rc	Cs|j|d|j�|j�}t|j��}x4|D],}|jd|�t|||j�|jd�q.W|jr�|jd�t|j�dkr�|jdj	t
jkr�|jdj|ddd�n8|j|�x"|jD]}|j|||||�q�W|j|�|jd|j|f�n|jd	|�dS)
Nrzz %s="r{r|r(rrz</%s>%sz/>%s)
r~r��_get_attributes�sortedr�rr�r$r�rr	rFr)	rr"r �	addindentr!r�Za_namesZa_namerAr
r
rrQs$



zElement.writexmlcCs|j�t|j|j|�S)N)r�r�r�r�)rr
r
rr�lszElement._get_attributescCs|jr
dSdSdS)NTF)r�)rr
r
r�
hasAttributespszElement.hasAttributescCs|j|�}|j|�dS)N)r��setIdAttributeNode)rr��idAttrr
r
r�setIdAttributexs
zElement.setIdAttributecCs|j||�}|j|�dS)N)r�r)rrrrwrr
r
r�setIdAttributeNS|szElement.setIdAttributeNScCsl|dks|j|j�r tjj��t|�dk	r6tjj��|jshd|_|jd7_|j	j
d7_
t|�dS)NTr()rYr�r/r0r8�_get_containing_entref�NoModificationAllowedErrr�r�rOr�r:)rrr
r
rr�s

zElement.setIdAttributeNode)rOr3r�r�rsrrr�r$r�r�r<r=)rrr).rorprqr�r	rJrr�r�r�r�r�r�rFr�r�r.rr�r�rWr�rHr�r�r�r�r�r�r�ZsetAttributeNodeNSr�r�r�ZremoveAttributeNodeNSr�r�r�r�r�rr�r�rrrr
r
r
rr��sT		

r�r�z*NamedNodeMap of attributes on the element.z%Namespace-local name of this element.cCs8t|�|j�||j|j<||j|j|jf<||_dS)N)r:r�r�r�r�rrrwr�)�elementr�r
r
rr��s
r�c@sfeZdZdZfZdZe�ZdZdZ	dd�Z
dd�Zdd�Zd	d
�Z
dd�Zd
d�Zdd�Zdd�ZdS)�	Childlessz�Mixin that makes childless-ness easy to implement and avoids
    the complexity of the Node methods that deal with children.
    NcCsdS)Nr
)rr
r
rr'�szChildless._get_firstChildcCsdS)Nr
)rr
r
rr*�szChildless._get_lastChildcCstjj|jd��dS)Nz nodes cannot have children)r/r0r1r�)rrAr
r
rr5�szChildless.appendChildcCsdS)NFr
)rr
r
rr%�szChildless.hasChildNodescCstjj|jd��dS)Nz nodes do not have children)r/r0r1r�)rr>r?r
r
rr-�szChildless.insertBeforecCstjj|jd��dS)Nz nodes do not have children)r/r0r8r�)rrCr
r
rr4�szChildless.removeChildcCsdS)Nr
)rr
r
rrK�szChildless.normalizecCstjj|jd��dS)Nz nodes do not have children)r/r0r1r�)rr>rCr
r
rrD�szChildless.replaceChild)rorprqr�r�r�Z
EmptyNodeListr$rtrvr'r*r5r%r-r4rKrDr
r
r
rr�src@s\eZdZejZdZdd�Zdd�Zdd�Z	e
ee	�Zd	d
�Zdd�Z
e
ee
�Zddd�ZdS)�ProcessingInstruction�targetrGcCs||_||_dS)N)r	rG)rr	rGr
r
rr��szProcessingInstruction.__init__cCs|jS)N)rG)rr
r
r�_get_nodeValue�sz$ProcessingInstruction._get_nodeValuecCs
||_dS)N)rG)rr�r
r
r�_set_nodeValue�sz$ProcessingInstruction._set_nodeValuecCs|jS)N)r	)rr
r
r�
_get_nodeName�sz#ProcessingInstruction._get_nodeNamecCs
||_dS)N)r	)rr�r
r
r�
_set_nodeName�sz#ProcessingInstruction._set_nodeNamercCs|jd||j|j|f�dS)Nz
%s<?%s %s?>%s)r~r	rG)rr"r r�r!r
r
rr�szProcessingInstruction.writexmlN)r	rG)rrr)rorprqr	r�rr�r�r
rr�r�rr
r�rr
r
r
rr�s

rc@sreZdZdZdd�Zdd	�ZeZd
d�Zdd
�Ze	ee�Z
Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�
CharacterData�_datarOr3r=r<cCs,d|_|_d|_|_d|_tj|�dS)Nr)rOr3r=r<rr	r�)rr
r
rr��szCharacterData.__init__cCs
t|j�S)N)r�rG)rr
r
rr��szCharacterData._get_lengthcCs|jS)N)r)rr
r
r�	_get_data�szCharacterData._get_datacCs
||_dS)N)r)rrGr
r
r�	_set_data�szCharacterData._set_datacCs6|j}t|�dkrd}nd}d|jj|dd�|fS)N�
z...rz<DOM %s node "%r%s">r)rGr�r�ro)rrGZ	dotdotdotr
r
rr��szCharacterData.__repr__cCsT|dkrtjjd��|t|j�kr.tjjd��|dkrBtjjd��|j|||�S)Nrzoffset cannot be negativez#offset cannot be beyond end of datazcount cannot be negative)r/r0�IndexSizeErrr�rG)r�offset�countr
r
r�
substringData�szCharacterData.substringDatacCs|j||_dS)N)rG)r�argr
r
r�
appendDataszCharacterData.appendDatacCsZ|dkrtjjd��|t|j�kr.tjjd��|rVd|jd|�||j|d�f|_dS)Nrzoffset cannot be negativez#offset cannot be beyond end of dataz%s%s%s)r/r0rr�rG)rrrr
r
r�
insertDataszCharacterData.insertDatacCsl|dkrtjjd��|t|j�kr.tjjd��|dkrBtjjd��|rh|jd|�|j||d�|_dS)Nrzoffset cannot be negativez#offset cannot be beyond end of datazcount cannot be negative)r/r0rr�rG)rrrr
r
r�
deleteDataszCharacterData.deleteDatacCsr|dkrtjjd��|t|j�kr.tjjd��|dkrBtjjd��|rnd|jd|�||j||d�f|_dS)Nrzoffset cannot be negativez#offset cannot be beyond end of datazcount cannot be negativez%s%s%s)r/r0rr�rG)rrrrr
r
r�replaceDataszCharacterData.replaceDataN)rrOr3r=r<)rorprqr�r�r�r�rrr�rGr�r�rrrrrr
r
r
rr�s			
rzLength of the string data.c@sHeZdZfZejZdZdZdd�Z	ddd�Z
dd	�Zd
d�Zdd
�Z
dS)r�z#textNcCs�|dks|t|j�kr"tjjd��|j�}|j|d�|_|j|_|j}|jr~||jj	kr~|dkrp|jj
|�n|jj||�|jd|�|_|S)Nrzillegal offset value)r�rGr/r0rr�rOr<r3r$r5r-)rrZnewText�nextr
r
r�	splitText0szText.splitTextrcCst|d||j|f�dS)Nz%s%s%s)rrG)rr"r r�r!r
r
rr?sz
Text.writexmlcCs�|jg}|j}x6|dk	rD|jtjtjfkr@|jd|j�|j}qPqW|j}x4|dk	r�|jtjtjfkr||j|j�|j}qNPqNWdj	|�S)Nrr)
rGr=rr	rFr�r;r<rI�join)rrLr�r
r
r�_get_wholeTextDs

zText._get_wholeTextcCs�|j}|j}x6|dk	rB|jtjtjfkr>|j}|j|�|}qPqW|j}|sX|j|�x6|dk	r�|jtjtjfkr�|j}|j|�|}qZPqZW|r�||_|SdSdS)N)	r3r=rr	rFr�r4r<rG)rZcontentr�r�rr
r
r�replaceWholeTextVs*




zText.replaceWholeTextcCsF|jj�rdSt|�}|dkr"dS|jj|�}|dkr:dS|j�SdS)NF)rG�strip�_get_containing_elementrOr��isElementContent)rr�r�r
r
r�!_get_isWhitespaceInElementContentrs
z&Text._get_isWhitespaceInElementContent)rrr)rorprqr�r	rFrr�r�rrrr r$r
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}x"|dk	r(|jtjkr |S|j}qWdS)N)r3rr	rJ)rAr@r
r
rr"�s

r"cCs.|j}x"|dk	r(|jtjkr |S|j}qWdS)N)r3rr	r�)rAr@r
r
rr�s

rc@s(eZdZejZdZdd�Zddd�ZdS)	�Commentz#commentcCstj|�||_dS)N)rr�r)rrGr
r
rr��s
zComment.__init__rcCs,d|jkrtd��|jd||j|f�dS)Nz--z%'--' is not allowed in a comment nodez
%s<!--%s-->%s)rGr7r~)rr"r r�r!r
r
rr�s
zComment.writexmlN)rrr)	rorprqr	r�rr�r�rr
r
r
rr%�sr%c@s$eZdZfZejZdZddd�ZdS)�CDATASectionz#cdata-sectionrcCs,|jjd�dkrtd��|jd|j�dS)Nz]]>rz$']]>' not allowed in a CDATA sectionz<![CDATA[%s]]>)rG�findr7r~)rr"r r�r!r
r
rr�szCDATASection.writexmlN)rrr)	rorprqr�r	r�rr�rr
r
r
rr&�sr&c@s|eZdZdZffdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�ZdS)�ReadOnlySequentialNamedNodeMap�_seqcCs
||_dS)N)r))r�seqr
r
rr��sz'ReadOnlySequentialNamedNodeMap.__init__cCs
t|j�S)N)r�r))rr
r
rr��sz&ReadOnlySequentialNamedNodeMap.__len__cCs
t|j�S)N)r�r))rr
r
rr��sz*ReadOnlySequentialNamedNodeMap._get_lengthcCs"x|jD]}|j|kr|SqWdS)N)r)r�)rr�r�r
r
rr��s
z+ReadOnlySequentialNamedNodeMap.getNamedItemcCs,x&|jD]}|j|kr|j|kr|SqWdS)N)r)rrrw)rrrrwr�r
r
rr��sz-ReadOnlySequentialNamedNodeMap.getNamedItemNScCs4t|t�r|j|�}n
|j|�}|dkr0t|��|S)N)r�r,r�r�r])rZ
name_or_tuplerAr
r
rr��s

z*ReadOnlySequentialNamedNodeMap.__getitem__cCs0|dkrdSy
|j|Stk
r*dSXdS)Nr)r)r�)rr6r
r
rr��s
z#ReadOnlySequentialNamedNodeMap.itemcCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rr�r
r
rr��sz.ReadOnlySequentialNamedNodeMap.removeNamedItemcCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rrrrwr
r
rr��sz0ReadOnlySequentialNamedNodeMap.removeNamedItemNScCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rrAr
r
rr��sz+ReadOnlySequentialNamedNodeMap.setNamedItemcCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rrAr
r
rr��sz-ReadOnlySequentialNamedNodeMap.setNamedItemNScCs|jgS)N)r))rr
r
rr��sz+ReadOnlySequentialNamedNodeMap.__getstate__cCs|d|_dS)Nr)r))rr�r
r
rr��sz+ReadOnlySequentialNamedNodeMap.__setstate__N)r))rorprqr�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||_||_dS)N)r,r-)rr,r-r
r
r�_identified_mixin_init�sz!Identified._identified_mixin_initcCs|jS)N)r,)rr
r
r�
_get_publicId�szIdentified._get_publicIdcCs|jS)N)r-)rr
r
r�
_get_systemId�szIdentified._get_systemIdN)r,r-)rorprqr�r�r.r/r0r
r
r
rr+�s
r+c@sHeZdZejZdZdZdZdZ	dZ
dd�Zdd�Zdd�Z
dd	d
�ZdS)�DocumentTypeNcCs2t�|_t�|_|r&t|�\}}||_|j|_dS)N)r(�entities�	notationsr�r�r�)rr�rsr�r
r
rr�	szDocumentType.__init__cCs|jS)N)�internalSubset)rr
r
r�_get_internalSubsetsz DocumentType._get_internalSubsetcCs�|jdkr�td�}|j|_|j|_tjjj}|r�g|j_	g|j
_	x>|j
j	D]2}t|j|j|j
�}|j
j	j|�|j|||�qJWxZ|jj	D]N}t|j|j|j
|j�}|j|_|j|_|j|_|jj	j|�|j|||�q�W|j|||�|SdSdS)N)rOr1r�r�r/r0�UserDataHandler�NODE_CLONEDr2r)r3�Notationr,r-rIrj�Entity�notationName�actualEncodingrrU)rrP�clonergr��notation�e�entityr
r
rrQs.

zDocumentType.cloneNodercCs�|jd�|j|j�|jr8|jd||j||jf�n|jrR|jd||jf�|jdk	r||jd�|j|j�|jd�|jd|�dS)Nz
<!DOCTYPE z%s  PUBLIC '%s'%s  '%s'z%s  SYSTEM '%s'z [�]r|)r~r�r,r-r4)rr"r r�r!r
r
rr/s



zDocumentType.writexml)rrr)rorprqr	�DOCUMENT_TYPE_NODErr�r�r,r-r4r�r5rQrr
r
r
rr1sr1c@sfeZdZdZejZdZdZdZ	dZ
dd�Zdd�Zdd�Z
dd	�Zd
d�Zdd
�Zdd�Zdd�ZdS)r9NcCs$||_||_t�|_|j||�dS)N)r�r:rkr$r.)rr�r,r-r=r
r
rr�FszEntity.__init__cCs|jS)N)r;)rr
r
r�_get_actualEncodingLszEntity._get_actualEncodingcCs|jS)N)r)rr
r
r�
_get_encodingOszEntity._get_encodingcCs|jS)N)rU)rr
r
r�_get_versionRszEntity._get_versioncCstjjd��dS)Nz(cannot append children to an entity node)r/r0r1)rr>r
r
rr5UszEntity.appendChildcCstjjd��dS)Nz+cannot insert children below an entity node)r/r0r1)rr>r?r
r
rr-YszEntity.insertBeforecCstjjd��dS)Nz*cannot remove children from an entity node)r/r0r1)rrCr
r
rr4]szEntity.removeChildcCstjjd��dS)Nz)cannot replace children of an entity node)r/r0r1)rr>rCr
r
rrDaszEntity.replaceChild)rorprqr�r	ZENTITY_NODErr�r;rrUr�rBrCrDr5r-r4rDr
r
r
rr9=sr9c@seZdZejZdZdd�ZdS)r8NcCs||_|j||�dS)N)r�r.)rr�r,r-r
r
rr�iszNotation.__init__)rorprqr	r�rr�r�r
r
r
rr8esr8c	@sHeZdZddddddddgZdd	�Zd
d�Zdd
�Zdd�Zdd�ZdS)�DOMImplementation�core�1.0�2.0Nr/�ls-load�3.0cCs|dkrd}|j�|f|jkS)Nr)�lower�	_features)rrTrUr
r
rrSyszDOMImplementation.hasFeaturec	Cs�|r|jdk	rtjjd��|j�}|dko8|dko8|dk}|rR|rRtjjd��|r�t|�\}}|dkr~|dkr~tjjd��|r�|r�tjjd��|j||�}|r�|j	|�|j	|�|r�||_|_
||_||_|S)Nz(doctype object owned by another DOM treezElement with no namer/z$http://www.w3.org/XML/1998/namespacezillegal use of 'xml' prefixz(illegal use of prefix without namespaces)
r3r/r0�WrongDocumentErr�_create_documentZInvalidCharacterErrr�r��createElementNSr5rO�doctyperR)	rrrr�rPruZadd_root_elementrsr�rr
r
r�createDocument~s4





z DOMImplementation.createDocumentcCst|�}||_||_|S)N)r1r,r-)rr�r,r-rPr
r
r�createDocumentType�sz$DOMImplementation.createDocumentTypecCs|j|d�r|SdSdS)N)rS)rrTr
r
rrZ�szDOMImplementation.getInterfacecCst�S)N)�Document)rr
r
rrN�sz"DOMImplementation._create_document)rFrG)rFrH)rFN)r/rG)r/rH)r/N)rIrJ)rIN)	rorprqrLrSrQrRrZrNr
r
r
rrEns-rEc@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.

    r�cCs
||_dS)N)r�)rr�r
r
rr��szElementInfo.__init__cCstS)N)r�)r�anamer
r
rr��szElementInfo.getAttributeTypecCstS)N)r�)rrrrwr
r
rr��szElementInfo.getAttributeTypeNScCsdS)NFr
)rr
r
rr#�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
)rrUr
r
rr��szElementInfo.isIdcCsdS)z<Returns true iff the identified attribute is a DTD-style ID.Fr
)rrrrwr
r
rr��szElementInfo.isIdNScCs|jS)N)r�)rr
r
rr��szElementInfo.__getstate__cCs
||_dS)N)r�)rr�r
r
rr��szElementInfo.__setstate__N)r�)rorprqr�r�r�r�r�r#rVr�r�r�r�r
r
r
rrT�srTcCs>|jtjkr|jj�d|_nt|�r:|jjj�d|j_dS)N)rr	r�	_id_cache�clear�_id_search_stackrxrO)rAr
r
rr:�s
r:c@sreZdZdMZejejejejfZ	e
�ZejZ
dZdZdZdZdZZdZdZdZdZdZdZdZd	Zd
d�Zdd
�Zdd�Zdd�Zdd�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/�Z.d0d1�Z/d2d3�Z0d4d5�Z1d6d7�Z2d8d9�Z3d:d;�Z4d<d=�Z5d>d?�Z6d@dA�Z7dBdC�Z8dDdE�Z9dFdG�Z:dNdIdJ�Z;dKdL�Z<dS)OrS�
_elem_inforPrYr$rWz	#documentNFrcCs$d|_t�|_i|_i|_d|_dS)N)rPrkr$rZrWrY)rr
r
rr�
s
zDocument.__init__cCs&|jr|j|jf}n|j}|jj|�S)N)rrrwr�rZr�)rrr^r
r
rr�szDocument._get_elem_infocCs|jS)N)r;)rr
r
rrBszDocument._get_actualEncodingcCs|jS)N)rP)rr
r
r�_get_doctypeszDocument._get_doctypecCs|jS)N)�documentURI)rr
r
r�_get_documentURI szDocument._get_documentURIcCs|jS)N)r)rr
r
rrC#szDocument._get_encodingcCs|jS)N)�errorHandler)rr
r
r�_get_errorHandler&szDocument._get_errorHandlercCs|jS)N)�
standalone)rr
r
r�_get_standalone)szDocument._get_standalonecCs|jS)N)�strictErrorChecking)rr
r
r�_get_strictErrorChecking,sz!Document._get_strictErrorCheckingcCs|jS)N)rU)rr
r
rrD/szDocument._get_versioncCsj|j|jkr(tjjdt|�t|�f��|jdk	r>|jj|�|jtj	kr^|j
�r^tjjd��tj||�S)Nz%s cannot be child of %sz two document elements disallowed)rr.r/r0r1r2r3r4r	rJ�_get_documentElementr5)rrAr
r
rr52s
zDocument.appendChildcCsVy|jj|�Wntk
r.tjj��YnXd|_|_d|_|j	|krRd|_	|S)N)
r$rEr7r/r0r8r<r=r3�documentElement)rrCr
r
rr4Bs
zDocument.removeChildcCs$x|jD]}|jtjkr|SqWdS)N)r$rr	rJ)rrAr
r
rrdNszDocument._get_documentElementcCs(|jdk	r|jj�d|_tj|�dS)N)rPrHr	)rr
r
rrHSs

zDocument.unlinkcCs�|sdS|jjddd�}|j|_|j|_|j|_xx|jD]n}t|||�}|jj|�sXt	�|jj
|�|jtj
kr�|jdks�t	�n |jtjkr�|jdks�t	�||_||_q8W|jtjjj||�|S)N)rRrQrr`rUr$rNrOrY�AssertionErrorrIrr	rrerArPr3rjr/r0r6r7)rrPr<r�Z
childcloner
r
rrQYs&
zDocument.cloneNodecCst�}||_|S)N)r�rO)rrbr
r
r�createDocumentFragmentnszDocument.createDocumentFragmentcCst|�}||_|S)N)r�rO)rr�r>r
r
r�
createElementsszDocument.createElementcCs(t|t�std��t�}||_||_|S)Nznode contents must be a string)r�r�r�r�rGrO)rrG�tr
r
r�createTextNodexs
zDocument.createTextNodecCs(t|t�std��t�}||_||_|S)Nznode contents must be a string)r�r�r�r&rGrO)rrGr@r
r
r�createCDATASection�s
zDocument.createCDATASectioncCst|�}||_|S)N)r%rO)rrGr@r
r
r�
createComment�szDocument.createCommentcCst||�}||_|S)N)rrO)rr	rG�pr
r
r�createProcessingInstruction�s
z$Document.createProcessingInstructioncCst|�}||_d|_|S)Nr)r�rOr�)rr��ar
r
r�createAttribute�szDocument.createAttributecCs"t|�\}}t|||�}||_|S)N)r�r�rO)rrrr�rsrwr>r
r
rrO�szDocument.createElementNScCs*t|�\}}t||||�}||_d|_|S)Nr)r�r�rOr�)rrrr�rsrwror
r
r�createAttributeNS�s
zDocument.createAttributeNScCst||||�}||_|S)N)r9rO)rr�r,r-r:r>r
r
r�_create_entity�szDocument._create_entitycCst|||�}||_|S)N)r8rO)rr�r,r-r�r
r
r�_create_notation�szDocument._create_notationcCs�||jkr|j|S|jp|js$dS|j}|dkrB|jg}||_n|sJdSd}�x>|�r�|j�}|jdd�|jD��|j|�}|�r@x�|j	j
�D]�}|jr�|j|j|j
�r�||j|j<|j|kr�|}n|js�Pq�|j|j��r
||j|j<|j|k�r�|}n
|j�s:Pq�|jr�||j|j<|j|k�r.|}q�|jdkr�Pq�WnB|j�r�x8|j	j
�D]*}|j�rT||j|j<|j|k�rT|}�qTW|dk	rRPqRW|S)NcSsg|]}|jtkr|�qSr
)rr9)�.0rMr
r
r�
<listcomp>�sz+Document.getElementById.<locals>.<listcomp>r()rWrZr�rYre�pop�extendr$r�r�r�rrr�rwr�r�r�r�r�)rr��stack�resultrAr�r�r
r
r�getElementById�sZ






zDocument.getElementByIdcCst||t��S)N)r�rk)rr�r
r
rr��szDocument.getElementsByTagNamecCst|||t��S)N)r�rk)rrrrwr
r
rr��szDocument.getElementsByTagNameNScCs|jj||�S)N)rRrS)rrTrUr
r
rrV�szDocument.isSupportedcCs>|jtjkrtjjd��n|jtjkr2tjjd��t|||�S)Nzcannot import document nodesz!cannot import document type nodes)rr	rr/r0�NotSupportedErrrArN)rrArPr
r
r�
importNode�s
zDocument.importNodercCsN|dkr|jd|�n|jd||f�x|jD]}|j||||�q2WdS)Nz<?xml version="1.0" ?>z%<?xml version="1.0" encoding="%s"?>%s)r~r$r)rr"r r�r!rrAr
r
rr�szDocument.writexmlcCsJ|j|k	r tjjd||jf��|jtjtjfkr>tjjd��|t	kr�d|kr�|j
dd�\}}|dkr�|tjjkr�tjjd��q�|dkr�|tjjkr�|jtjkr�tjjd��d}|}nd}d}|jtjkr�|j
}|dk	r�|j}|j|�nd}||_||_||_||_|jtjk�r||_n*||_|dk	�rF|j|�|�rF|j|�|S)Nz?cannot rename nodes from other documents;
expected %s,
found %sz8renameNode() only applies to element and attribute nodesr�r(r�zillegal use of 'xmlns' prefixz$illegal use of the 'xmlns' attribute)rOr/r0rMrr	rJr�r{rr�rr�r�r�r�rsr�rrr�r�r�r�r)rr�rrr�rsrwrZis_idr
r
r�
renameNodesR



zDocument.renameNode)rZrPrYr$rW)rrrN)=rorprqr�r	rJr�r�rAr.rErRrrr�r�r�r3r=r<r;rr`rUrbr^r\r�r�r�rBr[r]rCr_rarcrDr5r4rdrHrQrgrhrjrkrlrnrprOrqrrrsrzr�r�rVr|rr}r
r
r
rrS�sh	
:
rSrez#Top-level element of this document.c
Cs�|jj|�rtjjj}n
tjjj}|jtj	kr�|j
|j|j�}x>|j
j�D]0}|j|j|j|j�|j|j|j�}|j|_qJW|r�x$|jD]}t|||�}|j|�q�W�n"|jtjkr�|j�}|r�x$|jD]}t|||�}|j|�q�W�n�|jtjk�r|j|j�}�n�|jtjk�r*|j|j�}�n�|jtjk�rL|j|j |j�}�n�|jtj!k�rj|j"|j�}�nd|jtj#k�r�|j$|j|j�}d|_|j|_�n4|jtj%k�r�|j|k	�s�t&�tjjj}|j'j(|j)|j*|j+�}||_|�r�g|j,_-g|j._-xR|j.j-D]F}	t/|	j|	j*|	j+�}
||
_|j.j-j0|
�t1|	d��r�|	j2||	|
��q�Wx�|j,j-D]b}t3|j|j*|j+|j4�}|j5|_5|j6|_6|j7|_7||_|j,j-j0|�t1|d��rR|j2|||��qRWntjj8dt9|���t1|d��r�|j2|||�|S)zo
    Clone a node and give it the new owner document.
    Called by Node.cloneNode and Document.importNode
    TrjzCannot clone node %s):rOrYr/r0r6r7Z
NODE_IMPORTEDrr	rJrOrrr�r�r�r�r�r�rwr�r$rNr5r+rgrFrjrGr�rkr�rnr	r�rlr�rqrArfrRrRr�r,r-r2r)r3r8rIrdrjr9r:r;rrUr{r2)
rArPZnewOwnerDocumentrgr<r�rorMr@r�r=r>r?r
r
rrNAs~

rNcCs,|jdd�}t|�dkr|Sd|dfSdS)Nr�r(�r)r�r�)r�Zfieldsr
r
rr��sr�cCs,|||�}|j�\}}|j|�|j�|S)N)ZgetEventZ
expandNoderX)�func�args�kwargsZeventsZtoktypeZrootNoder
r
r�_do_pulldom_parse�s


r�cCsJ|dkr$|r$ddlm}|j|�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}|j|�Sddlm}t|j|fd|i�SdS)z&Parse a file into a DOM from a string.Nr)r�)r�r�)r�r��parseStringr�r�)�stringr�r�r�r
r
rr��s

r�cCsB|r<t|t�rtj|�}x"|D]\}}tjj||�sdSqWtjS)N)r�r�rZ_parse_feature_stringrSrRrS)Zfeatures�f�vr
r
r�getDOMImplementation�s

r�)NN)N)N)7r�rr�r/rrrrZxml.dom.minicompatZxml.dom.xmlbuilderrrr0r	rJr�r9ZdefpropertyrBrxrr�r�r�r��objectr�Z
AttributeListr�r�r�r�rrrr�r"rr%r&r(r+r1r9r8rErTr:rSrNr�r�r�r�r�r
r
r
r�<module>s�v
	y$
w)GU	><(	O*PR



PK�"[�AP�	�	/dom/__pycache__/minicompat.cpython-36.opt-2.pycnu�[���3


 \'
�@sFddddgZddlZefZGdd�de�ZGdd�de�Zdd�Z	dS)	�NodeList�
EmptyNodeList�StringTypes�defproperty�Nc@s>eZdZfZdd�Zdd�Zdd�Zeeedd�Zd	d
�Z	dS)rcCs(d|kot|�knr$||SdS)Nr)�len)�self�index�r	�*/usr/lib64/python3.6/xml/dom/minicompat.py�item5sz
NodeList.itemcCst|�S)N)r)rr	r	r
�_get_length9szNodeList._get_lengthcCstjjd��dS)Nz.attempt to modify read-only attribute 'length')�xml�dom�NoModificationAllowedErr)r�valuer	r	r
�_set_length<szNodeList._set_lengthz$The number of nodes in the NodeList.)�doccCs|dkrg}||dd�<dS)Nr	)r�stater	r	r
�__setstate__DszNodeList.__setstate__N)
�__name__�
__module__�__qualname__�	__slots__rrr�property�lengthrr	r	r	r
r2sc@sFeZdZfZdd�Zdd�Zdd�Zdd�Zd	d
�Ze	eedd�Z
d
S)rcCst�}|j|�|S)N)r�extend)r�other�NLr	r	r
�__add__Ms
zEmptyNodeList.__add__cCst�}|j|�|S)N)rr)rrrr	r	r
�__radd__Rs
zEmptyNodeList.__radd__cCsdS)Nr	)rrr	r	r
rWszEmptyNodeList.itemcCsdS)Nrr	)rr	r	r
rZszEmptyNodeList._get_lengthcCstjjd��dS)Nz.attempt to modify read-only attribute 'length')r
rr)rrr	r	r
r]szEmptyNodeList._set_lengthz$The number of nodes in the NodeList.)rN)rrrrrrrrrrrr	r	r	r
rJscCs8t|d|�}|fdd�}t|||d�}t|||�dS)NZ_get_cSstjjdt|���dS)Nz&attempt to modify read-only attribute )r
rr�repr)rr�namer	r	r
�setgszdefproperty.<locals>.set)r)�getattrr�setattr)�klassr!r�getr"Zpropr	r	r
res)
�__all__Zxml.domr
�strr�listr�tuplerrr	r	r	r
�<module>+s
PK�"[�S�����,dom/__pycache__/minidom.cpython-36.opt-2.pycnu�[���3


 \�@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.6/xml/dom/minidom.py�__bool__+sz
Node.__bool__cCs|jdd|�S)N�)�toprettyxml)r�encodingr
r
r�toxml.sz
Node.toxml�	�
cCsx|dkrtj�}ntjtj�|ddd�}|jtjkrH|j|d|||�n|j|d||�|dkrh|j�S|j	�j�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�
childNodes)rr
r
r�
hasChildNodesCszNode.hasChildNodescCs|jS)N)r$)rr
r
r�_get_childNodesFszNode._get_childNodescCs|jr|jdSdS)Nr)r$)rr
r
r�_get_firstChildIszNode._get_firstChildcCs|jr|jdSdS)N����)r$)rr
r
r�_get_lastChildMszNode._get_lastChildcCs|j|jkr0xt|j�D]}|j||�qW|S|j|jkrXtjjdt	|�t	|�f��|j
dk	rn|j
j|�|dkr�|j|�n�y|jj
|�}Wntk
r�tjj��YnX|jtkr�t|�|jj||�||_||_|r�|j|d}||_||_nd|_||_
|S)Nz%s cannot be child of %sr()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�cr6�noder
r
rr-Qs6

zNode.insertBeforecCs�|j|jkr.xt|j�D]}|j|�qW|S|j|jkrXtjjdt	|�t	|�f��n|jt
krjt|�|jdk	r�|jj
|�t||�d|_|S)Nz%s cannot be child of %s)rr+r,r$r5r.r/r0r1r2r9r:r3r4�
_append_childr<)rrAr@r
r
rr5qs


zNode.appendChildcCs|j|jkr(|j}|j|�|j||�S|j|jkrPtjjdt	|�t	|�f��||kr\dS|j
dk	rr|j
j|�y|jj|�}Wnt
k
r�tjj��YnX||j|<||_
d|_
|jtks�|jtkr�t|�|j|_|j|_d|_d|_|jr�||j_|j�r||j_|S)Nz%s cannot be child of %s)rr+r<r4r-r.r/r0r1r2r3r$r6r7r8r9r:r=)rr>�oldChildr?r6r
r
r�replaceChild�s<




zNode.replaceChildcCs�y|jj|�Wntk
r.tjj��YnX|jdk	rD|j|j_|jdk	rX|j|j_d|_|_|jt	krvt
|�d|_|S)N)r$�remover7r/r0r8r<r=rr9r:r3)rrCr
r
rr4�s




zNode.removeChildcCs�g}x�|jD]�}|jtjkr�|jsL|r2|j|d_|jrB|j|j_|j�q�|r�|dj|jkr�|d}|j|j|_|j|_|jr�||j_|j�q�|j|�q|j|�|jtj	kr|j
�qW||jdd�<dS)Nr(r)r)r))r$rr	�	TEXT_NODE�datar<r=�unlink�append�ELEMENT_NODE�	normalize)r�L�childrAr
r
rrK�s*



zNode.normalizecCst|||jp|�S)N)�_clone_node�
ownerDocument)r�deepr
r
r�	cloneNode�szNode.cloneNodecCs|jjj||�S)N)rO�implementation�
hasFeature)r�feature�versionr
r
r�isSupported�szNode.isSupportedcCsdS)Nr
)rr
r
r�_get_localName�szNode._get_localNamecCs||kS)Nr
)r�otherr
r
r�
isSameNode�szNode.isSameNodecCs|j|d�r|SdSdS)N)rV)rrTr
r
r�getInterface�szNode.getInterfacecCs,y|j|dSttfk
r&dSXdS)Nr)�
_user_data�AttributeError�KeyError)r�keyr
r
r�getUserData�szNode.getUserDatacCsnd}y
|j}Wntk
r,i}||_YnX||krB||d}|dkr^d}|dk	rj||=n||f||<|S)Nr)r[r\)rr^rG�handler�old�dr
r
r�setUserData�s
zNode.setUserDatacCsHt|d�rDx8t|jj��D]&\}\}}|dk	r|j|||||�qWdS)Nr[)�hasattr�listr[�itemsZhandle)r�	operation�src�dstr^rGr`r
r
r�_call_user_data_handler�s
zNode._call_user_data_handlercCsBd|_|_|jr2x|jD]}|j�qWt�|_d|_d|_dS)N)r3rOr$rH�NodeListr=r<)rrMr
r
rrHszNode.unlinkcCs|S)Nr
)rr
r
r�	__enter__szNode.__enter__cCs|j�dS)N)rH)rZetZev�tbr
r
r�__exit__sz
Node.__exit__)N)rrN)!�__name__�
__module__�__qualname__�namespaceURIr3rOr<r=r�prefixr
rrr%r&r'r*r-r5rDr4rKrQrVrWrYrZr_rcrjrHrlrnr
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}||_||_|j|�||_dS)Nr(r))r$r=r<rIr3)rrAr$Zlastr
r
rrBs
rBcCs(x"|dk	r"|jtjkrdS|j}qWdS)NTF)rr	rr3)rAr
r
r�_in_document&s


rxcCs6|r2|jdd�jdd�jdd�jdd�}|j|�dS)	N�&z&amp;�<z&lt;�"z&quot;�>z&gt;)�replace�write)r"rGr
r
r�_write_data.srcCsHxB|jD]8}|jtjkr4|dks*|j|kr4|j|�t|||�qW|S)Nr)r$rr	rJ�tagNamerI�_get_elements_by_tagName_helper)�parent�name�rcrAr
r
rr�5s
r�cCs\xV|jD]L}|jtjkr|dks*|j|krF|dks<|j|krF|j|�t||||�qW|S)Nr)r$rr	rJrwrrrI�"_get_elements_by_tagName_ns_helper)r�ZnsURIrwr�rAr
r
rr�=s
r�c@sJeZdZejZdZdZdZdZ	ej
ejejej
ejejejfZdd�ZdS)�DocumentFragmentz#document-fragmentNcCst�|_dS)N)rkr$)rr
r
r�__init__TszDocumentFragment.__init__)rorprqr	r+r�nodeName�	nodeValue�
attributesr3rJrF�CDATA_SECTION_NODE�ENTITY_REFERENCE_NODE�PROCESSING_INSTRUCTION_NODE�COMMENT_NODE�
NOTATION_NODEr.r�r
r
r
rr�Fsr�c@s�eZdZd#ZejZd	Zd
Zd
Z	ej
ejfZe
d	d	fdd�Zd
d�Zdd�Zdd�Zdd�Zeee�ZZdd�Zdd�Zeee�ZZdd�Zdd�Zeee�Zdd�Zdd �Zd!d"�Zd	S)$�Attr�_name�_valuerr�_prefixr$�
_localNamerO�ownerElementNFcCs2d|_||_||_||_t�|_|jjt��dS)N)r�r�rrr�rkr$rI�Text)r�qNamerrrwrsr
r
rr�bsz
Attr.__init__cCs.y|jStk
r(|jjdd�dSXdS)N�:r(r))r�r\r��split)rr
r
rrWoszAttr._get_localNamecCs|jS)N)�	specified)rr
r
r�_get_specifieduszAttr._get_specifiedcCs|jS)N)r�)rr
r
r�	_get_namexszAttr._get_namecCs||_|jdk	rt|j�dS)N)r�r�r:)r�valuer
r
r�	_set_name{s
zAttr._set_namecCs|jS)N)r�)rr
r
r�
_get_value�szAttr._get_valuecCs6||_||jd_|jdk	r&t|j�||jd_dS)Nr)r�r$rGr�r:)rr�r
r
r�
_set_value�s


zAttr._set_valuecCs|jS)N)r�)rr
r
r�_get_prefix�szAttr._get_prefixcCsd|j}|dkr&|r&|tkr&tjjd��||_|dkr<|j}nd||jf}|jrZt|j�||_	dS)N�xmlnsz5illegal use of 'xmlns' prefix for the wrong namespacez%s:%s)
rrrr/r0�NamespaceErrr�rwr�r:r�)rrsZnsuriZnewNamer
r
r�_set_prefix�s
zAttr._set_prefixcCsz|j}|dk	rR|j|j=|j|j|jf=|jrRd|_|jd8_|jj	d8_	x|j
D]}|j�qZW|j
dd�=dS)NFr()r��_attrsr��_attrsNSrrrw�_is_id�_magic_id_nodesrO�_magic_id_countr$rH)r�elemrMr
r
rrH�s
zAttr.unlinkcCsf|jr
dS|j}|j}|dks&|dkr*dS|j|�}|dkr@dS|jrV|j|j|j�S|j|j�SdS)NTF)	r�rOr��_get_elem_inforr�isIdNSrw�isIdr�)rrur��infor
r
r�	_get_isId�s
zAttr._get_isIdcCs\|j}|j}|dks|dkr tS|j|�}|dkr6tS|jrL|j|j|j�S|j|j�SdS)N)	rOr��_no_typer�rr�getAttributeTypeNSrw�getAttributeTyper�)rrur�r�r
r
r�_get_schemaType�s
zAttr._get_schemaType)r�r�rrr�r$r�rOr�) rorprq�	__slots__r	�ATTRIBUTE_NODErr�r�r�rFr�r.rr�rWr�r�r��propertyr�r�r�r�r�r�r�r�rsrHr�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�eZdZd;Zdd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�Zdd�Zd<dd�Z
eZdd�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)=�NamedNodeMapr�r��
_ownerElementcCs||_||_||_dS)N)r�r�r�)r�attrsZattrsNSr�r
r
rr��szNamedNodeMap.__init__cCs
t|j�S)N)�lenr�)rr
r
r�_get_length�szNamedNodeMap._get_lengthcCs0y|t|jj��|Stk
r*dSXdS)N)rer��keys�
IndexError)rr6r
r
r�item�szNamedNodeMap.itemcCs.g}x$|jj�D]}|j|j|jf�qW|S)N)r��valuesrIr�r�)rrLrAr
r
rrf�szNamedNodeMap.itemscCs4g}x*|jj�D]}|j|j|jf|jf�qW|S)N)r�r�rIrrrwr�)rrLrAr
r
r�itemsNS�szNamedNodeMap.itemsNScCs"t|t�r||jkS||jkSdS)N)�
isinstance�strr�r�)rr^r
r
r�__contains__�s

zNamedNodeMap.__contains__cCs
|jj�S)N)r�r�)rr
r
rr�szNamedNodeMap.keyscCs
|jj�S)N)r�r�)rr
r
r�keysNSszNamedNodeMap.keysNScCs
|jj�S)N)r�r�)rr
r
rr�szNamedNodeMap.valuesNcCs|jj||�S)N)r��get)rr�r�r
r
rr�
szNamedNodeMap.getcCs:|jt|dd�krdSt|�t|�kt|�t|�kSdS)Nr�r)r��getattr�id)rrXr
r
r�_cmpszNamedNodeMap._cmpcCs|j|�dkS)Nr)r�)rrXr
r
r�__eq__szNamedNodeMap.__eq__cCs|j|�dkS)Nr)r�)rrXr
r
r�__ge__szNamedNodeMap.__ge__cCs|j|�dkS)Nr)r�)rrXr
r
r�__gt__szNamedNodeMap.__gt__cCs|j|�dkS)Nr)r�)rrXr
r
r�__le__szNamedNodeMap.__le__cCs|j|�dkS)Nr)r�)rrXr
r
r�__lt__!szNamedNodeMap.__lt__cCs"t|t�r|j|S|j|SdS)N)r�r,r�r�)r�attname_or_tupler
r
r�__getitem__$s

zNamedNodeMap.__getitem__cCsvt|t�rRy|j|}Wn0tk
rHt|�}|jj|_|j|�YnX||_n t|t�sdt	d��|}|j|�dS)Nz%value must be a string or Attr object)
r�r�r�r]r�r�rO�setNamedItemr��	TypeError)r�attnamer�rAr
r
r�__setitem__+s


zNamedNodeMap.__setitem__cCs$y
|j|Stk
rdSXdS)N)r�r])rr�r
r
r�getNamedItem:s
zNamedNodeMap.getNamedItemcCs(y|j||fStk
r"dSXdS)N)r�r])rrrrwr
r
r�getNamedItemNS@szNamedNodeMap.getNamedItemNScCsX|j|�}|dk	rJt|j�|j|j=|j|j|jf=t|d�rFd|_	|St
jj��dS)Nr�)
r�r:r�r�r�r�rrrwrdr�r/r0r8)rr��nr
r
r�removeNamedItemFs



zNamedNodeMap.removeNamedItemcCsZ|j||�}|dk	rLt|j�|j|j|jf=|j|j=t|d�rHd|_	|St
jj��dS)Nr�)
r�r:r�r�rrrwr�r�rdr�r/r0r8)rrrrwr�r
r
r�removeNamedItemNSRs


zNamedNodeMap.removeNamedItemNScCstt|t�s&tjjdt|�t|�f��|jj|j�}|r@|j	�||j|j<||j
|j|jf<|j
|_t|j�|S)Nz%s cannot be child of %s)r�r�r/r0r1r2r�r�r�rHr�rrrwr�r�r:)rrArar
r
rr�^s

zNamedNodeMap.setNamedItemcCs
|j|�S)N)r�)rrAr
r
r�setNamedItemNSkszNamedNodeMap.setNamedItemNScCs||}t|j�|j�dS)N)r:r�rH)rr�rAr
r
r�__delitem__ns
zNamedNodeMap.__delitem__cCs|j|j|jfS)N)r�r�r�)rr
r
r�__getstate__sszNamedNodeMap.__getstate__cCs|\|_|_|_dS)N)r�r�r�)r�stater
r
r�__setstate__vszNamedNodeMap.__setstate__)r�r�r�)N) rorprqr�r�r�r�rfr�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@s0eZdZdZdd�Zdd�Zdd�Zd	d
�ZdS)
�TypeInfo�	namespacer�cCs||_||_dS)N)r�r�)rr�r�r
r
rr��szTypeInfo.__init__cCs2|jrd|jj|j|jfSd|jj|jfSdS)Nz<%s %r (from %r)>z<%s %r>)r��	__class__ror�)rr
r
r�__repr__�s
zTypeInfo.__repr__cCs|jS)N)r�)rr
r
rr��szTypeInfo._get_namecCs|jS)N)r�)rr
r
r�_get_namespace�szTypeInfo._get_namespaceN)r�r�)rorprqr�r�r�r�r�r
r
r
rr�s
r�c@s eZdZdDZejZd
ZeZ	dZ
ejejejej
ejejfZed
d
fdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�ZeZd'd(�Zd)d*�Z d+d,�Z!e!Z"d-d.�Z#d/d0�Z$d1d2�Z%d3d4�Z&d5d6�Z'dEd8d9�Z(d:d;�Z)d<d=�Z*d>d?�Z+d@dA�Z,dBdC�Z-d
S)F�ElementrOr3r�r�rsrrr�r$r�r�r<r=NrcCsBd|_||_|_||_||_t�|_d|_|_d|_	d|_
dS)N)r3r�r�rsrrrkr$r<r=r�r�)rr�rrrsrwr
r
rr��s
zElement.__init__cCs|jdkri|_i|_dS)N)r�r�)rr
r
r�_ensure_attributes�s
zElement._ensure_attributescCs.y|jStk
r(|jjdd�dSXdS)Nr�r(r))r�r\r�r�)rr
r
rrW�szElement._get_localNamecCs|jS)N)r�)rr
r
r�_get_tagName�szElement._get_tagNamecCsD|jdk	r*xt|jj��D]}|j�qWd|_d|_tj|�dS)N)r�rer�rHr�r	)r�attrr
r
rrH�s
zElement.unlinkcCs4|jdkrdSy|j|jStk
r.dSXdS)Nr)r�r�r])rr�r
r
r�getAttribute�s
zElement.getAttributecCs8|jdkrdSy|j||fjStk
r2dSXdS)Nr)r�r�r])rrrrwr
r
r�getAttributeNS�s
zElement.getAttributeNScCsV|j|�}|dkr4t|�}||_|j|_|j|�n||jkrR||_|jrRt|�dS)N)�getAttributeNoder�r�rO�setAttributeNoder�r:)rr�r�r�r
r
r�setAttribute�s

zElement.setAttributecCs�t|�\}}|j||�}|dkrHt||||�}||_|j|_|j|�n4||jkrf||_|jrft|�|j|kr|||_||_	dS)N)
�_nssplit�getAttributeNodeNSr�r�rOr�r�r:rsr�)rrr�
qualifiedNamer�rs�	localnamer�r
r
r�setAttributeNS�s

zElement.setAttributeNScCs|jdkrdS|jj|�S)N)r�r�)rZattrnamer
r
rr��s
zElement.getAttributeNodecCs|jdkrdS|jj||f�S)N)r�r�)rrrrwr
r
rr�s
zElement.getAttributeNodeNScCs�|jd|fkrtjjd��|j�|jj|jd�}|dk	rD|j|�|j	j|j
|jfd�}|dk	rt||k	rt|j|�t||�||k	r�|S||k	r�|SdS)Nzattribute node already owned)
r�r/r0ZInuseAttributeErrr�r�r�r��removeAttributeNoder�rrrw�_set_attribute_node)rr�Zold1Zold2r
r
rr�s


zElement.setAttributeNodecCsP|jdkrtjj��y|j|}Wntk
r@tjj��YnX|j|�dS)N)r�r/r0r8r�r]r�)rr�r�r
r
r�removeAttributes

zElement.removeAttributecCsT|jdkrtjj��y|j||f}Wntk
rDtjj��YnX|j|�dS)N)r�r/r0r8r]r�)rrrrwr�r
r
r�removeAttributeNS%s

zElement.removeAttributeNScCs^|dkrtjj��y|j|jWntk
r@tjj��YnXt|�|j�|j|_dS)N)	r/r0r8r�r�r]r:rHrO)rrAr
r
rr�.s
zElement.removeAttributeNodecCs|jdkrdS||jkS)NF)r�)rr�r
r
r�hasAttribute=s
zElement.hasAttributecCs|jdkrdS||f|jkS)NF)r�)rrrrwr
r
r�hasAttributeNSBs
zElement.hasAttributeNScCst||t��S)N)r�rk)rr�r
r
r�getElementsByTagNameGszElement.getElementsByTagNamecCst|||t��S)N)r�rk)rrrrwr
r
r�getElementsByTagNameNSJszElement.getElementsByTagNameNScCsd|jt|�fS)Nz<DOM Element: %s at %#x>)r�r�)rr
r
rr�NszElement.__repr__rc	Cs|j|d|j�|j�}t|j��}x4|D],}|jd|�t|||j�|jd�q.W|jr�|jd�t|j�dkr�|jdj	t
jkr�|jdj|ddd�n8|j|�x"|jD]}|j|||||�q�W|j|�|jd|j|f�n|jd	|�dS)
Nrzz %s="r{r|r(rrz</%s>%sz/>%s)
r~r��_get_attributes�sortedr�rr�r$r�rr	rFr)	rr"r �	addindentr!r�Za_namesZa_namerAr
r
rrQs$



zElement.writexmlcCs|j�t|j|j|�S)N)r�r�r�r�)rr
r
rr�lszElement._get_attributescCs|jr
dSdSdS)NTF)r�)rr
r
r�
hasAttributespszElement.hasAttributescCs|j|�}|j|�dS)N)r��setIdAttributeNode)rr��idAttrr
r
r�setIdAttributexs
zElement.setIdAttributecCs|j||�}|j|�dS)N)r�r�)rrrrwrr
r
r�setIdAttributeNS|szElement.setIdAttributeNScCsl|dks|j|j�r tjj��t|�dk	r6tjj��|jshd|_|jd7_|j	j
d7_
t|�dS)NTr()rYr�r/r0r8�_get_containing_entref�NoModificationAllowedErrr�r�rOr�r:)rrr
r
rr��s

zElement.setIdAttributeNode)rOr3r�r�rsrrr�r$r�r�r<r=)rrr).rorprqr�r	rJrr�r�r�r�r�r�rFr�r�r.rr�r�rWr�rHr�r�r�r�r�r�r�ZsetAttributeNodeNSr�r�r�ZremoveAttributeNodeNSr�r�r�r�r�rr�r�rrr�r
r
r
rr��sT		

r�r�z*NamedNodeMap of attributes on the element.z%Namespace-local name of this element.cCs8t|�|j�||j|j<||j|j|jf<||_dS)N)r:r�r�r�r�rrrwr�)�elementr�r
r
rr��s
r�c@sbeZdZfZdZe�ZdZdZdd�Z	dd�Z
dd�Zdd	�Zd
d�Z
dd
�Zdd�Zdd�ZdS)�	ChildlessNcCsdS)Nr
)rr
r
rr'�szChildless._get_firstChildcCsdS)Nr
)rr
r
rr*�szChildless._get_lastChildcCstjj|jd��dS)Nz nodes cannot have children)r/r0r1r�)rrAr
r
rr5�szChildless.appendChildcCsdS)NFr
)rr
r
rr%�szChildless.hasChildNodescCstjj|jd��dS)Nz nodes do not have children)r/r0r1r�)rr>r?r
r
rr-�szChildless.insertBeforecCstjj|jd��dS)Nz nodes do not have children)r/r0r8r�)rrCr
r
rr4�szChildless.removeChildcCsdS)Nr
)rr
r
rrK�szChildless.normalizecCstjj|jd��dS)Nz nodes do not have children)r/r0r1r�)rr>rCr
r
rrD�szChildless.replaceChild)rorprqr�r�Z
EmptyNodeListr$rtrvr'r*r5r%r-r4rKrDr
r
r
rr�src@s\eZdZejZdZdd�Zdd�Zdd�Z	e
ee	�Zd	d
�Zdd�Z
e
ee
�Zddd�ZdS)�ProcessingInstruction�targetrGcCs||_||_dS)N)rrG)rrrGr
r
rr��szProcessingInstruction.__init__cCs|jS)N)rG)rr
r
r�_get_nodeValue�sz$ProcessingInstruction._get_nodeValuecCs
||_dS)N)rG)rr�r
r
r�_set_nodeValue�sz$ProcessingInstruction._set_nodeValuecCs|jS)N)r)rr
r
r�
_get_nodeName�sz#ProcessingInstruction._get_nodeNamecCs
||_dS)N)r)rr�r
r
r�
_set_nodeName�sz#ProcessingInstruction._set_nodeNamercCs|jd||j|j|f�dS)Nz
%s<?%s %s?>%s)r~rrG)rr"r r�r!r
r
rr�szProcessingInstruction.writexmlN)rrG)rrr)rorprqr	r�rr�r�r	r
r�r�rrr�rr
r
r
rr�s

rc@sreZdZdZdd�Zdd	�ZeZd
d�Zdd
�Ze	ee�Z
Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�
CharacterData�_datarOr3r=r<cCs,d|_|_d|_|_d|_tj|�dS)Nr)rOr3r=r<rr	r�)rr
r
rr��szCharacterData.__init__cCs
t|j�S)N)r�rG)rr
r
rr��szCharacterData._get_lengthcCs|jS)N)r)rr
r
r�	_get_data�szCharacterData._get_datacCs
||_dS)N)r)rrGr
r
r�	_set_data�szCharacterData._set_datacCs6|j}t|�dkrd}nd}d|jj|dd�|fS)N�
z...rz<DOM %s node "%r%s">r)rGr�r�ro)rrGZ	dotdotdotr
r
rr��szCharacterData.__repr__cCsT|dkrtjjd��|t|j�kr.tjjd��|dkrBtjjd��|j|||�S)Nrzoffset cannot be negativez#offset cannot be beyond end of datazcount cannot be negative)r/r0�IndexSizeErrr�rG)r�offset�countr
r
r�
substringData�szCharacterData.substringDatacCs|j||_dS)N)rG)r�argr
r
r�
appendDataszCharacterData.appendDatacCsZ|dkrtjjd��|t|j�kr.tjjd��|rVd|jd|�||j|d�f|_dS)Nrzoffset cannot be negativez#offset cannot be beyond end of dataz%s%s%s)r/r0rr�rG)rrrr
r
r�
insertDataszCharacterData.insertDatacCsl|dkrtjjd��|t|j�kr.tjjd��|dkrBtjjd��|rh|jd|�|j||d�|_dS)Nrzoffset cannot be negativez#offset cannot be beyond end of datazcount cannot be negative)r/r0rr�rG)rrrr
r
r�
deleteDataszCharacterData.deleteDatacCsr|dkrtjjd��|t|j�kr.tjjd��|dkrBtjjd��|rnd|jd|�||j||d�f|_dS)Nrzoffset cannot be negativez#offset cannot be beyond end of datazcount cannot be negativez%s%s%s)r/r0rr�rG)rrrrr
r
r�replaceDataszCharacterData.replaceDataN)rrOr3r=r<)rorprqr�r�r�r�rrr�rGr�r�rrrrrr
r
r
rr
�s			
r
zLength of the string data.c@sHeZdZfZejZdZdZdd�Z	ddd�Z
dd	�Zd
d�Zdd
�Z
dS)r�z#textNcCs�|dks|t|j�kr"tjjd��|j�}|j|d�|_|j|_|j}|jr~||jj	kr~|dkrp|jj
|�n|jj||�|jd|�|_|S)Nrzillegal offset value)r�rGr/r0rr�rOr<r3r$r5r-)rrZnewText�nextr
r
r�	splitText0szText.splitTextrcCst|d||j|f�dS)Nz%s%s%s)rrG)rr"r r�r!r
r
rr?sz
Text.writexmlcCs�|jg}|j}x6|dk	rD|jtjtjfkr@|jd|j�|j}qPqW|j}x4|dk	r�|jtjtjfkr||j|j�|j}qNPqNWdj	|�S)Nrr)
rGr=rr	rFr�r;r<rI�join)rrLr�r
r
r�_get_wholeTextDs

zText._get_wholeTextcCs�|j}|j}x6|dk	rB|jtjtjfkr>|j}|j|�|}qPqW|j}|sX|j|�x6|dk	r�|jtjtjfkr�|j}|j|�|}qZPqZW|r�||_|SdSdS)N)	r3r=rr	rFr�r4r<rG)rZcontentr�r�rr
r
r�replaceWholeTextVs*




zText.replaceWholeTextcCsF|jj�rdSt|�}|dkr"dS|jj|�}|dkr:dS|j�SdS)NF)rG�strip�_get_containing_elementrOr��isElementContent)rr�r�r
r
r�!_get_isWhitespaceInElementContentrs
z&Text._get_isWhitespaceInElementContent)rrr)rorprqr�r	rFrr�r�rrrrr#r
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}x"|dk	r(|jtjkr |S|j}qWdS)N)r3rr	rJ)rAr@r
r
rr!�s

r!cCs.|j}x"|dk	r(|jtjkr |S|j}qWdS)N)r3rr	r�)rAr@r
r
rr�s

rc@s(eZdZejZdZdd�Zddd�ZdS)	�Commentz#commentcCstj|�||_dS)N)r
r�r)rrGr
r
rr��s
zComment.__init__rcCs,d|jkrtd��|jd||j|f�dS)Nz--z%'--' is not allowed in a comment nodez
%s<!--%s-->%s)rGr7r~)rr"r r�r!r
r
rr�s
zComment.writexmlN)rrr)	rorprqr	r�rr�r�rr
r
r
rr$�sr$c@s$eZdZfZejZdZddd�ZdS)�CDATASectionz#cdata-sectionrcCs,|jjd�dkrtd��|jd|j�dS)Nz]]>rz$']]>' not allowed in a CDATA sectionz<![CDATA[%s]]>)rG�findr7r~)rr"r r�r!r
r
rr�szCDATASection.writexmlN)rrr)	rorprqr�r	r�rr�rr
r
r
rr%�sr%c@s|eZdZdZffdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�ZdS)�ReadOnlySequentialNamedNodeMap�_seqcCs
||_dS)N)r()r�seqr
r
rr��sz'ReadOnlySequentialNamedNodeMap.__init__cCs
t|j�S)N)r�r()rr
r
rr��sz&ReadOnlySequentialNamedNodeMap.__len__cCs
t|j�S)N)r�r()rr
r
rr��sz*ReadOnlySequentialNamedNodeMap._get_lengthcCs"x|jD]}|j|kr|SqWdS)N)r(r�)rr�r�r
r
rr��s
z+ReadOnlySequentialNamedNodeMap.getNamedItemcCs,x&|jD]}|j|kr|j|kr|SqWdS)N)r(rrrw)rrrrwr�r
r
rr��sz-ReadOnlySequentialNamedNodeMap.getNamedItemNScCs4t|t�r|j|�}n
|j|�}|dkr0t|��|S)N)r�r,r�r�r])rZ
name_or_tuplerAr
r
rr��s

z*ReadOnlySequentialNamedNodeMap.__getitem__cCs0|dkrdSy
|j|Stk
r*dSXdS)Nr)r(r�)rr6r
r
rr��s
z#ReadOnlySequentialNamedNodeMap.itemcCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rr�r
r
rr��sz.ReadOnlySequentialNamedNodeMap.removeNamedItemcCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rrrrwr
r
rr��sz0ReadOnlySequentialNamedNodeMap.removeNamedItemNScCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rrAr
r
rr��sz+ReadOnlySequentialNamedNodeMap.setNamedItemcCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rrAr
r
rr��sz-ReadOnlySequentialNamedNodeMap.setNamedItemNScCs|jgS)N)r()rr
r
rr��sz+ReadOnlySequentialNamedNodeMap.__getstate__cCs|d|_dS)Nr)r()rr�r
r
rr��sz+ReadOnlySequentialNamedNodeMap.__setstate__N)r()rorprqr�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(eZdZd
Zdd�Zdd�Zdd�Zd	S)�
Identified�publicId�systemIdcCs||_||_dS)N)r+r,)rr+r,r
r
r�_identified_mixin_init�sz!Identified._identified_mixin_initcCs|jS)N)r+)rr
r
r�
_get_publicId�szIdentified._get_publicIdcCs|jS)N)r,)rr
r
r�
_get_systemId�szIdentified._get_systemIdN)r+r,)rorprqr�r-r.r/r
r
r
rr*�sr*c@sHeZdZejZdZdZdZdZ	dZ
dd�Zdd�Zdd�Z
dd	d
�ZdS)�DocumentTypeNcCs2t�|_t�|_|r&t|�\}}||_|j|_dS)N)r'�entities�	notationsr�r�r�)rr�rsr�r
r
rr�	szDocumentType.__init__cCs|jS)N)�internalSubset)rr
r
r�_get_internalSubsetsz DocumentType._get_internalSubsetcCs�|jdkr�td�}|j|_|j|_tjjj}|r�g|j_	g|j
_	x>|j
j	D]2}t|j|j|j
�}|j
j	j|�|j|||�qJWxZ|jj	D]N}t|j|j|j
|j�}|j|_|j|_|j|_|jj	j|�|j|||�q�W|j|||�|SdSdS)N)rOr0r�r�r/r0�UserDataHandler�NODE_CLONEDr1r(r2�Notationr+r,rIrj�Entity�notationName�actualEncodingrrU)rrP�clonergr��notation�e�entityr
r
rrQs.

zDocumentType.cloneNodercCs�|jd�|j|j�|jr8|jd||j||jf�n|jrR|jd||jf�|jdk	r||jd�|j|j�|jd�|jd|�dS)Nz
<!DOCTYPE z%s  PUBLIC '%s'%s  '%s'z%s  SYSTEM '%s'z [�]r|)r~r�r+r,r3)rr"r r�r!r
r
rr/s



zDocumentType.writexml)rrr)rorprqr	�DOCUMENT_TYPE_NODErr�r�r+r,r3r�r4rQrr
r
r
rr0sr0c@sfeZdZdZejZdZdZdZ	dZ
dd�Zdd�Zdd�Z
dd	�Zd
d�Zdd
�Zdd�Zdd�ZdS)r8NcCs$||_||_t�|_|j||�dS)N)r�r9rkr$r-)rr�r+r,r<r
r
rr�FszEntity.__init__cCs|jS)N)r:)rr
r
r�_get_actualEncodingLszEntity._get_actualEncodingcCs|jS)N)r)rr
r
r�
_get_encodingOszEntity._get_encodingcCs|jS)N)rU)rr
r
r�_get_versionRszEntity._get_versioncCstjjd��dS)Nz(cannot append children to an entity node)r/r0r1)rr>r
r
rr5UszEntity.appendChildcCstjjd��dS)Nz+cannot insert children below an entity node)r/r0r1)rr>r?r
r
rr-YszEntity.insertBeforecCstjjd��dS)Nz*cannot remove children from an entity node)r/r0r1)rrCr
r
rr4]szEntity.removeChildcCstjjd��dS)Nz)cannot replace children of an entity node)r/r0r1)rr>rCr
r
rrDaszEntity.replaceChild)rorprqr�r	ZENTITY_NODErr�r:rrUr�rArBrCr5r-r4rDr
r
r
rr8=sr8c@seZdZejZdZdd�ZdS)r7NcCs||_|j||�dS)N)r�r-)rr�r+r,r
r
rr�iszNotation.__init__)rorprqr	r�rr�r�r
r
r
rr7esr7c	@sHeZdZddddddddgZdd	�Zd
d�Zdd
�Zdd�Zdd�ZdS)�DOMImplementation�core�1.0�2.0Nr/�ls-load�3.0cCs|dkrd}|j�|f|jkS)Nr)�lower�	_features)rrTrUr
r
rrSyszDOMImplementation.hasFeaturec	Cs�|r|jdk	rtjjd��|j�}|dko8|dko8|dk}|rR|rRtjjd��|r�t|�\}}|dkr~|dkr~tjjd��|r�|r�tjjd��|j||�}|r�|j	|�|j	|�|r�||_|_
||_||_|S)Nz(doctype object owned by another DOM treezElement with no namer/z$http://www.w3.org/XML/1998/namespacezillegal use of 'xml' prefixz(illegal use of prefix without namespaces)
r3r/r0�WrongDocumentErr�_create_documentZInvalidCharacterErrr�r��createElementNSr5rO�doctyperR)	rrrr�rOruZadd_root_elementrsr�rr
r
r�createDocument~s4





z DOMImplementation.createDocumentcCst|�}||_||_|S)N)r0r+r,)rr�r+r,rOr
r
r�createDocumentType�sz$DOMImplementation.createDocumentTypecCs|j|d�r|SdSdS)N)rS)rrTr
r
rrZ�szDOMImplementation.getInterfacecCst�S)N)�Document)rr
r
rrM�sz"DOMImplementation._create_document)rErF)rErG)rEN)r/rF)r/rG)r/N)rHrI)rHN)	rorprqrKrSrPrQrZrMr
r
r
rrDns-rDc@sXeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�ZdS)�ElementInfor�cCs
||_dS)N)r�)rr�r
r
rr��szElementInfo.__init__cCstS)N)r�)r�anamer
r
rr��szElementInfo.getAttributeTypecCstS)N)r�)rrrrwr
r
rr��szElementInfo.getAttributeTypeNScCsdS)NFr
)rr
r
rr"�szElementInfo.isElementContentcCsdS)NFr
)rr
r
r�isEmpty�szElementInfo.isEmptycCsdS)NFr
)rrTr
r
rr��szElementInfo.isIdcCsdS)NFr
)rrrrwr
r
rr��szElementInfo.isIdNScCs|jS)N)r�)rr
r
rr��szElementInfo.__getstate__cCs
||_dS)N)r�)rr�r
r
rr��szElementInfo.__setstate__N)r�)
rorprqr�r�r�r�r"rUr�r�r�r�r
r
r
rrS�s	rScCs>|jtjkr|jj�d|_nt|�r:|jjj�d|j_dS)N)rr	r�	_id_cache�clear�_id_search_stackrxrO)rAr
r
rr:�s
r:c@sreZdZdMZejejejejfZ	e
�ZejZ
dZdZdZdZdZZdZdZdZdZdZdZdZd	Zd
d�Zdd
�Zdd�Zdd�Zdd�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/�Z.d0d1�Z/d2d3�Z0d4d5�Z1d6d7�Z2d8d9�Z3d:d;�Z4d<d=�Z5d>d?�Z6d@dA�Z7dBdC�Z8dDdE�Z9dFdG�Z:dNdIdJ�Z;dKdL�Z<dS)OrR�
_elem_inforOrXr$rVz	#documentNFrcCs$d|_t�|_i|_i|_d|_dS)N)rOrkr$rYrVrX)rr
r
rr�
s
zDocument.__init__cCs&|jr|j|jf}n|j}|jj|�S)N)rrrwr�rYr�)rrr^r
r
rr�szDocument._get_elem_infocCs|jS)N)r:)rr
r
rrAszDocument._get_actualEncodingcCs|jS)N)rO)rr
r
r�_get_doctypeszDocument._get_doctypecCs|jS)N)�documentURI)rr
r
r�_get_documentURI szDocument._get_documentURIcCs|jS)N)r)rr
r
rrB#szDocument._get_encodingcCs|jS)N)�errorHandler)rr
r
r�_get_errorHandler&szDocument._get_errorHandlercCs|jS)N)�
standalone)rr
r
r�_get_standalone)szDocument._get_standalonecCs|jS)N)�strictErrorChecking)rr
r
r�_get_strictErrorChecking,sz!Document._get_strictErrorCheckingcCs|jS)N)rU)rr
r
rrC/szDocument._get_versioncCsj|j|jkr(tjjdt|�t|�f��|jdk	r>|jj|�|jtj	kr^|j
�r^tjjd��tj||�S)Nz%s cannot be child of %sz two document elements disallowed)rr.r/r0r1r2r3r4r	rJ�_get_documentElementr5)rrAr
r
rr52s
zDocument.appendChildcCsVy|jj|�Wntk
r.tjj��YnXd|_|_d|_|j	|krRd|_	|S)N)
r$rEr7r/r0r8r<r=r3�documentElement)rrCr
r
rr4Bs
zDocument.removeChildcCs$x|jD]}|jtjkr|SqWdS)N)r$rr	rJ)rrAr
r
rrcNszDocument._get_documentElementcCs(|jdk	r|jj�d|_tj|�dS)N)rOrHr	)rr
r
rrHSs

zDocument.unlinkcCs�|sdS|jjddd�}|j|_|j|_|j|_xL|jD]B}t|||�}|jj|�|jt	j
krbn|jt	jkrt||_||_
q8W|jtjjj||�|S)N)rRrPrr_rUr$rNrIrr	rr@rOr3rjr/r0r5r6)rrPr;r�Z
childcloner
r
rrQYs"
zDocument.cloneNodecCst�}||_|S)N)r�rO)rrbr
r
r�createDocumentFragmentnszDocument.createDocumentFragmentcCst|�}||_|S)N)r�rO)rr�r=r
r
r�
createElementsszDocument.createElementcCs(t|t�std��t�}||_||_|S)Nznode contents must be a string)r�r�r�r�rGrO)rrG�tr
r
r�createTextNodexs
zDocument.createTextNodecCs(t|t�std��t�}||_||_|S)Nznode contents must be a string)r�r�r�r%rGrO)rrGr@r
r
r�createCDATASection�s
zDocument.createCDATASectioncCst|�}||_|S)N)r$rO)rrGr@r
r
r�
createComment�szDocument.createCommentcCst||�}||_|S)N)rrO)rrrG�pr
r
r�createProcessingInstruction�s
z$Document.createProcessingInstructioncCst|�}||_d|_|S)Nr)r�rOr�)rr��ar
r
r�createAttribute�szDocument.createAttributecCs"t|�\}}t|||�}||_|S)N)r�r�rO)rrrr�rsrwr=r
r
rrN�szDocument.createElementNScCs*t|�\}}t||||�}||_d|_|S)Nr)r�r�rOr�)rrrr�rsrwrmr
r
r�createAttributeNS�s
zDocument.createAttributeNScCst||||�}||_|S)N)r8rO)rr�r+r,r9r=r
r
r�_create_entity�szDocument._create_entitycCst|||�}||_|S)N)r7rO)rr�r+r,r�r
r
r�_create_notation�szDocument._create_notationcCs�||jkr|j|S|jp|js$dS|j}|dkrB|jg}||_n|sJdSd}�x>|�r�|j�}|jdd�|jD��|j|�}|�r@x�|j	j
�D]�}|jr�|j|j|j
�r�||j|j<|j|kr�|}n|js�Pq�|j|j��r
||j|j<|j|k�r�|}n
|j�s:Pq�|jr�||j|j<|j|k�r.|}q�|jdkr�Pq�WnB|j�r�x8|j	j
�D]*}|j�rT||j|j<|j|k�rT|}�qTW|dk	rRPqRW|S)NcSsg|]}|jtkr|�qSr
)rr9)�.0rMr
r
r�
<listcomp>�sz+Document.getElementById.<locals>.<listcomp>r()rVrYr�rXrd�pop�extendr$r�r�r�rrr�rwr�r�r�r�r�)rr��stack�resultrAr�r�r
r
r�getElementById�sZ






zDocument.getElementByIdcCst||t��S)N)r�rk)rr�r
r
rr��szDocument.getElementsByTagNamecCst|||t��S)N)r�rk)rrrrwr
r
rr��szDocument.getElementsByTagNameNScCs|jj||�S)N)rRrS)rrTrUr
r
rrV�szDocument.isSupportedcCs>|jtjkrtjjd��n|jtjkr2tjjd��t|||�S)Nzcannot import document nodesz!cannot import document type nodes)rr	rr/r0�NotSupportedErrr@rN)rrArPr
r
r�
importNode�s
zDocument.importNodercCsN|dkr|jd|�n|jd||f�x|jD]}|j||||�q2WdS)Nz<?xml version="1.0" ?>z%<?xml version="1.0" encoding="%s"?>%s)r~r$r)rr"r r�r!rrAr
r
rr�szDocument.writexmlcCsJ|j|k	r tjjd||jf��|jtjtjfkr>tjjd��|t	kr�d|kr�|j
dd�\}}|dkr�|tjjkr�tjjd��q�|dkr�|tjjkr�|jtjkr�tjjd��d}|}nd}d}|jtjkr�|j
}|dk	r�|j}|j|�nd}||_||_||_||_|jtjk�r||_n*||_|dk	�rF|j|�|�rF|j|�|S)Nz?cannot rename nodes from other documents;
expected %s,
found %sz8renameNode() only applies to element and attribute nodesr�r(r�zillegal use of 'xmlns' prefixz$illegal use of the 'xmlns' attribute)rOr/r0rLrr	rJr�ryrr�rr�r�r�r�rsr�rrr�r�r�r�r�)rr�rrr�rsrwrZis_idr
r
r�
renameNodesR



zDocument.renameNode)rYrOrXr$rV)rrrN)=rorprqr�r	rJr�r�r@r.rDrRrrr�r�r�r3r=r<r:rr_rUrar]r[r�r�r�rArZr\rBr^r`rbrCr5r4rcrHrQrerfrhrirjrlrnrNrorprqrxr�r�rVrzrr{r
r
r
rrR�sh	
:
rRrdz#Top-level element of this document.c
Cs�|jj|�rtjjj}n
tjjj}|jtj	kr�|j
|j|j�}x>|j
j�D]0}|j|j|j|j�|j|j|j�}|j|_qJW|r�x$|jD]}t|||�}|j|�q�W�n|jtjkr�|j�}|r�x$|jD]}t|||�}|j|�q�W�n�|jtjk�r|j|j�}�n�|jtjk�r*|j|j�}�n�|jtjk�rL|j|j |j�}�nr|jtj!k�rj|j"|j�}�nT|jtj#k�r�|j$|j|j�}d|_|j|_�n$|jtj%k�r�tjjj}|j&j'|j(|j)|j*�}||_|�r�g|j+_,g|j-_,xR|j-j,D]F}	t.|	j|	j)|	j*�}
||
_|j-j,j/|
�t0|	d��r�|	j1||	|
��q�Wx�|j+j,D]b}t2|j|j)|j*|j3�}|j4|_4|j5|_5|j6|_6||_|j+j,j/|�t0|d��rB|j1|||��qBWntjj7dt8|���t0|d��r�|j1|||�|S)NTrjzCannot clone node %s)9rOrYr/r0r5r6Z
NODE_IMPORTEDrr	rJrNrrr�r�r�r�r�r�rwr�r$rNr5r+rerFrhrGr�rir�rlrr�rjr�ror@rRrQr�r+r,r1r(r2r7rIrdrjr8r9r:rrUryr2)
rArPZnewOwnerDocumentrgr;r�rmrMr@r�r<r=r>r
r
rrNAs|

rNcCs,|jdd�}t|�dkr|Sd|dfSdS)Nr�r(�r)r�r�)r�Zfieldsr
r
rr��sr�cCs,|||�}|j�\}}|j|�|j�|S)N)ZgetEventZ
expandNoderW)�func�args�kwargsZeventsZtoktypeZrootNoder
r
r�_do_pulldom_parse�s


r�cCsJ|dkr$|r$ddlm}|j|�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}|j|�Sddlm}t|j|fd|i�SdS)Nr)r�)r�r�)r�r��parseStringr�r�)�stringr�r�r�r
r
rr��s

r�cCsB|r<t|t�rtj|�}x"|D]\}}tjj||�sdSqWtjS)N)r�r�rZ_parse_feature_stringrRrRrS)Zfeatures�f�vr
r
r�getDOMImplementation�s

r�)NN)N)N)6rr�r/rrrrZxml.dom.minicompatZxml.dom.xmlbuilderrrr0r	rJr�r9ZdefpropertyrBrxrr�r�r�r��objectr�Z
AttributeListr�r�r�r�rrr
r�r!rr$r%r'r*r0r8r7rDrSr:rRrNr�r�r�r�r�r
r
r
r�<module>s�v
	y$
w)GU	><(	O*PR



PK�"[��=&3&3/dom/__pycache__/xmlbuilder.cpython-36.opt-2.pycnu�[���3


 \�2�@s�ddlZddlZddlZddlmZdddgZGdd�d�ZGdd�d�Zd	d
�Z	Gdd�de
�ZGdd�de
�ZGd
d�d�Z
[Gdd�d�ZGdd�d�Z[Gdd�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.6/xml/dom/xmlbuilder.pyr
s&
rc5@sVeZdZdZdZdZdZdZdZdZ	eeee	fZ
dd�Zdd	�Zd
d�Z
dd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd4d5gd6d7gd8d9gd:d;gd<d=gd>d?gd@dAgdBdCgdDdEgdFdGgdHdIdJgdKdLgdMdNgdOdPgdQdRgdSdTgdUdVgdWdXgdYdZgd[d\gd]gd^d_d`dadbdcdddedfdgg	dhdigdjdkgdldmgiZd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�ZdS)nrNr���cCst�|_dS)N)r�_options)�selfrrr�__init__:szDOMBuilder.__init__cCs|jS)N)�entityResolver)r"rrr�_get_entityResolver=szDOMBuilder._get_entityResolvercCs
||_dS)N)r$)r"r$rrr�_set_entityResolver?szDOMBuilder._set_entityResolvercCs|jS)N)r)r"rrr�_get_errorHandlerBszDOMBuilder._get_errorHandlercCs
||_dS)N)r)r"rrrr�_set_errorHandlerDszDOMBuilder._set_errorHandlercCs|jS)N)r)r"rrr�_get_filterGszDOMBuilder._get_filtercCs
||_dS)N)r)r"rrrr�_set_filterIszDOMBuilder._set_filterc
Cs�|j|�rv|rdpd}y|jt|�|f}Wn&tk
rRtjjd|f��Yq�Xx4|D]\}}t|j||�qZWntjj	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|��S)N)�hasattrr!r-)r"r5rrrr+ZszDOMBuilder.supportsFeaturecCst|�|rdpdf}||jkS)Nrr)r-r,)r"r5r6�keyrrr�
canSetFeature]szDOMBuilder.canSetFeaturerrr
rrrrrrrrrrrrrcCs�t|�}yt|j|�Stk
r�|dkrj|j}|joh|joh|joh|joh|jpf|j	pf|j
pf|jpf|jSt
jjdt|���YnXdS)Nrzfeature %s not known)r-�getattrr!�AttributeErrorrrrrrrrrrr/r0r3r4)r"r5Zxname�optionsrrr�
getFeature�s zDOMBuilder.getFeaturecCs.|jr|jjd|�}nt�jd|�}|j|�S)N)r$�
resolveEntityr�parse)r"�uri�inputrrr�parseURI�szDOMBuilder.parseURIcCsRtj|j�}|j|_|j|_|j}|dkrF|jrFddl}|jj|j�}|j	||�S)Nr)
�copyr!rr�
byteStream�systemId�urllib.request�requestZurlopen�_parse_bytestream)r"rCr>�fp�urllibrrrrA�szDOMBuilder.parsecCs||jkrtd��td��dS)Nznot a legal actionzHaven't written this yet...)�_legal_actions�
ValueError�NotImplementedError)r"rCZcnode�actionrrr�parseWithContext�s
zDOMBuilder.parseWithContextcCs ddl}|jjj|�}|j|�S)Nr)Zxml.dom.expatbuilderr0ZexpatbuilderZmakeBuilderZ	parseFile)r"�streamr>r/ZbuilderrrrrJ�szDOMBuilder._parse_bytestream)rr)rr)rr)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)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr	r
r$rrZACTION_REPLACEZACTION_APPEND_AS_CHILDRENZACTION_INSERT_AFTERZACTION_INSERT_BEFORErMr#r%r&r'r(r)r*r8r+r;r,r?rDrArQrJrrrrr-s�

cCs|j�jdd�S)N�-�_)�lower�replace)r5rrrr-�sr-c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)r�_openerc
Cs�t�}||_||_|j�j|�|_|j|�|_ddl}ddl	}|j
j|�}|\}}}	}
}}|	r�|	jd�r�|j
|	�d}	|||	|
||f}|j
j|�|_|S)Nr�/)r�publicIdrG�_get_opener�openrF�_guess_media_encoding�encoding�	posixpathZurllib.parserAZurlparse�endswith�dirnameZ
urlunparse�baseURI)
r"rYrG�sourcer^rL�parts�schemeZnetloc�pathZparamsZqueryZfragmentrrrr@�szDOMEntityResolver.resolveEntitycCs,y|jStk
r&|j�|_|jSXdS)N)rWr=�_create_opener)r"rrrrZ�s

zDOMEntityResolver._get_openercCsddl}|jj�S)Nr)rHrIZbuild_opener)r"rLrrrrf�sz DOMEntityResolver._create_openercCsF|jj�}d|krBx.|j�D]"}|jd�r|jdd�dj�SqWdS)NzContent-Typezcharset=�=r)rF�infoZgetplist�
startswith�splitrU)r"rbrhZparamrrrr\�s


z'DOMEntityResolver._guess_media_encodingN)rW)rr	r
�	__slots__r@rZrfr\rrrrr�s
c@s�eZdZd'Zdd	�Zd
d�Zdd
�Zdd�Zdd�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&S)(rrF�characterStream�
stringDatar]rYrGracCs.d|_d|_d|_d|_d|_d|_d|_dS)N)rFrlrmr]rYrGra)r"rrrr#szDOMInputSource.__init__cCs|jS)N)rF)r"rrr�_get_byteStreamszDOMInputSource._get_byteStreamcCs
||_dS)N)rF)r"rFrrr�_set_byteStreamszDOMInputSource._set_byteStreamcCs|jS)N)rl)r"rrr�_get_characterStreamsz#DOMInputSource._get_characterStreamcCs
||_dS)N)rl)r"rlrrr�_set_characterStreamsz#DOMInputSource._set_characterStreamcCs|jS)N)rm)r"rrr�_get_stringDataszDOMInputSource._get_stringDatacCs
||_dS)N)rm)r"�datarrr�_set_stringDataszDOMInputSource._set_stringDatacCs|jS)N)r])r"rrr�
_get_encodingszDOMInputSource._get_encodingcCs
||_dS)N)r])r"r]rrr�
_set_encodingszDOMInputSource._set_encodingcCs|jS)N)rY)r"rrr�
_get_publicId"szDOMInputSource._get_publicIdcCs
||_dS)N)rY)r"rYrrr�
_set_publicId$szDOMInputSource._set_publicIdcCs|jS)N)rG)r"rrr�
_get_systemId'szDOMInputSource._get_systemIdcCs
||_dS)N)rG)r"rGrrr�
_set_systemId)szDOMInputSource._set_systemIdcCs|jS)N)ra)r"rrr�_get_baseURI,szDOMInputSource._get_baseURIcCs
||_dS)N)ra)r"rBrrr�_set_baseURI.szDOMInputSource._set_baseURIN)rFrlrmr]rYrGra)rr	r
rkr#rnrorprqrrrtrurvrwrxryrzr{r|rrrrrs"	c@s:eZdZdZdZdZdZejZ	dd�Z
dd�Zd	d
�ZdS)�DOMBuilderFilterrrrr cCs|jS)N)�
whatToShow)r"rrr�_get_whatToShowCsz DOMBuilderFilter._get_whatToShowcCs|jS)N)�
FILTER_ACCEPT)r"�elementrrr�
acceptNodeFszDOMBuilderFilter.acceptNodecCs|jS)N)r�)r"r�rrr�startContainerIszDOMBuilderFilter.startContainerN)
rr	r
r�Z
FILTER_REJECTZFILTER_SKIPZFILTER_INTERRUPTrZSHOW_ALLr~rr�r�rrrrr}2s
r}c@s$eZdZdd�Zdd�Zdd�ZdS)�_AsyncDeprecatedPropertycCs|j}tjdj|d�t�dS)Nz+{cls}.async is deprecated; use {cls}.async_)�cls)r�warnings�warn�format�DeprecationWarning)r"r�Zclsnamerrrr�Ps
z_AsyncDeprecatedProperty.warncCs|j|�|dk	r|jSdS)NF)r��async_)r"�instancer�rrr�__get__Vs
z _AsyncDeprecatedProperty.__get__cCs|jt|��t|d|�dS)Nr�)r��typer2)r"r�r7rrr�__set__\sz _AsyncDeprecatedProperty.__set__N)rr	r
r�r�r�rrrrr�Osr�c@sLeZdZdZe�e�d<dd�Zdd�Zdd�Zd	d
�Z	dd�Z
d
d�ZdS)�
DocumentLSF�asynccCsdS)NFr)r"rrr�
_get_asyncgszDocumentLS._get_asynccCs|rtjjd��dS)Nz.asynchronous document loading is not supported)r/r0r1)r"�flagrrr�
_set_asyncjszDocumentLS._set_asynccCstd��dS)Nz'haven't figured out what this means yet)rO)r"rrr�abortoszDocumentLS.abortcCstd��dS)Nzhaven't written this yet)rO)r"rBrrr�loaduszDocumentLS.loadcCstd��dS)Nzhaven't written this yet)rO)r"rbrrr�loadXMLxszDocumentLS.loadXMLcCs*|dkr|}n|j|k	r"tjj��|j�S)N)Z
ownerDocumentr/r0ZWrongDocumentErrZtoxml)r"Zsnoderrr�saveXML{s


zDocumentLS.saveXMLN)rr	r
r�r��localsr�r�r�r�r�r�rrrrr�asr�c@s,eZdZdZdZdd�Zdd�Zdd�Zd	S)
�DOMImplementationLSrrcCsF|dk	rtjjd��||jkr$t�S||jkr:tjjd��td��dS)NzschemaType not yet supportedz'asynchronous builders are not supportedzunknown value for mode)r/r0r1�MODE_SYNCHRONOUSr�MODE_ASYNCHRONOUSrN)r"�modeZ
schemaTyperrr�createDOMBuilder�s

z$DOMImplementationLS.createDOMBuildercCstd��dS)Nz-the writer interface hasn't been written yet!)rO)r"rrr�createDOMWriter�sz#DOMImplementationLS.createDOMWritercCst�S)N)r)r"rrr�createDOMInputSource�sz(DOMImplementationLS.createDOMInputSourceN)rr	r
r�r�r�r�r�rrrrr��s
r�)rEr�Zxml.domr/Zxml.dom.NodeFilterr�__all__rrr-�objectrrr}r�r�r�rrrr�<module>s 
 %,1"PK�"[�{ΑUU+dom/__pycache__/domreg.cpython-36.opt-2.pycnu�[���3


 \{
�@s@ddlZddd�ZiZdd�Zdd�Zdffd	d
�Zdd�ZdS)
�Nzxml.dom.minidomzxml.dom.DOMImplementation)ZminidomZ4DOMcCs|t|<dS)N)�
registered)�name�factory�r�&/usr/lib64/python3.6/xml/dom/domreg.py�registerDOMImplementations	rcCs&x |D]\}}|j||�sdSqWdS)Nr�)Z
hasFeature)�dom�features�f�vrrr�_good_enough sr
cCs�ddl}d}tj|�}|r2t|iidg�}|j�S|r@t|�Stjjrdd|j	krdt|j	dd�St
|t�rvt|�}x$tj
�D]}|�}t||�r�|Sq�WxDtj�D]8}yt|d�}Wntk
r�w�YnXt||�r�|Sq�Wtd��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}|j�}d}t|�}xp||kr�||}|ddkrDtd|f��|d}d}||krx||}|ddkrx|d}|}|j||f�qWt|�S)Nr�
0123456789zbad feature name: %rr)�split�len�
ValueError�append�tuple)�sr
�parts�iZlengthZfeature�versionrrrrrRs"
r)rrrrr
rrrrrr�<module>	s+PK�"[H��^��)dom/__pycache__/NodeFilter.cpython-36.pycnu�[���3


 \��@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.6/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>sPK�"[H��^��/dom/__pycache__/NodeFilter.cpython-36.opt-1.pycnu�[���3


 \��@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.6/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>sPK�"[R�������,dom/__pycache__/minidom.cpython-36.opt-1.pycnu�[���3


 \�@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.6/xml/dom/minidom.py�__bool__+sz
Node.__bool__cCs|jdd|�S)N�)�toprettyxml)r�encodingr
r
r�toxml.sz
Node.toxml�	�
cCsx|dkrtj�}ntjtj�|ddd�}|jtjkrH|j|d|||�n|j|d||�|dkrh|j�S|j	�j�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�
childNodes)rr
r
r�
hasChildNodesCszNode.hasChildNodescCs|jS)N)r$)rr
r
r�_get_childNodesFszNode._get_childNodescCs|jr|jdSdS)Nr)r$)rr
r
r�_get_firstChildIszNode._get_firstChildcCs|jr|jdSdS)N����)r$)rr
r
r�_get_lastChildMszNode._get_lastChildcCs|j|jkr0xt|j�D]}|j||�qW|S|j|jkrXtjjdt	|�t	|�f��|j
dk	rn|j
j|�|dkr�|j|�n�y|jj
|�}Wntk
r�tjj��YnX|jtkr�t|�|jj||�||_||_|r�|j|d}||_||_nd|_||_
|S)Nz%s cannot be child of %sr()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�cr6�noder
r
rr-Qs6

zNode.insertBeforecCs�|j|jkr.xt|j�D]}|j|�qW|S|j|jkrXtjjdt	|�t	|�f��n|jt
krjt|�|jdk	r�|jj
|�t||�d|_|S)Nz%s cannot be child of %s)rr+r,r$r5r.r/r0r1r2r9r:r3r4�
_append_childr<)rrAr@r
r
rr5qs


zNode.appendChildcCs|j|jkr(|j}|j|�|j||�S|j|jkrPtjjdt	|�t	|�f��||kr\dS|j
dk	rr|j
j|�y|jj|�}Wnt
k
r�tjj��YnX||j|<||_
d|_
|jtks�|jtkr�t|�|j|_|j|_d|_d|_|jr�||j_|j�r||j_|S)Nz%s cannot be child of %s)rr+r<r4r-r.r/r0r1r2r3r$r6r7r8r9r:r=)rr>�oldChildr?r6r
r
r�replaceChild�s<




zNode.replaceChildcCs�y|jj|�Wntk
r.tjj��YnX|jdk	rD|j|j_|jdk	rX|j|j_d|_|_|jt	krvt
|�d|_|S)N)r$�remover7r/r0r8r<r=rr9r:r3)rrCr
r
rr4�s




zNode.removeChildcCs�g}x�|jD]�}|jtjkr�|jsL|r2|j|d_|jrB|j|j_|j�q�|r�|dj|jkr�|d}|j|j|_|j|_|jr�||j_|j�q�|j|�q|j|�|jtj	kr|j
�qW||jdd�<dS)Nr(r)r)r))r$rr	�	TEXT_NODE�datar<r=�unlink�append�ELEMENT_NODE�	normalize)r�L�childrAr
r
rrK�s*



zNode.normalizecCst|||jp|�S)N)�_clone_node�
ownerDocument)r�deepr
r
r�	cloneNode�szNode.cloneNodecCs|jjj||�S)N)rO�implementation�
hasFeature)r�feature�versionr
r
r�isSupported�szNode.isSupportedcCsdS)Nr
)rr
r
r�_get_localName�szNode._get_localNamecCs||kS)Nr
)r�otherr
r
r�
isSameNode�szNode.isSameNodecCs|j|d�r|SdSdS)N)rV)rrTr
r
r�getInterface�szNode.getInterfacecCs,y|j|dSttfk
r&dSXdS)Nr)�
_user_data�AttributeError�KeyError)r�keyr
r
r�getUserData�szNode.getUserDatacCsnd}y
|j}Wntk
r,i}||_YnX||krB||d}|dkr^d}|dk	rj||=n||f||<|S)Nr)r[r\)rr^rG�handler�old�dr
r
r�setUserData�s
zNode.setUserDatacCsHt|d�rDx8t|jj��D]&\}\}}|dk	r|j|||||�qWdS)Nr[)�hasattr�listr[�itemsZhandle)r�	operation�src�dstr^rGr`r
r
r�_call_user_data_handler�s
zNode._call_user_data_handlercCsBd|_|_|jr2x|jD]}|j�qWt�|_d|_d|_dS)N)r3rOr$rH�NodeListr=r<)rrMr
r
rrHszNode.unlinkcCs|S)Nr
)rr
r
r�	__enter__szNode.__enter__cCs|j�dS)N)rH)rZetZev�tbr
r
r�__exit__sz
Node.__exit__)N)rrN)!�__name__�
__module__�__qualname__�namespaceURIr3rOr<r=r�prefixr
rrr%r&r'r*r-r5rDr4rKrQrVrWrYrZr_rcrjrHrlrnr
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}||_||_|j|�||_dS)Nr(r))r$r=r<rIr3)rrAr$Zlastr
r
rrBs
rBcCs(x"|dk	r"|jtjkrdS|j}qWdS)NTF)rr	rr3)rAr
r
r�_in_document&s


rxcCs6|r2|jdd�jdd�jdd�jdd�}|j|�d	S)
zWrites datachars to writer.�&z&amp;�<z&lt;�"z&quot;�>z&gt;N)�replace�write)r"rGr
r
r�_write_data.srcCsHxB|jD]8}|jtjkr4|dks*|j|kr4|j|�t|||�qW|S)Nr)r$rr	rJ�tagNamerI�_get_elements_by_tagName_helper)�parent�name�rcrAr
r
rr�5s
r�cCs\xV|jD]L}|jtjkr|dks*|j|krF|dks<|j|krF|j|�t||||�qW|S)Nr)r$rr	rJrwrrrI�"_get_elements_by_tagName_ns_helper)r�ZnsURIrwr�rAr
r
rr�=s
r�c@sJeZdZejZdZdZdZdZ	ej
ejejej
ejejejfZdd�ZdS)�DocumentFragmentz#document-fragmentNcCst�|_dS)N)rkr$)rr
r
r�__init__TszDocumentFragment.__init__)rorprqr	r+r�nodeName�	nodeValue�
attributesr3rJrF�CDATA_SECTION_NODE�ENTITY_REFERENCE_NODE�PROCESSING_INSTRUCTION_NODE�COMMENT_NODE�
NOTATION_NODEr.r�r
r
r
rr�Fsr�c@s�eZdZd#ZejZd	Zd
Zd
Z	ej
ejfZe
d	d	fdd�Zd
d�Zdd�Zdd�Zdd�Zeee�ZZdd�Zdd�Zeee�ZZdd�Zdd�Zeee�Zdd�Zdd �Zd!d"�Zd	S)$�Attr�_name�_valuerr�_prefixr$�
_localNamerO�ownerElementNFcCs2d|_||_||_||_t�|_|jjt��dS)N)r�r�rrr�rkr$rI�Text)r�qNamerrrwrsr
r
rr�bsz
Attr.__init__cCs.y|jStk
r(|jjdd�dSXdS)N�:r(r))r�r\r��split)rr
r
rrWoszAttr._get_localNamecCs|jS)N)�	specified)rr
r
r�_get_specifieduszAttr._get_specifiedcCs|jS)N)r�)rr
r
r�	_get_namexszAttr._get_namecCs||_|jdk	rt|j�dS)N)r�r�r:)r�valuer
r
r�	_set_name{s
zAttr._set_namecCs|jS)N)r�)rr
r
r�
_get_value�szAttr._get_valuecCs6||_||jd_|jdk	r&t|j�||jd_dS)Nr)r�r$rGr�r:)rr�r
r
r�
_set_value�s


zAttr._set_valuecCs|jS)N)r�)rr
r
r�_get_prefix�szAttr._get_prefixcCsd|j}|dkr&|r&|tkr&tjjd��||_|dkr<|j}nd||jf}|jrZt|j�||_	dS)N�xmlnsz5illegal use of 'xmlns' prefix for the wrong namespacez%s:%s)
rrrr/r0�NamespaceErrr�rwr�r:r�)rrsZnsuriZnewNamer
r
r�_set_prefix�s
zAttr._set_prefixcCsz|j}|dk	rR|j|j=|j|j|jf=|jrRd|_|jd8_|jj	d8_	x|j
D]}|j�qZW|j
dd�=dS)NFr()r��_attrsr��_attrsNSrrrw�_is_id�_magic_id_nodesrO�_magic_id_countr$rH)r�elemrMr
r
rrH�s
zAttr.unlinkcCsf|jr
dS|j}|j}|dks&|dkr*dS|j|�}|dkr@dS|jrV|j|j|j�S|j|j�SdS)NTF)	r�rOr��_get_elem_inforr�isIdNSrw�isIdr�)rrur��infor
r
r�	_get_isId�s
zAttr._get_isIdcCs\|j}|j}|dks|dkr tS|j|�}|dkr6tS|jrL|j|j|j�S|j|j�SdS)N)	rOr��_no_typer�rr�getAttributeTypeNSrw�getAttributeTyper�)rrur�r�r
r
r�_get_schemaType�s
zAttr._get_schemaType)r�r�rrr�r$r�rOr�) rorprq�	__slots__r	�ATTRIBUTE_NODErr�r�r�rFr�r.rr�rWr�r�r��propertyr�r�r�r�r�r�r�r�rsrHr�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�eZdZdZd<Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
d=dd�ZeZdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Zd:d;�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||_||_||_dS)N)r�r�r�)r�attrsZattrsNSr�r
r
rr��szNamedNodeMap.__init__cCs
t|j�S)N)�lenr�)rr
r
r�_get_length�szNamedNodeMap._get_lengthcCs0y|t|jj��|Stk
r*dSXdS)N)rer��keys�
IndexError)rr6r
r
r�item�szNamedNodeMap.itemcCs.g}x$|jj�D]}|j|j|jf�qW|S)N)r��valuesrIr�r�)rrLrAr
r
rrf�szNamedNodeMap.itemscCs4g}x*|jj�D]}|j|j|jf|jf�qW|S)N)r�r�rIrrrwr�)rrLrAr
r
r�itemsNS�szNamedNodeMap.itemsNScCs"t|t�r||jkS||jkSdS)N)�
isinstance�strr�r�)rr^r
r
r�__contains__�s

zNamedNodeMap.__contains__cCs
|jj�S)N)r�r�)rr
r
rr�szNamedNodeMap.keyscCs
|jj�S)N)r�r�)rr
r
r�keysNSszNamedNodeMap.keysNScCs
|jj�S)N)r�r�)rr
r
rr�szNamedNodeMap.valuesNcCs|jj||�S)N)r��get)rr�r�r
r
rr�
szNamedNodeMap.getcCs:|jt|dd�krdSt|�t|�kt|�t|�kSdS)Nr�r)r��getattr�id)rrXr
r
r�_cmpszNamedNodeMap._cmpcCs|j|�dkS)Nr)r�)rrXr
r
r�__eq__szNamedNodeMap.__eq__cCs|j|�dkS)Nr)r�)rrXr
r
r�__ge__szNamedNodeMap.__ge__cCs|j|�dkS)Nr)r�)rrXr
r
r�__gt__szNamedNodeMap.__gt__cCs|j|�dkS)Nr)r�)rrXr
r
r�__le__szNamedNodeMap.__le__cCs|j|�dkS)Nr)r�)rrXr
r
r�__lt__!szNamedNodeMap.__lt__cCs"t|t�r|j|S|j|SdS)N)r�r,r�r�)r�attname_or_tupler
r
r�__getitem__$s

zNamedNodeMap.__getitem__cCsvt|t�rRy|j|}Wn0tk
rHt|�}|jj|_|j|�YnX||_n t|t�sdt	d��|}|j|�dS)Nz%value must be a string or Attr object)
r�r�r�r]r�r�rO�setNamedItemr��	TypeError)r�attnamer�rAr
r
r�__setitem__+s


zNamedNodeMap.__setitem__cCs$y
|j|Stk
rdSXdS)N)r�r])rr�r
r
r�getNamedItem:s
zNamedNodeMap.getNamedItemcCs(y|j||fStk
r"dSXdS)N)r�r])rrrrwr
r
r�getNamedItemNS@szNamedNodeMap.getNamedItemNScCsX|j|�}|dk	rJt|j�|j|j=|j|j|jf=t|d�rFd|_	|St
jj��dS)Nr�)
r�r:r�r�r�r�rrrwrdr�r/r0r8)rr��nr
r
r�removeNamedItemFs



zNamedNodeMap.removeNamedItemcCsZ|j||�}|dk	rLt|j�|j|j|jf=|j|j=t|d�rHd|_	|St
jj��dS)Nr�)
r�r:r�r�rrrwr�r�rdr�r/r0r8)rrrrwr�r
r
r�removeNamedItemNSRs


zNamedNodeMap.removeNamedItemNScCstt|t�s&tjjdt|�t|�f��|jj|j�}|r@|j	�||j|j<||j
|j|jf<|j
|_t|j�|S)Nz%s cannot be child of %s)r�r�r/r0r1r2r�r�r�rHr�rrrwr�r�r:)rrArar
r
rr�^s

zNamedNodeMap.setNamedItemcCs
|j|�S)N)r�)rrAr
r
r�setNamedItemNSkszNamedNodeMap.setNamedItemNScCs||}t|j�|j�dS)N)r:r�rH)rr�rAr
r
r�__delitem__ns
zNamedNodeMap.__delitem__cCs|j|j|jfS)N)r�r�r�)rr
r
r�__getstate__sszNamedNodeMap.__getstate__cCs|\|_|_|_dS)N)r�r�r�)r�stater
r
r�__setstate__vszNamedNodeMap.__setstate__)r�r�r�)N)!rorprq�__doc__r�r�r�r�rfr�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@s0eZdZdZdd�Zdd�Zdd�Zd	d
�ZdS)
�TypeInfo�	namespacer�cCs||_||_dS)N)r�r�)rr�r�r
r
rr��szTypeInfo.__init__cCs2|jrd|jj|j|jfSd|jj|jfSdS)Nz<%s %r (from %r)>z<%s %r>)r��	__class__ror�)rr
r
r�__repr__�s
zTypeInfo.__repr__cCs|jS)N)r�)rr
r
rr��szTypeInfo._get_namecCs|jS)N)r�)rr
r
r�_get_namespace�szTypeInfo._get_namespaceN)r�r�)rorprqr�r�r�r�r�r
r
r
rr�s
r�c@s eZdZdDZejZd
ZeZ	dZ
ejejejej
ejejfZed
d
fdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�ZeZd'd(�Zd)d*�Z d+d,�Z!e!Z"d-d.�Z#d/d0�Z$d1d2�Z%d3d4�Z&d5d6�Z'dEd8d9�Z(d:d;�Z)d<d=�Z*d>d?�Z+d@dA�Z,dBdC�Z-d
S)F�ElementrOr3r�r�rsrrr�r$r�r�r<r=NrcCsBd|_||_|_||_||_t�|_d|_|_d|_	d|_
dS)N)r3r�r�rsrrrkr$r<r=r�r�)rr�rrrsrwr
r
rr��s
zElement.__init__cCs|jdkri|_i|_dS)N)r�r�)rr
r
r�_ensure_attributes�s
zElement._ensure_attributescCs.y|jStk
r(|jjdd�dSXdS)Nr�r(r))r�r\r�r�)rr
r
rrW�szElement._get_localNamecCs|jS)N)r�)rr
r
r�_get_tagName�szElement._get_tagNamecCsD|jdk	r*xt|jj��D]}|j�qWd|_d|_tj|�dS)N)r�rer�rHr�r	)r�attrr
r
rrH�s
zElement.unlinkcCs4|jdkrdSy|j|jStk
r.dSXdS)Nr)r�r�r])rr�r
r
r�getAttribute�s
zElement.getAttributecCs8|jdkrdSy|j||fjStk
r2dSXdS)Nr)r�r�r])rrrrwr
r
r�getAttributeNS�s
zElement.getAttributeNScCsV|j|�}|dkr4t|�}||_|j|_|j|�n||jkrR||_|jrRt|�dS)N)�getAttributeNoder�r�rO�setAttributeNoder�r:)rr�r�r�r
r
r�setAttribute�s

zElement.setAttributecCs�t|�\}}|j||�}|dkrHt||||�}||_|j|_|j|�n4||jkrf||_|jrft|�|j|kr|||_||_	dS)N)
�_nssplit�getAttributeNodeNSr�r�rOr�r�r:rsr�)rrr�
qualifiedNamer�rs�	localnamer�r
r
r�setAttributeNS�s

zElement.setAttributeNScCs|jdkrdS|jj|�S)N)r�r�)rZattrnamer
r
rr��s
zElement.getAttributeNodecCs|jdkrdS|jj||f�S)N)r�r�)rrrrwr
r
rr�s
zElement.getAttributeNodeNScCs�|jd|fkrtjjd��|j�|jj|jd�}|dk	rD|j|�|j	j|j
|jfd�}|dk	rt||k	rt|j|�t||�||k	r�|S||k	r�|SdS)Nzattribute node already owned)
r�r/r0ZInuseAttributeErrr�r�r�r��removeAttributeNoder�rrrw�_set_attribute_node)rr�Zold1Zold2r
r
rr�s


zElement.setAttributeNodecCsP|jdkrtjj��y|j|}Wntk
r@tjj��YnX|j|�dS)N)r�r/r0r8r�r]r�)rr�r�r
r
r�removeAttributes

zElement.removeAttributecCsT|jdkrtjj��y|j||f}Wntk
rDtjj��YnX|j|�dS)N)r�r/r0r8r]r�)rrrrwr�r
r
r�removeAttributeNS%s

zElement.removeAttributeNScCs^|dkrtjj��y|j|jWntk
r@tjj��YnXt|�|j�|j|_dS)N)	r/r0r8r�r�r]r:rHrO)rrAr
r
rr�.s
zElement.removeAttributeNodecCs|jdkrdS||jkS)NF)r�)rr�r
r
r�hasAttribute=s
zElement.hasAttributecCs|jdkrdS||f|jkS)NF)r�)rrrrwr
r
r�hasAttributeNSBs
zElement.hasAttributeNScCst||t��S)N)r�rk)rr�r
r
r�getElementsByTagNameGszElement.getElementsByTagNamecCst|||t��S)N)r�rk)rrrrwr
r
r�getElementsByTagNameNSJszElement.getElementsByTagNameNScCsd|jt|�fS)Nz<DOM Element: %s at %#x>)r�r�)rr
r
rr�NszElement.__repr__rc	Cs|j|d|j�|j�}t|j��}x4|D],}|jd|�t|||j�|jd�q.W|jr�|jd�t|j�dkr�|jdj	t
jkr�|jdj|ddd�n8|j|�x"|jD]}|j|||||�q�W|j|�|jd|j|f�n|jd	|�dS)
Nrzz %s="r{r|r(rrz</%s>%sz/>%s)
r~r��_get_attributes�sortedr�rr�r$r�rr	rFr)	rr"r �	addindentr!r�Za_namesZa_namerAr
r
rrQs$



zElement.writexmlcCs|j�t|j|j|�S)N)r�r�r�r�)rr
r
rr�lszElement._get_attributescCs|jr
dSdSdS)NTF)r�)rr
r
r�
hasAttributespszElement.hasAttributescCs|j|�}|j|�dS)N)r��setIdAttributeNode)rr��idAttrr
r
r�setIdAttributexs
zElement.setIdAttributecCs|j||�}|j|�dS)N)r�r)rrrrwrr
r
r�setIdAttributeNS|szElement.setIdAttributeNScCsl|dks|j|j�r tjj��t|�dk	r6tjj��|jshd|_|jd7_|j	j
d7_
t|�dS)NTr()rYr�r/r0r8�_get_containing_entref�NoModificationAllowedErrr�r�rOr�r:)rrr
r
rr�s

zElement.setIdAttributeNode)rOr3r�r�rsrrr�r$r�r�r<r=)rrr).rorprqr�r	rJrr�r�r�r�r�r�rFr�r�r.rr�r�rWr�rHr�r�r�r�r�r�r�ZsetAttributeNodeNSr�r�r�ZremoveAttributeNodeNSr�r�r�r�r�rr�r�rrrr
r
r
rr��sT		

r�r�z*NamedNodeMap of attributes on the element.z%Namespace-local name of this element.cCs8t|�|j�||j|j<||j|j|jf<||_dS)N)r:r�r�r�r�rrrwr�)�elementr�r
r
rr��s
r�c@sfeZdZdZfZdZe�ZdZdZ	dd�Z
dd�Zdd�Zd	d
�Z
dd�Zd
d�Zdd�Zdd�ZdS)�	Childlessz�Mixin that makes childless-ness easy to implement and avoids
    the complexity of the Node methods that deal with children.
    NcCsdS)Nr
)rr
r
rr'�szChildless._get_firstChildcCsdS)Nr
)rr
r
rr*�szChildless._get_lastChildcCstjj|jd��dS)Nz nodes cannot have children)r/r0r1r�)rrAr
r
rr5�szChildless.appendChildcCsdS)NFr
)rr
r
rr%�szChildless.hasChildNodescCstjj|jd��dS)Nz nodes do not have children)r/r0r1r�)rr>r?r
r
rr-�szChildless.insertBeforecCstjj|jd��dS)Nz nodes do not have children)r/r0r8r�)rrCr
r
rr4�szChildless.removeChildcCsdS)Nr
)rr
r
rrK�szChildless.normalizecCstjj|jd��dS)Nz nodes do not have children)r/r0r1r�)rr>rCr
r
rrD�szChildless.replaceChild)rorprqr�r�r�Z
EmptyNodeListr$rtrvr'r*r5r%r-r4rKrDr
r
r
rr�src@s\eZdZejZdZdd�Zdd�Zdd�Z	e
ee	�Zd	d
�Zdd�Z
e
ee
�Zddd�ZdS)�ProcessingInstruction�targetrGcCs||_||_dS)N)r	rG)rr	rGr
r
rr��szProcessingInstruction.__init__cCs|jS)N)rG)rr
r
r�_get_nodeValue�sz$ProcessingInstruction._get_nodeValuecCs
||_dS)N)rG)rr�r
r
r�_set_nodeValue�sz$ProcessingInstruction._set_nodeValuecCs|jS)N)r	)rr
r
r�
_get_nodeName�sz#ProcessingInstruction._get_nodeNamecCs
||_dS)N)r	)rr�r
r
r�
_set_nodeName�sz#ProcessingInstruction._set_nodeNamercCs|jd||j|j|f�dS)Nz
%s<?%s %s?>%s)r~r	rG)rr"r r�r!r
r
rr�szProcessingInstruction.writexmlN)r	rG)rrr)rorprqr	r�rr�r�r
rr�r�rr
r�rr
r
r
rr�s

rc@sreZdZdZdd�Zdd	�ZeZd
d�Zdd
�Ze	ee�Z
Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�
CharacterData�_datarOr3r=r<cCs,d|_|_d|_|_d|_tj|�dS)Nr)rOr3r=r<rr	r�)rr
r
rr��szCharacterData.__init__cCs
t|j�S)N)r�rG)rr
r
rr��szCharacterData._get_lengthcCs|jS)N)r)rr
r
r�	_get_data�szCharacterData._get_datacCs
||_dS)N)r)rrGr
r
r�	_set_data�szCharacterData._set_datacCs6|j}t|�dkrd}nd}d|jj|dd�|fS)N�
z...rz<DOM %s node "%r%s">r)rGr�r�ro)rrGZ	dotdotdotr
r
rr��szCharacterData.__repr__cCsT|dkrtjjd��|t|j�kr.tjjd��|dkrBtjjd��|j|||�S)Nrzoffset cannot be negativez#offset cannot be beyond end of datazcount cannot be negative)r/r0�IndexSizeErrr�rG)r�offset�countr
r
r�
substringData�szCharacterData.substringDatacCs|j||_dS)N)rG)r�argr
r
r�
appendDataszCharacterData.appendDatacCsZ|dkrtjjd��|t|j�kr.tjjd��|rVd|jd|�||j|d�f|_dS)Nrzoffset cannot be negativez#offset cannot be beyond end of dataz%s%s%s)r/r0rr�rG)rrrr
r
r�
insertDataszCharacterData.insertDatacCsl|dkrtjjd��|t|j�kr.tjjd��|dkrBtjjd��|rh|jd|�|j||d�|_dS)Nrzoffset cannot be negativez#offset cannot be beyond end of datazcount cannot be negative)r/r0rr�rG)rrrr
r
r�
deleteDataszCharacterData.deleteDatacCsr|dkrtjjd��|t|j�kr.tjjd��|dkrBtjjd��|rnd|jd|�||j||d�f|_dS)Nrzoffset cannot be negativez#offset cannot be beyond end of datazcount cannot be negativez%s%s%s)r/r0rr�rG)rrrrr
r
r�replaceDataszCharacterData.replaceDataN)rrOr3r=r<)rorprqr�r�r�r�rrr�rGr�r�rrrrrr
r
r
rr�s			
rzLength of the string data.c@sHeZdZfZejZdZdZdd�Z	ddd�Z
dd	�Zd
d�Zdd
�Z
dS)r�z#textNcCs�|dks|t|j�kr"tjjd��|j�}|j|d�|_|j|_|j}|jr~||jj	kr~|dkrp|jj
|�n|jj||�|jd|�|_|S)Nrzillegal offset value)r�rGr/r0rr�rOr<r3r$r5r-)rrZnewText�nextr
r
r�	splitText0szText.splitTextrcCst|d||j|f�dS)Nz%s%s%s)rrG)rr"r r�r!r
r
rr?sz
Text.writexmlcCs�|jg}|j}x6|dk	rD|jtjtjfkr@|jd|j�|j}qPqW|j}x4|dk	r�|jtjtjfkr||j|j�|j}qNPqNWdj	|�S)Nrr)
rGr=rr	rFr�r;r<rI�join)rrLr�r
r
r�_get_wholeTextDs

zText._get_wholeTextcCs�|j}|j}x6|dk	rB|jtjtjfkr>|j}|j|�|}qPqW|j}|sX|j|�x6|dk	r�|jtjtjfkr�|j}|j|�|}qZPqZW|r�||_|SdSdS)N)	r3r=rr	rFr�r4r<rG)rZcontentr�r�rr
r
r�replaceWholeTextVs*




zText.replaceWholeTextcCsF|jj�rdSt|�}|dkr"dS|jj|�}|dkr:dS|j�SdS)NF)rG�strip�_get_containing_elementrOr��isElementContent)rr�r�r
r
r�!_get_isWhitespaceInElementContentrs
z&Text._get_isWhitespaceInElementContent)rrr)rorprqr�r	rFrr�r�rrrr r$r
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}x"|dk	r(|jtjkr |S|j}qWdS)N)r3rr	rJ)rAr@r
r
rr"�s

r"cCs.|j}x"|dk	r(|jtjkr |S|j}qWdS)N)r3rr	r�)rAr@r
r
rr�s

rc@s(eZdZejZdZdd�Zddd�ZdS)	�Commentz#commentcCstj|�||_dS)N)rr�r)rrGr
r
rr��s
zComment.__init__rcCs,d|jkrtd��|jd||j|f�dS)Nz--z%'--' is not allowed in a comment nodez
%s<!--%s-->%s)rGr7r~)rr"r r�r!r
r
rr�s
zComment.writexmlN)rrr)	rorprqr	r�rr�r�rr
r
r
rr%�sr%c@s$eZdZfZejZdZddd�ZdS)�CDATASectionz#cdata-sectionrcCs,|jjd�dkrtd��|jd|j�dS)Nz]]>rz$']]>' not allowed in a CDATA sectionz<![CDATA[%s]]>)rG�findr7r~)rr"r r�r!r
r
rr�szCDATASection.writexmlN)rrr)	rorprqr�r	r�rr�rr
r
r
rr&�sr&c@s|eZdZdZffdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�ZdS)�ReadOnlySequentialNamedNodeMap�_seqcCs
||_dS)N)r))r�seqr
r
rr��sz'ReadOnlySequentialNamedNodeMap.__init__cCs
t|j�S)N)r�r))rr
r
rr��sz&ReadOnlySequentialNamedNodeMap.__len__cCs
t|j�S)N)r�r))rr
r
rr��sz*ReadOnlySequentialNamedNodeMap._get_lengthcCs"x|jD]}|j|kr|SqWdS)N)r)r�)rr�r�r
r
rr��s
z+ReadOnlySequentialNamedNodeMap.getNamedItemcCs,x&|jD]}|j|kr|j|kr|SqWdS)N)r)rrrw)rrrrwr�r
r
rr��sz-ReadOnlySequentialNamedNodeMap.getNamedItemNScCs4t|t�r|j|�}n
|j|�}|dkr0t|��|S)N)r�r,r�r�r])rZ
name_or_tuplerAr
r
rr��s

z*ReadOnlySequentialNamedNodeMap.__getitem__cCs0|dkrdSy
|j|Stk
r*dSXdS)Nr)r)r�)rr6r
r
rr��s
z#ReadOnlySequentialNamedNodeMap.itemcCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rr�r
r
rr��sz.ReadOnlySequentialNamedNodeMap.removeNamedItemcCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rrrrwr
r
rr��sz0ReadOnlySequentialNamedNodeMap.removeNamedItemNScCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rrAr
r
rr��sz+ReadOnlySequentialNamedNodeMap.setNamedItemcCstjjd��dS)Nz"NamedNodeMap instance is read-only)r/r0r)rrAr
r
rr��sz-ReadOnlySequentialNamedNodeMap.setNamedItemNScCs|jgS)N)r))rr
r
rr��sz+ReadOnlySequentialNamedNodeMap.__getstate__cCs|d|_dS)Nr)r))rr�r
r
rr��sz+ReadOnlySequentialNamedNodeMap.__setstate__N)r))rorprqr�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||_||_dS)N)r,r-)rr,r-r
r
r�_identified_mixin_init�sz!Identified._identified_mixin_initcCs|jS)N)r,)rr
r
r�
_get_publicId�szIdentified._get_publicIdcCs|jS)N)r-)rr
r
r�
_get_systemId�szIdentified._get_systemIdN)r,r-)rorprqr�r�r.r/r0r
r
r
rr+�s
r+c@sHeZdZejZdZdZdZdZ	dZ
dd�Zdd�Zdd�Z
dd	d
�ZdS)�DocumentTypeNcCs2t�|_t�|_|r&t|�\}}||_|j|_dS)N)r(�entities�	notationsr�r�r�)rr�rsr�r
r
rr�	szDocumentType.__init__cCs|jS)N)�internalSubset)rr
r
r�_get_internalSubsetsz DocumentType._get_internalSubsetcCs�|jdkr�td�}|j|_|j|_tjjj}|r�g|j_	g|j
_	x>|j
j	D]2}t|j|j|j
�}|j
j	j|�|j|||�qJWxZ|jj	D]N}t|j|j|j
|j�}|j|_|j|_|j|_|jj	j|�|j|||�q�W|j|||�|SdSdS)N)rOr1r�r�r/r0�UserDataHandler�NODE_CLONEDr2r)r3�Notationr,r-rIrj�Entity�notationName�actualEncodingrrU)rrP�clonergr��notation�e�entityr
r
rrQs.

zDocumentType.cloneNodercCs�|jd�|j|j�|jr8|jd||j||jf�n|jrR|jd||jf�|jdk	r||jd�|j|j�|jd�|jd|�dS)Nz
<!DOCTYPE z%s  PUBLIC '%s'%s  '%s'z%s  SYSTEM '%s'z [�]r|)r~r�r,r-r4)rr"r r�r!r
r
rr/s



zDocumentType.writexml)rrr)rorprqr	�DOCUMENT_TYPE_NODErr�r�r,r-r4r�r5rQrr
r
r
rr1sr1c@sfeZdZdZejZdZdZdZ	dZ
dd�Zdd�Zdd�Z
dd	�Zd
d�Zdd
�Zdd�Zdd�ZdS)r9NcCs$||_||_t�|_|j||�dS)N)r�r:rkr$r.)rr�r,r-r=r
r
rr�FszEntity.__init__cCs|jS)N)r;)rr
r
r�_get_actualEncodingLszEntity._get_actualEncodingcCs|jS)N)r)rr
r
r�
_get_encodingOszEntity._get_encodingcCs|jS)N)rU)rr
r
r�_get_versionRszEntity._get_versioncCstjjd��dS)Nz(cannot append children to an entity node)r/r0r1)rr>r
r
rr5UszEntity.appendChildcCstjjd��dS)Nz+cannot insert children below an entity node)r/r0r1)rr>r?r
r
rr-YszEntity.insertBeforecCstjjd��dS)Nz*cannot remove children from an entity node)r/r0r1)rrCr
r
rr4]szEntity.removeChildcCstjjd��dS)Nz)cannot replace children of an entity node)r/r0r1)rr>rCr
r
rrDaszEntity.replaceChild)rorprqr�r	ZENTITY_NODErr�r;rrUr�rBrCrDr5r-r4rDr
r
r
rr9=sr9c@seZdZejZdZdd�ZdS)r8NcCs||_|j||�dS)N)r�r.)rr�r,r-r
r
rr�iszNotation.__init__)rorprqr	r�rr�r�r
r
r
rr8esr8c	@sHeZdZddddddddgZdd	�Zd
d�Zdd
�Zdd�Zdd�ZdS)�DOMImplementation�core�1.0�2.0Nr/�ls-load�3.0cCs|dkrd}|j�|f|jkS)Nr)�lower�	_features)rrTrUr
r
rrSyszDOMImplementation.hasFeaturec	Cs�|r|jdk	rtjjd��|j�}|dko8|dko8|dk}|rR|rRtjjd��|r�t|�\}}|dkr~|dkr~tjjd��|r�|r�tjjd��|j||�}|r�|j	|�|j	|�|r�||_|_
||_||_|S)Nz(doctype object owned by another DOM treezElement with no namer/z$http://www.w3.org/XML/1998/namespacezillegal use of 'xml' prefixz(illegal use of prefix without namespaces)
r3r/r0�WrongDocumentErr�_create_documentZInvalidCharacterErrr�r��createElementNSr5rO�doctyperR)	rrrr�rPruZadd_root_elementrsr�rr
r
r�createDocument~s4





z DOMImplementation.createDocumentcCst|�}||_||_|S)N)r1r,r-)rr�r,r-rPr
r
r�createDocumentType�sz$DOMImplementation.createDocumentTypecCs|j|d�r|SdSdS)N)rS)rrTr
r
rrZ�szDOMImplementation.getInterfacecCst�S)N)�Document)rr
r
rrN�sz"DOMImplementation._create_document)rFrG)rFrH)rFN)r/rG)r/rH)r/N)rIrJ)rIN)	rorprqrLrSrQrRrZrNr
r
r
rrEns-rEc@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.

    r�cCs
||_dS)N)r�)rr�r
r
rr��szElementInfo.__init__cCstS)N)r�)r�anamer
r
rr��szElementInfo.getAttributeTypecCstS)N)r�)rrrrwr
r
rr��szElementInfo.getAttributeTypeNScCsdS)NFr
)rr
r
rr#�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
)rrUr
r
rr��szElementInfo.isIdcCsdS)z<Returns true iff the identified attribute is a DTD-style ID.Fr
)rrrrwr
r
rr��szElementInfo.isIdNScCs|jS)N)r�)rr
r
rr��szElementInfo.__getstate__cCs
||_dS)N)r�)rr�r
r
rr��szElementInfo.__setstate__N)r�)rorprqr�r�r�r�r�r#rVr�r�r�r�r
r
r
rrT�srTcCs>|jtjkr|jj�d|_nt|�r:|jjj�d|j_dS)N)rr	r�	_id_cache�clear�_id_search_stackrxrO)rAr
r
rr:�s
r:c@sreZdZdMZejejejejfZ	e
�ZejZ
dZdZdZdZdZZdZdZdZdZdZdZdZd	Zd
d�Zdd
�Zdd�Zdd�Zdd�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/�Z.d0d1�Z/d2d3�Z0d4d5�Z1d6d7�Z2d8d9�Z3d:d;�Z4d<d=�Z5d>d?�Z6d@dA�Z7dBdC�Z8dDdE�Z9dFdG�Z:dNdIdJ�Z;dKdL�Z<dS)OrS�
_elem_inforPrYr$rWz	#documentNFrcCs$d|_t�|_i|_i|_d|_dS)N)rPrkr$rZrWrY)rr
r
rr�
s
zDocument.__init__cCs&|jr|j|jf}n|j}|jj|�S)N)rrrwr�rZr�)rrr^r
r
rr�szDocument._get_elem_infocCs|jS)N)r;)rr
r
rrBszDocument._get_actualEncodingcCs|jS)N)rP)rr
r
r�_get_doctypeszDocument._get_doctypecCs|jS)N)�documentURI)rr
r
r�_get_documentURI szDocument._get_documentURIcCs|jS)N)r)rr
r
rrC#szDocument._get_encodingcCs|jS)N)�errorHandler)rr
r
r�_get_errorHandler&szDocument._get_errorHandlercCs|jS)N)�
standalone)rr
r
r�_get_standalone)szDocument._get_standalonecCs|jS)N)�strictErrorChecking)rr
r
r�_get_strictErrorChecking,sz!Document._get_strictErrorCheckingcCs|jS)N)rU)rr
r
rrD/szDocument._get_versioncCsj|j|jkr(tjjdt|�t|�f��|jdk	r>|jj|�|jtj	kr^|j
�r^tjjd��tj||�S)Nz%s cannot be child of %sz two document elements disallowed)rr.r/r0r1r2r3r4r	rJ�_get_documentElementr5)rrAr
r
rr52s
zDocument.appendChildcCsVy|jj|�Wntk
r.tjj��YnXd|_|_d|_|j	|krRd|_	|S)N)
r$rEr7r/r0r8r<r=r3�documentElement)rrCr
r
rr4Bs
zDocument.removeChildcCs$x|jD]}|jtjkr|SqWdS)N)r$rr	rJ)rrAr
r
rrdNszDocument._get_documentElementcCs(|jdk	r|jj�d|_tj|�dS)N)rPrHr	)rr
r
rrHSs

zDocument.unlinkcCs�|sdS|jjddd�}|j|_|j|_|j|_xL|jD]B}t|||�}|jj|�|jt	j
krbn|jt	jkrt||_||_
q8W|jtjjj||�|S)N)rRrQrr`rUr$rNrIrr	rrArPr3rjr/r0r6r7)rrPr<r�Z
childcloner
r
rrQYs"
zDocument.cloneNodecCst�}||_|S)N)r�rO)rrbr
r
r�createDocumentFragmentnszDocument.createDocumentFragmentcCst|�}||_|S)N)r�rO)rr�r>r
r
r�
createElementsszDocument.createElementcCs(t|t�std��t�}||_||_|S)Nznode contents must be a string)r�r�r�r�rGrO)rrG�tr
r
r�createTextNodexs
zDocument.createTextNodecCs(t|t�std��t�}||_||_|S)Nznode contents must be a string)r�r�r�r&rGrO)rrGr@r
r
r�createCDATASection�s
zDocument.createCDATASectioncCst|�}||_|S)N)r%rO)rrGr@r
r
r�
createComment�szDocument.createCommentcCst||�}||_|S)N)rrO)rr	rG�pr
r
r�createProcessingInstruction�s
z$Document.createProcessingInstructioncCst|�}||_d|_|S)Nr)r�rOr�)rr��ar
r
r�createAttribute�szDocument.createAttributecCs"t|�\}}t|||�}||_|S)N)r�r�rO)rrrr�rsrwr>r
r
rrO�szDocument.createElementNScCs*t|�\}}t||||�}||_d|_|S)Nr)r�r�rOr�)rrrr�rsrwrnr
r
r�createAttributeNS�s
zDocument.createAttributeNScCst||||�}||_|S)N)r9rO)rr�r,r-r:r>r
r
r�_create_entity�szDocument._create_entitycCst|||�}||_|S)N)r8rO)rr�r,r-r�r
r
r�_create_notation�szDocument._create_notationcCs�||jkr|j|S|jp|js$dS|j}|dkrB|jg}||_n|sJdSd}�x>|�r�|j�}|jdd�|jD��|j|�}|�r@x�|j	j
�D]�}|jr�|j|j|j
�r�||j|j<|j|kr�|}n|js�Pq�|j|j��r
||j|j<|j|k�r�|}n
|j�s:Pq�|jr�||j|j<|j|k�r.|}q�|jdkr�Pq�WnB|j�r�x8|j	j
�D]*}|j�rT||j|j<|j|k�rT|}�qTW|dk	rRPqRW|S)NcSsg|]}|jtkr|�qSr
)rr9)�.0rMr
r
r�
<listcomp>�sz+Document.getElementById.<locals>.<listcomp>r()rWrZr�rYre�pop�extendr$r�r�r�rrr�rwr�r�r�r�r�)rr��stack�resultrAr�r�r
r
r�getElementById�sZ






zDocument.getElementByIdcCst||t��S)N)r�rk)rr�r
r
rr��szDocument.getElementsByTagNamecCst|||t��S)N)r�rk)rrrrwr
r
rr��szDocument.getElementsByTagNameNScCs|jj||�S)N)rRrS)rrTrUr
r
rrV�szDocument.isSupportedcCs>|jtjkrtjjd��n|jtjkr2tjjd��t|||�S)Nzcannot import document nodesz!cannot import document type nodes)rr	rr/r0�NotSupportedErrrArN)rrArPr
r
r�
importNode�s
zDocument.importNodercCsN|dkr|jd|�n|jd||f�x|jD]}|j||||�q2WdS)Nz<?xml version="1.0" ?>z%<?xml version="1.0" encoding="%s"?>%s)r~r$r)rr"r r�r!rrAr
r
rr�szDocument.writexmlcCsJ|j|k	r tjjd||jf��|jtjtjfkr>tjjd��|t	kr�d|kr�|j
dd�\}}|dkr�|tjjkr�tjjd��q�|dkr�|tjjkr�|jtjkr�tjjd��d}|}nd}d}|jtjkr�|j
}|dk	r�|j}|j|�nd}||_||_||_||_|jtjk�r||_n*||_|dk	�rF|j|�|�rF|j|�|S)Nz?cannot rename nodes from other documents;
expected %s,
found %sz8renameNode() only applies to element and attribute nodesr�r(r�zillegal use of 'xmlns' prefixz$illegal use of the 'xmlns' attribute)rOr/r0rMrr	rJr�rzrr�rr�r�r�r�rsr�rrr�r�r�r�r)rr�rrr�rsrwrZis_idr
r
r�
renameNodesR



zDocument.renameNode)rZrPrYr$rW)rrrN)=rorprqr�r	rJr�r�rAr.rErRrrr�r�r�r3r=r<r;rr`rUrbr^r\r�r�r�rBr[r]rCr_rarcrDr5r4rdrHrQrfrgrirjrkrmrorOrprqrrryr�r�rVr{rr|r
r
r
rrS�sh	
:
rSrez#Top-level element of this document.c
Cs�|jj|�rtjjj}n
tjjj}|jtj	kr�|j
|j|j�}x>|j
j�D]0}|j|j|j|j�|j|j|j�}|j|_qJW|r�x$|jD]}t|||�}|j|�q�W�n|jtjkr�|j�}|r�x$|jD]}t|||�}|j|�q�W�n�|jtjk�r|j|j�}�n�|jtjk�r*|j|j�}�n�|jtjk�rL|j|j |j�}�nr|jtj!k�rj|j"|j�}�nT|jtj#k�r�|j$|j|j�}d|_|j|_�n$|jtj%k�r�tjjj}|j&j'|j(|j)|j*�}||_|�r�g|j+_,g|j-_,xR|j-j,D]F}	t.|	j|	j)|	j*�}
||
_|j-j,j/|
�t0|	d��r�|	j1||	|
��q�Wx�|j+j,D]b}t2|j|j)|j*|j3�}|j4|_4|j5|_5|j6|_6||_|j+j,j/|�t0|d��rB|j1|||��qBWntjj7dt8|���t0|d��r�|j1|||�|S)zo
    Clone a node and give it the new owner document.
    Called by Node.cloneNode and Document.importNode
    TrjzCannot clone node %s)9rOrYr/r0r6r7Z
NODE_IMPORTEDrr	rJrOrrr�r�r�r�r�r�rwr�r$rNr5r+rfrFrirGr�rjr�rmr	r�rkr�rprArRrRr�r,r-r2r)r3r8rIrdrjr9r:r;rrUrzr2)
rArPZnewOwnerDocumentrgr<r�rnrMr@r�r=r>r?r
r
rrNAs|

rNcCs,|jdd�}t|�dkr|Sd|dfSdS)Nr�r(�r)r�r�)r�Zfieldsr
r
rr��sr�cCs,|||�}|j�\}}|j|�|j�|S)N)ZgetEventZ
expandNoderX)�func�args�kwargsZeventsZtoktypeZrootNoder
r
r�_do_pulldom_parse�s


r�cCsJ|dkr$|r$ddlm}|j|�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}|j|�Sddlm}t|j|fd|i�SdS)z&Parse a file into a DOM from a string.Nr)r�)r�r�)r�r��parseStringr�r�)�stringr�r�r�r
r
rr��s

r�cCsB|r<t|t�rtj|�}x"|D]\}}tjj||�sdSqWtjS)N)r�r�rZ_parse_feature_stringrSrRrS)Zfeatures�f�vr
r
r�getDOMImplementation�s

r�)NN)N)N)7r�rr�r/rrrrZxml.dom.minicompatZxml.dom.xmlbuilderrrr0r	rJr�r9ZdefpropertyrBrxrr�r�r�r��objectr�Z
AttributeListr�r�r�r�rrrr�r"rr%r&r(r+r1r9r8rErTr:rSrNr�r�r�r�r�r
r
r
r�<module>s�v
	y$
w)GU	><(	O*PR



PK�"[�a��4�4/dom/__pycache__/xmlbuilder.cpython-36.opt-1.pycnu�[���3


 \�2�@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�Z[Gdd�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.6/xml/dom/xmlbuilder.pyr
s(rc5@sVeZdZdZdZdZdZdZdZdZ	eeee	fZ
dd�Zdd	�Zd
d�Z
dd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd4d5gd6d7gd8d9gd:d;gd<d=gd>d?gd@dAgdBdCgdDdEgdFdGgdHdIdJgdKdLgdMdNgdOdPgdQdRgdSdTgdUdVgdWdXgdYdZgd[d\gd]gd^d_d`dadbdcdddedfdgg	dhdigdjdkgdldmgiZd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�ZdS)nrNr���cCst�|_dS)N)r�_options)�selfrrr�__init__:szDOMBuilder.__init__cCs|jS)N)�entityResolver)r#rrr�_get_entityResolver=szDOMBuilder._get_entityResolvercCs
||_dS)N)r%)r#r%rrr�_set_entityResolver?szDOMBuilder._set_entityResolvercCs|jS)N)r)r#rrr�_get_errorHandlerBszDOMBuilder._get_errorHandlercCs
||_dS)N)r)r#rrrr�_set_errorHandlerDszDOMBuilder._set_errorHandlercCs|jS)N)r)r#rrr�_get_filterGszDOMBuilder._get_filtercCs
||_dS)N)r)r#rrrr�_set_filterIszDOMBuilder._set_filterc
Cs�|j|�rv|rdpd}y|jt|�|f}Wn&tk
rRtjjd|f��Yq�Xx4|D]\}}t|j||�qZWntjj	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|��S)N)�hasattrr"r.)r#r6rrrr,ZszDOMBuilder.supportsFeaturecCst|�|rdpdf}||jkS)Nrr)r.r-)r#r6r7�keyrrr�
canSetFeature]szDOMBuilder.canSetFeaturer
rrrrrrrrrrrrrrrcCs�t|�}yt|j|�Stk
r�|dkrj|j}|joh|joh|joh|joh|jpf|j	pf|j
pf|jpf|jSt
jjdt|���YnXdS)Nrzfeature %s not known)r.�getattrr"�AttributeErrorrrrrr
rrrrr0r1r4r5)r#r6Zxname�optionsrrr�
getFeature�s zDOMBuilder.getFeaturecCs.|jr|jjd|�}nt�jd|�}|j|�S)N)r%�
resolveEntityr�parse)r#�uri�inputrrr�parseURI�szDOMBuilder.parseURIcCsRtj|j�}|j|_|j|_|j}|dkrF|jrFddl}|jj|j�}|j	||�S)Nr)
�copyr"rr�
byteStream�systemId�urllib.request�requestZurlopen�_parse_bytestream)r#rDr?�fp�urllibrrrrB�szDOMBuilder.parsecCs||jkrtd��td��dS)Nznot a legal actionzHaven't written this yet...)�_legal_actions�
ValueError�NotImplementedError)r#rDZcnode�actionrrr�parseWithContext�s
zDOMBuilder.parseWithContextcCs ddl}|jjj|�}|j|�S)Nr)Zxml.dom.expatbuilderr1ZexpatbuilderZmakeBuilderZ	parseFile)r#�streamr?r0ZbuilderrrrrK�szDOMBuilder._parse_bytestream)r
r)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)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)r
r)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr	r
r%rrZACTION_REPLACEZACTION_APPEND_AS_CHILDRENZACTION_INSERT_AFTERZACTION_INSERT_BEFORErNr$r&r'r(r)r*r+r9r,r<r-r@rErBrRrKrrrrr-s�

cCs|j�jdd�S)N�-�_)�lower�replace)r6rrrr.�sr.c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)r�_openerc
Cs�t�}||_||_|j�j|�|_|j|�|_ddl}ddl	}|j
j|�}|\}}}	}
}}|	r�|	jd�r�|j
|	�d}	|||	|
||f}|j
j|�|_|S)Nr�/)r�publicIdrH�_get_opener�openrG�_guess_media_encoding�encoding�	posixpathZurllib.parserBZurlparse�endswith�dirnameZ
urlunparse�baseURI)
r#rZrH�sourcer_rM�parts�schemeZnetloc�pathZparamsZqueryZfragmentrrrrA�szDOMEntityResolver.resolveEntitycCs,y|jStk
r&|j�|_|jSXdS)N)rXr>�_create_opener)r#rrrr[�s

zDOMEntityResolver._get_openercCsddl}|jj�S)Nr)rIrJZbuild_opener)r#rMrrrrg�sz DOMEntityResolver._create_openercCsF|jj�}d|krBx.|j�D]"}|jd�r|jdd�dj�SqWdS)NzContent-Typezcharset=�=r)rG�infoZgetplist�
startswith�splitrV)r#rcriZparamrrrr]�s


z'DOMEntityResolver._guess_media_encodingN)rX)rr	r
�	__slots__rAr[rgr]rrrrr�s
c@s�eZdZd'Zdd	�Zd
d�Zdd
�Zdd�Zdd�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&S)(rrG�characterStream�
stringDatar^rZrHrbcCs.d|_d|_d|_d|_d|_d|_d|_dS)N)rGrmrnr^rZrHrb)r#rrrr$szDOMInputSource.__init__cCs|jS)N)rG)r#rrr�_get_byteStreamszDOMInputSource._get_byteStreamcCs
||_dS)N)rG)r#rGrrr�_set_byteStreamszDOMInputSource._set_byteStreamcCs|jS)N)rm)r#rrr�_get_characterStreamsz#DOMInputSource._get_characterStreamcCs
||_dS)N)rm)r#rmrrr�_set_characterStreamsz#DOMInputSource._set_characterStreamcCs|jS)N)rn)r#rrr�_get_stringDataszDOMInputSource._get_stringDatacCs
||_dS)N)rn)r#�datarrr�_set_stringDataszDOMInputSource._set_stringDatacCs|jS)N)r^)r#rrr�
_get_encodingszDOMInputSource._get_encodingcCs
||_dS)N)r^)r#r^rrr�
_set_encodingszDOMInputSource._set_encodingcCs|jS)N)rZ)r#rrr�
_get_publicId"szDOMInputSource._get_publicIdcCs
||_dS)N)rZ)r#rZrrr�
_set_publicId$szDOMInputSource._set_publicIdcCs|jS)N)rH)r#rrr�
_get_systemId'szDOMInputSource._get_systemIdcCs
||_dS)N)rH)r#rHrrr�
_set_systemId)szDOMInputSource._set_systemIdcCs|jS)N)rb)r#rrr�_get_baseURI,szDOMInputSource._get_baseURIcCs
||_dS)N)rb)r#rCrrr�_set_baseURI.szDOMInputSource._set_baseURIN)rGrmrnr^rZrHrb)rr	r
rlr$rorprqrrrsrurvrwrxryrzr{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|jS)N)�
whatToShow)r#rrr�_get_whatToShowCsz DOMBuilderFilter._get_whatToShowcCs|jS)N)�
FILTER_ACCEPT)r#�elementrrr�
acceptNodeFszDOMBuilderFilter.acceptNodecCs|jS)N)r�)r#r�rrr�startContainerIszDOMBuilderFilter.startContainerN)rr	r
rr�Z
FILTER_REJECTZFILTER_SKIPZFILTER_INTERRUPTrZSHOW_ALLrr�r�r�rrrrr~2sr~c@s$eZdZdd�Zdd�Zdd�ZdS)�_AsyncDeprecatedPropertycCs|j}tjdj|d�t�dS)Nz+{cls}.async is deprecated; use {cls}.async_)�cls)r�warnings�warn�format�DeprecationWarning)r#r�Zclsnamerrrr�Ps
z_AsyncDeprecatedProperty.warncCs|j|�|dk	r|jSdS)NF)r��async_)r#�instancer�rrr�__get__Vs
z _AsyncDeprecatedProperty.__get__cCs|jt|��t|d|�dS)Nr�)r��typer3)r#r�r8rrr�__set__\sz _AsyncDeprecatedProperty.__set__N)rr	r
r�r�r�rrrrr�Osr�c@sPeZdZdZdZe�e�d<dd�Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�ZdS)�
DocumentLSz=Mixin to create documents that conform to the load/save spec.F�asynccCsdS)NFr)r#rrr�
_get_asyncgszDocumentLS._get_asynccCs|rtjjd��dS)Nz.asynchronous document loading is not supported)r0r1r2)r#�flagrrr�
_set_asyncjszDocumentLS._set_asynccCstd��dS)Nz'haven't figured out what this means yet)rP)r#rrr�abortoszDocumentLS.abortcCstd��dS)Nzhaven't written this yet)rP)r#rCrrr�loaduszDocumentLS.loadcCstd��dS)Nzhaven't written this yet)rP)r#rcrrr�loadXMLxszDocumentLS.loadXMLcCs*|dkr|}n|j|k	r"tjj��|j�S)N)Z
ownerDocumentr0r1ZWrongDocumentErrZtoxml)r#Zsnoderrr�saveXML{s


zDocumentLS.saveXMLN)
rr	r
rr�r��localsr�r�r�r�r�r�rrrrr�asr�c@s,eZdZdZdZdd�Zdd�Zdd�Zd	S)
�DOMImplementationLSrrcCsF|dk	rtjjd��||jkr$t�S||jkr:tjjd��td��dS)NzschemaType not yet supportedz'asynchronous builders are not supportedzunknown value for mode)r0r1r2�MODE_SYNCHRONOUSr�MODE_ASYNCHRONOUSrO)r#�modeZ
schemaTyperrr�createDOMBuilder�s

z$DOMImplementationLS.createDOMBuildercCstd��dS)Nz-the writer interface hasn't been written yet!)rP)r#rrr�createDOMWriter�sz#DOMImplementationLS.createDOMWritercCst�S)N)r)r#rrr�createDOMInputSource�sz(DOMImplementationLS.createDOMInputSourceN)rr	r
r�r�r�r�r�rrrrr��s
r�)rrFr�Zxml.domr0Zxml.dom.NodeFilterr�__all__rrr.�objectrrr~r�r�r�rrrr�<module>s"
 %,1"PK�"[�)<*-dom/__pycache__/__init__.cpython-36.opt-2.pycnu�[���3


 \��@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@eZdZfZdZdZdZdZdZdZ	dZ
dZd	Zd
Z
dZdZd
S)�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_NODE�rr�(/usr/lib64/python3.6/xml/dom/__init__.pyrs	rrrrrrrrr	r
rr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
PK�"[����99'dom/__pycache__/__init__.cpython-36.pycnu�[���3


 \��@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@sDeZdZdZfZdZdZdZdZdZ	dZ
dZd	Zd
Z
dZdZd
ZdS)�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_NODE�rr�(/usr/lib64/python3.6/xml/dom/__init__.pyrs	rrrrrrrrr	r
rr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
PK�"[Wd!))))&dom/__pycache__/pulldom.cpython-36.pycnu�[���3


 \�-�@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|_y|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.6/xml/dom/pulldom.py�__init__s

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

zPullDOM.startPrefixMappingcCs|jj�|_dS)N)rrr)rr%rrr�endPrefixMapping0szPullDOM.endPrefixMappingcCs�d}t|dd�}|dk	r>x|D]\}}||j||f<qWg|_|\}}	|r�|dkrr|j|}
|
rn|
d|	}n|	}|jr�|jj||�}q�|j||�}n |jr�|jj|	�}n|jd|	�}x�|j�D]�\}}|\}}
||k�r
|
dkr�|
}nd|
}|jj	||�}|j
|�nX|�rL|j|}
|
�r.|
d|
}n|
}|jj	||�}|j
|�n|jj|
�}|j|�||_
q�Wt|fdg|jd<|jd|_|j|�dS)Nzhttp://www.w3.org/2000/xmlns/r!�:r"zxmlns:r
)�getattrZ_attrsr!r�documentZcreateElementNS�
buildDocument�
createElement�itemsZcreateAttributeNSZsetAttributeNodeNS�createAttribute�setAttributeNode�valuerrr)r�name�tagName�attrsZ	xmlns_uriZxmlns_attrs�anamer1r&Z	localnamer%�nodeZa_uriZa_localnameZqname�attrrrr�startElementNS3sP




zPullDOM.startElementNScCs&t|j�fdg|jd<|jd|_dS)Nr
)rrr)rr2r3rrr�endElementNSlszPullDOM.endElementNScCs~|jr|jj|�}n|jd|�}x0|j�D]$\}}|jj|�}||_|j|�q*Wt|fdg|jd<|jd|_|j	|�dS)Nr
)
r+r-r,r.r/r1r0rrr)rr2r4r6r5r1r7rrr�startElementpszPullDOM.startElementcCs&t|j�fdg|jd<|jd|_dS)Nr
)rrr)rr2rrr�
endElementszPullDOM.endElementcCsN|jr2|jj|�}t|fdg|jd<|jd|_nt|fdg}|jj|�dS)Nr
)r+�
createCommentrrrr)r�sr6�eventrrr�comment�szPullDOM.commentcCsR|jr4|jj||�}t|fdg|jd<|jd|_nt||fdg}|jj|�dS)Nr
)r+�createProcessingInstructionrrrr)r�target�datar6r>rrr�processingInstruction�szPullDOM.processingInstructioncCs.|jj|�}t|fdg|jd<|jd|_dS)Nr
)r+�createTextNoderr)r�charsr6rrr�ignorableWhitespace�szPullDOM.ignorableWhitespacecCs.|jj|�}t|fdg|jd<|jd|_dS)Nr
)r+rDr	r)rrEr6rrr�
characters�szPullDOM.characterscCs$|jdkr ddl}|jjjj|_dS)Nr)rZxml.dom.minidomZdomZminidomZDocument�implementation)rrrrr�
startDocument�s
zPullDOM.startDocumentc	Cs�|jj||d�}||_t|fdg|jd<|jd|_|j|�x�|jD]�}|ddtkr�|d\}}}|jj||�}t|f|d<nD|ddt	kr�|jj
|dd�}t	|f|d<ntd|dd��||jd<||_qFWd|_|jS)Nr
rzUnknown pending event )
rZcreateDocumentr+rrrrrr@rr<�AssertionErrorZ
firstChild)	rr&Ztagnamer6�e�_rArB�nrrrr,�s$


zPullDOM.buildDocumentcCs t|jfdg|jd<|j�dS)Nr
)rr+rr)rrrr�endDocument�szPullDOM.endDocumentcCs
d|_dS)z.clear(): Explicitly release parsing structuresN)r+)rrrr�clear�sz
PullDOM.clear)N)�__name__�
__module__�__qualname__rr+rrr r'r(r8r9r:r;r?rCrFrGrIr,rNrOrrrrr

s&
9		r
c@s$eZdZdd�Zdd�Zdd�ZdS)�ErrorHandlercCst|�dS)N)�print)r�	exceptionrrr�warning�szErrorHandler.warningcCs|�dS)Nr)rrUrrr�error�szErrorHandler.errorcCs|�dS)Nr)rrUrrr�
fatalError�szErrorHandler.fatalErrorN)rPrQrRrVrWrXrrrrrS�srSc@s\eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�ZdS)�DOMEventStreamcCs2||_||_||_t|jd�s&|j|_|j�dS)N�feed)�stream�parser�bufsizer#�_slurp�getEvent�reset)rr[r\r]rrrr�szDOMEventStream.__init__cCs.t�|_|jjtjjjd�|jj|j�dS)Nr
)	r
�pulldomr\Z
setFeaturer�saxZhandlerZfeature_namespacesZsetContentHandler)rrrrr`�szDOMEventStream.resetcCs|j�}|r|St�dS)N)r_�
IndexError)r�pos�rcrrr�__getitem__�szDOMEventStream.__getitem__cCs|j�}|r|St�dS)N)r_�
StopIteration)rrerrr�__next__�szDOMEventStream.__next__cCs|S)Nr)rrrr�__iter__�szDOMEventStream.__iter__cCsp|j�}|g}x\|rj|\}}||kr(dS|tkr>|dj|�|tkrR|j|�n|tkr`|d=|j�}qWdS)Nr
rr)r_r�appendChildrr)rr6r>�parents�tokenZcur_noderrr�
expandNode�szDOMEventStream.expandNodecCs�|jjds|jj|j_x<|jjdsT|jj|j�}|sF|jj�dS|jj|�qW|jjdd}|jjdd|jjd<|S)Nr
r)	rarrr[�readr]r\�closerZ)r�bufrerrrr_�s
zDOMEventStream.getEventcCs|jj|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).
        )r\�parser[�_emitr_)rrrrr^szDOMEventStream._slurpcCs,|jjdd}|jjdd|jjd<|S)zn Fallback replacement for getEvent() that emits
            the events that _slurp() read previously.
        r
r)rar)rrerrrrrszDOMEventStream._emitcCs|jj�|`d|_d|_dS)z+clear(): Explicitly release parsing objectsN)rarOr\r[)rrrrrOs
zDOMEventStream.clearN)
rPrQrRrr`rfrhrirmr_r^rrrOrrrrrY�s
rYc@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�SAX2DOMcCs2tj||||�|jd}|jd}|j|�dS)Nr
�r���)r
r8rrj)rr2r3r4�curNode�
parentNoderrrr8#s

zSAX2DOM.startElementNScCs0tj|||�|jd}|jd}|j|�dS)Nr
rtrru)r
r:rrj)rr2r4rvrwrrrr:)s

zSAX2DOM.startElementcCs4tj|||�|jdd}|jd}|j|�dS)Nrr
r)r
rCrrrj)rrArBr6rwrrrrC/s
zSAX2DOM.processingInstructioncCs2tj||�|jdd}|jd}|j|�dS)Nrr
r)r
rFrrrj)rrEr6rwrrrrF5s
zSAX2DOM.ignorableWhitespacecCs2tj||�|jdd}|jd}|j|�dS)Nrr
r)r
rGrrrj)rrEr6rwrrrrG;s
zSAX2DOM.charactersN)rPrQrRr8r:rCrFrGrrrrrs!s
rsrt��cCs@|dkrt}t|t�r"t|d�}n|}|s4tjj�}t|||�S)N�rb)�default_bufsize�
isinstance�str�openrrb�make_parserrY)Zstream_or_stringr\r]r[rrrrqDs

rqcCs6ddlm}t|�}||�}|s*tjj�}t|||�S)Nr)�StringIO)�ior��lenrrbrrY)�stringr\r�r]rprrr�parseStringOs
r�i@i�?)NN)N)Zxml.saxrZxml.sax.handlerrrrrrrrr	rbZContentHandlerr
rSrYrsr{rqr�rrrr�<module>s"8U!
PK�"[>�Mpw'w',dom/__pycache__/pulldom.cpython-36.opt-2.pycnu�[���3


 \�-�@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|_y|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.6/xml/dom/pulldom.py�__init__s

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

zPullDOM.startPrefixMappingcCs|jj�|_dS)N)rrr)rr%rrr�endPrefixMapping0szPullDOM.endPrefixMappingcCs�d}t|dd�}|dk	r>x|D]\}}||j||f<qWg|_|\}}	|r�|dkrr|j|}
|
rn|
d|	}n|	}|jr�|jj||�}q�|j||�}n |jr�|jj|	�}n|jd|	�}x�|j�D]�\}}|\}}
||k�r
|
dkr�|
}nd|
}|jj	||�}|j
|�nX|�rL|j|}
|
�r.|
d|
}n|
}|jj	||�}|j
|�n|jj|
�}|j|�||_
q�Wt|fdg|jd<|jd|_|j|�dS)Nzhttp://www.w3.org/2000/xmlns/r!�:r"zxmlns:r
)�getattrZ_attrsr!r�documentZcreateElementNS�
buildDocument�
createElement�itemsZcreateAttributeNSZsetAttributeNodeNS�createAttribute�setAttributeNode�valuerrr)r�name�tagName�attrsZ	xmlns_uriZxmlns_attrs�anamer1r&Z	localnamer%�nodeZa_uriZa_localnameZqname�attrrrr�startElementNS3sP




zPullDOM.startElementNScCs&t|j�fdg|jd<|jd|_dS)Nr
)rrr)rr2r3rrr�endElementNSlszPullDOM.endElementNScCs~|jr|jj|�}n|jd|�}x0|j�D]$\}}|jj|�}||_|j|�q*Wt|fdg|jd<|jd|_|j	|�dS)Nr
)
r+r-r,r.r/r1r0rrr)rr2r4r6r5r1r7rrr�startElementpszPullDOM.startElementcCs&t|j�fdg|jd<|jd|_dS)Nr
)rrr)rr2rrr�
endElementszPullDOM.endElementcCsN|jr2|jj|�}t|fdg|jd<|jd|_nt|fdg}|jj|�dS)Nr
)r+�
createCommentrrrr)r�sr6�eventrrr�comment�szPullDOM.commentcCsR|jr4|jj||�}t|fdg|jd<|jd|_nt||fdg}|jj|�dS)Nr
)r+�createProcessingInstructionrrrr)r�target�datar6r>rrr�processingInstruction�szPullDOM.processingInstructioncCs.|jj|�}t|fdg|jd<|jd|_dS)Nr
)r+�createTextNoderr)r�charsr6rrr�ignorableWhitespace�szPullDOM.ignorableWhitespacecCs.|jj|�}t|fdg|jd<|jd|_dS)Nr
)r+rDr	r)rrEr6rrr�
characters�szPullDOM.characterscCs$|jdkr ddl}|jjjj|_dS)Nr)rZxml.dom.minidomZdomZminidomZDocument�implementation)rrrrr�
startDocument�s
zPullDOM.startDocumentc	Cs�|jj||d�}||_t|fdg|jd<|jd|_|j|�x�|jD]�}|ddtkr�|d\}}}|jj||�}t|f|d<nD|ddt	kr�|jj
|dd�}t	|f|d<ntd|dd��||jd<||_qFWd|_|jS)Nr
rzUnknown pending event )
rZcreateDocumentr+rrrrrr@rr<�AssertionErrorZ
firstChild)	rr&Ztagnamer6�e�_rArB�nrrrr,�s$


zPullDOM.buildDocumentcCs t|jfdg|jd<|j�dS)Nr
)rr+rr)rrrr�endDocument�szPullDOM.endDocumentcCs
d|_dS)N)r+)rrrr�clear�sz
PullDOM.clear)N)�__name__�
__module__�__qualname__rr+rrr r'r(r8r9r:r;r?rCrFrGrIr,rNrOrrrrr

s&
9		r
c@s$eZdZdd�Zdd�Zdd�ZdS)�ErrorHandlercCst|�dS)N)�print)r�	exceptionrrr�warning�szErrorHandler.warningcCs|�dS)Nr)rrUrrr�error�szErrorHandler.errorcCs|�dS)Nr)rrUrrr�
fatalError�szErrorHandler.fatalErrorN)rPrQrRrVrWrXrrrrrS�srSc@s\eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�ZdS)�DOMEventStreamcCs2||_||_||_t|jd�s&|j|_|j�dS)N�feed)�stream�parser�bufsizer#�_slurp�getEvent�reset)rr[r\r]rrrr�szDOMEventStream.__init__cCs.t�|_|jjtjjjd�|jj|j�dS)Nr
)	r
�pulldomr\Z
setFeaturer�saxZhandlerZfeature_namespacesZsetContentHandler)rrrrr`�szDOMEventStream.resetcCs|j�}|r|St�dS)N)r_�
IndexError)r�pos�rcrrr�__getitem__�szDOMEventStream.__getitem__cCs|j�}|r|St�dS)N)r_�
StopIteration)rrerrr�__next__�szDOMEventStream.__next__cCs|S)Nr)rrrr�__iter__�szDOMEventStream.__iter__cCsp|j�}|g}x\|rj|\}}||kr(dS|tkr>|dj|�|tkrR|j|�n|tkr`|d=|j�}qWdS)Nr
rr)r_r�appendChildrr)rr6r>�parents�tokenZcur_noderrr�
expandNode�szDOMEventStream.expandNodecCs�|jjds|jj|j_x<|jjdsT|jj|j�}|sF|jj�dS|jj|�qW|jjdd}|jjdd|jjd<|S)Nr
r)	rarrr[�readr]r\�closerZ)r�bufrerrrr_�s
zDOMEventStream.getEventcCs|jj|j�|j|_|j�S)N)r\�parser[�_emitr_)rrrrr^szDOMEventStream._slurpcCs,|jjdd}|jjdd|jjd<|S)Nr
r)rar)rrerrrrrszDOMEventStream._emitcCs|jj�|`d|_d|_dS)N)rarOr\r[)rrrrrOs
zDOMEventStream.clearN)
rPrQrRrr`rfrhrirmr_r^rrrOrrrrrY�s
rYc@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�SAX2DOMcCs2tj||||�|jd}|jd}|j|�dS)Nr
�r���)r
r8rrj)rr2r3r4�curNode�
parentNoderrrr8#s

zSAX2DOM.startElementNScCs0tj|||�|jd}|jd}|j|�dS)Nr
rtrru)r
r:rrj)rr2r4rvrwrrrr:)s

zSAX2DOM.startElementcCs4tj|||�|jdd}|jd}|j|�dS)Nrr
r)r
rCrrrj)rrArBr6rwrrrrC/s
zSAX2DOM.processingInstructioncCs2tj||�|jdd}|jd}|j|�dS)Nrr
r)r
rFrrrj)rrEr6rwrrrrF5s
zSAX2DOM.ignorableWhitespacecCs2tj||�|jdd}|jd}|j|�dS)Nrr
r)r
rGrrrj)rrEr6rwrrrrG;s
zSAX2DOM.charactersN)rPrQrRr8r:rCrFrGrrrrrs!s
rsrt��cCs@|dkrt}t|t�r"t|d�}n|}|s4tjj�}t|||�S)N�rb)�default_bufsize�
isinstance�str�openrrb�make_parserrY)Zstream_or_stringr\r]r[rrrrqDs

rqcCs6ddlm}t|�}||�}|s*tjj�}t|||�S)Nr)�StringIO)�ior��lenrrbrrY)�stringr\r�r]rprrr�parseStringOs
r�i@i�?)NN)N)Zxml.saxrZxml.sax.handlerrrrrrrrr	rbZContentHandlerr
rSrYrsr{rqr�rrrr�<module>s"8U!
PK�"[���%dom/__pycache__/domreg.cpython-36.pycnu�[���3


 \{
�@sDdZddlZddd�ZiZdd�Zdd	�Zdffd
d�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.6/xml/dom/domreg.py�registerDOMImplementations	rcCs&x |D]\}}|j||�sdSqWdS)zF_good_enough(dom, features) -> Return 1 if the dom offers the featuresr�)Z
hasFeature)�dom�features�f�vrrr�_good_enough sr
cCs�ddl}d}tj|�}|r2t|iidg�}|j�S|r@t|�Stjjrdd|j	krdt|j	dd�St
|t�rvt|�}x$tj
�D]}|�}t||�r�|Sq�WxDtj�D]8}yt|d�}Wntk
r�w�YnXt||�r�|Sq�Wtd��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}|j�}d}t|�}xp||kr�||}|ddkrDtd|f��|d}d}||krx||}|ddkrx|d}|}|j||f�qWt|�S)Nr�
0123456789zbad feature name: %rr)�split�len�
ValueError�append�tuple)�sr
�parts�iZlengthZfeature�versionrrrrrRs"
r)�__doc__rrrrr
rrrrrr�<module>s+PK�"[��9�4�4)dom/__pycache__/xmlbuilder.cpython-36.pycnu�[���3


 \�2�@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�Z[Gdd�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.6/xml/dom/xmlbuilder.pyr
s(rc5@sVeZdZdZdZdZdZdZdZdZ	eeee	fZ
dd�Zdd	�Zd
d�Z
dd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd4d5gd6d7gd8d9gd:d;gd<d=gd>d?gd@dAgdBdCgdDdEgdFdGgdHdIdJgdKdLgdMdNgdOdPgdQdRgdSdTgdUdVgdWdXgdYdZgd[d\gd]gd^d_d`dadbdcdddedfdgg	dhdigdjdkgdldmgiZd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�ZdS)nrNr���cCst�|_dS)N)r�_options)�selfrrr�__init__:szDOMBuilder.__init__cCs|jS)N)�entityResolver)r#rrr�_get_entityResolver=szDOMBuilder._get_entityResolvercCs
||_dS)N)r%)r#r%rrr�_set_entityResolver?szDOMBuilder._set_entityResolvercCs|jS)N)r)r#rrr�_get_errorHandlerBszDOMBuilder._get_errorHandlercCs
||_dS)N)r)r#rrrr�_set_errorHandlerDszDOMBuilder._set_errorHandlercCs|jS)N)r)r#rrr�_get_filterGszDOMBuilder._get_filtercCs
||_dS)N)r)r#rrrr�_set_filterIszDOMBuilder._set_filterc
Cs�|j|�rv|rdpd}y|jt|�|f}Wn&tk
rRtjjd|f��Yq�Xx4|D]\}}t|j||�qZWntjj	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|��S)N)�hasattrr"r.)r#r6rrrr,ZszDOMBuilder.supportsFeaturecCst|�|rdpdf}||jkS)Nrr)r.r-)r#r6r7�keyrrr�
canSetFeature]szDOMBuilder.canSetFeaturer
rrrrrrrrrrrrrrrcCs�t|�}yt|j|�Stk
r�|dkrj|j}|joh|joh|joh|joh|jpf|j	pf|j
pf|jpf|jSt
jjdt|���YnXdS)Nrzfeature %s not known)r.�getattrr"�AttributeErrorrrrrr
rrrrr0r1r4r5)r#r6Zxname�optionsrrr�
getFeature�s zDOMBuilder.getFeaturecCs.|jr|jjd|�}nt�jd|�}|j|�S)N)r%�
resolveEntityr�parse)r#�uri�inputrrr�parseURI�szDOMBuilder.parseURIcCsRtj|j�}|j|_|j|_|j}|dkrF|jrFddl}|jj|j�}|j	||�S)Nr)
�copyr"rr�
byteStream�systemId�urllib.request�requestZurlopen�_parse_bytestream)r#rDr?�fp�urllibrrrrB�szDOMBuilder.parsecCs||jkrtd��td��dS)Nznot a legal actionzHaven't written this yet...)�_legal_actions�
ValueError�NotImplementedError)r#rDZcnode�actionrrr�parseWithContext�s
zDOMBuilder.parseWithContextcCs ddl}|jjj|�}|j|�S)Nr)Zxml.dom.expatbuilderr1ZexpatbuilderZmakeBuilderZ	parseFile)r#�streamr?r0ZbuilderrrrrK�szDOMBuilder._parse_bytestream)r
r)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)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)r
r)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr)rr	r
r%rrZACTION_REPLACEZACTION_APPEND_AS_CHILDRENZACTION_INSERT_AFTERZACTION_INSERT_BEFORErNr$r&r'r(r)r*r+r9r,r<r-r@rErBrRrKrrrrr-s�

cCs|j�jdd�S)N�-�_)�lower�replace)r6rrrr.�sr.c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)r�_openerc
Cs�|dk	st�t�}||_||_|j�j|�|_|j|�|_ddl	}ddl
}|jj|�}|\}}}	}
}}|	r�|	j
d�r�|j|	�d}	|||	|
||f}|jj|�|_|S)Nr�/)�AssertionErrorr�publicIdrH�_get_opener�openrG�_guess_media_encoding�encoding�	posixpathZurllib.parserBZurlparse�endswith�dirnameZ
urlunparse�baseURI)
r#r[rH�sourcer`rM�parts�schemeZnetloc�pathZparamsZqueryZfragmentrrrrA�szDOMEntityResolver.resolveEntitycCs,y|jStk
r&|j�|_|jSXdS)N)rXr>�_create_opener)r#rrrr\�s

zDOMEntityResolver._get_openercCsddl}|jj�S)Nr)rIrJZbuild_opener)r#rMrrrrh�sz DOMEntityResolver._create_openercCsF|jj�}d|krBx.|j�D]"}|jd�r|jdd�dj�SqWdS)NzContent-Typezcharset=�=r)rG�infoZgetplist�
startswith�splitrV)r#rdrjZparamrrrr^�s


z'DOMEntityResolver._guess_media_encodingN)rX)rr	r
�	__slots__rAr\rhr^rrrrr�s
c@s�eZdZd'Zdd	�Zd
d�Zdd
�Zdd�Zdd�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&S)(rrG�characterStream�
stringDatar_r[rHrccCs.d|_d|_d|_d|_d|_d|_d|_dS)N)rGrnror_r[rHrc)r#rrrr$szDOMInputSource.__init__cCs|jS)N)rG)r#rrr�_get_byteStreamszDOMInputSource._get_byteStreamcCs
||_dS)N)rG)r#rGrrr�_set_byteStreamszDOMInputSource._set_byteStreamcCs|jS)N)rn)r#rrr�_get_characterStreamsz#DOMInputSource._get_characterStreamcCs
||_dS)N)rn)r#rnrrr�_set_characterStreamsz#DOMInputSource._set_characterStreamcCs|jS)N)ro)r#rrr�_get_stringDataszDOMInputSource._get_stringDatacCs
||_dS)N)ro)r#�datarrr�_set_stringDataszDOMInputSource._set_stringDatacCs|jS)N)r_)r#rrr�
_get_encodingszDOMInputSource._get_encodingcCs
||_dS)N)r_)r#r_rrr�
_set_encodingszDOMInputSource._set_encodingcCs|jS)N)r[)r#rrr�
_get_publicId"szDOMInputSource._get_publicIdcCs
||_dS)N)r[)r#r[rrr�
_set_publicId$szDOMInputSource._set_publicIdcCs|jS)N)rH)r#rrr�
_get_systemId'szDOMInputSource._get_systemIdcCs
||_dS)N)rH)r#rHrrr�
_set_systemId)szDOMInputSource._set_systemIdcCs|jS)N)rc)r#rrr�_get_baseURI,szDOMInputSource._get_baseURIcCs
||_dS)N)rc)r#rCrrr�_set_baseURI.szDOMInputSource._set_baseURIN)rGrnror_r[rHrc)rr	r
rmr$rprqrrrsrtrvrwrxryrzr{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|jS)N)�
whatToShow)r#rrr�_get_whatToShowCsz DOMBuilderFilter._get_whatToShowcCs|jS)N)�
FILTER_ACCEPT)r#�elementrrr�
acceptNodeFszDOMBuilderFilter.acceptNodecCs|jS)N)r�)r#r�rrr�startContainerIszDOMBuilderFilter.startContainerN)rr	r
rr�Z
FILTER_REJECTZFILTER_SKIPZFILTER_INTERRUPTrZSHOW_ALLr�r�r�r�rrrrr2src@s$eZdZdd�Zdd�Zdd�ZdS)�_AsyncDeprecatedPropertycCs|j}tjdj|d�t�dS)Nz+{cls}.async is deprecated; use {cls}.async_)�cls)r�warnings�warn�format�DeprecationWarning)r#r�Zclsnamerrrr�Ps
z_AsyncDeprecatedProperty.warncCs|j|�|dk	r|jSdS)NF)r��async_)r#�instancer�rrr�__get__Vs
z _AsyncDeprecatedProperty.__get__cCs|jt|��t|d|�dS)Nr�)r��typer3)r#r�r8rrr�__set__\sz _AsyncDeprecatedProperty.__set__N)rr	r
r�r�r�rrrrr�Osr�c@sPeZdZdZdZe�e�d<dd�Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�ZdS)�
DocumentLSz=Mixin to create documents that conform to the load/save spec.F�asynccCsdS)NFr)r#rrr�
_get_asyncgszDocumentLS._get_asynccCs|rtjjd��dS)Nz.asynchronous document loading is not supported)r0r1r2)r#�flagrrr�
_set_asyncjszDocumentLS._set_asynccCstd��dS)Nz'haven't figured out what this means yet)rP)r#rrr�abortoszDocumentLS.abortcCstd��dS)Nzhaven't written this yet)rP)r#rCrrr�loaduszDocumentLS.loadcCstd��dS)Nzhaven't written this yet)rP)r#rdrrr�loadXMLxszDocumentLS.loadXMLcCs*|dkr|}n|j|k	r"tjj��|j�S)N)Z
ownerDocumentr0r1ZWrongDocumentErrZtoxml)r#Zsnoderrr�saveXML{s


zDocumentLS.saveXMLN)
rr	r
rr�r��localsr�r�r�r�r�r�rrrrr�asr�c@s,eZdZdZdZdd�Zdd�Zdd�Zd	S)
�DOMImplementationLSrrcCsF|dk	rtjjd��||jkr$t�S||jkr:tjjd��td��dS)NzschemaType not yet supportedz'asynchronous builders are not supportedzunknown value for mode)r0r1r2�MODE_SYNCHRONOUSr�MODE_ASYNCHRONOUSrO)r#�modeZ
schemaTyperrr�createDOMBuilder�s

z$DOMImplementationLS.createDOMBuildercCstd��dS)Nz-the writer interface hasn't been written yet!)rP)r#rrr�createDOMWriter�sz#DOMImplementationLS.createDOMWritercCst�S)N)r)r#rrr�createDOMInputSource�sz(DOMImplementationLS.createDOMInputSourceN)rr	r
r�r�r�r�r�rrrrr��s
r�)rrFr�Zxml.domr0Zxml.dom.NodeFilterr�__all__rrr.�objectrrrr�r�r�rrrr�<module>s"
 %,1"PK�"[ɵ�	�
�
/dom/__pycache__/minicompat.cpython-36.opt-1.pycnu�[���3


 \'
�@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>eZdZfZdd�Zdd�Zdd�Zeeedd�Zd	d
�Z	dS)rcCs(d|kot|�knr$||SdS)Nr)�len)�self�index�r	�*/usr/lib64/python3.6/xml/dom/minicompat.py�item5sz
NodeList.itemcCst|�S)N)r)rr	r	r
�_get_length9szNodeList._get_lengthcCstjjd��dS)Nz.attempt to modify read-only attribute 'length')�xml�dom�NoModificationAllowedErr)r�valuer	r	r
�_set_length<szNodeList._set_lengthz$The number of nodes in the NodeList.)�doccCs|dkrg}||dd�<dS)Nr	)r�stater	r	r
�__setstate__DszNodeList.__setstate__N)
�__name__�
__module__�__qualname__�	__slots__rrr�property�lengthrr	r	r	r
r2sc@sFeZdZfZdd�Zdd�Zdd�Zdd�Zd	d
�Ze	eedd�Z
d
S)rcCst�}|j|�|S)N)r�extend)r�other�NLr	r	r
�__add__Ms
zEmptyNodeList.__add__cCst�}|j|�|S)N)rr)rrrr	r	r
�__radd__Rs
zEmptyNodeList.__radd__cCsdS)Nr	)rrr	r	r
rWszEmptyNodeList.itemcCsdS)Nrr	)rr	r	r
rZszEmptyNodeList._get_lengthcCstjjd��dS)Nz.attempt to modify read-only attribute 'length')r
rr)rrr	r	r
r]szEmptyNodeList._set_lengthz$The number of nodes in the NodeList.)rN)rrrrrrrrrrrr	r	r	r
rJscCs8t|d|�}|fdd�}t|||d�}t|||�dS)NZ_get_cSstjjdt|���dS)Nz&attempt to modify read-only attribute )r
rr�repr)rr�namer	r	r
�setgszdefproperty.<locals>.set)r)�getattrr�setattr)�klassr!r�getr"Zpropr	r	r
res)�__doc__�__all__Zxml.domr
�strr�listr�tuplerrr	r	r	r
�<module>s&PK�"[�|�6�
�
)dom/__pycache__/minicompat.cpython-36.pycnu�[���3


 \'
�@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>eZdZfZdd�Zdd�Zdd�Zeeedd�Zd	d
�Z	dS)rcCs(d|kot|�knr$||SdS)Nr)�len)�self�index�r	�*/usr/lib64/python3.6/xml/dom/minicompat.py�item5sz
NodeList.itemcCst|�S)N)r)rr	r	r
�_get_length9szNodeList._get_lengthcCstjjd��dS)Nz.attempt to modify read-only attribute 'length')�xml�dom�NoModificationAllowedErr)r�valuer	r	r
�_set_length<szNodeList._set_lengthz$The number of nodes in the NodeList.)�doccCs|dkrg}||dd�<dS)Nr	)r�stater	r	r
�__setstate__DszNodeList.__setstate__N)
�__name__�
__module__�__qualname__�	__slots__rrr�property�lengthrr	r	r	r
r2sc@sFeZdZfZdd�Zdd�Zdd�Zdd�Zd	d
�Ze	eedd�Z
d
S)rcCst�}|j|�|S)N)r�extend)r�other�NLr	r	r
�__add__Ms
zEmptyNodeList.__add__cCst�}|j|�|S)N)rr)rrrr	r	r
�__radd__Rs
zEmptyNodeList.__radd__cCsdS)Nr	)rrr	r	r
rWszEmptyNodeList.itemcCsdS)Nrr	)rr	r	r
rZszEmptyNodeList._get_lengthcCstjjd��dS)Nz.attempt to modify read-only attribute 'length')r
rr)rrr	r	r
r]szEmptyNodeList._set_lengthz$The number of nodes in the NodeList.)rN)rrrrrrrrrrrr	r	r	r
rJscCsTt|d|�}|fdd�}t|d|�s6td|��t|||d�}t|||�dS)NZ_get_cSstjjdt|���dS)Nz&attempt to modify read-only attribute )r
rr�repr)rr�namer	r	r
�setgszdefproperty.<locals>.setZ_set_zexpected not to find _set_)r)�getattr�hasattr�AssertionErrorr�setattr)�klassr!r�getr"Zpropr	r	r
res
)�__doc__�__all__Zxml.domr
�strr�listr�tuplerrr	r	r	r
�<module>s&PK�"[�Jꃺ]�]1dom/__pycache__/expatbuilder.cpython-36.opt-2.pycnu�[���3


 \���@sddlmZmZmZddlmZmZmZddlmZddl	m
Z
mZddlm
Z
ejZejZejZejjZejjZejjZejjZej�Zejdd�ejdd�ejdd	�ejdd
�ejdd�ejdd�ejdd
�ejdd�ejdd�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�Zd	d
�Zdd�Zd
d�Zdd�Z	dd�Z
dd�Zdd�ZdS)�ElementInfo�
_attr_info�_model�tagNameNcCs||_g|_||_dS)N)rrr)�selfr�model�r�,/usr/lib64/python3.6/xml/dom/expatbuilder.py�__init__?szElementInfo.__init__cCs|j|j|jfS)N)rrr)rrrr�__getstate__DszElementInfo.__getstate__cCs|\|_|_|_dS)N)rrr)r�staterrr�__setstate__GszElementInfo.__setstate__cCsJxB|jD]8}|d|kr|d}|ddkr4tdSt|dSqWtjS)N��r�(r���r!)r�
_typeinfo_mapr�_no_type)r�aname�info�trrr�getAttributeTypeJszElementInfo.getAttributeTypecCstjS)N)rr#)rZnamespaceURIZ	localNamerrr�getAttributeTypeNSTszElementInfo.getAttributeTypeNScCs,|jr$|jd}|tjjtjjfkSdSdS)NrF)rrrZ
XML_CTYPE_ANYZXML_CTYPE_MIXED)r�typerrr�isElementContentWs

zElementInfo.isElementContentcCs |jr|jdtjjkSdSdS)NrF)rrrZXML_CTYPE_EMPTY)rrrr�isEmpty_szElementInfo.isEmptycCs,x&|jD]}|d|kr|ddkSqWdS)NrrrFr!)r)rr$r%rrr�isIdeszElementInfo.isIdcCs|j||f�S)N)r,)rZeuriZenameZaurir$rrr�isIdNSkszElementInfo.isIdNS)rrr)N)
�__name__�
__module__�__qualname__�	__slots__rrrr'r(r*r+r,r-rrrrr<s

rcCs|j||�S)N)�_intern_setdefault)�builder�srrr�_internosr5cCs�|jd�}|j}t|�dkrR|\}}}|||�}d||f}|||�}|||�}n4t|�dkrz|\}}t}|||�}}ntd|��|||�|||fS)N� �z%s:%srz4Unsupported syntax: spaces in URIs not supported: %r)�splitr2�lenr�
ValueError)r3�name�parts�intern�uri�	localname�prefix�qnamerrr�_parse_ns_namers



rBc@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|dkrtj�}||_|jjdk	r2t|jj�|_nd|_t|_d|_|j	�dS)N)
rZOptions�_options�filter�FilterVisibilityController�_filterr�_finish_start_element�_parser�reset)r�optionsrrrr�szExpatBuilder.__init__cCstj�S)N)r�ParserCreate)rrrr�createParser�szExpatBuilder.createParsercCsF|js@|j�|_|jjj|_d|j_d|j_d|j_|j|j�|jS)NT)	rIrMr=�
setdefaultr2Zbuffer_textZordered_attributesZspecified_attributes�install)rrrr�	getParser�s
zExpatBuilder.getParsercCs,tjtdd�|_|j|_|jj|_d|_dS)NF)�theDOMImplementationZcreateDocumentr�document�curNode�
_elem_info�_cdata)rrrrrJ�s

zExpatBuilder.resetcCs�|j|_|j|_|j|_|j|_|jj	r0|j
|_|j|_
|jjrH|j|_|jjrj|j|_|j|_|j|_n|j|_|j|_|j|_|j|_|j|_ dS)N)!�start_doctype_decl_handler�StartDoctypeDeclHandler�first_element_handler�StartElementHandler�end_element_handler�EndElementHandler�
pi_handler�ProcessingInstructionHandlerrDr�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�parserrrrrO�s$
zExpatBuilder.installcCs�|j�}d}yLx:|jd�}|s P|j|d�|rB|jjrB|j|�d}qW|jdd�Wntk
rlYnX|j}|j�d|_|S)NT�irF�i@)	rP�read�ParserR�documentElement�
_setup_subset�ParseEscaperJrI)r�filerqZfirst_buffer�buffer�docrrr�	parseFile�s$

zExpatBuilder.parseFilecCsP|j�}y|j|d�|j|�Wntk
r6YnX|j}|j�d|_|S)NT)rPrurwrxrRrJrI)r�stringrqr{rrr�parseString�szExpatBuilder.parseStringcCs.|jjr*t�}|j|�|j�}||jj_dS)N)rR�doctype�InternalSubsetExtractorr~�	getSubset�internalSubset)rrzZ	extractor�subsetrrrrw�s

zExpatBuilder._setup_subsetcCs�|jjj|||�}|j|_t|j|�||j_|jrj|jj|�tkrjd|j_|jj	d=d}d|j
_d|j
_|r�|dk	r�g|j
_g|j_d|j
_d|j
_|j|j
_dS)Nr���)rR�implementationZcreateDocumentType�
ownerDocumentr	rrG�
acceptNode�
FILTER_REJECT�
childNodesrIr_rar�_seq�	notationsrdr]�end_doctype_decl_handler�EndDoctypeDeclHandler)rZdoctypeName�systemId�publicId�has_internal_subsetrrrrrV�s$

z'ExpatBuilder.start_doctype_decl_handlercCs2|jjr|j|j_|j|j_|jp&|js.t	|_
dS)N)rDrbrcrIrdr\r]rTrGr�_finish_end_element)rrrrr�s


z%ExpatBuilder.end_doctype_decl_handlercCs@|jj||�}t|j|�|jr<|jj|�tkr<|jj|�dS)N)rRZcreateProcessingInstructionr	rSrGr�r��removeChild)r�target�data�noderrrr\szExpatBuilder.pi_handlercCs�|jj}|jrH|jr4|djtkr4|dj|�dS|jj|�}d|_nD|rv|djt	krv|d}|j
|}||_
dStj�}||_
|j|_
t|j|�dS)NrTr�r�r�r�)rSr�rU�_cdata_continue�nodeType�CDATA_SECTION_NODEZ
appendDatarRZcreateCDATASection�	TEXT_NODEr�r�Textr�r	)rr�r�r��valuerrrris"
z)ExpatBuilder.character_data_handler_cdatacCs^|jj}|r2|djtkr2|d}|j||_dStj�}|j||_|j|_t	|j|�dS)Nrr�r�)
rSr�r�r�r�rr�rRr�r	)rr�r�r�rrrrk&sz#ExpatBuilder.character_data_handlerc
Cs�|rdS|jjsdS|jj||||�}|dk	rF|jj|�}	|jj|	�|jjjjj|�|j	r||j	j
|�tkr||jjjjd=dS)Nrr�)rDrrRZ_create_entityZcreateTextNoder��appendrr�rGr�r�)
rZ
entityNameZis_parameter_entityr��baser�r��notationNamer��childrrrr^1s
z ExpatBuilder.entity_decl_handlercCsJ|jj|||�}|jjjjj|�|jrF|jj|�tkrF|jjjjd=dS)Nrr�)	rRZ_create_notationrr�r�r�rGr��
FILTER_ACCEPT)rr�r�r�r�r�rrrr`Csz"ExpatBuilder.notation_decl_handlercCs>|jj|�}t|j|�|jr:|jj|�tkr:|jj|�dS)N)rRZ
createCommentr	rSrGr�r�r�)rr�r�rrrrcIszExpatBuilder.comment_handlercCsd|_d|_dS)NTF)rUr�)rrrrreOsz(ExpatBuilder.start_cdata_section_handlercCsd|_d|_dS)NF)rUr�)rrrrrgSsz&ExpatBuilder.end_cdata_section_handlercCsdS)Nrr)r�contextr�r�r�rrrrlWsz(ExpatBuilder.external_entity_ref_handlercCs4|jdkr|jrt|_|j|j�_|j||�dS)N)rGrTrr��start_element_handlerrPrY)rr;�
attributesrrrrXZsz"ExpatBuilder.first_element_handlercCs�|jj|�}t|j|�||_|rtxPtdt|�d�D]<}tj||tdt	�}||d}||_
|j|_t||�q4W||jj
k	r�|j|�dS)Nrrr)rRZ
createElementr	rS�ranger9r�Attrrrr�r�r
rvrH)rr;r�r��i�ar�rrrr�`sz"ExpatBuilder.start_element_handlercCsj|jrf||jjkrdS|jj|�}|tkr4t|�n|tkrFt|�ndS|j|_	|jj
|�|j�dS)N)rGrRrv�startContainerr��Rejecter�FILTER_SKIP�Skipper�
parentNoderSr��unlink)rr�ZfiltrrrrHqs

z"ExpatBuilder._finish_start_elementcCs|j}|j|_|j|�dS)N)rSr�r�)rr;rSrrrrZ�sz ExpatBuilder.end_element_handlercCs\|jj|j�}|r|j||�|jrX||jjkr4dS|jj|�tkrX|j	j
|�|j�dS)N)rT�getr�_handle_white_text_nodesrGrRrvr�r�rSr�r�)rrSr%rrrr��sz ExpatBuilder._finish_end_elementcCsf|jjs|j�rdSg}x.|jD]$}|jtkr"|jj�r"|j|�q"Wx|D]}|j	|�qPWdS)N)
rDZwhitespace_in_element_contentr*r�r�r�r��stripr�r�)rr�r%�Lr�rrrr��s

z%ExpatBuilder._handle_white_text_nodescCs0|jj|�}|dkr&t||�|j|<n||_dS)N)rTr�rr)rr;rr%rrrro�sz!ExpatBuilder.element_decl_handlerc	CsF|jj|�}|dkr&t|�}||j|<|jjd|dd|d||g�dS)Nr)rTr�rrr�)r�elemr;r)�defaultZrequiredr%rrrrp�s
z!ExpatBuilder.attlist_decl_handlercCs2||j_||j_|dkr.|r&d|j_nd|j_dS)NrTF)rR�version�encoding�
standalone)rr�r�r�rrrrn�s
zExpatBuilder.xml_decl_handler)N)r.r/r0rrMrPrJrOr|r~rwrVr�r\rirkr^r`rcrergrlrXr�rHrZr�r�rorprnrrrrrC�s8

rCc@s�eZdZd	Zdd�Zdd�Zdd�Zeje	j
eje	jej
e	jeje	jeje	jeje	jeje	jeje	jeje	jeje	jeje	jeje	j iZ!dS)
rFrEcCs
||_dS)N)rE)rrErrrr�sz#FilterVisibilityController.__init__cCsT|j|j}|jj|@rL|jj|�}|tkr0t�|tkrHtdt	|���|St
SdS)Nz)startContainer() returned illegal value: )�_nodetype_maskr�rE�
whatToShowr��FILTER_INTERRUPTrx�_ALLOWED_FILTER_RETURNSr:�reprr�)rr��mask�valrrrr��sz)FilterVisibilityController.startContainercCs�|j|j}|jj|@r�|jj|�}|tkr0t�|tkrd|j}x |j	dd�D]}|j
|�qNWtS|tkr|t
dt|���|StSdS)Nz%acceptNode() returned illegal value: )r�r�rEr�r�r�rxr�r�r�ZappendChildr�r�r:r�r�)rr�r�r��parentr�rrrr��sz%FilterVisibilityController.acceptNodeN)rE)"r.r/r0r1rr�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�rrrrrF�s 
rFc@seZdZdZdd�ZdS)	�FilterCrutch�_builder�_level�
_old_start�_old_endcCs6d|_||_|j}|j|_|j|_|j|_|j|_dS)Nr)	r�r�rIrYr�r[r�r�rZ)rr3rqrrrrszFilterCrutch.__init__N)r�r�r�r�)r.r/r0r1rrrrrr�sr�c@s(eZdZfZdd�Zdd�Zdd�ZdS)r�cCs0tj||�|j}xdD]}t||d�qWdS)Nr]rdrjrfrhrm)r]rdrjrfrhrm)r�rrI�setattr)rr3rqr;rrrrszRejecter.__init__cGs|jd|_dS)Nr)r�)r�argsrrrr�szRejecter.start_element_handlercGs@|jdkr0|jj}|jj|�|j|_|j|_n|jd|_dS)Nrr)r�r�rIrOr�rYr�r[)rr�rqrrrrZ s

zRejecter.end_element_handlerN)r.r/r0r1rr�rZrrrrr�sr�c@s eZdZfZdd�Zdd�ZdS)r�cGs.|jj}|j|�|jj|k	r*|jd|_dS)Nr)r�rSr�r�)rr�r�rrrr�-s
zSkipper.start_element_handlercGsD|jdkr*|j|jj_|j|jj_d|_n|jd|_|j|�dS)Nrr)r�r�r�rIrYr�r[)rr�rrrrZ3s
zSkipper.end_element_handlerN)r.r/r0r1r�rZrrrrr�*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|_||_tj||�dS)N)r�r��originalDocumentr�r�rCr)rr�rKrrrr[s
zFragmentBuilder.__init__cCstj|�d|_dS)N)rCrJ�fragment)rrrrrJds
zFragmentBuilder.resetcCs|j|j��S)N)r~rt)rryrrrr|hszFragmentBuilder.parseFilec		Cs�||_|j�}|jj}d}|rV|jp*|j�}|jrDd|j|jf}qZ|jrZd|j}nd}|j�}t	|||f}y|j
|d�Wn|j��YnX|j}|j�|S)NrszPUBLIC "%s" "%s"zSYSTEM "%s"r)
�_sourcerPr�rr��_getDeclarationsr�r��_getNSattrs�_FRAGMENT_BUILDER_TEMPLATErurJr�)	rr}rqrZidentr�ZnsattrsrRr�rrrr~ms,zFragmentBuilder.parseStringcCs|jjj}d}|�rxbt|jj�D]R}|jj|�}|r>|d}d||jf}|jrfd||j|j	f}q"d||j	f}q"Wx�t|j
j�D]�}|j
j|�}|r�|d}d||jf}|jr�d||j|j	f}n&|j	r�d||j	f}nd	||jjf}|j
�rd
||j
f}|d}q�W|S)Nrsz
  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�rr�r�Zlength�itemZnodeNamer�r�rZ
firstChildr�r�)rrr4r�Znotationr
rrrr��s6
z FragmentBuilder._getDeclarationscCsdS)Nrsr)rrrrr��szFragmentBuilder._getNSattrscCs~|tkrh|j}|j}|jj|�}|j|_|jj�|_|j|_z|j|j	d�Wd||_||_d|_	XdSt
j|||||�SdS)Nrr�)�$_FRAGMENT_BUILDER_INTERNAL_SYSTEM_IDrRrSrIZExternalEntityParserCreater�ZcreateDocumentFragmentr�rur�rCrl)rr�r�r�r�Zold_documentZold_cur_noderqrrrrl�sz+FragmentBuilder.external_entity_ref_handler)N)
r.r/r0rrJr|r~r�r�rlrrrrr�Rs	
	$r�c@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�
NamespacescCs
g|_dS)N)�_ns_ordered_prefixes)rrrr�_initNamespaces�szNamespaces._initNamespacescCstjdd�}d|_|S)Nr6)Znamespace_separatorT)rrLZnamespace_prefixes)rrqrrrrM�szNamespaces.createParsercCs tj||�|jjr|j|_dS)N)rCrOrDZnamespace_declarations�start_namespace_decl_handlerZStartNamespaceDeclHandler)rrqrrrrO�szNamespaces.installcCs|jj||f�dS)N)r�r�)rr@r>rrrr��sz'Namespaces.start_namespace_decl_handlercCs�d|krt||�\}}}}nt}|}d}t}tj||||�}|j|_t|j|�||_|j	r�xZ|j	D]P\}}|r�tj
t|d|�t|d�}ntj
dtdt�}||_
|j|_t||�qdW|j	dd�=|�r�|j�|j}	|j}
x�tdt|�d�D]�}||}||d}
d|k�rJt||�\}}}}tj
||||�}||	|<||
||f<n$tj
|t|t�}||	|<||
t|f<|j|_|
|_
||_q�WdS)Nr6zxmlns:�xmlnsrrr)rBrrrZElementrRr�r	rSr�r�r5rr�r
Z_ensure_attributes�_attrs�_attrsNSr�r9ZownerElement)rr;r�r>r?r@rAr�r�r�r�r�r$r�rrrr��sP
z Namespaces.start_element_handlerN)r.r/r0r�rMrOr�r�rrrrr��s/r�c@seZdZdd�ZdS)�ExpatBuilderNScCstj|�|j�dS)N)rCrJr�)rrrrrJ)s
zExpatBuilderNS.resetN)r.r/r0rJrrrrr�&sr�c@seZdZdd�Zdd�ZdS)�FragmentBuilderNScCstj|�|j�dS)N)r�rJr�)rrrrrJ1s
zFragmentBuilderNS.resetcCs�d}|j}g}xv|r�t|d�r|x\|jj�D]N\}}||kr<q*|j|�|rTd|}nd}|rld|||f}q*d||f}q*W|j}qW|S)Nrs�_ns_prefix_urizxmlns:r�z%s
    %s='%s'z %s='%s')r��hasattrr��itemsr�r�)r�attrsr�r�r@r>Zdeclnamerrrr�5s"



zFragmentBuilderNS._getNSattrsN)r.r/r0rJr�rrrrr�.sr�c@seZdZdS)rxN)r.r/r0rrrrrxSsrxc@sHeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dS)r�NcCs|jS)N)r�)rrrrr�\sz!InternalSubsetExtractor.getSubsetcCs*ytj||�Wntk
r$YnXdS)N)rCr|rx)rryrrrr|`sz!InternalSubsetExtractor.parseFilecCs*ytj||�Wntk
r$YnXdS)N)rCr~rx)rr}rrrr~fsz#InternalSubsetExtractor.parseStringcCs|j|_|j|_dS)N)rVrWr�rY)rrqrrrrOlszInternalSubsetExtractor.installcCs0|r&|j�}g|_|jj|_|j|_nt��dS)N)rPr�r�ZDefaultHandlerr�r�rx)rr;r�r�r�rqrrrrVps

z2InternalSubsetExtractor.start_doctype_decl_handlercCs,dj|j�jdd�jdd�}||_t��dS)Nrsz
�
�
)�joinr��replacerx)rr4rrrr�zsz0InternalSubsetExtractor.end_doctype_decl_handlercCs
t��dS)N)rx)rr;r�rrrr�sz-InternalSubsetExtractor.start_element_handler)r.r/r0r�r�r|r~rOrVr�r�rrrrr�Ws
r�Tc	CsL|rt�}nt�}t|t�r>t|d��}|j|�}WdQRXn
|j|�}|S)N�rb)r�rC�
isinstance�str�openr|)ry�
namespacesr3�fp�resultrrr�parse�s

r�cCs|rt�}nt�}|j|�S)N)r�rCr~)r}r�r3rrrr~�sr~c	CsP|rt|�}nt|�}t|t�rBt|d��}|j|�}WdQRXn
|j|�}|S)Nr�)r�r�r�r�r�r|)ryr�r�r3r�r�rrr�
parseFragment�s


r�cCs |rt|�}nt|�}|j|�S)N)r�r�r~)r}r�r�r3rrr�parseFragmentString�s
r�cCs|jrt|�St|�SdS)N)r�r�rC)rKrrr�makeBuilder�sr�)T)T)T)T)2Zxml.domrrrrrrZxml.parsersrZxml.dom.minidomr	r
Zxml.dom.NodeFilterrr�r�r�ZDOMBuilderFilterr�r�r�r�ZgetDOMImplementationrQZTypeInfor"�objectrr5rBrCr�rFr�r�r�r�r�r�r�r�r��	Exceptionrxr�r�r~r�r�r�rrrr�<module>s\







3C
:u_%,



PK�"[�$YG
j
j+dom/__pycache__/expatbuilder.cpython-36.pycnu�[���3


 \���@sdZddlmZmZmZddlmZmZmZddlm	Z	ddl
mZmZddl
mZejZejZejZejjZejjZejjZejjZej�Zejdd�ejdd	�ejdd
�ejdd�ejdd�ejdd
�ejdd�ejdd�ejdd�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�Zd	d
�Zdd�Zd
d�Zdd�Z	dd�Z
dd�Zdd�ZdS)�ElementInfo�
_attr_info�_model�tagNameNcCs||_g|_||_dS)N)rrr)�selfr�model�r�,/usr/lib64/python3.6/xml/dom/expatbuilder.py�__init__?szElementInfo.__init__cCs|j|j|jfS)N)rrr)rrrr�__getstate__DszElementInfo.__getstate__cCs|\|_|_|_dS)N)rrr)r�staterrr�__setstate__GszElementInfo.__setstate__cCsJxB|jD]8}|d|kr|d}|ddkr4tdSt|dSqWtjS)N��r�(r���r!)r�
_typeinfo_mapr�_no_type)r�aname�info�trrr�getAttributeTypeJszElementInfo.getAttributeTypecCstjS)N)rr#)r�namespaceURI�	localNamerrr�getAttributeTypeNSTszElementInfo.getAttributeTypeNScCs,|jr$|jd}|tjjtjjfkSdSdS)NrF)rrrZ
XML_CTYPE_ANYZXML_CTYPE_MIXED)r�typerrr�isElementContentWs

zElementInfo.isElementContentcCs |jr|jdtjjkSdSdS)NrF)rrrZXML_CTYPE_EMPTY)rrrr�isEmpty_szElementInfo.isEmptycCs,x&|jD]}|d|kr|ddkSqWdS)NrrrFr!)r)rr$r%rrr�isIdeszElementInfo.isIdcCs|j||f�S)N)r.)rZeuriZenameZaurir$rrr�isIdNSkszElementInfo.isIdNS)rrr)N)
�__name__�
__module__�__qualname__�	__slots__rrrr'r*r,r-r.r/rrrrr<s

rcCs|j||�S)N)�_intern_setdefault)�builder�srrr�_internosr7cCs�d|kst�|jd�}|j}t|�dkr^|\}}}|||�}d||f}|||�}|||�}n4t|�dkr�|\}}t}|||�}}ntd|��|||�|||fS)N� �z%s:%srz4Unsupported syntax: spaces in URIs not supported: %r)�AssertionError�splitr4�lenr�
ValueError)r5�name�parts�intern�uri�	localname�prefix�qnamerrr�_parse_ns_namers



rEc@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|dkrtj�}||_|jjdk	r2t|jj�|_nd|_t|_d|_|j	�dS)N)
rZOptions�_options�filter�FilterVisibilityController�_filterr�_finish_start_element�_parser�reset)r�optionsrrrr�szExpatBuilder.__init__cCstj�S)zCreate a new parser object.)r�ParserCreate)rrrr�createParser�szExpatBuilder.createParsercCsF|js@|j�|_|jjj|_d|j_d|j_d|j_|j|j�|jS)z7Return the parser object, creating a new one if needed.T)	rLrPr@�
setdefaultr4Zbuffer_textZordered_attributesZspecified_attributes�install)rrrr�	getParser�s
zExpatBuilder.getParsercCs,tjtdd�|_|j|_|jj|_d|_dS)z6Free all data structures used during DOM construction.NF)�theDOMImplementationZcreateDocumentr�document�curNode�
_elem_info�_cdata)rrrrrM�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�ProcessingInstructionHandlerrGr�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�parserrrrrR�s$
zExpatBuilder.installcCs�|j�}d}yLx:|jd�}|s P|j|d�|rB|jjrB|j|�d}qW|jdd�Wntk
rlYnX|j}|j�d|_|S)	zIParse a document from a file object, returning the document
        node.T�irF�Ni@)	rS�read�ParserU�documentElement�
_setup_subset�ParseEscaperMrL)r�filertZfirst_buffer�buffer�docrrr�	parseFile�s$

zExpatBuilder.parseFilecCsP|j�}y|j|d�|j|�Wntk
r6YnX|j}|j�d|_|S)z<Parse a document from a string, returning the document node.TN)rSrxrzr{rUrMrL)r�stringrtr~rrr�parseString�szExpatBuilder.parseStringcCs.|jjr*t�}|j|�|j�}||jj_dS)z/Load the internal subset if there might be one.N)rU�doctype�InternalSubsetExtractorr��	getSubset�internalSubset)rr}Z	extractor�subsetrrrrz�s

zExpatBuilder._setup_subsetcCs�|jjj|||�}|j|_t|j|�||j_|jrj|jj|�tkrjd|j_|jj	d=d}d|j
_d|j
_|r�|dk	r�g|j
_g|j_d|j
_d|j
_|j|j
_dS)Nr���)rU�implementationZcreateDocumentType�
ownerDocumentr	r�rJ�
acceptNode�
FILTER_REJECT�
childNodesrLrbrdr�_seq�	notationsrgr`�end_doctype_decl_handler�EndDoctypeDeclHandler)rZdoctypeName�systemId�publicId�has_internal_subsetr�rrrrY�s$

z'ExpatBuilder.start_doctype_decl_handlercCs2|jjr|j|j_|j|j_|jp&|js.t	|_
dS)N)rGrerfrLrgr_r`rWrJr�_finish_end_element)rrrrr�s


z%ExpatBuilder.end_doctype_decl_handlercCs@|jj||�}t|j|�|jr<|jj|�tkr<|jj|�dS)N)rUZcreateProcessingInstructionr	rVrJr�r��removeChild)r�target�data�noderrrr_szExpatBuilder.pi_handlercCs�|jj}|jrH|jr4|djtkr4|dj|�dS|jj|�}d|_nD|rv|djt	krv|d}|j
|}||_
dStj�}||_
|j|_
t|j|�dS)NrTr�r�r�r�)rVr�rX�_cdata_continue�nodeType�CDATA_SECTION_NODEZ
appendDatarUZcreateCDATASection�	TEXT_NODEr�r�Textr�r	)rr�r�r��valuerrrrls"
z)ExpatBuilder.character_data_handler_cdatacCs^|jj}|r2|djtkr2|d}|j||_dStj�}|j||_|j|_t	|j|�dS)Nrr�r�)
rVr�r�r�r�rr�rUr�r	)rr�r�r�rrrrn&sz#ExpatBuilder.character_data_handlerc
Cs�|rdS|jjsdS|jj||||�}|dk	rF|jj|�}	|jj|	�|jjjjj|�|j	r||j	j
|�tkr||jjjjd=dS)Nrr�)rGrrUZ_create_entityZcreateTextNoder��appendr�r�rJr�r�)
rZ
entityNameZis_parameter_entityr��baser�r��notationNamer��childrrrra1s
z ExpatBuilder.entity_decl_handlercCsJ|jj|||�}|jjjjj|�|jrF|jj|�tkrF|jjjjd=dS)Nrr�)	rUZ_create_notationr�r�r�r�rJr��
FILTER_ACCEPT)rr�r�r�r�r�rrrrcCsz"ExpatBuilder.notation_decl_handlercCs>|jj|�}t|j|�|jr:|jj|�tkr:|jj|�dS)N)rUZ
createCommentr	rVrJr�r�r�)rr�r�rrrrfIszExpatBuilder.comment_handlercCsd|_d|_dS)NTF)rXr�)rrrrrhOsz(ExpatBuilder.start_cdata_section_handlercCsd|_d|_dS)NF)rXr�)rrrrrjSsz&ExpatBuilder.end_cdata_section_handlercCsdS)Nrr)r�contextr�r�r�rrrroWsz(ExpatBuilder.external_entity_ref_handlercCs4|jdkr|jrt|_|j|j�_|j||�dS)N)rJrWrr��start_element_handlerrSr\)rr>�
attributesrrrr[Zsz"ExpatBuilder.first_element_handlercCs�|jj|�}t|j|�||_|rtxPtdt|�d�D]<}tj||tdt	�}||d}||_
|j|_t||�q4W||jj
k	r�|j|�dS)Nrrr)rUZ
createElementr	rV�ranger<r�Attrrrr�r�r
ryrK)rr>r�r��i�ar�rrrr�`sz"ExpatBuilder.start_element_handlercCsj|jrf||jjkrdS|jj|�}|tkr4t|�n|tkrFt|�ndS|j|_	|jj
|�|j�dS)N)rJrUry�startContainerr��Rejecter�FILTER_SKIP�Skipper�
parentNoderVr��unlink)rr�ZfiltrrrrKqs

z"ExpatBuilder._finish_start_elementcCs|j}|j|_|j|�dS)N)rVr�r�)rr>rVrrrr]�sz ExpatBuilder.end_element_handlercCs\|jj|j�}|r|j||�|jrX||jjkr4dS|jj|�tkrX|j	j
|�|j�dS)N)rW�getr�_handle_white_text_nodesrJrUryr�r�rVr�r�)rrVr%rrrr��sz ExpatBuilder._finish_end_elementcCsf|jjs|j�rdSg}x.|jD]$}|jtkr"|jj�r"|j|�q"Wx|D]}|j	|�qPWdS)N)
rGZwhitespace_in_element_contentr,r�r�r�r��stripr�r�)rr�r%�Lr�rrrr��s

z%ExpatBuilder._handle_white_text_nodescCs>|jj|�}|dkr&t||�|j|<n|jdks4t�||_dS)N)rWr�rrr:)rr>rr%rrrrr�s
z!ExpatBuilder.element_decl_handlerc	CsF|jj|�}|dkr&t|�}||j|<|jjd|dd|d||g�dS)Nr)rWr�rrr�)r�elemr>r+�defaultZrequiredr%rrrrs�s
z!ExpatBuilder.attlist_decl_handlercCs2||j_||j_|dkr.|r&d|j_nd|j_dS)NrTF)rU�version�encoding�
standalone)rr�r�r�rrrrq�s
zExpatBuilder.xml_decl_handler)N) r0r1r2�__doc__rrPrSrMrRrr�rzrYr�r_rlrnrarcrfrhrjror[r�rKr]r�r�rrrsrqrrrrrF�s:

rFc@s�eZdZdZd
Zdd�Zdd�Zdd�Zej	e
jeje
j
eje
jeje
jeje
jeje
jeje
jeje
jeje
jeje
jeje
jej e
j!iZ"d	S)rIzoWrapper around a DOMBuilderFilter which implements the checks
    to make the whatToShow filter attribute work.rHcCs
||_dS)N)rH)rrHrrrr�sz#FilterVisibilityController.__init__cCsT|j|j}|jj|@rL|jj|�}|tkr0t�|tkrHtdt	|���|St
SdS)Nz)startContainer() returned illegal value: )�_nodetype_maskr�rH�
whatToShowr��FILTER_INTERRUPTr{�_ALLOWED_FILTER_RETURNSr=�reprr�)rr��mask�valrrrr��sz)FilterVisibilityController.startContainercCs�|j|j}|jj|@r�|jj|�}|tkr0t�|tkrd|j}x |j	dd�D]}|j
|�qNWtS|tkr|t
dt|���|StSdS)Nz%acceptNode() returned illegal value: )r�r�rHr�r�r�r{r�r�r�ZappendChildr�r�r=r�r�)rr�r�r��parentr�rrrr��sz%FilterVisibilityController.acceptNodeN)rH)#r0r1r2r�r3rr�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�rrrrrI�s"
rIc@seZdZdZdd�ZdS)	�FilterCrutch�_builder�_level�
_old_start�_old_endcCs6d|_||_|j}|j|_|j|_|j|_|j|_dS)Nr)	r�r�rLr\r�r^r�r�r])rr5rtrrrrszFilterCrutch.__init__N)r�r�r�r�)r0r1r2r3rrrrrr�sr�c@s(eZdZfZdd�Zdd�Zdd�ZdS)r�cCs0tj||�|j}xdD]}t||d�qWdS)Nr`rgrmrirkrp)r`rgrmrirkrp)r�rrL�setattr)rr5rtr>rrrrszRejecter.__init__cGs|jd|_dS)Nr)r�)r�argsrrrr�szRejecter.start_element_handlercGs@|jdkr0|jj}|jj|�|j|_|j|_n|jd|_dS)Nrr)r�r�rLrRr�r\r�r^)rr�rtrrrr] s

zRejecter.end_element_handlerN)r0r1r2r3rr�r]rrrrr�sr�c@s eZdZfZdd�Zdd�ZdS)r�cGs.|jj}|j|�|jj|k	r*|jd|_dS)Nr)r�rVr�r�)rr�r�rrrr�-s
zSkipper.start_element_handlercGsD|jdkr*|j|jj_|j|jj_d|_n|jd|_|j|�dS)Nrr)r�r�r�rLr\r�r^)rr�rrrr]3s
zSkipper.end_element_handlerN)r0r1r2r3r�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|_||_tj||�dS)N)r�r��originalDocumentr�r�rFr)rr�rNrrrr[s
zFragmentBuilder.__init__cCstj|�d|_dS)N)rFrM�fragment)rrrrrMds
zFragmentBuilder.resetcCs|j|j��S)zRParse a document fragment from a file object, returning the
        fragment node.)r�rw)rr|rrrrhszFragmentBuilder.parseFilec		Cs�||_|j�}|jj}d}|rV|jp*|j�}|jrDd|j|jf}qZ|jrZd|j}nd}|j�}t	|||f}y|j
|d�Wn|j��YnX|j}|j�|S)zMParse a document fragment from a string, returning the
        fragment node.rvzPUBLIC "%s" "%s"zSYSTEM "%s"r)
�_sourcerSr�r�r��_getDeclarationsr�r��_getNSattrs�_FRAGMENT_BUILDER_TEMPLATErxrMr�)	rr�rtr�Zidentr�ZnsattrsrUr�rrrr�ms,zFragmentBuilder.parseStringcCs|jjj}d}|�rxbt|jj�D]R}|jj|�}|r>|d}d||jf}|jrfd||j|j	f}q"d||j	f}q"Wx�t|j
j�D]�}|j
j|�}|r�|d}d||jf}|jr�d||j|j	f}n&|j	r�d||j	f}nd	||jjf}|j
�rd
||j
f}|d}q�W|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.
        rvz
  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�r6r�Znotationr
rrrr��s6
z FragmentBuilder._getDeclarationscCsdS)Nrvr)rrrrr��szFragmentBuilder._getNSattrscCs~|tkrh|j}|j}|jj|�}|j|_|jj�|_|j|_z|j|j	d�Wd||_||_d|_	XdSt
j|||||�SdS)Nrr�)�$_FRAGMENT_BUILDER_INTERNAL_SYSTEM_IDrUrVrLZExternalEntityParserCreater�ZcreateDocumentFragmentr�rxr�rFro)rr�r�r�r�Zold_documentZold_cur_nodertrrrro�sz+FragmentBuilder.external_entity_ref_handler)N)r0r1r2r�rrMrr�r�r�rorrrrr�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|_dS)N)�_ns_ordered_prefixes)rrrr�_initNamespaces�szNamespaces._initNamespacescCstjdd�}d|_|S)z'Create a new namespace-handling parser.r8)Znamespace_separatorT)rrOZnamespace_prefixes)rrtrrrrP�szNamespaces.createParsercCs tj||�|jjr|j|_dS)z.Insert the namespace-handlers onto the parser.N)rFrRrGZnamespace_declarations�start_namespace_decl_handlerZStartNamespaceDeclHandler)rrtrrrrR�szNamespaces.installcCs|jj||f�dS)z/Push this namespace declaration on our storage.N)r�r�)rrCrArrrr��sz'Namespaces.start_namespace_decl_handlercCs�d|krt||�\}}}}nt}|}d}t}tj||||�}|j|_t|j|�||_|j	r�xZ|j	D]P\}}|r�tj
t|d|�t|d�}ntj
dtdt�}||_
|j|_t||�qdW|j	dd�=|�r�|j�|j}	|j}
x�tdt|�d�D]�}||}||d}
d|k�rJt||�\}}}}tj
||||�}||	|<||
||f<n$tj
|t|t�}||	|<||
t|f<|j|_|
|_
||_q�WdS)Nr8zxmlns:�xmlnsrrr)rErrrZElementrUr�r	rVr�r�r7rr�r
Z_ensure_attributes�_attrs�_attrsNSr�r<ZownerElement)rr>r�rArBrCrDr�r�r�r�r�r$r�rrrr��sP
z Namespaces.start_element_handlercCs�|j}d|krHt||�\}}}}|j|kr>|j|kr>|j|ksltd��n$|j|ksZtd��|jtksltd��|j|_|j	|�dS)Nr8z$element stack messed up! (namespace)z&element stack messed up - bad nodeNamez*element stack messed up - bad namespaceURI)
rVrEr(r)rCr:r�rr�r�)rr>rVrArBrCrDrrrr]s

zNamespaces.end_element_handlerN)
r0r1r2r�r�rPrRr�r�r]rrrrr��s5r�c@seZdZdZdd�ZdS)�ExpatBuilderNSz*Document builder that supports namespaces.cCstj|�|j�dS)N)rFrMr�)rrrrrM)s
zExpatBuilderNS.resetN)r0r1r2r�rMrrrrr�&sr�c@s eZdZdZdd�Zdd�ZdS)�FragmentBuilderNSz*Fragment builder that supports namespaces.cCstj|�|j�dS)N)r�rMr�)rrrrrM1s
zFragmentBuilderNS.resetcCs�d}|j}g}xv|r�t|d�r|x\|jj�D]N\}}||kr<q*|j|�|rTd|}nd}|rld|||f}q*d||f}q*W|j}qW|S)zNReturn string of namespace attributes from this element and
        ancestors.rv�_ns_prefix_urizxmlns:r�z%s
    %s='%s'z %s='%s')r��hasattrr��itemsr�r�)r�attrsr�r�rCrAZdeclnamerrrr�5s"



zFragmentBuilderNS._getNSattrsN)r0r1r2r�rMr�rrrrr�.sr�c@seZdZdZdS)r{zEException raised to short-circuit parsing in InternalSubsetExtractor.N)r0r1r2r�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*ytj||�Wntk
r$YnXdS)N)rFrr{)rr|rrrr`sz!InternalSubsetExtractor.parseFilecCs*ytj||�Wntk
r$YnXdS)N)rFr�r{)rr�rrrr�fsz#InternalSubsetExtractor.parseStringcCs|j|_|j|_dS)N)rYrZr�r\)rrtrrrrRlszInternalSubsetExtractor.installcCs0|r&|j�}g|_|jj|_|j|_nt��dS)N)rSr�r�ZDefaultHandlerr�r�r{)rr>r�r�r�rtrrrrYps

z2InternalSubsetExtractor.start_doctype_decl_handlercCs,dj|j�jdd�jdd�}||_t��dS)Nrvz
�
�
)�joinr��replacer{)rr6rrrr�zsz0InternalSubsetExtractor.end_doctype_decl_handlercCs
t��dS)N)r{)rr>r�rrrr�sz-InternalSubsetExtractor.start_element_handler)r0r1r2r�r�r�rr�rRrYr�r�rrrrr�Ws
r�Tc	CsL|rt�}nt�}t|t�r>t|d��}|j|�}WdQRXn
|j|�}|S)z{Parse a document, returning the resulting Document node.

    'file' may be either a file name or an open file object.
    �rbN)r�rF�
isinstance�str�openr)r|�
namespacesr5�fp�resultrrr�parse�s

r�cCs|rt�}nt�}|j|�S)zOParse a document from a string, returning the resulting
    Document node.
    )r�rFr�)r�r�r5rrrr��sr�c	CsP|rt|�}nt|�}t|t�rBt|d��}|j|�}WdQRXn
|j|�}|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�N)r�r�r�r�r�r)r|r�r�r5r�r�rrr�
parseFragment�s


r�cCs |rt|�}nt|�}|j|�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�r5rrr�parseFragmentString�s
r�cCs|jrt|�St|�SdS)z,Create a builder based on an Options object.N)r�r�rF)rNrrr�makeBuilder�sr�)T)T)T)T)3r�Zxml.domrrrrrrZxml.parsersrZxml.dom.minidomr	r
Zxml.dom.NodeFilterrr�r�r�ZDOMBuilderFilterr�r�r�r�ZgetDOMImplementationrTZTypeInfor"�objectrr7rErFr�rIr�r�r�r�r�r�r�r�r��	Exceptionr{r�r�r�r�r�r�rrrr�<module>s^







3C
:u_%,



PK�"[.�o�\\/dom/__pycache__/NodeFilter.cpython-36.opt-2.pycnu�[���3


 \��@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.6/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>sPK�"[Wd!)))),dom/__pycache__/pulldom.cpython-36.opt-1.pycnu�[���3


 \�-�@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|_y|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.6/xml/dom/pulldom.py�__init__s

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

zPullDOM.startPrefixMappingcCs|jj�|_dS)N)rrr)rr%rrr�endPrefixMapping0szPullDOM.endPrefixMappingcCs�d}t|dd�}|dk	r>x|D]\}}||j||f<qWg|_|\}}	|r�|dkrr|j|}
|
rn|
d|	}n|	}|jr�|jj||�}q�|j||�}n |jr�|jj|	�}n|jd|	�}x�|j�D]�\}}|\}}
||k�r
|
dkr�|
}nd|
}|jj	||�}|j
|�nX|�rL|j|}
|
�r.|
d|
}n|
}|jj	||�}|j
|�n|jj|
�}|j|�||_
q�Wt|fdg|jd<|jd|_|j|�dS)Nzhttp://www.w3.org/2000/xmlns/r!�:r"zxmlns:r
)�getattrZ_attrsr!r�documentZcreateElementNS�
buildDocument�
createElement�itemsZcreateAttributeNSZsetAttributeNodeNS�createAttribute�setAttributeNode�valuerrr)r�name�tagName�attrsZ	xmlns_uriZxmlns_attrs�anamer1r&Z	localnamer%�nodeZa_uriZa_localnameZqname�attrrrr�startElementNS3sP




zPullDOM.startElementNScCs&t|j�fdg|jd<|jd|_dS)Nr
)rrr)rr2r3rrr�endElementNSlszPullDOM.endElementNScCs~|jr|jj|�}n|jd|�}x0|j�D]$\}}|jj|�}||_|j|�q*Wt|fdg|jd<|jd|_|j	|�dS)Nr
)
r+r-r,r.r/r1r0rrr)rr2r4r6r5r1r7rrr�startElementpszPullDOM.startElementcCs&t|j�fdg|jd<|jd|_dS)Nr
)rrr)rr2rrr�
endElementszPullDOM.endElementcCsN|jr2|jj|�}t|fdg|jd<|jd|_nt|fdg}|jj|�dS)Nr
)r+�
createCommentrrrr)r�sr6�eventrrr�comment�szPullDOM.commentcCsR|jr4|jj||�}t|fdg|jd<|jd|_nt||fdg}|jj|�dS)Nr
)r+�createProcessingInstructionrrrr)r�target�datar6r>rrr�processingInstruction�szPullDOM.processingInstructioncCs.|jj|�}t|fdg|jd<|jd|_dS)Nr
)r+�createTextNoderr)r�charsr6rrr�ignorableWhitespace�szPullDOM.ignorableWhitespacecCs.|jj|�}t|fdg|jd<|jd|_dS)Nr
)r+rDr	r)rrEr6rrr�
characters�szPullDOM.characterscCs$|jdkr ddl}|jjjj|_dS)Nr)rZxml.dom.minidomZdomZminidomZDocument�implementation)rrrrr�
startDocument�s
zPullDOM.startDocumentc	Cs�|jj||d�}||_t|fdg|jd<|jd|_|j|�x�|jD]�}|ddtkr�|d\}}}|jj||�}t|f|d<nD|ddt	kr�|jj
|dd�}t	|f|d<ntd|dd��||jd<||_qFWd|_|jS)Nr
rzUnknown pending event )
rZcreateDocumentr+rrrrrr@rr<�AssertionErrorZ
firstChild)	rr&Ztagnamer6�e�_rArB�nrrrr,�s$


zPullDOM.buildDocumentcCs t|jfdg|jd<|j�dS)Nr
)rr+rr)rrrr�endDocument�szPullDOM.endDocumentcCs
d|_dS)z.clear(): Explicitly release parsing structuresN)r+)rrrr�clear�sz
PullDOM.clear)N)�__name__�
__module__�__qualname__rr+rrr r'r(r8r9r:r;r?rCrFrGrIr,rNrOrrrrr

s&
9		r
c@s$eZdZdd�Zdd�Zdd�ZdS)�ErrorHandlercCst|�dS)N)�print)r�	exceptionrrr�warning�szErrorHandler.warningcCs|�dS)Nr)rrUrrr�error�szErrorHandler.errorcCs|�dS)Nr)rrUrrr�
fatalError�szErrorHandler.fatalErrorN)rPrQrRrVrWrXrrrrrS�srSc@s\eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�ZdS)�DOMEventStreamcCs2||_||_||_t|jd�s&|j|_|j�dS)N�feed)�stream�parser�bufsizer#�_slurp�getEvent�reset)rr[r\r]rrrr�szDOMEventStream.__init__cCs.t�|_|jjtjjjd�|jj|j�dS)Nr
)	r
�pulldomr\Z
setFeaturer�saxZhandlerZfeature_namespacesZsetContentHandler)rrrrr`�szDOMEventStream.resetcCs|j�}|r|St�dS)N)r_�
IndexError)r�pos�rcrrr�__getitem__�szDOMEventStream.__getitem__cCs|j�}|r|St�dS)N)r_�
StopIteration)rrerrr�__next__�szDOMEventStream.__next__cCs|S)Nr)rrrr�__iter__�szDOMEventStream.__iter__cCsp|j�}|g}x\|rj|\}}||kr(dS|tkr>|dj|�|tkrR|j|�n|tkr`|d=|j�}qWdS)Nr
rr)r_r�appendChildrr)rr6r>�parents�tokenZcur_noderrr�
expandNode�szDOMEventStream.expandNodecCs�|jjds|jj|j_x<|jjdsT|jj|j�}|sF|jj�dS|jj|�qW|jjdd}|jjdd|jjd<|S)Nr
r)	rarrr[�readr]r\�closerZ)r�bufrerrrr_�s
zDOMEventStream.getEventcCs|jj|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).
        )r\�parser[�_emitr_)rrrrr^szDOMEventStream._slurpcCs,|jjdd}|jjdd|jjd<|S)zn Fallback replacement for getEvent() that emits
            the events that _slurp() read previously.
        r
r)rar)rrerrrrrszDOMEventStream._emitcCs|jj�|`d|_d|_dS)z+clear(): Explicitly release parsing objectsN)rarOr\r[)rrrrrOs
zDOMEventStream.clearN)
rPrQrRrr`rfrhrirmr_r^rrrOrrrrrY�s
rYc@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�SAX2DOMcCs2tj||||�|jd}|jd}|j|�dS)Nr
�r���)r
r8rrj)rr2r3r4�curNode�
parentNoderrrr8#s

zSAX2DOM.startElementNScCs0tj|||�|jd}|jd}|j|�dS)Nr
rtrru)r
r:rrj)rr2r4rvrwrrrr:)s

zSAX2DOM.startElementcCs4tj|||�|jdd}|jd}|j|�dS)Nrr
r)r
rCrrrj)rrArBr6rwrrrrC/s
zSAX2DOM.processingInstructioncCs2tj||�|jdd}|jd}|j|�dS)Nrr
r)r
rFrrrj)rrEr6rwrrrrF5s
zSAX2DOM.ignorableWhitespacecCs2tj||�|jdd}|jd}|j|�dS)Nrr
r)r
rGrrrj)rrEr6rwrrrrG;s
zSAX2DOM.charactersN)rPrQrRr8r:rCrFrGrrrrrs!s
rsrt��cCs@|dkrt}t|t�r"t|d�}n|}|s4tjj�}t|||�S)N�rb)�default_bufsize�
isinstance�str�openrrb�make_parserrY)Zstream_or_stringr\r]r[rrrrqDs

rqcCs6ddlm}t|�}||�}|s*tjj�}t|||�S)Nr)�StringIO)�ior��lenrrbrrY)�stringr\r�r]rprrr�parseStringOs
r�i@i�?)NN)N)Zxml.saxrZxml.sax.handlerrrrrrrrr	rbZContentHandlerr
rSrYrsr{rqr�rrrr�<module>s"8U!
PK�"[�M+�g�g1dom/__pycache__/expatbuilder.cpython-36.opt-1.pycnu�[���3


 \���@sdZddlmZmZmZddlmZmZmZddlm	Z	ddl
mZmZddl
mZejZejZejZejjZejjZejjZejjZej�Zejdd�ejdd	�ejdd
�ejdd�ejdd�ejdd
�ejdd�ejdd�ejdd�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�Zd	d
�Zdd�Zd
d�Zdd�Z	dd�Z
dd�Zdd�ZdS)�ElementInfo�
_attr_info�_model�tagNameNcCs||_g|_||_dS)N)rrr)�selfr�model�r�,/usr/lib64/python3.6/xml/dom/expatbuilder.py�__init__?szElementInfo.__init__cCs|j|j|jfS)N)rrr)rrrr�__getstate__DszElementInfo.__getstate__cCs|\|_|_|_dS)N)rrr)r�staterrr�__setstate__GszElementInfo.__setstate__cCsJxB|jD]8}|d|kr|d}|ddkr4tdSt|dSqWtjS)N��r�(r���r!)r�
_typeinfo_mapr�_no_type)r�aname�info�trrr�getAttributeTypeJszElementInfo.getAttributeTypecCstjS)N)rr#)rZnamespaceURIZ	localNamerrr�getAttributeTypeNSTszElementInfo.getAttributeTypeNScCs,|jr$|jd}|tjjtjjfkSdSdS)NrF)rrrZ
XML_CTYPE_ANYZXML_CTYPE_MIXED)r�typerrr�isElementContentWs

zElementInfo.isElementContentcCs |jr|jdtjjkSdSdS)NrF)rrrZXML_CTYPE_EMPTY)rrrr�isEmpty_szElementInfo.isEmptycCs,x&|jD]}|d|kr|ddkSqWdS)NrrrFr!)r)rr$r%rrr�isIdeszElementInfo.isIdcCs|j||f�S)N)r,)rZeuriZenameZaurir$rrr�isIdNSkszElementInfo.isIdNS)rrr)N)
�__name__�
__module__�__qualname__�	__slots__rrrr'r(r*r+r,r-rrrrr<s

rcCs|j||�S)N)�_intern_setdefault)�builder�srrr�_internosr5cCs�|jd�}|j}t|�dkrR|\}}}|||�}d||f}|||�}|||�}n4t|�dkrz|\}}t}|||�}}ntd|��|||�|||fS)N� �z%s:%srz4Unsupported syntax: spaces in URIs not supported: %r)�splitr2�lenr�
ValueError)r3�name�parts�intern�uri�	localname�prefix�qnamerrr�_parse_ns_namers



rBc@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|dkrtj�}||_|jjdk	r2t|jj�|_nd|_t|_d|_|j	�dS)N)
rZOptions�_options�filter�FilterVisibilityController�_filterr�_finish_start_element�_parser�reset)r�optionsrrrr�szExpatBuilder.__init__cCstj�S)zCreate a new parser object.)r�ParserCreate)rrrr�createParser�szExpatBuilder.createParsercCsF|js@|j�|_|jjj|_d|j_d|j_d|j_|j|j�|jS)z7Return the parser object, creating a new one if needed.T)	rIrMr=�
setdefaultr2Zbuffer_textZordered_attributesZspecified_attributes�install)rrrr�	getParser�s
zExpatBuilder.getParsercCs,tjtdd�|_|j|_|jj|_d|_dS)z6Free all data structures used during DOM construction.NF)�theDOMImplementationZcreateDocumentr�document�curNode�
_elem_info�_cdata)rrrrrJ�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�ProcessingInstructionHandlerrDr�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�parserrrrrO�s$
zExpatBuilder.installcCs�|j�}d}yLx:|jd�}|s P|j|d�|rB|jjrB|j|�d}qW|jdd�Wntk
rlYnX|j}|j�d|_|S)	zIParse a document from a file object, returning the document
        node.T�irF�Ni@)	rP�read�ParserR�documentElement�
_setup_subset�ParseEscaperJrI)r�filerqZfirst_buffer�buffer�docrrr�	parseFile�s$

zExpatBuilder.parseFilecCsP|j�}y|j|d�|j|�Wntk
r6YnX|j}|j�d|_|S)z<Parse a document from a string, returning the document node.TN)rPrurwrxrRrJrI)r�stringrqr{rrr�parseString�szExpatBuilder.parseStringcCs.|jjr*t�}|j|�|j�}||jj_dS)z/Load the internal subset if there might be one.N)rR�doctype�InternalSubsetExtractorr~�	getSubset�internalSubset)rrzZ	extractor�subsetrrrrw�s

zExpatBuilder._setup_subsetcCs�|jjj|||�}|j|_t|j|�||j_|jrj|jj|�tkrjd|j_|jj	d=d}d|j
_d|j
_|r�|dk	r�g|j
_g|j_d|j
_d|j
_|j|j
_dS)Nr���)rR�implementationZcreateDocumentType�
ownerDocumentr	rrG�
acceptNode�
FILTER_REJECT�
childNodesrIr_rar�_seq�	notationsrdr]�end_doctype_decl_handler�EndDoctypeDeclHandler)rZdoctypeName�systemId�publicId�has_internal_subsetrrrrrV�s$

z'ExpatBuilder.start_doctype_decl_handlercCs2|jjr|j|j_|j|j_|jp&|js.t	|_
dS)N)rDrbrcrIrdr\r]rTrGr�_finish_end_element)rrrrr�s


z%ExpatBuilder.end_doctype_decl_handlercCs@|jj||�}t|j|�|jr<|jj|�tkr<|jj|�dS)N)rRZcreateProcessingInstructionr	rSrGr�r��removeChild)r�target�data�noderrrr\szExpatBuilder.pi_handlercCs�|jj}|jrH|jr4|djtkr4|dj|�dS|jj|�}d|_nD|rv|djt	krv|d}|j
|}||_
dStj�}||_
|j|_
t|j|�dS)NrTr�r�r�r�)rSr�rU�_cdata_continue�nodeType�CDATA_SECTION_NODEZ
appendDatarRZcreateCDATASection�	TEXT_NODEr�r�Textr�r	)rr�r�r��valuerrrris"
z)ExpatBuilder.character_data_handler_cdatacCs^|jj}|r2|djtkr2|d}|j||_dStj�}|j||_|j|_t	|j|�dS)Nrr�r�)
rSr�r�r�r�rr�rRr�r	)rr�r�r�rrrrk&sz#ExpatBuilder.character_data_handlerc
Cs�|rdS|jjsdS|jj||||�}|dk	rF|jj|�}	|jj|	�|jjjjj|�|j	r||j	j
|�tkr||jjjjd=dS)Nrr�)rDrrRZ_create_entityZcreateTextNoder��appendrr�rGr�r�)
rZ
entityNameZis_parameter_entityr��baser�r��notationNamer��childrrrr^1s
z ExpatBuilder.entity_decl_handlercCsJ|jj|||�}|jjjjj|�|jrF|jj|�tkrF|jjjjd=dS)Nrr�)	rRZ_create_notationrr�r�r�rGr��
FILTER_ACCEPT)rr�r�r�r�r�rrrr`Csz"ExpatBuilder.notation_decl_handlercCs>|jj|�}t|j|�|jr:|jj|�tkr:|jj|�dS)N)rRZ
createCommentr	rSrGr�r�r�)rr�r�rrrrcIszExpatBuilder.comment_handlercCsd|_d|_dS)NTF)rUr�)rrrrreOsz(ExpatBuilder.start_cdata_section_handlercCsd|_d|_dS)NF)rUr�)rrrrrgSsz&ExpatBuilder.end_cdata_section_handlercCsdS)Nrr)r�contextr�r�r�rrrrlWsz(ExpatBuilder.external_entity_ref_handlercCs4|jdkr|jrt|_|j|j�_|j||�dS)N)rGrTrr��start_element_handlerrPrY)rr;�
attributesrrrrXZsz"ExpatBuilder.first_element_handlercCs�|jj|�}t|j|�||_|rtxPtdt|�d�D]<}tj||tdt	�}||d}||_
|j|_t||�q4W||jj
k	r�|j|�dS)Nrrr)rRZ
createElementr	rS�ranger9r�Attrrrr�r�r
rvrH)rr;r�r��i�ar�rrrr�`sz"ExpatBuilder.start_element_handlercCsj|jrf||jjkrdS|jj|�}|tkr4t|�n|tkrFt|�ndS|j|_	|jj
|�|j�dS)N)rGrRrv�startContainerr��Rejecter�FILTER_SKIP�Skipper�
parentNoderSr��unlink)rr�ZfiltrrrrHqs

z"ExpatBuilder._finish_start_elementcCs|j}|j|_|j|�dS)N)rSr�r�)rr;rSrrrrZ�sz ExpatBuilder.end_element_handlercCs\|jj|j�}|r|j||�|jrX||jjkr4dS|jj|�tkrX|j	j
|�|j�dS)N)rT�getr�_handle_white_text_nodesrGrRrvr�r�rSr�r�)rrSr%rrrr��sz ExpatBuilder._finish_end_elementcCsf|jjs|j�rdSg}x.|jD]$}|jtkr"|jj�r"|j|�q"Wx|D]}|j	|�qPWdS)N)
rDZwhitespace_in_element_contentr*r�r�r�r��stripr�r�)rr�r%�Lr�rrrr��s

z%ExpatBuilder._handle_white_text_nodescCs0|jj|�}|dkr&t||�|j|<n||_dS)N)rTr�rr)rr;rr%rrrro�sz!ExpatBuilder.element_decl_handlerc	CsF|jj|�}|dkr&t|�}||j|<|jjd|dd|d||g�dS)Nr)rTr�rrr�)r�elemr;r)�defaultZrequiredr%rrrrp�s
z!ExpatBuilder.attlist_decl_handlercCs2||j_||j_|dkr.|r&d|j_nd|j_dS)NrTF)rR�version�encoding�
standalone)rr�r�r�rrrrn�s
zExpatBuilder.xml_decl_handler)N) r.r/r0�__doc__rrMrPrJrOr|r~rwrVr�r\rirkr^r`rcrergrlrXr�rHrZr�r�rorprnrrrrrC�s:

rCc@s�eZdZdZd
Zdd�Zdd�Zdd�Zej	e
jeje
j
eje
jeje
jeje
jeje
jeje
jeje
jeje
jeje
jeje
jej e
j!iZ"d	S)rFzoWrapper around a DOMBuilderFilter which implements the checks
    to make the whatToShow filter attribute work.rEcCs
||_dS)N)rE)rrErrrr�sz#FilterVisibilityController.__init__cCsT|j|j}|jj|@rL|jj|�}|tkr0t�|tkrHtdt	|���|St
SdS)Nz)startContainer() returned illegal value: )�_nodetype_maskr�rE�
whatToShowr��FILTER_INTERRUPTrx�_ALLOWED_FILTER_RETURNSr:�reprr�)rr��mask�valrrrr��sz)FilterVisibilityController.startContainercCs�|j|j}|jj|@r�|jj|�}|tkr0t�|tkrd|j}x |j	dd�D]}|j
|�qNWtS|tkr|t
dt|���|StSdS)Nz%acceptNode() returned illegal value: )r�r�rEr�r�r�rxr�r�r�ZappendChildr�r�r:r�r�)rr�r�r��parentr�rrrr��sz%FilterVisibilityController.acceptNodeN)rE)#r.r/r0r�r1rr�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�rrrrrF�s"
rFc@seZdZdZdd�ZdS)	�FilterCrutch�_builder�_level�
_old_start�_old_endcCs6d|_||_|j}|j|_|j|_|j|_|j|_dS)Nr)	r�r�rIrYr�r[r�r�rZ)rr3rqrrrrszFilterCrutch.__init__N)r�r�r�r�)r.r/r0r1rrrrrr�sr�c@s(eZdZfZdd�Zdd�Zdd�ZdS)r�cCs0tj||�|j}xdD]}t||d�qWdS)Nr]rdrjrfrhrm)r]rdrjrfrhrm)r�rrI�setattr)rr3rqr;rrrrszRejecter.__init__cGs|jd|_dS)Nr)r�)r�argsrrrr�szRejecter.start_element_handlercGs@|jdkr0|jj}|jj|�|j|_|j|_n|jd|_dS)Nrr)r�r�rIrOr�rYr�r[)rr�rqrrrrZ s

zRejecter.end_element_handlerN)r.r/r0r1rr�rZrrrrr�sr�c@s eZdZfZdd�Zdd�ZdS)r�cGs.|jj}|j|�|jj|k	r*|jd|_dS)Nr)r�rSr�r�)rr�r�rrrr�-s
zSkipper.start_element_handlercGsD|jdkr*|j|jj_|j|jj_d|_n|jd|_|j|�dS)Nrr)r�r�r�rIrYr�r[)rr�rrrrZ3s
zSkipper.end_element_handlerN)r.r/r0r1r�rZrrrrr�*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|_||_tj||�dS)N)r�r��originalDocumentr�r�rCr)rr�rKrrrr[s
zFragmentBuilder.__init__cCstj|�d|_dS)N)rCrJ�fragment)rrrrrJds
zFragmentBuilder.resetcCs|j|j��S)zRParse a document fragment from a file object, returning the
        fragment node.)r~rt)rryrrrr|hszFragmentBuilder.parseFilec		Cs�||_|j�}|jj}d}|rV|jp*|j�}|jrDd|j|jf}qZ|jrZd|j}nd}|j�}t	|||f}y|j
|d�Wn|j��YnX|j}|j�|S)zMParse a document fragment from a string, returning the
        fragment node.rszPUBLIC "%s" "%s"zSYSTEM "%s"r)
�_sourcerPr�rr��_getDeclarationsr�r��_getNSattrs�_FRAGMENT_BUILDER_TEMPLATErurJr�)	rr}rqrZidentr�ZnsattrsrRr�rrrr~ms,zFragmentBuilder.parseStringcCs|jjj}d}|�rxbt|jj�D]R}|jj|�}|r>|d}d||jf}|jrfd||j|j	f}q"d||j	f}q"Wx�t|j
j�D]�}|j
j|�}|r�|d}d||jf}|jr�d||j|j	f}n&|j	r�d||j	f}nd	||jjf}|j
�rd
||j
f}|d}q�W|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.
        rsz
  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�rr�r�Zlength�itemZnodeNamer�r�rZ
firstChildr�r�)rrr4r�Znotationr
rrrr��s6
z FragmentBuilder._getDeclarationscCsdS)Nrsr)rrrrr��szFragmentBuilder._getNSattrscCs~|tkrh|j}|j}|jj|�}|j|_|jj�|_|j|_z|j|j	d�Wd||_||_d|_	XdSt
j|||||�SdS)Nrr�)�$_FRAGMENT_BUILDER_INTERNAL_SYSTEM_IDrRrSrIZExternalEntityParserCreater�ZcreateDocumentFragmentr�rur�rCrl)rr�r�r�r�Zold_documentZold_cur_noderqrrrrl�sz+FragmentBuilder.external_entity_ref_handler)N)r.r/r0r�rrJr|r~r�r�rlrrrrr�Rs
	$r�c@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�
Namespacesz7Mix-in class for builders; adds support for namespaces.cCs
g|_dS)N)�_ns_ordered_prefixes)rrrr�_initNamespaces�szNamespaces._initNamespacescCstjdd�}d|_|S)z'Create a new namespace-handling parser.r6)Znamespace_separatorT)rrLZnamespace_prefixes)rrqrrrrM�szNamespaces.createParsercCs tj||�|jjr|j|_dS)z.Insert the namespace-handlers onto the parser.N)rCrOrDZnamespace_declarations�start_namespace_decl_handlerZStartNamespaceDeclHandler)rrqrrrrO�szNamespaces.installcCs|jj||f�dS)z/Push this namespace declaration on our storage.N)r�r�)rr@r>rrrr��sz'Namespaces.start_namespace_decl_handlercCs�d|krt||�\}}}}nt}|}d}t}tj||||�}|j|_t|j|�||_|j	r�xZ|j	D]P\}}|r�tj
t|d|�t|d�}ntj
dtdt�}||_
|j|_t||�qdW|j	dd�=|�r�|j�|j}	|j}
x�tdt|�d�D]�}||}||d}
d|k�rJt||�\}}}}tj
||||�}||	|<||
||f<n$tj
|t|t�}||	|<||
t|f<|j|_|
|_
||_q�WdS)Nr6zxmlns:�xmlnsrrr)rBrrrZElementrRr�r	rSr�r�r5rr�r
Z_ensure_attributes�_attrs�_attrsNSr�r9ZownerElement)rr;r�r>r?r@rAr�r�r�r�r�r$r�rrrr��sP
z Namespaces.start_element_handlerN)	r.r/r0r�r�rMrOr�r�rrrrr��s/r�c@seZdZdZdd�ZdS)�ExpatBuilderNSz*Document builder that supports namespaces.cCstj|�|j�dS)N)rCrJr�)rrrrrJ)s
zExpatBuilderNS.resetN)r.r/r0r�rJrrrrr�&sr�c@s eZdZdZdd�Zdd�ZdS)�FragmentBuilderNSz*Fragment builder that supports namespaces.cCstj|�|j�dS)N)r�rJr�)rrrrrJ1s
zFragmentBuilderNS.resetcCs�d}|j}g}xv|r�t|d�r|x\|jj�D]N\}}||kr<q*|j|�|rTd|}nd}|rld|||f}q*d||f}q*W|j}qW|S)zNReturn string of namespace attributes from this element and
        ancestors.rs�_ns_prefix_urizxmlns:r�z%s
    %s='%s'z %s='%s')r��hasattrr��itemsr�r�)r�attrsr�r�r@r>Zdeclnamerrrr�5s"



zFragmentBuilderNS._getNSattrsN)r.r/r0r�rJr�rrrrr�.sr�c@seZdZdZdS)rxzEException raised to short-circuit parsing in InternalSubsetExtractor.N)r.r/r0r�rrrrrxSsrxc@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*ytj||�Wntk
r$YnXdS)N)rCr|rx)rryrrrr|`sz!InternalSubsetExtractor.parseFilecCs*ytj||�Wntk
r$YnXdS)N)rCr~rx)rr}rrrr~fsz#InternalSubsetExtractor.parseStringcCs|j|_|j|_dS)N)rVrWr�rY)rrqrrrrOlszInternalSubsetExtractor.installcCs0|r&|j�}g|_|jj|_|j|_nt��dS)N)rPr�r�ZDefaultHandlerr�r�rx)rr;r�r�r�rqrrrrVps

z2InternalSubsetExtractor.start_doctype_decl_handlercCs,dj|j�jdd�jdd�}||_t��dS)Nrsz
�
�
)�joinr��replacerx)rr4rrrr�zsz0InternalSubsetExtractor.end_doctype_decl_handlercCs
t��dS)N)rx)rr;r�rrrr�sz-InternalSubsetExtractor.start_element_handler)r.r/r0r�r�r�r|r~rOrVr�r�rrrrr�Ws
r�Tc	CsL|rt�}nt�}t|t�r>t|d��}|j|�}WdQRXn
|j|�}|S)z{Parse a document, returning the resulting Document node.

    'file' may be either a file name or an open file object.
    �rbN)r�rC�
isinstance�str�openr|)ry�
namespacesr3�fp�resultrrr�parse�s

r�cCs|rt�}nt�}|j|�S)zOParse a document from a string, returning the resulting
    Document node.
    )r�rCr~)r}r�r3rrrr~�sr~c	CsP|rt|�}nt|�}t|t�rBt|d��}|j|�}WdQRXn
|j|�}|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�N)r�r�r�r�r�r|)ryr�r�r3r�r�rrr�
parseFragment�s


r�cCs |rt|�}nt|�}|j|�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�r3rrr�parseFragmentString�s
r�cCs|jrt|�St|�SdS)z,Create a builder based on an Options object.N)r�r�rC)rKrrr�makeBuilder�sr�)T)T)T)T)3r�Zxml.domrrrrrrZxml.parsersrZxml.dom.minidomr	r
Zxml.dom.NodeFilterrr�r�r�ZDOMBuilderFilterr�r�r�r�ZgetDOMImplementationrQZTypeInfor"�objectrr5rBrCr�rFr�r�r�r�r�r�r�r�r��	Exceptionrxr�r�r~r�r�r�rrrr�<module>s^







3C
:u_%,



PK�"[���+dom/__pycache__/domreg.cpython-36.opt-1.pycnu�[���3


 \{
�@sDdZddlZddd�ZiZdd�Zdd	�Zdffd
d�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.6/xml/dom/domreg.py�registerDOMImplementations	rcCs&x |D]\}}|j||�sdSqWdS)zF_good_enough(dom, features) -> Return 1 if the dom offers the featuresr�)Z
hasFeature)�dom�features�f�vrrr�_good_enough sr
cCs�ddl}d}tj|�}|r2t|iidg�}|j�S|r@t|�Stjjrdd|j	krdt|j	dd�St
|t�rvt|�}x$tj
�D]}|�}t||�r�|Sq�WxDtj�D]8}yt|d�}Wntk
r�w�YnXt||�r�|Sq�Wtd��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}|j�}d}t|�}xp||kr�||}|ddkrDtd|f��|d}d}||krx||}|ddkrx|d}|}|j||f�qWt|�S)Nr�
0123456789zbad feature name: %rr)�split�len�
ValueError�append�tuple)�sr
�parts�iZlengthZfeature�versionrrrrrRs"
r)�__doc__rrrrr
rrrrrr�<module>s+PK�"[#�}P��3etree/__pycache__/cElementTree.cpython-36.opt-1.pycnu�[���3


 \R�@sddlTdS)�)�*N)Zxml.etree.ElementTree�rr�./usr/lib64/python3.6/xml/etree/cElementTree.py�<module>sPK�"[�A�3}}/etree/__pycache__/__init__.cpython-36.opt-1.pycnu�[���3


 \D�@sdS)N�rrr�*/usr/lib64/python3.6/xml/etree/__init__.py�<module>sPK�"[��xr5etree/__pycache__/ElementInclude.cpython-36.opt-1.pycnu�[���3


 \�@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.6/xml/etree/ElementInclude.pyr>src	Cs\|dkr.t|d��}tj|�j�}WdQRXn*|s6d}t|d|d��}|j�}WdQRX|S)N�xml�rbzUTF-8�r)�encoding)�openr�parseZgetroot�read)�hrefrr�file�datar	r	r
�default_loaderMsrcCsp|dkrt}d}�xX|t|�k�rj||}|jtk�r:|jd�}|jdd�}|dkr�|||�}|dkrvtd||f��tj|�}|jr�|jp�d|j|_|||<n�|dk�r,||||jd��}|dkr�td||f��|�r||d	}|jp�d||jp�d|_n|j�pd||j�pd|_||=qntd
|��n&|jt	k�rVtd|j��n
t
||�|d	}qWdS)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
rcsF





)N)N)
rrrZXINCLUDErr�SyntaxErrorrrrr	r	r	r
�<module>3s
PK�"[�Ib}��2etree/__pycache__/ElementPath.cpython-36.opt-2.pycnu�[���3


 \�&�@s�ddlZejd�Zddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Zdd�Z	dd�Z
eeee	ee
d�ZiZGdd�d�Z
ddd�Zd dd�Zd!dd�Zd"dd�ZdS)#�Nz\('[^']*'|\"[^\"]*\"|::|//?|\.\.|\(\)|[/.*:\[\]\(\)@=])|((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|\s+ccs�x�tj|�D]�}|d}|r�|ddkr�d|kr�y6|jdd�\}}|sJt�|dd|||ffVWq�tk
r�td|��Yq�Xq|VqWdS)N�r�{�:z{%s}%sz!prefix %r not found in prefix map)�xpath_tokenizer_re�findall�split�KeyError�SyntaxError)�pattern�
namespaces�token�tag�prefixZuri�r�-/usr/lib64/python3.6/xml/etree/ElementPath.py�xpath_tokenizerIsrcCsF|j}|dkrBi|_}x(|jj�D]}x|D]}|||<q.Wq$W|S)N)�
parent_map�root�iter)�contextr�p�errr�get_parent_mapWs

rcs|d��fdd�}|S)Nrc3s0x*|D]"}x|D]}|j�kr|VqWqWdS)N)r
)r�result�elemr)r
rr�selectbs


zprepare_child.<locals>.selectr)�nextrrr)r
r�
prepare_child`srcCsdd�}|S)Ncssx|D]}|EdHqWdS)Nr)rrrrrrrjs
zprepare_star.<locals>.selectr)rrrrrr�prepare_starisrcCsdd�}|S)Ncss|EdHdS)Nr)rrrrrrpszprepare_self.<locals>.selectr)rrrrrr�prepare_selfosrcs\y
|�}Wntk
rdSX|ddkr2d�n|dsD|d�ntd���fdd�}|S)Nr�*rzinvalid descendantc3s4x.|D]&}x |j��D]}||k	r|VqWqWdS)N)r)rrrr)r
rrrs
z"prepare_descendant.<locals>.select)�
StopIterationr	)rrrr)r
r�prepare_descendantts

r"cCsdd�}|S)NcssDt|�}i}x2|D]*}||kr||}||krd||<|VqWdS)N)r)rrrZ
result_mapr�parentrrrr�s
zprepare_parent.<locals>.selectr)rrrrrr�prepare_parent�s
r$cs*g}g}x�y
|�}Wntk
r(dSX|ddkr8P|drh|ddd�dkrhd|ddd�f}|j|dpvd�|j|d�q
Wdj|�}|dkr�|d��fd	d
�}|S|dkr�|d�|d���fdd
�}|S|dk�rtjd
|d��r|d��fdd
�}|S|dk�rVtjd
|d��rV|d�|d���fdd
�}|S|dk�st|dk�st|dk�r|dk�r�t|d�d��dk�rtd��nl|ddk�r�td��|dk�r
yt|d�d�Wntk
�r�td��YnX�dk�rtd��nd��fdd
�}|Std��dS) Nr�]rz'"�'�-�z@-c3s&x |D]}|j��dk	r|VqWdS)N)�get)rrr)�keyrrr�s
z!prepare_predicate.<locals>.selectz@-='c3s&x |D]}|j���kr|VqWdS)N)r))rrr)r*�valuerrr�s
z\-?\d+$c3s&x |D]}|j��dk	r|VqWdS)N)�find)rrr)r
rrr�s
z-='c3s@x:|D]2}x,|j��D]}dj|j���kr|VPqWqWdS)Nr()r�joinZitertext)rrrr)r
r+rrr�s

z-()z-()-zXPath position >= 1 expectedZlastzunsupported function�zunsupported expressionz)XPath offset from last() must be negativec
3sbt|�}xT|D]L}y.||}t|j|j��}|�|kr>|VWqttfk
rXYqXqWdS)N)r�listrr
�
IndexErrorr)rrrrr#Zelems)�indexrrr�s

zinvalid predicate���r2r2���r2)r!�appendr-�re�match�intr	�
ValueError)rrZ	signatureZ	predicaterr)r1r*r
r+r�prepare_predicate�sd







r9)r(r �.z..z//�[c@seZdZdZdd�ZdS)�_SelectorContextNcCs
||_dS)N)r)�selfrrrr�__init__�sz_SelectorContext.__init__)�__name__�
__module__�__qualname__rr>rrrrr<�sr<c
!Csh||dkrdntt|j���f}|dd�dkr8|d}yt|}Wn�tk
�r:tt�dkrjtj�|dd�dkr�td��tt	||��j
}y
|�}Wntk
r�dSXg}xvy|jt
|d||��Wntk
r�td��YnXy|�}|ddk�r|�}Wq�tk
�r(PYq�Xq�W|t|<YnX|g}t|�}x|D]}	|	||�}�qPW|S)	Nr�/r �dz#cannot use absolute path on elementrzinvalid pathr2)�tuple�sorted�items�_cacher�len�clearr	rr�__next__r!r4�opsr<)
r�pathrZ	cache_keyZselectorrrrrrrrr�iterfindsD


rMcCstt|||�d�S)N)rrM)rrLrrrrr,)sr,cCstt|||��S)N)r/rM)rrLrrrrr/srcCs4ytt|||��}|jpdStk
r.|SXdS)Nr()rrM�textr!)rrL�defaultrrrr�findtext5s

rP)N)N)N)N)NN)r5�compilerrrrrrr"r$r9rKrGr<rMr,rrPrrrr�<module>;s,
		
Y

)

PK�"[��xr/etree/__pycache__/ElementInclude.cpython-36.pycnu�[���3


 \�@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.6/xml/etree/ElementInclude.pyr>src	Cs\|dkr.t|d��}tj|�j�}WdQRXn*|s6d}t|d|d��}|j�}WdQRX|S)N�xml�rbzUTF-8�r)�encoding)�openr�parseZgetroot�read)�hrefrr�file�datar	r	r
�default_loaderMsrcCsp|dkrt}d}�xX|t|�k�rj||}|jtk�r:|jd�}|jdd�}|dkr�|||�}|dkrvtd||f��tj|�}|jr�|jp�d|j|_|||<n�|dk�r,||||jd��}|dkr�td||f��|�r||d	}|jp�d||jp�d|_n|j�pd||j�pd|_||=qntd
|��n&|jt	k�rVtd|j��n
t
||�|d	}qWdS)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
rcsF





)N)N)
rrrZXINCLUDErr�SyntaxErrorrrrr	r	r	r
�<module>3s
PK�"[�Ib}��,etree/__pycache__/ElementPath.cpython-36.pycnu�[���3


 \�&�@s�ddlZejd�Zddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Zdd�Z	dd�Z
eeee	ee
d�ZiZGdd�d�Z
ddd�Zd dd�Zd!dd�Zd"dd�ZdS)#�Nz\('[^']*'|\"[^\"]*\"|::|//?|\.\.|\(\)|[/.*:\[\]\(\)@=])|((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|\s+ccs�x�tj|�D]�}|d}|r�|ddkr�d|kr�y6|jdd�\}}|sJt�|dd|||ffVWq�tk
r�td|��Yq�Xq|VqWdS)N�r�{�:z{%s}%sz!prefix %r not found in prefix map)�xpath_tokenizer_re�findall�split�KeyError�SyntaxError)�pattern�
namespaces�token�tag�prefixZuri�r�-/usr/lib64/python3.6/xml/etree/ElementPath.py�xpath_tokenizerIsrcCsF|j}|dkrBi|_}x(|jj�D]}x|D]}|||<q.Wq$W|S)N)�
parent_map�root�iter)�contextr�p�errr�get_parent_mapWs

rcs|d��fdd�}|S)Nrc3s0x*|D]"}x|D]}|j�kr|VqWqWdS)N)r
)r�result�elemr)r
rr�selectbs


zprepare_child.<locals>.selectr)�nextrrr)r
r�
prepare_child`srcCsdd�}|S)Ncssx|D]}|EdHqWdS)Nr)rrrrrrrjs
zprepare_star.<locals>.selectr)rrrrrr�prepare_starisrcCsdd�}|S)Ncss|EdHdS)Nr)rrrrrrpszprepare_self.<locals>.selectr)rrrrrr�prepare_selfosrcs\y
|�}Wntk
rdSX|ddkr2d�n|dsD|d�ntd���fdd�}|S)Nr�*rzinvalid descendantc3s4x.|D]&}x |j��D]}||k	r|VqWqWdS)N)r)rrrr)r
rrrs
z"prepare_descendant.<locals>.select)�
StopIterationr	)rrrr)r
r�prepare_descendantts

r"cCsdd�}|S)NcssDt|�}i}x2|D]*}||kr||}||krd||<|VqWdS)N)r)rrrZ
result_mapr�parentrrrr�s
zprepare_parent.<locals>.selectr)rrrrrr�prepare_parent�s
r$cs*g}g}x�y
|�}Wntk
r(dSX|ddkr8P|drh|ddd�dkrhd|ddd�f}|j|dpvd�|j|d�q
Wdj|�}|dkr�|d��fd	d
�}|S|dkr�|d�|d���fdd
�}|S|dk�rtjd
|d��r|d��fdd
�}|S|dk�rVtjd
|d��rV|d�|d���fdd
�}|S|dk�st|dk�st|dk�r|dk�r�t|d�d��dk�rtd��nl|ddk�r�td��|dk�r
yt|d�d�Wntk
�r�td��YnX�dk�rtd��nd��fdd
�}|Std��dS) Nr�]rz'"�'�-�z@-c3s&x |D]}|j��dk	r|VqWdS)N)�get)rrr)�keyrrr�s
z!prepare_predicate.<locals>.selectz@-='c3s&x |D]}|j���kr|VqWdS)N)r))rrr)r*�valuerrr�s
z\-?\d+$c3s&x |D]}|j��dk	r|VqWdS)N)�find)rrr)r
rrr�s
z-='c3s@x:|D]2}x,|j��D]}dj|j���kr|VPqWqWdS)Nr()r�joinZitertext)rrrr)r
r+rrr�s

z-()z-()-zXPath position >= 1 expectedZlastzunsupported function�zunsupported expressionz)XPath offset from last() must be negativec
3sbt|�}xT|D]L}y.||}t|j|j��}|�|kr>|VWqttfk
rXYqXqWdS)N)r�listrr
�
IndexErrorr)rrrrr#Zelems)�indexrrr�s

zinvalid predicate���r2r2���r2)r!�appendr-�re�match�intr	�
ValueError)rrZ	signatureZ	predicaterr)r1r*r
r+r�prepare_predicate�sd







r9)r(r �.z..z//�[c@seZdZdZdd�ZdS)�_SelectorContextNcCs
||_dS)N)r)�selfrrrr�__init__�sz_SelectorContext.__init__)�__name__�
__module__�__qualname__rr>rrrrr<�sr<c
!Csh||dkrdntt|j���f}|dd�dkr8|d}yt|}Wn�tk
�r:tt�dkrjtj�|dd�dkr�td��tt	||��j
}y
|�}Wntk
r�dSXg}xvy|jt
|d||��Wntk
r�td��YnXy|�}|ddk�r|�}Wq�tk
�r(PYq�Xq�W|t|<YnX|g}t|�}x|D]}	|	||�}�qPW|S)	Nr�/r �dz#cannot use absolute path on elementrzinvalid pathr2)�tuple�sorted�items�_cacher�len�clearr	rr�__next__r!r4�opsr<)
r�pathrZ	cache_keyZselectorrrrrrrrr�iterfindsD


rMcCstt|||�d�S)N)rrM)rrLrrrrr,)sr,cCstt|||��S)N)r/rM)rrLrrrrr/srcCs4ytt|||��}|jpdStk
r.|SXdS)Nr()rrM�textr!)rrL�defaultrrrr�findtext5s

rP)N)N)N)N)NN)r5�compilerrrrrrr"r$r9rKrGr<rMr,rrPrrrr�<module>;s,
		
Y

)

PK�"[��.����,etree/__pycache__/ElementTree.cpython-36.pycnu�[���3


 \���@sHdZddddddddd	d
ddd
ddddddddddgZdZddlZddlZddlZddlZddlZddlZddl	m
Z
Gdd
�d
e�Zdd�Z
Gdd�d�Zifd d�Zd^d!d�Zd_d"d�ZeZGd#d
�d
�ZGd$d�d�Zejd%d&��Zd`d'd(�Zd)d*�ZdaZyee�ZWnek
�r"YnXd8d9�Zd:d;�Zeeed<�Zd=d�Zd>d?d@dAdBdCdDdE�Z e e_ dFdG�Z!dHdI�Z"dJdK�Z#dLdM�Z$dbdNdO�dPd�Z%GdQdR�dRej&�Z'dcdNdO�dSd�Z(dTd�Z)dddUd	�Z*dedVd�Z+GdWd�d�Z,dfdXd�Z-dgdYd�Z.e-Z/dhdZd�Z0Gd[d�d�Z1Gd\d�d�Z2yeZ3dd]l4TWne5k
�rBYnXdS)iaLightweight 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_namespacez1.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__�rr�-/usr/lib64/python3.6/xml/etree/ElementTree.pyr
hscCs
t|d�S)z2Return True if *element* appears to be an Element.�tag)�hasattr)�elementrrr rvsc@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

    NcKsDt|t�std|jjf��|j�}|j|�||_||_g|_	dS)Nzattrib must be dict, not %s)
�
isinstance�dict�	TypeError�	__class__r�copy�updater!�attrib�	_children)�selfr!r*�extrarrr �__init__�s

zElement.__init__cCsd|jj|jt|�fS)Nz<%s %r at %#x>)r'rr!�id)r,rrr �__repr__�szElement.__repr__cCs|j||�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*rrr �makeelement�s	zElement.makeelementcCs0|j|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)r1r!r*�text�tail)r,�elemrrr r(�s
zElement.copycCs
t|j�S)N)�lenr+)r,rrr �__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�
FutureWarningr5r+)r,rrr �__bool__�s
zElement.__bool__cCs
|j|S)N)r+)r,�indexrrr �__getitem__�szElement.__getitem__cCs||j|<dS)N)r+)r,r=r#rrr �__setitem__�szElement.__setitem__cCs|j|=dS)N)r+)r,r=rrr �__delitem__�szElement.__delitem__cCs|j|�|jj|�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)�_assert_is_elementr+�append)r,�
subelementrrr rB�s
zElement.appendcCs(x|D]}|j|�qW|jj|�dS)zkAppend subelements from a sequence.

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

        N)rAr+�extend)r,�elementsr#rrr rD�s
zElement.extendcCs|j|�|jj||�dS)z(Insert *subelement* at position *index*.N)rAr+�insert)r,r=rCrrr rF�s
zElement.insertcCs t|t�stdt|�j��dS)Nzexpected an Element, not %s)r$�_Element_Pyr&�typer)r,�errr rA�s
zElement._assert_is_elementcCs|jj|�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+�remove)r,rCrrr rJs
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.r7)r8)r9r:�DeprecationWarningr+)r,rrr �getchildrens
zElement.getchildrencCstj|||�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�
namespacesrrr rM!s	zElement.findcCstj||||�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,rN�defaultrOrrr rP,szElement.findtextcCstj|||�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�findall)r,rNrOrrr rR:s	zElement.findallcCstj|||�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�iterfind)r,rNrOrrr rSEs	zElement.iterfindcCs |jj�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+r2r3)r,rrr rTPs
z
Element.clearcCs|jj||�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,�keyrQrrr rU[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,rV�valuerrr �sethszElement.setcCs
|jj�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*�keys)r,rrr rYrszElement.keyscCs
|jj�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*�items)r,rrr rZ{s	z
Element.itemsccsH|dkrd}|dks|j|kr$|Vx|jD]}|j|�EdHq,WdS)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!rIrrr r\�szElement.itercCstjdtdd�t|j|��S)NzbThis method will be removed in future versions.  Use 'elem.iter()' or 'list(elem.iter())' instead.r7)r8)r9r:�PendingDeprecationWarning�listr\)r,r!rrr �getiterator�s
zElement.getiteratorccs^|j}t|t�r|dk	rdS|j}|r.|Vx*|D]"}|j�EdH|j}|r4|Vq4WdS)z�Create text iterator.

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

        N)r!r$�strr2�itertextr3)r,r!�trIrrr ra�s
zElement.itertext)N)NN)N)N)N)N)N)#rrrrr!r*r2r3r.r0r1r(r6r<r>r?r@rBrDrFrArJrLrMrPrRrSrTrUrXrYrZr\r_rarrrr r{s@	









	

	cKs,|j�}|j|�|j||�}|j|�|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.

    )r(r)r1rB)�parentr!r*r-r#rrr 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.

    )rrr2)r2r#rrr 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r2)�targetr2r#rrr 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)r2)r,Ztext_or_urir!rrr r.�szQName.__init__cCs|jS)N)r2)r,rrr �__str__sz
QName.__str__cCsd|jj|jfS)Nz<%s %r>)r'rr2)r,rrr r0szQName.__repr__cCs
t|j�S)N)�hashr2)r,rrr �__hash__szQName.__hash__cCs t|t�r|j|jkS|j|kS)N)r$r
r2)r,�otherrrr �__le__s
zQName.__le__cCs t|t�r|j|jkS|j|kS)N)r$r
r2)r,rirrr �__lt__
s
zQName.__lt__cCs t|t�r|j|jkS|j|kS)N)r$r
r2)r,rirrr �__ge__s
zQName.__ge__cCs t|t�r|j|jkS|j|kS)N)r$r
r2)r,rirrr �__gt__s
zQName.__gt__cCs t|t�r|j|jkS|j|kS)N)r$r
r2)r,rirrr �__eq__s
zQName.__eq__)N)
rrrrr.rfr0rhrjrkrlrmrnrrrr 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|j|�dS)N)�_rootr	)r,r#�filerrr r.)szElementTree.__init__cCs|jS)z!Return root element of this tree.)ro)r,rrr �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!

        N)ro)r,r#rrr �_setroot3szElementTree._setrootc
Cs�d}t|d�st|d�}d}zZ|dkrHt�}t|d�rH|j|�|_|jSx|jd�}|sZP|j|�qJW|j�|_|jS|r�|j�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"�openrrurors�feed�close)r,�source�parser�close_source�datarrr r	=s&




zElementTree.parsecCs|jj|�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).

        )ror\)r,r!rrr r\bs
zElementTree.itercCstjdtdd�t|j|��S)NzbThis method will be removed in future versions.  Use 'tree.iter()' or 'list(tree.iter())' instead.r7)r8)r9r:r]r^r\)r,r!rrr r_os
zElementTree.getiteratorcCs:|dd�dkr,d|}tjd|tdd�|jj||�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�/�.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 %rr7)r8)r9r:r;rorM)r,rNrOrrr rMxs
zElementTree.findcCs<|dd�dkr,d|}tjd|tdd�|jj|||�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~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 %rr7)r8)r9r:r;rorP)r,rNrQrOrrr rP�s
zElementTree.findtextcCs:|dd�dkr,d|}tjd|tdd�|jj||�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~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 %rr7)r8)r9r:r;rorR)r,rNrOrrr rR�s
zElementTree.findallcCs:|dd�dkr,d|}tjd|tdd�|jj||�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~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 %rr7)r8)r9r:r;rorS)r,rNrOrrr rS�s
zElementTree.iterfindT)�short_empty_elementscCs�|s
d}n|tkrtd|��|s4|dkr0d}nd}|j�}t||���}|dkr�|sd|dkr�|dkr�|}	|dkr�ddl}
|
j�}	|d	|	f�|d
kr�t||j�n,t|j|�\}}t|}
|
||j|||d�WdQRXdS)
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�unicoderz$<?xml version='1.0' encoding='%s'?>
r2)r)r�r�r�)	�
_serialize�
ValueError�lower�_get_writer�locale�getpreferredencoding�_serialize_textro�_namespaces)r,�file_or_filename�encodingZxml_declaration�default_namespace�methodrZ	enc_lower�writeZdeclared_encodingr��qnamesrOZ	serializerrr r��s2
zElementTree.writecCs|j|dd�S)Nr�)r�)r�)r,rprrr �
write_c14n
szElementTree.write_c14n)NN)N)N)N)N)NN)N)N)NNNN)rrrrr.rqrrr	r\r_rMrPrRrSr�r�rrrr rs"



%

	



5ccs"y
|j}WnPtk
rZ|dkr.t|d�}nt|d|dd�}|�|jVWdQRXYn�X|dkrl|Vn�tj���}t|tj�r�|}nft|tj�r�tj	|�}|j
|j�nBtj�}dd�|_||_y|j
|_
|j|_Wntk
r�YnXtj||ddd�}|j
|j�|jVWdQRXdS)	Nr��w�xmlcharrefreplace)r��errorscSsdS)NTrrrrr �<lambda>3sz_get_writer.<locals>.<lambda>�
)r�r��newline)r��AttributeErrorrv�
contextlib�	ExitStackr$�io�BufferedIOBase�	RawIOBase�BufferedWriter�callback�detach�writable�seekable�tell�
TextIOWrapper)r�r�r�rp�stackrrr r�s>



r�csddi�i��rd��<���fdd�}x�|j�D]�}|j}t|t�r\|j�kr�||j�n<t|t�rx|�kr�||�n |dk	r�|tk	r�|tk	r�t|�xR|j	�D]F\}}t|t�r�|j}|�kr�||�t|t�r�|j�kr�||j�q�W|j}t|t�r2|j�kr2||j�q2W��fS)N�cs�y�|dd�dkr�|dd�jdd�\}}�j|�}|dkrjtj|�}|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)�rsplitrU�_namespace_mapr5r�r&�_raise_serialization_error)Zqname�urir!�prefix)r�rOr�rr �	add_qnamePs&


z_namespaces.<locals>.add_qname)
r\r!r$r
r2r`rrr�rZ)r4r�r�r!rVrWr2r)r�rOr�r r�Es4




r�cKs�|j}|j}|tkr$|d|��n�|tkr<|d|��nv||}|dkr�|r\|t|��x|D]}t|||d|d�qbW�n2|d|�t|j��}	|	s�|�rD|r�x@t|j�dd�d�D](\}
}|r�d|}|d	|t	|
�f�q�WxZt|	�D]N\}}
t
|t��r|j}t
|
t��r$||
j}
nt	|
�}
|d
|||
f�q�W|�s\t|��s\|�r�|d�|�rv|t|��x |D]}t|||d|d��q|W|d|d�n|d
�|j
�r�|t|j
��dS)Nz	<!--%s-->z<?%s?>)r�<cSs|dS)Nrr)�xrrr r��sz _serialize_xml.<locals>.<lambda>)rV�:z
 xmlns%s="%s"z %s="%s"�>z</z />)r!r2rr�
_escape_cdata�_serialize_xmlr^rZ�sorted�_escape_attribr$r
r5r3)r�r4r�rOr�kwargsr!r2rIrZ�v�krrr r��sT





r��area�base�basefont�br�col�frame�hr�img�input�isindex�link�meta�paramcKs�|j}|j}|tkr(|dt|���n�|tkrD|dt|���n|||}|dkr�|rd|t|��x|D]}t|||d�qjW�n<|d|�t|j��}|s�|�rH|r�x@t|j�dd�d�D](\}	}
|
r�d|
}
|d|
t	|	�f�q�WxZt|�D]N\}
}	t
|
t��r|
j}
t
|	t��r(||	j}	nt|	�}	|d	||
|	f�q�W|d
�|j
�}|�r�|dk�sr|dk�r|||�n|t|��x|D]}t|||d��q�W|tk�r�|d
|d
�|j�r�|t|j��dS)Nz	<!--%s-->z<?%s?>r�cSs|dS)Nrr)r�rrr r��sz!_serialize_html.<locals>.<lambda>)rVr�z
 xmlns%s="%s"z %s="%s"r�ZscriptZstylez</)r!r2rr�r�_serialize_htmlr^rZr�r�r$r
�_escape_attrib_htmlr��
HTML_EMPTYr3)r�r4r�rOr�r!r2rIrZr�r�Zltagrrr r��sT





r�cCs.x|j�D]}||�q
W|jr*||j�dS)N)rar3)r�r4�partrrr r��sr�)r��htmlr2cCsPtjd|�rtd��x.ttj��D]\}}||ks:||kr"t|=q"W|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�r^r�rZ)r�r�r�r�rrr r�s
r�r�ZrdfZwsdlZxsZxsiZdc)z$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&rHr)r2rrr r�sr�cCsfy@d|kr|jdd�}d|kr*|jdd�}d|kr>|jdd�}|Sttfk
r`t|�YnXdS)N�&z&amp;r�z&lt;r�z&gt;)�replacer&r�r�)r2rrr r�$sr�cCs�y�d|kr|jdd�}d|kr*|jdd�}d|kr>|jdd�}d|krR|jdd�}d	|krf|jd	d
�}d|krz|jdd
�}d
|kr�|jd
d�}d
|kr�|jd
d�}|Sttfk
r�t|�YnXdS)Nr�z&amp;r�z&lt;r�z&gt;�"z&quot;z
r��
z&#10;�	z&#09;)r�r&r�r�)r2rrr r�4s(r�cCsfy@d|kr|jdd�}d|kr*|jdd�}d|kr>|jdd�}|Sttfk
r`t|�YnXdS)Nr�z&amp;r�z&gt;r�z&quot;)r�r&r�r�)r2rrr r�Psr�T)rcCs6|dkrtj�ntj�}t|�j||||d�|j�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".

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

    r�)r�r)r��StringIO�BytesIOrr��getvalue)r#r�r�r�streamrrr r_sc@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�_ListDataStreamz7An auxiliary stream accumulating into a list reference.cCs
||_dS)N)�lst)r,r�rrr r.tsz_ListDataStream.__init__cCsdS)NTr)r,rrr r�wsz_ListDataStream.writablecCsdS)NTr)r,rrr r�zsz_ListDataStream.seekablecCs|jj|�dS)N)r�rB)r,�brrr r�}sz_ListDataStream.writecCs
t|j�S)N)r5r�)r,rrr r��sz_ListDataStream.tellN)	rrrrr.r�r�r�r�rrrr r�rsr�cCs&g}t|�}t|�j||||d�|S)N)r�r)r�rr�)r#r�r�rr�r�rrr r�s
cCsNt|t�st|�}|jtjdd�|j�j}|s>|ddkrJtjjd�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�rr�N���)r$rr��sys�stdoutrqr3)r4r3rrr r�s

cCst�}|j||�|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	)ryrz�treerrr r	�s	csdt||d������fdd��G�fdd�dtj�}|��d�_�~d�t�d�s`t�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�_parserc
3sbzNx,�j�EdH�jd�}|s"P�j|�qW�j�}�j�EdH|�_Wd�r\�j�XdS)N�ii@)�read_eventsrsrw�_close_and_return_root�rootrx)r|r�)r{�it�
pullparserryrr �iterator�s

ziterparse.<locals>.iteratorcseZdZ��jZdS)z$iterparse.<locals>.IterParseIteratorN)rrr�__next__r)r�rr �IterParseIterator�sr�NFrsrtT)r�collections�Iteratorr�r"rv)ryr�rzr�r)r{r�r�r�ryr r�s

c@s<eZdZd
dd�dd�Zdd�Zdd�Zd	d
�Zdd�ZdS)rN)r�cCs<tj�|_|ptt�d�|_|dkr(d}|jj|j|�dS)N)re�end)r�)r��deque�
_events_queuerrr��
_setevents)r,r�r�rrr r.�s

zXMLPullParser.__init__cCsZ|jdkrtd��|rVy|jj|�Wn.tk
rT}z|jj|�WYdd}~XnXdS)zFeed encoded data to parser.Nz!feed() called after end of stream)r�r�rw�SyntaxErrorr�rB)r,r|�excrrr rw�s
zXMLPullParser.feedcCs|jj�}d|_|S)N)r�rx)r,r�rrr r��s
z$XMLPullParser._close_and_return_rootcCs|j�dS)z�Finish feeding data to parser.

        Unlike XMLParser, does not return the root element. Use
        read_events() to consume elements from XMLPullParser.
        N)r�)r,rrr rx�szXMLPullParser.closeccs2|j}x&|r,|j�}t|t�r$|�q|VqWdS)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��eventrrr r�s
zXMLPullParser.read_events)N)rrrr.rwr�rxr�rrrr r�s

cCs"|stt�d�}|j|�|j�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.

    )re)rrrwrx)r2rzrrr rs
cCsV|stt�d�}|j|�|j�}i}x&|j�D]}|jd�}|r0|||<q0W||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.

    )rer/)rrrwrxr\rU)r2rzr�Zidsr4r/rrr r&s


cCs0|stt�d�}x|D]}|j|�qW|j�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.

    )re)rrrwrx)Zsequencerzr2rrr r>s
	
c@sBeZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dS)ra�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.

    NcCs.g|_g|_d|_d|_|dkr$t}||_dS)N)�_data�_elem�_last�_tailr�_factory)r,Zelement_factoryrrr r.]szTreeBuilder.__init__cCs.t|j�dkstd��|jdk	s(td��|jS)z;Flush builder buffers and return toplevel document Element.rzmissing end tagsNzmissing toplevel element)r5r��AssertionErrorr�)r,rrr rxfszTreeBuilder.closecCsf|jrb|jdk	r\dj|j�}|jr@|jjdks6td��||j_n|jjdksTtd��||j_g|_dS)Nr�zinternal error (tail)zinternal error (text))r�r��joinr�r3r�r2)r,r2rrr �_flushls

zTreeBuilder._flushcCs|jj|�dS)zAdd text to current element.N)r�rB)r,r|rrr r|xszTreeBuilder.datacCsF|j�|j||�|_}|jr0|jdj|�|jj|�d|_|S)z�Open new element and return it.

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

        rrr�)r�r�r�r�rBr�)r,r!Zattrsr4rrr �start|szTreeBuilder.startcCs@|j�|jj�|_|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��popr�r!r�r�)r,r!rrr r��szTreeBuilder.end)N)
rrrrr.rxr�r|r�r�rrrr rPs
	c@sfeZdZdZddd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�ZeZdd�Z
dd�ZdS)ra�Element structure builder for XML source data based on the expat parser.

    *html* are predefined HTML entities (deprecated and not supported),
    *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

    rNcCs<yddlm}Wn>tk
rNyddl}Wntk
rHtd��YnXYnX|j|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|_d
|_d
|_d
|_d|_i|_yd|j|_ Wnt!k
�r6YnXdS)Nr)�expatz7No module named expat; use SimpleXMLTreeBuilder insteadr�r�r�r|�comment�pirzExpat %d.%d.%d)"�xml.parsersr�ImportErrorZpyexpatZParserCreaterrzr�re�_target�error�_error�_names�_defaultZDefaultHandlerExpandr"�_start�StartElementHandler�_end�EndElementHandlerr|ZCharacterDataHandlerrZCommentHandlerrZProcessingInstructionHandlerZbuffer_text�ordered_attributes�specified_attributes�_doctype�entity�version_info�versionr�)r,r�rer�rrzrrr r.�sF




zXMLParser.__init__cCs�|j}|j}x�|D]�}|dkrDd|_d|_|||jfdd�}||_q|dkrf|||jfdd�}||_q|dkr�||fdd�}||_q|d	kr�||fd
d�}||_	qt
d|��qWdS)Nr�rcSs|||||�f�dS)Nr)r!Z	attrib_inr�rBr�rrr �handler�sz%XMLParser._setevents.<locals>.handlerr�cSs||||�f�dS)Nr)r!r�rBr�rrr r�szstart-nscSs|||p
d|pdff�dS)Nr�r)r�r�r�rBrrr r�szend-nscSs||df�dS)Nr)r�r�rBrrr r�szunknown event %r)r�rBrrr
rrr
ZStartNamespaceDeclHandlerZEndNamespaceDeclHandlerr�)r,Zevents_queueZevents_to_reportrzrBZ
event_namerrrr r��s(
zXMLParser._seteventscCs&t|�}|j|_|j|jf|_|�dS)N)r
�code�lineno�offsetZposition)r,rW�errrrr �_raiseerror�szXMLParser._raiseerrorcCsFy|j|}Wn2tk
r@|}d|kr2d|}||j|<YnX|S)Nr�r�)r�KeyError)r,rV�namerrr �_fixname�szXMLParser._fixnamecCsV|j}||�}i}|rHx0tdt|�d�D]}||d||||�<q(W|jj||�S)Nrr7r)r�ranger5rer�)r,r!Z	attr_listZfixnamer*�irrr r
szXMLParser._startcCs|jj|j|��S)N)rer�r)r,r!rrr rszXMLParser._endcCs�|dd�}|dkr�y|jj}Wntk
r4dSXy||j|dd��WnZtk
r�ddlm}|jd||jj	|jj
f�}d|_|jj	|_|jj
|_
|�YnX�nD|dkr�|dd�d	kr�g|_�n"|jdk	�r�|d
kr�d|_dS|j�}|�sdS|jj|�t|j�}|dk�r�|jd}|dk�rb|d
k�rb|j\}}}	}
|	�r�|	dd�}	n*|dk�r�|dk�r�|j\}}}
d}	ndSt|jd��r�|jj||	|
dd��n:|j|jk�r�|j||	|
dd��|j||	|
dd��d|_dS)Nrr�r)rz'undefined entity %s: line %d, column %d�r��	z	<!DOCTYPEr�r7ZPUBLIC�ZSYSTEM��doctyper�r�r�r�r�)rer|r�rrrrrrzZErrorLineNumberZErrorColumnNumberrrrr�striprBr5r"r#�_XMLParser__doctype)r,r2r�Zdata_handlerrr�nrHr�pubid�systemrrr r	sZ





zXMLParser._defaultcCstjdt�dS)z�(Deprecated)  Handle doctype declaration

        *name* is the Doctype name, *pubid* is the public identifier,
        and *system* is the system identifier.

        z[This method of XMLParser is deprecated.  Define doctype() method on the TreeBuilder target.N)r9r:rK)r,rr'r(rrr r#EszXMLParser.doctypecCsFy|jj|d�Wn.|jk
r@}z|j|�WYdd}~XnXdS)zFeed encoded data to parser.rN)rz�Parserr)r,r|r�rrr rwUszXMLParser.feedcCs�y|jjdd�Wn.|jk
r@}z|j|�WYdd}~XnXz,y|jj}Wntk
rdYnX|�SWd|`|`|`|`XdS)z;Finish feeding data to parser and return element structure.r�rN)	rzr)rrrerxr�r�r)r,r�Z
close_handlerrrr rx\s
zXMLParser.close)rNN)rrrrr.r�rrr
rr	r#r%rwrxrrrr r�s	
*!4)r[)N)N)N)
r�r�r�r�r�r�r�r�r�r�r�r�r�)NN)NN)N)NN)N)N)N)6r�__all__rr�r�r9r�r�r�r�rr�r
rrrrrrr
r�contextmanagerr�r�r�r�rX�	NameErrorr�r�r�rr�r�r�r�r�rr�r�rrr	rrrrrrrrrGZ_elementtreerrrrr �<module>"s�)A

0t4
=22

05


KUPK�"[�A�3}}/etree/__pycache__/__init__.cpython-36.opt-2.pycnu�[���3


 \D�@sdS)N�rrr�*/usr/lib64/python3.6/xml/etree/__init__.py�<module>sPK�"[�A�3}})etree/__pycache__/__init__.cpython-36.pycnu�[���3


 \D�@sdS)N�rrr�*/usr/lib64/python3.6/xml/etree/__init__.py�<module>sPK�"[�1�b�m�m2etree/__pycache__/ElementTree.cpython-36.opt-2.pycnu�[���3


 \���@sDdddddddddd	d
ddd
dddddddddgZdZddlZddlZddlZddlZddlZddlZddlm	Z	Gdd	�d	e
�Zdd�ZGdd�d�Z
ifdd
�Zd]d d�Zd^d!d�ZeZGd"d�d�ZGd#d�d�Zejd$d%��Zd_d&d'�Zd(d)�Zd`Zyee�ZWnek
�rYnXd7d8�Zd9d:�Zeeed;�Zd<d�Zd=d>d?d@dAdBdCdD�Zee_dEdF�Z dGdH�Z!dIdJ�Z"dKdL�Z#dadMdN�dOd�Z$GdPdQ�dQej%�Z&dbdMdN�dRd�Z'dSd�Z(dcdTd�Z)dddUd�Z*GdVd�d�Z+dedWd�Z,dfdXd�Z-e,Z.dgdYd�Z/GdZd�d�Z0Gd[d�d�Z1ye
Z2dd\l3TWne4k
�r>YnXdS)h�Comment�dump�Element�ElementTree�
fromstring�fromstringlist�	iselement�	iterparse�parse�
ParseError�PI�ProcessingInstruction�QName�
SubElement�tostring�tostringlist�TreeBuilder�VERSION�XML�XMLID�	XMLParser�
XMLPullParser�register_namespacez1.3.0�N�)�ElementPathc@seZdZdS)r
N)�__name__�
__module__�__qualname__�rr�-/usr/lib64/python3.6/xml/etree/ElementTree.pyr
hs	cCs
t|d�S)N�tag)�hasattr)�elementrrrrvsc@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)?rNcKsDt|t�std|jjf��|j�}|j|�||_||_g|_	dS)Nzattrib must be dict, not %s)
�
isinstance�dict�	TypeError�	__class__r�copy�updater �attrib�	_children)�selfr r)�extrarrr�__init__�s

zElement.__init__cCsd|jj|jt|�fS)Nz<%s %r at %#x>)r&rr �id)r+rrr�__repr__�szElement.__repr__cCs|j||�S)N)r&)r+r r)rrr�makeelement�s	zElement.makeelementcCs0|j|j|j�}|j|_|j|_||dd�<|S)N)r0r r)�text�tail)r+�elemrrrr'�s
zElement.copycCs
t|j�S)N)�lenr*)r+rrr�__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�
FutureWarningr4r*)r+rrr�__bool__�s
zElement.__bool__cCs
|j|S)N)r*)r+�indexrrr�__getitem__�szElement.__getitem__cCs||j|<dS)N)r*)r+r<r"rrr�__setitem__�szElement.__setitem__cCs|j|=dS)N)r*)r+r<rrr�__delitem__�szElement.__delitem__cCs|j|�|jj|�dS)N)�_assert_is_elementr*�append)r+�
subelementrrrrA�s
zElement.appendcCs(x|D]}|j|�qW|jj|�dS)N)r@r*�extend)r+�elementsr"rrrrC�s
zElement.extendcCs|j|�|jj||�dS)N)r@r*�insert)r+r<rBrrrrE�s
zElement.insertcCs t|t�stdt|�j��dS)Nzexpected an Element, not %s)r#�_Element_Pyr%�typer)r+�errrr@�s
zElement._assert_is_elementcCs|jj|�dS)N)r*�remove)r+rBrrrrIs
zElement.removecCstjdtdd�|jS)NzaThis method will be removed in future versions.  Use 'list(elem)' or iteration over elem instead.r6)r7)r8r9�DeprecationWarningr*)r+rrr�getchildrens
zElement.getchildrencCstj|||�S)N)r�find)r+�path�
namespacesrrrrL!s	zElement.findcCstj||||�S)N)r�findtext)r+rM�defaultrNrrrrO,szElement.findtextcCstj|||�S)N)r�findall)r+rMrNrrrrQ:s	zElement.findallcCstj|||�S)N)r�iterfind)r+rMrNrrrrREs	zElement.iterfindcCs |jj�g|_d|_|_dS)N)r)�clearr*r1r2)r+rrrrSPs
z
Element.clearcCs|jj||�S)N)r)�get)r+�keyrPrrrrT[szElement.getcCs||j|<dS)N)r))r+rU�valuerrr�sethszElement.setcCs
|jj�S)N)r)�keys)r+rrrrXrszElement.keyscCs
|jj�S)N)r)�items)r+rrrrY{s	z
Element.itemsccsH|dkrd}|dks|j|kr$|Vx|jD]}|j|�EdHq,WdS)N�*)r r*�iter)r+r rHrrrr[�szElement.itercCstjdtdd�t|j|��S)NzbThis method will be removed in future versions.  Use 'elem.iter()' or 'list(elem.iter())' instead.r6)r7)r8r9�PendingDeprecationWarning�listr[)r+r rrr�getiterator�s
zElement.getiteratorccs^|j}t|t�r|dk	rdS|j}|r.|Vx*|D]"}|j�EdH|j}|r4|Vq4WdS)N)r r#�strr1�itertextr2)r+r �trHrrrr`�s
zElement.itertext)N)NN)N)N)N)N)N)"rrrr r)r1r2r-r/r0r'r5r;r=r>r?rArCrEr@rIrKrLrOrQrRrSrTrWrXrYr[r^r`rrrrr{s>	









	

	cKs,|j�}|j|�|j||�}|j|�|S)N)r'r(r0rA)�parentr r)r,r"rrrr�s


cCstt�}||_|S)N)rrr1)r1r"rrrr�s	cCs&tt�}||_|r"|jd||_|S)N� )rrr1)�targetr1r"rrrr�s

c@sVeZdZddd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�ZdS)r
NcCs|rd||f}||_dS)Nz{%s}%s)r1)r+Ztext_or_urir rrrr-�szQName.__init__cCs|jS)N)r1)r+rrr�__str__sz
QName.__str__cCsd|jj|jfS)Nz<%s %r>)r&rr1)r+rrrr/szQName.__repr__cCs
t|j�S)N)�hashr1)r+rrr�__hash__szQName.__hash__cCs t|t�r|j|jkS|j|kS)N)r#r
r1)r+�otherrrr�__le__s
zQName.__le__cCs t|t�r|j|jkS|j|kS)N)r#r
r1)r+rhrrr�__lt__
s
zQName.__lt__cCs t|t�r|j|jkS|j|kS)N)r#r
r1)r+rhrrr�__ge__s
zQName.__ge__cCs t|t�r|j|jkS|j|kS)N)r#r
r1)r+rhrrr�__gt__s
zQName.__gt__cCs t|t�r|j|jkS|j|kS)N)r#r
r1)r+rhrrr�__eq__s
zQName.__eq__)N)rrrr-rer/rgrirjrkrlrmrrrrr
�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|j|�dS)N)�_rootr	)r+r"�filerrrr-)szElementTree.__init__cCs|jS)N)rn)r+rrr�getroot/szElementTree.getrootcCs
||_dS)N)rn)r+r"rrr�_setroot3szElementTree._setrootc
Cs�d}t|d�st|d�}d}zZ|dkrHt�}t|d�rH|j|�|_|jSx|jd�}|sZP|j|�qJW|j�|_|jS|r�|j�XdS)NF�read�rbT�_parse_wholei)r!�openrrtrnrr�feed�close)r+�source�parser�close_source�datarrrr	=s&




zElementTree.parsecCs|jj|�S)N)rnr[)r+r rrrr[bs
zElementTree.itercCstjdtdd�t|j|��S)NzbThis method will be removed in future versions.  Use 'tree.iter()' or 'list(tree.iter())' instead.r6)r7)r8r9r\r]r[)r+r rrrr^os
zElementTree.getiteratorcCs:|dd�dkr,d|}tjd|tdd�|jj||�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 %rr6)r7)r8r9r:rnrL)r+rMrNrrrrLxs
zElementTree.findcCs<|dd�dkr,d|}tjd|tdd�|jj|||�S)Nrr|r}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 %rr6)r7)r8r9r:rnrO)r+rMrPrNrrrrO�s
zElementTree.findtextcCs:|dd�dkr,d|}tjd|tdd�|jj||�S)Nrr|r}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 %rr6)r7)r8r9r:rnrQ)r+rMrNrrrrQ�s
zElementTree.findallcCs:|dd�dkr,d|}tjd|tdd�|jj||�S)Nrr|r}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 %rr6)r7)r8r9r:rnrR)r+rMrNrrrrR�s
zElementTree.iterfindT)�short_empty_elementscCs�|s
d}n|tkrtd|��|s4|dkr0d}nd}|j�}t||���}|dkr�|sd|dkr�|dkr�|}	|dkr�ddl}
|
j�}	|d|	f�|d	kr�t||j�n,t|j|�\}}t|}
|
||j|||d
�WdQRXdS)N�xmlzunknown method %r�c14n�utf-8�us-ascii�unicoderz$<?xml version='1.0' encoding='%s'?>
r1)r~)r�r�r�)	�
_serialize�
ValueError�lower�_get_writer�locale�getpreferredencoding�_serialize_textrn�_namespaces)r+�file_or_filename�encodingZxml_declaration�default_namespace�methodr~Z	enc_lower�writeZdeclared_encodingr��qnamesrNZ	serializerrrr��s2
zElementTree.writecCs|j|dd�S)Nr�)r�)r�)r+rorrr�
write_c14n
szElementTree.write_c14n)NN)N)N)N)N)NN)N)N)NNNN)rrrr-rprqr	r[r^rLrOrQrRr�r�rrrrrs 


%

	



5ccs"y
|j}WnPtk
rZ|dkr.t|d�}nt|d|dd�}|�|jVWdQRXYn�X|dkrl|Vn�tj���}t|tj�r�|}nft|tj�r�tj	|�}|j
|j�nBtj�}dd�|_||_y|j
|_
|j|_Wntk
r�YnXtj||ddd�}|j
|j�|jVWdQRXdS)	Nr��w�xmlcharrefreplace)r��errorscSsdS)NTrrrrr�<lambda>3sz_get_writer.<locals>.<lambda>�
)r�r��newline)r��AttributeErrorru�
contextlib�	ExitStackr#�io�BufferedIOBase�	RawIOBase�BufferedWriter�callback�detach�writable�seekable�tell�
TextIOWrapper)r�r�r�ro�stackrrrr�s>



r�csddi�i��rd��<���fdd�}x�|j�D]�}|j}t|t�r\|j�kr�||j�n<t|t�rx|�kr�||�n |dk	r�|tk	r�|tk	r�t|�xR|j	�D]F\}}t|t�r�|j}|�kr�||�t|t�r�|j�kr�||j�q�W|j}t|t�r2|j�kr2||j�q2W��fS)N�cs�y�|dd�dkr�|dd�jdd�\}}�j|�}|dkrjtj|�}|dkrZdt��}|dkrj|�|<|r�d||f�|<q�|�|<n�r�td��|�|<Wntk
r�t|�YnXdS)Nr�{�}zns%drz%s:%sz<cannot use non-qualified names with default_namespace option)�rsplitrT�_namespace_mapr4r�r%�_raise_serialization_error)Zqname�urir �prefix)r�rNr�rr�	add_qnamePs&


z_namespaces.<locals>.add_qname)
r[r r#r
r1r_rrr�rY)r3r�r�r rUrVr1r)r�rNr�rr�Es4




r�cKs�|j}|j}|tkr$|d|��n�|tkr<|d|��nv||}|dkr�|r\|t|��x|D]}t|||d|d�qbW�n2|d|�t|j��}	|	s�|�rD|r�x@t|j�dd�d�D](\}
}|r�d|}|d	|t	|
�f�q�WxZt|	�D]N\}}
t
|t��r|j}t
|
t��r$||
j}
nt	|
�}
|d
|||
f�q�W|�s\t|��s\|�r�|d�|�rv|t|��x |D]}t|||d|d��q|W|d|d�n|d
�|j
�r�|t|j
��dS)Nz	<!--%s-->z<?%s?>)r~�<cSs|dS)Nrr)�xrrrr��sz _serialize_xml.<locals>.<lambda>)rU�:z
 xmlns%s="%s"z %s="%s"�>z</z />)r r1rr�
_escape_cdata�_serialize_xmlr]rY�sorted�_escape_attribr#r
r4r2)r�r3r�rNr~�kwargsr r1rHrY�v�krrrr��sT





r��area�base�basefont�br�col�frame�hr�img�input�isindex�link�meta�paramcKs�|j}|j}|tkr(|dt|���n�|tkrD|dt|���n|||}|dkr�|rd|t|��x|D]}t|||d�qjW�n<|d|�t|j��}|s�|�rH|r�x@t|j�dd�d�D](\}	}
|
r�d|
}
|d|
t	|	�f�q�WxZt|�D]N\}
}	t
|
t��r|
j}
t
|	t��r(||	j}	nt|	�}	|d	||
|	f�q�W|d
�|j
�}|�r�|dk�sr|dk�r|||�n|t|��x|D]}t|||d��q�W|tk�r�|d
|d
�|j�r�|t|j��dS)Nz	<!--%s-->z<?%s?>r�cSs|dS)Nrr)r�rrrr��sz!_serialize_html.<locals>.<lambda>)rUr�z
 xmlns%s="%s"z %s="%s"r�ZscriptZstylez</)r r1rr�r�_serialize_htmlr]rYr�r�r#r
�_escape_attrib_htmlr��
HTML_EMPTYr2)r�r3r�rNr�r r1rHrYr�r�Zltagrrrr��sT





r�cCs.x|j�D]}||�q
W|jr*||j�dS)N)r`r2)r�r3�partrrrr��sr�)r�htmlr1cCsPtjd|�rtd��x.ttj��D]\}}||ks:||kr"t|=q"W|t|<dS)Nzns\d+$z'Prefix format reserved for internal use)�re�matchr�r]r�rY)r�r�r�r�rrrr�s
rr�ZrdfZwsdlZxsZxsiZdc)z$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%rGr)r1rrrr�sr�cCsfy@d|kr|jdd�}d|kr*|jdd�}d|kr>|jdd�}|Sttfk
r`t|�YnXdS)N�&z&amp;r�z&lt;r�z&gt;)�replacer%r�r�)r1rrrr�$sr�cCs�y�d|kr|jdd�}d|kr*|jdd�}d|kr>|jdd�}d|krR|jdd�}d	|krf|jd	d
�}d|krz|jdd
�}d
|kr�|jd
d�}d
|kr�|jd
d�}|Sttfk
r�t|�YnXdS)Nr�z&amp;r�z&lt;r�z&gt;�"z&quot;z
r��
z&#10;�	z&#09;)r�r%r�r�)r1rrrr�4s(r�cCsfy@d|kr|jdd�}d|kr*|jdd�}d|kr>|jdd�}|Sttfk
r`t|�YnXdS)Nr�z&amp;r�z&gt;r�z&quot;)r�r%r�r�)r1rrrr�Psr�T)r~cCs6|dkrtj�ntj�}t|�j||||d�|j�S)Nr�)r�r~)r��StringIO�BytesIOrr��getvalue)r"r�r�r~�streamrrrr_sc@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�_ListDataStreamcCs
||_dS)N)�lst)r+r�rrrr-tsz_ListDataStream.__init__cCsdS)NTr)r+rrrr�wsz_ListDataStream.writablecCsdS)NTr)r+rrrr�zsz_ListDataStream.seekablecCs|jj|�dS)N)r�rA)r+�brrrr�}sz_ListDataStream.writecCs
t|j�S)N)r4r�)r+rrrr��sz_ListDataStream.tellN)rrrr-r�r�r�r�rrrrr�rs
r�cCs&g}t|�}t|�j||||d�|S)N)r�r~)r�rr�)r"r�r�r~r�r�rrrr�s
cCsNt|t�st|�}|jtjdd�|j�j}|s>|ddkrJtjjd�dS)Nr�)r�rr����)r#rr��sys�stdoutrpr2)r3r2rrrr�s

cCst�}|j||�|S)N)rr	)rxry�treerrrr	�s	csdt||d������fdd��G�fdd�dtj�}|��d�_�~d�t�d�s`t�d��d	��S)
N)�events�_parserc
3sbzNx,�j�EdH�jd�}|s"P�j|�qW�j�}�j�EdH|�_Wd�r\�j�XdS)N�ii@)�read_eventsrrrv�_close_and_return_root�rootrw)r{r�)rz�it�
pullparserrxrr�iterator�s

ziterparse.<locals>.iteratorcseZdZ��jZdS)z$iterparse.<locals>.IterParseIteratorN)rrr�__next__r)r�rr�IterParseIterator�sr�FrrrsT)r�collections�Iteratorr�r!ru)rxr�ryr�r)rzr�r�r�rxrr�s

c@s<eZdZd
dd�dd�Zdd�Zdd�Zd	d
�Zdd�ZdS)rN)r�cCs<tj�|_|ptt�d�|_|dkr(d}|jj|j|�dS)N)rd�end)r�)r��deque�
_events_queuerrr��
_setevents)r+r�r�rrrr-�s

zXMLPullParser.__init__cCsZ|jdkrtd��|rVy|jj|�Wn.tk
rT}z|jj|�WYdd}~XnXdS)Nz!feed() called after end of stream)r�r�rv�SyntaxErrorr�rA)r+r{�excrrrrv�s
zXMLPullParser.feedcCs|jj�}d|_|S)N)r�rw)r+r�rrrr��s
z$XMLPullParser._close_and_return_rootcCs|j�dS)N)r�)r+rrrrw�szXMLPullParser.closeccs2|j}x&|r,|j�}t|t�r$|�q|VqWdS)N)r��popleftr#�	Exception)r+r��eventrrrr�s
zXMLPullParser.read_events)N)rrrr-rvr�rwr�rrrrr�s

cCs"|stt�d�}|j|�|j�S)N)rd)rrrvrw)r1ryrrrrs
cCsV|stt�d�}|j|�|j�}i}x&|j�D]}|jd�}|r0|||<q0W||fS)N)rdr.)rrrvrwr[rT)r1ryr�Zidsr3r.rrrr&s


cCs0|stt�d�}x|D]}|j|�qW|j�S)N)rd)rrrvrw)Zsequenceryr1rrrr>s
	
c@s>eZdZddd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�ZdS)rNcCs.g|_g|_d|_d|_|dkr$t}||_dS)N)�_data�_elem�_last�_tailr�_factory)r+Zelement_factoryrrrr-]szTreeBuilder.__init__cCs|jS)N)r�)r+rrrrwfszTreeBuilder.closecCs>|jr:|jdk	r4dj|j�}|jr,||j_n||j_g|_dS)Nr�)r�r��joinr�r2r1)r+r1rrr�_flushls

zTreeBuilder._flushcCs|jj|�dS)N)r�rA)r+r{rrrr{xszTreeBuilder.datacCsF|j�|j||�|_}|jr0|jdj|�|jj|�d|_|S)Nrrr�)r�r�r�r�rAr�)r+r Zattrsr3rrr�start|szTreeBuilder.startcCs |j�|jj�|_d|_|jS)Nr)r�r��popr�r�)r+r rrrr��szTreeBuilder.end)N)	rrrr-rwr�r{r�r�rrrrrPs
	c@sbeZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Zdd�Z	dd�Z
e
Zdd�Zdd�Z
dS)rrNcCs<yddlm}Wn>tk
rNyddl}Wntk
rHtd��YnXYnX|j|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|_d
|_d
|_d
|_d|_i|_yd|j|_ Wnt!k
�r6YnXdS)Nr)�expatz7No module named expat; use SimpleXMLTreeBuilder insteadr�r�r�r{�comment�pirzExpat %d.%d.%d)"�xml.parsersr��ImportErrorZpyexpatZParserCreaterryr�rd�_target�error�_error�_names�_defaultZDefaultHandlerExpandr!�_start�StartElementHandler�_end�EndElementHandlerr{ZCharacterDataHandlerr�ZCommentHandlerrZProcessingInstructionHandlerZbuffer_text�ordered_attributes�specified_attributes�_doctype�entity�version_info�versionr�)r+r�rdr�r�ryrrrr-�sF




zXMLParser.__init__cCs�|j}|j}x�|D]�}|dkrDd|_d|_|||jfdd�}||_q|dkrf|||jfdd�}||_q|dkr�||fdd�}||_q|d	kr�||fd
d�}||_	qt
d|��qWdS)Nr�rcSs|||||�f�dS)Nr)r Z	attrib_inr�rAr�rrr�handler�sz%XMLParser._setevents.<locals>.handlerr�cSs||||�f�dS)Nr)r r�rAr�rrrr�szstart-nscSs|||p
d|pdff�dS)Nr�r)r�r�r�rArrrr�szend-nscSs||df�dS)Nr)r�r�rArrrr�szunknown event %r)r�rArr
rr	r
rZStartNamespaceDeclHandlerZEndNamespaceDeclHandlerr�)r+Zevents_queueZevents_to_reportryrAZ
event_namerrrrr��s(
zXMLParser._seteventscCs&t|�}|j|_|j|jf|_|�dS)N)r
�code�lineno�offsetZposition)r+rV�errrrr�_raiseerror�szXMLParser._raiseerrorcCsFy|j|}Wn2tk
r@|}d|kr2d|}||j|<YnX|S)Nr�r�)r�KeyError)r+rU�namerrr�_fixname�szXMLParser._fixnamecCsV|j}||�}i}|rHx0tdt|�d�D]}||d||||�<q(W|jj||�S)Nrr6r)r�ranger4rdr�)r+r Z	attr_listZfixnamer)�irrrrszXMLParser._startcCs|jj|j|��S)N)rdr�r)r+r rrrr
szXMLParser._endcCs�|dd�}|dkr�y|jj}Wntk
r4dSXy||j|dd��WnZtk
r�ddlm}|jd||jj	|jj
f�}d|_|jj	|_|jj
|_
|�YnX�nD|dkr�|dd�d	kr�g|_�n"|jdk	�r�|d
kr�d|_dS|j�}|�sdS|jj|�t|j�}|dk�r�|jd}|dk�rb|d
k�rb|j\}}}	}
|	�r�|	dd�}	n*|dk�r�|dk�r�|j\}}}
d}	ndSt|jd��r�|jj||	|
dd��n:|j|jk�r�|j||	|
dd��|j||	|
dd��d|_dS)Nrr�r)r�z'undefined entity %s: line %d, column %d�r��	z	<!DOCTYPEr�r6ZPUBLIC�ZSYSTEM��doctyper�r�r�r�r�)rdr{r�rrrr�rryZErrorLineNumberZErrorColumnNumberrrrr�striprAr4r!r!�_XMLParser__doctype)r+r1r�Zdata_handlerr�r�nrGr�pubid�systemrrrrsZ





zXMLParser._defaultcCstjdt�dS)Nz[This method of XMLParser is deprecated.  Define doctype() method on the TreeBuilder target.)r8r9rJ)r+rr%r&rrrr!EszXMLParser.doctypecCsFy|jj|d�Wn.|jk
r@}z|j|�WYdd}~XnXdS)Nr)ry�Parserr)r+r{r�rrrrvUszXMLParser.feedcCs�y|jjdd�Wn.|jk
r@}z|j|�WYdd}~XnXz,y|jj}Wntk
rdYnX|�SWd|`|`|`|`XdS)Nr�r)	ryr'rrrdrwr�r�r)r+r�Z
close_handlerrrrrw\s
zXMLParser.close)rNN)rrrr-r�rrrr
rr!r#rvrwrrrrr�s
*!4)rZ)N)N)N)
r�r�r�r�r�r�r�r�r�r�r�r�r�)NN)NN)N)NN)N)N)N)5�__all__rr�r�r8r�r�r�r�rr�r
rrrrrrr
r�contextmanagerr�r�r�r�rW�	NameErrorr�r�r�rr�r�r�r�r�rr�r�rrr	rrrrrrrrrFZ_elementtreerrrrr�<module>Ks�A

0t4
=22

05


KUPK�"[��xr5etree/__pycache__/ElementInclude.cpython-36.opt-2.pycnu�[���3


 \�@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.6/xml/etree/ElementInclude.pyr>src	Cs\|dkr.t|d��}tj|�j�}WdQRXn*|s6d}t|d|d��}|j�}WdQRX|S)N�xml�rbzUTF-8�r)�encoding)�openr�parseZgetroot�read)�hrefrr�file�datar	r	r
�default_loaderMsrcCsp|dkrt}d}�xX|t|�k�rj||}|jtk�r:|jd�}|jdd�}|dkr�|||�}|dkrvtd||f��tj|�}|jr�|jp�d|j|_|||<n�|dk�r,||||jd��}|dkr�td||f��|�r||d	}|jp�d||jp�d|_n|j�pd||j�pd|_||=qntd
|��n&|jt	k�rVtd|j��n
t
||�|d	}qWdS)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
rcsF





)N)N)
rrrZXINCLUDErr�SyntaxErrorrrrr	r	r	r
�<module>3s
PK�"[#�}P��3etree/__pycache__/cElementTree.cpython-36.opt-2.pycnu�[���3


 \R�@sddlTdS)�)�*N)Zxml.etree.ElementTree�rr�./usr/lib64/python3.6/xml/etree/cElementTree.py�<module>sPK�"[�Ib}��2etree/__pycache__/ElementPath.cpython-36.opt-1.pycnu�[���3


 \�&�@s�ddlZejd�Zddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Zdd�Z	dd�Z
eeee	ee
d�ZiZGdd�d�Z
ddd�Zd dd�Zd!dd�Zd"dd�ZdS)#�Nz\('[^']*'|\"[^\"]*\"|::|//?|\.\.|\(\)|[/.*:\[\]\(\)@=])|((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|\s+ccs�x�tj|�D]�}|d}|r�|ddkr�d|kr�y6|jdd�\}}|sJt�|dd|||ffVWq�tk
r�td|��Yq�Xq|VqWdS)N�r�{�:z{%s}%sz!prefix %r not found in prefix map)�xpath_tokenizer_re�findall�split�KeyError�SyntaxError)�pattern�
namespaces�token�tag�prefixZuri�r�-/usr/lib64/python3.6/xml/etree/ElementPath.py�xpath_tokenizerIsrcCsF|j}|dkrBi|_}x(|jj�D]}x|D]}|||<q.Wq$W|S)N)�
parent_map�root�iter)�contextr�p�errr�get_parent_mapWs

rcs|d��fdd�}|S)Nrc3s0x*|D]"}x|D]}|j�kr|VqWqWdS)N)r
)r�result�elemr)r
rr�selectbs


zprepare_child.<locals>.selectr)�nextrrr)r
r�
prepare_child`srcCsdd�}|S)Ncssx|D]}|EdHqWdS)Nr)rrrrrrrjs
zprepare_star.<locals>.selectr)rrrrrr�prepare_starisrcCsdd�}|S)Ncss|EdHdS)Nr)rrrrrrpszprepare_self.<locals>.selectr)rrrrrr�prepare_selfosrcs\y
|�}Wntk
rdSX|ddkr2d�n|dsD|d�ntd���fdd�}|S)Nr�*rzinvalid descendantc3s4x.|D]&}x |j��D]}||k	r|VqWqWdS)N)r)rrrr)r
rrrs
z"prepare_descendant.<locals>.select)�
StopIterationr	)rrrr)r
r�prepare_descendantts

r"cCsdd�}|S)NcssDt|�}i}x2|D]*}||kr||}||krd||<|VqWdS)N)r)rrrZ
result_mapr�parentrrrr�s
zprepare_parent.<locals>.selectr)rrrrrr�prepare_parent�s
r$cs*g}g}x�y
|�}Wntk
r(dSX|ddkr8P|drh|ddd�dkrhd|ddd�f}|j|dpvd�|j|d�q
Wdj|�}|dkr�|d��fd	d
�}|S|dkr�|d�|d���fdd
�}|S|dk�rtjd
|d��r|d��fdd
�}|S|dk�rVtjd
|d��rV|d�|d���fdd
�}|S|dk�st|dk�st|dk�r|dk�r�t|d�d��dk�rtd��nl|ddk�r�td��|dk�r
yt|d�d�Wntk
�r�td��YnX�dk�rtd��nd��fdd
�}|Std��dS) Nr�]rz'"�'�-�z@-c3s&x |D]}|j��dk	r|VqWdS)N)�get)rrr)�keyrrr�s
z!prepare_predicate.<locals>.selectz@-='c3s&x |D]}|j���kr|VqWdS)N)r))rrr)r*�valuerrr�s
z\-?\d+$c3s&x |D]}|j��dk	r|VqWdS)N)�find)rrr)r
rrr�s
z-='c3s@x:|D]2}x,|j��D]}dj|j���kr|VPqWqWdS)Nr()r�joinZitertext)rrrr)r
r+rrr�s

z-()z-()-zXPath position >= 1 expectedZlastzunsupported function�zunsupported expressionz)XPath offset from last() must be negativec
3sbt|�}xT|D]L}y.||}t|j|j��}|�|kr>|VWqttfk
rXYqXqWdS)N)r�listrr
�
IndexErrorr)rrrrr#Zelems)�indexrrr�s

zinvalid predicate���r2r2���r2)r!�appendr-�re�match�intr	�
ValueError)rrZ	signatureZ	predicaterr)r1r*r
r+r�prepare_predicate�sd







r9)r(r �.z..z//�[c@seZdZdZdd�ZdS)�_SelectorContextNcCs
||_dS)N)r)�selfrrrr�__init__�sz_SelectorContext.__init__)�__name__�
__module__�__qualname__rr>rrrrr<�sr<c
!Csh||dkrdntt|j���f}|dd�dkr8|d}yt|}Wn�tk
�r:tt�dkrjtj�|dd�dkr�td��tt	||��j
}y
|�}Wntk
r�dSXg}xvy|jt
|d||��Wntk
r�td��YnXy|�}|ddk�r|�}Wq�tk
�r(PYq�Xq�W|t|<YnX|g}t|�}x|D]}	|	||�}�qPW|S)	Nr�/r �dz#cannot use absolute path on elementrzinvalid pathr2)�tuple�sorted�items�_cacher�len�clearr	rr�__next__r!r4�opsr<)
r�pathrZ	cache_keyZselectorrrrrrrrr�iterfindsD


rMcCstt|||�d�S)N)rrM)rrLrrrrr,)sr,cCstt|||��S)N)r/rM)rrLrrrrr/srcCs4ytt|||��}|jpdStk
r.|SXdS)Nr()rrM�textr!)rrL�defaultrrrr�findtext5s

rP)N)N)N)N)NN)r5�compilerrrrrrr"r$r9rKrGr<rMr,rrPrrrr�<module>;s,
		
Y

)

PK�"[tH������2etree/__pycache__/ElementTree.cpython-36.opt-1.pycnu�[���3


 \���@sHdZddddddddd	d
ddd
ddddddddddgZdZddlZddlZddlZddlZddlZddlZddl	m
Z
Gdd
�d
e�Zdd�Z
Gdd�d�Zifd d�Zd^d!d�Zd_d"d�ZeZGd#d
�d
�ZGd$d�d�Zejd%d&��Zd`d'd(�Zd)d*�ZdaZyee�ZWnek
�r"YnXd8d9�Zd:d;�Zeeed<�Zd=d�Zd>d?d@dAdBdCdDdE�Z e e_ dFdG�Z!dHdI�Z"dJdK�Z#dLdM�Z$dbdNdO�dPd�Z%GdQdR�dRej&�Z'dcdNdO�dSd�Z(dTd�Z)dddUd	�Z*dedVd�Z+GdWd�d�Z,dfdXd�Z-dgdYd�Z.e-Z/dhdZd�Z0Gd[d�d�Z1Gd\d�d�Z2yeZ3dd]l4TWne5k
�rBYnXdS)iaLightweight 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_namespacez1.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__�rr�-/usr/lib64/python3.6/xml/etree/ElementTree.pyr
hscCs
t|d�S)z2Return True if *element* appears to be an Element.�tag)�hasattr)�elementrrr rvsc@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

    NcKsDt|t�std|jjf��|j�}|j|�||_||_g|_	dS)Nzattrib must be dict, not %s)
�
isinstance�dict�	TypeError�	__class__r�copy�updater!�attrib�	_children)�selfr!r*�extrarrr �__init__�s

zElement.__init__cCsd|jj|jt|�fS)Nz<%s %r at %#x>)r'rr!�id)r,rrr �__repr__�szElement.__repr__cCs|j||�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*rrr �makeelement�s	zElement.makeelementcCs0|j|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)r1r!r*�text�tail)r,�elemrrr r(�s
zElement.copycCs
t|j�S)N)�lenr+)r,rrr �__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�
FutureWarningr5r+)r,rrr �__bool__�s
zElement.__bool__cCs
|j|S)N)r+)r,�indexrrr �__getitem__�szElement.__getitem__cCs||j|<dS)N)r+)r,r=r#rrr �__setitem__�szElement.__setitem__cCs|j|=dS)N)r+)r,r=rrr �__delitem__�szElement.__delitem__cCs|j|�|jj|�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)�_assert_is_elementr+�append)r,�
subelementrrr rB�s
zElement.appendcCs(x|D]}|j|�qW|jj|�dS)zkAppend subelements from a sequence.

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

        N)rAr+�extend)r,�elementsr#rrr rD�s
zElement.extendcCs|j|�|jj||�dS)z(Insert *subelement* at position *index*.N)rAr+�insert)r,r=rCrrr rF�s
zElement.insertcCs t|t�stdt|�j��dS)Nzexpected an Element, not %s)r$�_Element_Pyr&�typer)r,�errr rA�s
zElement._assert_is_elementcCs|jj|�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+�remove)r,rCrrr rJs
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.r7)r8)r9r:�DeprecationWarningr+)r,rrr �getchildrens
zElement.getchildrencCstj|||�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�
namespacesrrr rM!s	zElement.findcCstj||||�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,rN�defaultrOrrr rP,szElement.findtextcCstj|||�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�findall)r,rNrOrrr rR:s	zElement.findallcCstj|||�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�iterfind)r,rNrOrrr rSEs	zElement.iterfindcCs |jj�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+r2r3)r,rrr rTPs
z
Element.clearcCs|jj||�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,�keyrQrrr rU[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,rV�valuerrr �sethszElement.setcCs
|jj�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*�keys)r,rrr rYrszElement.keyscCs
|jj�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*�items)r,rrr rZ{s	z
Element.itemsccsH|dkrd}|dks|j|kr$|Vx|jD]}|j|�EdHq,WdS)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!rIrrr r\�szElement.itercCstjdtdd�t|j|��S)NzbThis method will be removed in future versions.  Use 'elem.iter()' or 'list(elem.iter())' instead.r7)r8)r9r:�PendingDeprecationWarning�listr\)r,r!rrr �getiterator�s
zElement.getiteratorccs^|j}t|t�r|dk	rdS|j}|r.|Vx*|D]"}|j�EdH|j}|r4|Vq4WdS)z�Create text iterator.

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

        N)r!r$�strr2�itertextr3)r,r!�trIrrr ra�s
zElement.itertext)N)NN)N)N)N)N)N)#rrrrr!r*r2r3r.r0r1r(r6r<r>r?r@rBrDrFrArJrLrMrPrRrSrTrUrXrYrZr\r_rarrrr r{s@	









	

	cKs,|j�}|j|�|j||�}|j|�|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.

    )r(r)r1rB)�parentr!r*r-r#rrr 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.

    )rrr2)r2r#rrr 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r2)�targetr2r#rrr 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)r2)r,Ztext_or_urir!rrr r.�szQName.__init__cCs|jS)N)r2)r,rrr �__str__sz
QName.__str__cCsd|jj|jfS)Nz<%s %r>)r'rr2)r,rrr r0szQName.__repr__cCs
t|j�S)N)�hashr2)r,rrr �__hash__szQName.__hash__cCs t|t�r|j|jkS|j|kS)N)r$r
r2)r,�otherrrr �__le__s
zQName.__le__cCs t|t�r|j|jkS|j|kS)N)r$r
r2)r,rirrr �__lt__
s
zQName.__lt__cCs t|t�r|j|jkS|j|kS)N)r$r
r2)r,rirrr �__ge__s
zQName.__ge__cCs t|t�r|j|jkS|j|kS)N)r$r
r2)r,rirrr �__gt__s
zQName.__gt__cCs t|t�r|j|jkS|j|kS)N)r$r
r2)r,rirrr �__eq__s
zQName.__eq__)N)
rrrrr.rfr0rhrjrkrlrmrnrrrr 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|j|�dS)N)�_rootr	)r,r#�filerrr r.)szElementTree.__init__cCs|jS)z!Return root element of this tree.)ro)r,rrr �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!

        N)ro)r,r#rrr �_setroot3szElementTree._setrootc
Cs�d}t|d�st|d�}d}zZ|dkrHt�}t|d�rH|j|�|_|jSx|jd�}|sZP|j|�qJW|j�|_|jS|r�|j�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"�openrrurors�feed�close)r,�source�parser�close_source�datarrr r	=s&




zElementTree.parsecCs|jj|�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).

        )ror\)r,r!rrr r\bs
zElementTree.itercCstjdtdd�t|j|��S)NzbThis method will be removed in future versions.  Use 'tree.iter()' or 'list(tree.iter())' instead.r7)r8)r9r:r]r^r\)r,r!rrr r_os
zElementTree.getiteratorcCs:|dd�dkr,d|}tjd|tdd�|jj||�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�/�.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 %rr7)r8)r9r:r;rorM)r,rNrOrrr rMxs
zElementTree.findcCs<|dd�dkr,d|}tjd|tdd�|jj|||�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~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 %rr7)r8)r9r:r;rorP)r,rNrQrOrrr rP�s
zElementTree.findtextcCs:|dd�dkr,d|}tjd|tdd�|jj||�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~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 %rr7)r8)r9r:r;rorR)r,rNrOrrr rR�s
zElementTree.findallcCs:|dd�dkr,d|}tjd|tdd�|jj||�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~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 %rr7)r8)r9r:r;rorS)r,rNrOrrr rS�s
zElementTree.iterfindT)�short_empty_elementscCs�|s
d}n|tkrtd|��|s4|dkr0d}nd}|j�}t||���}|dkr�|sd|dkr�|dkr�|}	|dkr�ddl}
|
j�}	|d	|	f�|d
kr�t||j�n,t|j|�\}}t|}
|
||j|||d�WdQRXdS)
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�unicoderz$<?xml version='1.0' encoding='%s'?>
r2)r)r�r�r�)	�
_serialize�
ValueError�lower�_get_writer�locale�getpreferredencoding�_serialize_textro�_namespaces)r,�file_or_filename�encodingZxml_declaration�default_namespace�methodrZ	enc_lower�writeZdeclared_encodingr��qnamesrOZ	serializerrr r��s2
zElementTree.writecCs|j|dd�S)Nr�)r�)r�)r,rprrr �
write_c14n
szElementTree.write_c14n)NN)N)N)N)N)NN)N)N)NNNN)rrrrr.rqrrr	r\r_rMrPrRrSr�r�rrrr rs"



%

	



5ccs"y
|j}WnPtk
rZ|dkr.t|d�}nt|d|dd�}|�|jVWdQRXYn�X|dkrl|Vn�tj���}t|tj�r�|}nft|tj�r�tj	|�}|j
|j�nBtj�}dd�|_||_y|j
|_
|j|_Wntk
r�YnXtj||ddd�}|j
|j�|jVWdQRXdS)	Nr��w�xmlcharrefreplace)r��errorscSsdS)NTrrrrr �<lambda>3sz_get_writer.<locals>.<lambda>�
)r�r��newline)r��AttributeErrorrv�
contextlib�	ExitStackr$�io�BufferedIOBase�	RawIOBase�BufferedWriter�callback�detach�writable�seekable�tell�
TextIOWrapper)r�r�r�rp�stackrrr r�s>



r�csddi�i��rd��<���fdd�}x�|j�D]�}|j}t|t�r\|j�kr�||j�n<t|t�rx|�kr�||�n |dk	r�|tk	r�|tk	r�t|�xR|j	�D]F\}}t|t�r�|j}|�kr�||�t|t�r�|j�kr�||j�q�W|j}t|t�r2|j�kr2||j�q2W��fS)N�cs�y�|dd�dkr�|dd�jdd�\}}�j|�}|dkrjtj|�}|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)�rsplitrU�_namespace_mapr5r�r&�_raise_serialization_error)Zqname�urir!�prefix)r�rOr�rr �	add_qnamePs&


z_namespaces.<locals>.add_qname)
r\r!r$r
r2r`rrr�rZ)r4r�r�r!rVrWr2r)r�rOr�r r�Es4




r�cKs�|j}|j}|tkr$|d|��n�|tkr<|d|��nv||}|dkr�|r\|t|��x|D]}t|||d|d�qbW�n2|d|�t|j��}	|	s�|�rD|r�x@t|j�dd�d�D](\}
}|r�d|}|d	|t	|
�f�q�WxZt|	�D]N\}}
t
|t��r|j}t
|
t��r$||
j}
nt	|
�}
|d
|||
f�q�W|�s\t|��s\|�r�|d�|�rv|t|��x |D]}t|||d|d��q|W|d|d�n|d
�|j
�r�|t|j
��dS)Nz	<!--%s-->z<?%s?>)r�<cSs|dS)Nrr)�xrrr r��sz _serialize_xml.<locals>.<lambda>)rV�:z
 xmlns%s="%s"z %s="%s"�>z</z />)r!r2rr�
_escape_cdata�_serialize_xmlr^rZ�sorted�_escape_attribr$r
r5r3)r�r4r�rOr�kwargsr!r2rIrZ�v�krrr r��sT





r��area�base�basefont�br�col�frame�hr�img�input�isindex�link�meta�paramcKs�|j}|j}|tkr(|dt|���n�|tkrD|dt|���n|||}|dkr�|rd|t|��x|D]}t|||d�qjW�n<|d|�t|j��}|s�|�rH|r�x@t|j�dd�d�D](\}	}
|
r�d|
}
|d|
t	|	�f�q�WxZt|�D]N\}
}	t
|
t��r|
j}
t
|	t��r(||	j}	nt|	�}	|d	||
|	f�q�W|d
�|j
�}|�r�|dk�sr|dk�r|||�n|t|��x|D]}t|||d��q�W|tk�r�|d
|d
�|j�r�|t|j��dS)Nz	<!--%s-->z<?%s?>r�cSs|dS)Nrr)r�rrr r��sz!_serialize_html.<locals>.<lambda>)rVr�z
 xmlns%s="%s"z %s="%s"r�ZscriptZstylez</)r!r2rr�r�_serialize_htmlr^rZr�r�r$r
�_escape_attrib_htmlr��
HTML_EMPTYr3)r�r4r�rOr�r!r2rIrZr�r�Zltagrrr r��sT





r�cCs.x|j�D]}||�q
W|jr*||j�dS)N)rar3)r�r4�partrrr r��sr�)r��htmlr2cCsPtjd|�rtd��x.ttj��D]\}}||ks:||kr"t|=q"W|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�r^r�rZ)r�r�r�r�rrr r�s
r�r�ZrdfZwsdlZxsZxsiZdc)z$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&rHr)r2rrr r�sr�cCsfy@d|kr|jdd�}d|kr*|jdd�}d|kr>|jdd�}|Sttfk
r`t|�YnXdS)N�&z&amp;r�z&lt;r�z&gt;)�replacer&r�r�)r2rrr r�$sr�cCs�y�d|kr|jdd�}d|kr*|jdd�}d|kr>|jdd�}d|krR|jdd�}d	|krf|jd	d
�}d|krz|jdd
�}d
|kr�|jd
d�}d
|kr�|jd
d�}|Sttfk
r�t|�YnXdS)Nr�z&amp;r�z&lt;r�z&gt;�"z&quot;z
r��
z&#10;�	z&#09;)r�r&r�r�)r2rrr r�4s(r�cCsfy@d|kr|jdd�}d|kr*|jdd�}d|kr>|jdd�}|Sttfk
r`t|�YnXdS)Nr�z&amp;r�z&gt;r�z&quot;)r�r&r�r�)r2rrr r�Psr�T)rcCs6|dkrtj�ntj�}t|�j||||d�|j�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".

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

    r�)r�r)r��StringIO�BytesIOrr��getvalue)r#r�r�r�streamrrr r_sc@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�_ListDataStreamz7An auxiliary stream accumulating into a list reference.cCs
||_dS)N)�lst)r,r�rrr r.tsz_ListDataStream.__init__cCsdS)NTr)r,rrr r�wsz_ListDataStream.writablecCsdS)NTr)r,rrr r�zsz_ListDataStream.seekablecCs|jj|�dS)N)r�rB)r,�brrr r�}sz_ListDataStream.writecCs
t|j�S)N)r5r�)r,rrr r��sz_ListDataStream.tellN)	rrrrr.r�r�r�r�rrrr r�rsr�cCs&g}t|�}t|�j||||d�|S)N)r�r)r�rr�)r#r�r�rr�r�rrr r�s
cCsNt|t�st|�}|jtjdd�|j�j}|s>|ddkrJtjjd�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�rr�N���)r$rr��sys�stdoutrqr3)r4r3rrr r�s

cCst�}|j||�|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	)ryrz�treerrr r	�s	csdt||d������fdd��G�fdd�dtj�}|��d�_�~d�t�d�s`t�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�_parserc
3sbzNx,�j�EdH�jd�}|s"P�j|�qW�j�}�j�EdH|�_Wd�r\�j�XdS)N�ii@)�read_eventsrsrw�_close_and_return_root�rootrx)r|r�)r{�it�
pullparserryrr �iterator�s

ziterparse.<locals>.iteratorcseZdZ��jZdS)z$iterparse.<locals>.IterParseIteratorN)rrr�__next__r)r�rr �IterParseIterator�sr�NFrsrtT)r�collections�Iteratorr�r"rv)ryr�rzr�r)r{r�r�r�ryr r�s

c@s<eZdZd
dd�dd�Zdd�Zdd�Zd	d
�Zdd�ZdS)rN)r�cCs<tj�|_|ptt�d�|_|dkr(d}|jj|j|�dS)N)re�end)r�)r��deque�
_events_queuerrr��
_setevents)r,r�r�rrr r.�s

zXMLPullParser.__init__cCsZ|jdkrtd��|rVy|jj|�Wn.tk
rT}z|jj|�WYdd}~XnXdS)zFeed encoded data to parser.Nz!feed() called after end of stream)r�r�rw�SyntaxErrorr�rB)r,r|�excrrr rw�s
zXMLPullParser.feedcCs|jj�}d|_|S)N)r�rx)r,r�rrr r��s
z$XMLPullParser._close_and_return_rootcCs|j�dS)z�Finish feeding data to parser.

        Unlike XMLParser, does not return the root element. Use
        read_events() to consume elements from XMLPullParser.
        N)r�)r,rrr rx�szXMLPullParser.closeccs2|j}x&|r,|j�}t|t�r$|�q|VqWdS)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��eventrrr r�s
zXMLPullParser.read_events)N)rrrr.rwr�rxr�rrrr r�s

cCs"|stt�d�}|j|�|j�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.

    )re)rrrwrx)r2rzrrr rs
cCsV|stt�d�}|j|�|j�}i}x&|j�D]}|jd�}|r0|||<q0W||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.

    )rer/)rrrwrxr\rU)r2rzr�Zidsr4r/rrr r&s


cCs0|stt�d�}x|D]}|j|�qW|j�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.

    )re)rrrwrx)Zsequencerzr2rrr r>s
	
c@sBeZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dS)ra�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.

    NcCs.g|_g|_d|_d|_|dkr$t}||_dS)N)�_data�_elem�_last�_tailr�_factory)r,Zelement_factoryrrr r.]szTreeBuilder.__init__cCs|jS)z;Flush builder buffers and return toplevel document Element.)r�)r,rrr rxfszTreeBuilder.closecCs>|jr:|jdk	r4dj|j�}|jr,||j_n||j_g|_dS)Nr�)r�r��joinr�r3r2)r,r2rrr �_flushls

zTreeBuilder._flushcCs|jj|�dS)zAdd text to current element.N)r�rB)r,r|rrr r|xszTreeBuilder.datacCsF|j�|j||�|_}|jr0|jdj|�|jj|�d|_|S)z�Open new element and return it.

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

        rrr�)r�r�r�r�rBr�)r,r!Zattrsr4rrr �start|szTreeBuilder.startcCs |j�|jj�|_d|_|jS)zOClose and return current Element.

        *tag* is the element name.

        r)r�r��popr�r�)r,r!rrr r��szTreeBuilder.end)N)
rrrrr.rxr�r|r�r�rrrr rPs
	c@sfeZdZdZddd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�ZeZdd�Z
dd�ZdS)ra�Element structure builder for XML source data based on the expat parser.

    *html* are predefined HTML entities (deprecated and not supported),
    *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

    rNcCs<yddlm}Wn>tk
rNyddl}Wntk
rHtd��YnXYnX|j|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|_d
|_d
|_d
|_d|_i|_yd|j|_ Wnt!k
�r6YnXdS)Nr)�expatz7No module named expat; use SimpleXMLTreeBuilder insteadr�r�r�r|�comment�pirzExpat %d.%d.%d)"�xml.parsersr��ImportErrorZpyexpatZParserCreaterrzr�re�_target�error�_error�_names�_defaultZDefaultHandlerExpandr"�_start�StartElementHandler�_end�EndElementHandlerr|ZCharacterDataHandlerrZCommentHandlerrZProcessingInstructionHandlerZbuffer_text�ordered_attributes�specified_attributes�_doctype�entity�version_info�versionr�)r,r�rer�r�rzrrr r.�sF




zXMLParser.__init__cCs�|j}|j}x�|D]�}|dkrDd|_d|_|||jfdd�}||_q|dkrf|||jfdd�}||_q|dkr�||fdd�}||_q|d	kr�||fd
d�}||_	qt
d|��qWdS)Nr�rcSs|||||�f�dS)Nr)r!Z	attrib_inr�rBr�rrr �handler�sz%XMLParser._setevents.<locals>.handlerr�cSs||||�f�dS)Nr)r!r�rBr�rrr r�szstart-nscSs|||p
d|pdff�dS)Nr�r)r�r�r�rBrrr r�szend-nscSs||df�dS)Nr)r�r�rBrrr r�szunknown event %r)r�rBr
rr	r
rrZStartNamespaceDeclHandlerZEndNamespaceDeclHandlerr�)r,Zevents_queueZevents_to_reportrzrBZ
event_namerrrr r��s(
zXMLParser._seteventscCs&t|�}|j|_|j|jf|_|�dS)N)r
�code�lineno�offsetZposition)r,rW�errrrr �_raiseerror�szXMLParser._raiseerrorcCsFy|j|}Wn2tk
r@|}d|kr2d|}||j|<YnX|S)Nr�r�)r�KeyError)r,rV�namerrr �_fixname�szXMLParser._fixnamecCsV|j}||�}i}|rHx0tdt|�d�D]}||d||||�<q(W|jj||�S)Nrr7r)r�ranger5rer�)r,r!Z	attr_listZfixnamer*�irrr r	szXMLParser._startcCs|jj|j|��S)N)rer�r)r,r!rrr rszXMLParser._endcCs�|dd�}|dkr�y|jj}Wntk
r4dSXy||j|dd��WnZtk
r�ddlm}|jd||jj	|jj
f�}d|_|jj	|_|jj
|_
|�YnX�nD|dkr�|dd�d	kr�g|_�n"|jdk	�r�|d
kr�d|_dS|j�}|�sdS|jj|�t|j�}|dk�r�|jd}|dk�rb|d
k�rb|j\}}}	}
|	�r�|	dd�}	n*|dk�r�|dk�r�|j\}}}
d}	ndSt|jd��r�|jj||	|
dd��n:|j|jk�r�|j||	|
dd��|j||	|
dd��d|_dS)Nrr�r)r�z'undefined entity %s: line %d, column %d�r��	z	<!DOCTYPEr�r7ZPUBLIC�ZSYSTEM��doctyper�r�r�r�r�)rer|r�rrrr�rrzZErrorLineNumberZErrorColumnNumberrrrr�striprBr5r"r"�_XMLParser__doctype)r,r2r�Zdata_handlerr�r�nrHr�pubid�systemrrr rsZ





zXMLParser._defaultcCstjdt�dS)z�(Deprecated)  Handle doctype declaration

        *name* is the Doctype name, *pubid* is the public identifier,
        and *system* is the system identifier.

        z[This method of XMLParser is deprecated.  Define doctype() method on the TreeBuilder target.N)r9r:rK)r,rr&r'rrr r"EszXMLParser.doctypecCsFy|jj|d�Wn.|jk
r@}z|j|�WYdd}~XnXdS)zFeed encoded data to parser.rN)rz�Parserr)r,r|r�rrr rwUszXMLParser.feedcCs�y|jjdd�Wn.|jk
r@}z|j|�WYdd}~XnXz,y|jj}Wntk
rdYnX|�SWd|`|`|`|`XdS)z;Finish feeding data to parser and return element structure.r�rN)	rzr(rrrerxr�r�r)r,r�Z
close_handlerrrr rx\s
zXMLParser.close)rNN)rrrrr.r�rrr	rrr"r$rwrxrrrr r�s	
*!4)r[)N)N)N)
r�r�r�r�r�r�r�r�r�r�r�r�r�)NN)NN)N)NN)N)N)N)6r�__all__rr�r�r9r�r�r�r�rr�r
rrrrrrr
r�contextmanagerr�r�r�r�rX�	NameErrorr�r�r�rr�r�r�r�r�rr�r�rrr	rrrrrrrrrGZ_elementtreerrrrr �<module>"s�)A

0t4
=22

05


KUPK�"[#�}P��-etree/__pycache__/cElementTree.cpython-36.pycnu�[���3


 \R�@sddlTdS)�)�*N)Zxml.etree.ElementTree�rr�./usr/lib64/python3.6/xml/etree/cElementTree.py�<module>sPK�"[ �J��)__pycache__/__init__.cpython-36.opt-1.pycnu�[���3


 \-�@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.6/xml/__init__.py�<module>sPK�"[!�����)__pycache__/__init__.cpython-36.opt-2.pycnu�[���3


 \-�@sddddgZdS)ZdomZparsersZsaxZetreeN)�__all__�rr�$/usr/lib64/python3.6/xml/__init__.py�<module>sPK�"[ �J��#__pycache__/__init__.cpython-36.pycnu�[���3


 \-�@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.6/xml/__init__.py�<module>sPK�"[��VZZ-sax/__pycache__/__init__.cpython-36.opt-1.pycnu�[���3


 \.�@sdZddlmZddlmZmZddlmZmZm	Z	m
Z
mZe�fdd�Ze�fdd�Z
d	gZd
Zernd
dlZd
dlZd
dlZejjr�dejkr�ejdjd
�Z[dZejdd�dkr�ejje�r�ejje�jd
�Zgfdd�Zejdd�dk�rdd�Zndd�Z[dS)a�Simple API for XML (SAX) implementation for Python.

This module provides an implementation of the SAX 2 interface;
information about the Java version of the interface can be found at
http://www.megginson.com/SAX/.  The Python version of the interface is
documented at <...>.

This package contains the following modules:

handler -- Base classes and constants which define the SAX 2 API for
           the 'client-side' of SAX for Python.

saxutils -- Implementation of the convenience classes commonly used to
            work with SAX.

xmlreader -- Base classes and constants which define the SAX 2 API for
             the parsers used with SAX for Python.

expatreader -- Driver that allows use of the Expat parser with SAX.
�)�InputSource)�ContentHandler�ErrorHandler)�SAXException�SAXNotRecognizedException�SAXParseException�SAXNotSupportedException�SAXReaderNotAvailablecCs(t�}|j|�|j|�|j|�dS)N)�make_parser�setContentHandler�setErrorHandler�parse)�source�handler�errorHandler�parser�r�(/usr/lib64/python3.6/xml/sax/__init__.pyr
s

r
cCspddl}|dkrt�}t�}|j|�|j|�t�}t|t�rR|j|j	|��n|j
|j|��|j|�dS)N�)
�iorr
rrr�
isinstance�strZsetCharacterStream�StringIOZ
setByteStream�BytesIOr
)�stringrrrrZinpsrcrrr�parseString#s


rzxml.sax.expatreaderrNZ
PY_SAX_PARSER�,zpython.xml.sax.parser��javacCsrxb|tD]V}yt|�Stk
rL}zddl}||jkr<�WYdd}~Xq
tk
r^Yq
Xq
Wtdd��dS)a&Creates and returns a SAX parser.

    Creates the first parser it is able to instantiate of the ones
    given in the list created by doing parser_list +
    default_parser_list.  The lists must contain the names of Python
    modules containing both a SAX parser and a create_parser function.rNzNo parsers found)�default_parser_list�_create_parser�ImportError�sys�modulesr	)Zparser_list�parser_name�er"rrrr
Fs

r
cCs$ddlm}|j|dt��}|j�S)Nr)�imp)Zorg.python.corer&Z
importName�globals�
create_parser)r$r&�
drv_modulerrrr asr cCst|iidg�}|j�S)Nr()�
__import__r()r$r)rrrr gs)�__doc__Z	xmlreaderrrrr�_exceptionsrrrrr	r
rr�_falseZxml.sax.expatreaderZxml�osr"�flags�ignore_environment�environ�splitZ_key�platform�registryZcontainsKeyZgetPropertyr
r rrrr�<module>s*
PK�"[&�y�	2	2-sax/__pycache__/saxutils.cpython-36.opt-1.pycnu�[���3


 \�/�@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&x |j�D]\}}|j||�}q
W|S)z2Replace substrings of a string using a dictionary.)�items�replace)�s�d�key�value�r�(/usr/lib64/python3.6/xml/sax/saxutils.py�__dict_replacesr
cCs6|jdd�}|jdd�}|jdd�}|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.
    �&z&amp;�>z&gt;�<z&lt;)rr
)�data�entitiesrrr�escapes	
rcCs2|jdd�}|jdd�}|r&t||�}|jdd�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.
    z&lt;rz&gt;rz&amp;r)rr
)rrrrr�unescape"s

rcCs\|j�}|jdddd��t||�}d|krPd|krFd|jdd�}qXd	|}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')�copy�updaterr)rrrrr�	quoteattr0s

rcs��dkrddl}|jSt�tj�r&�St�tjtjf�r<�St�tj�rlG�fdd�d�}|�}dd�|_	nDtj
�}dd�|_�j|_y�j
|_
�j|_Wntk
r�YnXtj||ddd	d
�S)NrcseZdZ�jZ�fdd�ZdS)z _gettextwriter.<locals>._wrappercs
t�|�S)N)�getattr)�self�name)�outrr�__getattr__[sz,_gettextwriter.<locals>._wrapper.__getattr__N)�__name__�
__module__�__qualname__�	__class__r!r)r rr�_wrapperYsr&cSsdS)Nrrrrr�<lambda>^sz _gettextwriter.<locals>.<lambda>cSsdS)NTrrrrrr'cs�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)r-r&�bufferr)r r�_gettextwriterHs.
r?c@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-1FcCsVtjj|�t||�}|j|_|j|_ig|_|jd|_	g|_
||_||_d|_
dS)NrF���)r�ContentHandler�__init__r?r9�_write�flush�_flush�_ns_contexts�_current_context�_undeclared_ns_maps�	_encoding�_short_empty_elements�_pending_start_element)rr r)Zshort_empty_elementsrrrrDss
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�:)rI)rr�prefixrrr�_qnameszXMLGenerator._qnamecCs|jr|jd�d|_dS)NrF)rMrE)r�
endElementrrr�_finish_pending_start_element�s
z*XMLGenerator._finish_pending_start_elementcCs|jd|j�dS)Nz$<?xml version="1.0" encoding="%s"?>
)rErK)rrrr�
startDocument�szXMLGenerator.startDocumentcCs|j�dS)N)rG)rrrr�endDocument�szXMLGenerator.endDocumentcCs0|jj|jj��||j|<|jj||f�dS)N)rH�appendrIrrJ)rrO�urirrr�startPrefixMapping�s
zXMLGenerator.startPrefixMappingcCs|jd|_|jd=dS)NrrBrB)rHrI)rrOrrr�endPrefixMapping�szXMLGenerator.endPrefixMappingcCs^|j�|jd|�x*|j�D]\}}|jd|t|�f�q W|jrPd|_n
|jd�dS)Nrz %s=%sTr)rRrErrrLrM)rr�attrsr
rrr�startElement�szXMLGenerator.startElementcCs*|jr|jd�d|_n|jd|�dS)Nz/>Fz</%s>)rMrE)rrrrrrQ�s
zXMLGenerator.endElementcCs�|j�|jd|j|��x8|jD].\}}|rD|jd||f�q$|jd|�q$Wg|_x0|j�D]$\}}|jd|j|�t|�f�qfW|jr�d|_n
|jd�dS)Nrz xmlns:%s="%s"z xmlns="%s"z %s=%sTr)rRrErPrJrrrLrM)rr�qnamerYrOrVr
rrr�startElementNS�s zXMLGenerator.startElementNScCs0|jr|jd�d|_n|jd|j|��dS)Nz/>Fz</%s>)rMrErP)rrr[rrr�endElementNS�s
zXMLGenerator.endElementNScCs4|r0|j�t|t�s"t||j�}|jt|��dS)N)rRr/�strrKrEr)r�contentrrr�
characters�s

zXMLGenerator.characterscCs0|r,|j�t|t�s"t||j�}|j|�dS)N)rRr/r^rKrE)rr_rrr�ignorableWhitespace�s

z XMLGenerator.ignorableWhitespacecCs|j�|jd||f�dS)Nz	<?%s %s?>)rRrE)r�targetrrrr�processingInstruction�sz"XMLGenerator.processingInstruction)NrAF)F)r"r#r$rDrPrRrSrTrWrXrZrQr\r]r`rarcrrrrr@qs


r@c@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.NcCstjj|�||_dS)N)r�	XMLReaderrD�_parent)r�parentrrrrD�szXMLFilterBase.__init__cCs|jj|�dS)N)�_err_handler�error)r�	exceptionrrrri�szXMLFilterBase.errorcCs|jj|�dS)N)rh�
fatalError)rrjrrrrk�szXMLFilterBase.fatalErrorcCs|jj|�dS)N)rh�warning)rrjrrrrl�szXMLFilterBase.warningcCs|jj|�dS)N)�
_cont_handler�setDocumentLocator)rZlocatorrrrrn�sz XMLFilterBase.setDocumentLocatorcCs|jj�dS)N)rmrS)rrrrrSszXMLFilterBase.startDocumentcCs|jj�dS)N)rmrT)rrrrrTszXMLFilterBase.endDocumentcCs|jj||�dS)N)rmrW)rrOrVrrrrWsz XMLFilterBase.startPrefixMappingcCs|jj|�dS)N)rmrX)rrOrrrrX	szXMLFilterBase.endPrefixMappingcCs|jj||�dS)N)rmrZ)rrrYrrrrZszXMLFilterBase.startElementcCs|jj|�dS)N)rmrQ)rrrrrrQszXMLFilterBase.endElementcCs|jj|||�dS)N)rmr\)rrr[rYrrrr\szXMLFilterBase.startElementNScCs|jj||�dS)N)rmr])rrr[rrrr]szXMLFilterBase.endElementNScCs|jj|�dS)N)rmr`)rr_rrrr`szXMLFilterBase.characterscCs|jj|�dS)N)rmra)r�charsrrrrasz!XMLFilterBase.ignorableWhitespacecCs|jj||�dS)N)rmrc)rrbrrrrrcsz#XMLFilterBase.processingInstructioncCs|jj|�dS)N)rm�
skippedEntity)rrrrrrp!szXMLFilterBase.skippedEntitycCs|jj|||�dS)N)�_dtd_handler�notationDecl)rr�publicId�systemIdrrrrr&szXMLFilterBase.notationDeclcCs|jj||||�dS)N)rq�unparsedEntityDecl)rrrsrtZndatarrrru)sz XMLFilterBase.unparsedEntityDeclcCs|jj||�S)N)Z_ent_handler�
resolveEntity)rrsrtrrrrv.szXMLFilterBase.resolveEntitycCs@|jj|�|jj|�|jj|�|jj|�|jj|�dS)N)rfZsetContentHandlerZsetErrorHandlerZsetEntityResolverZ
setDTDHandler�parse)r�sourcerrrrw3s
zXMLFilterBase.parsecCs|jj|�dS)N)rf�	setLocale)rZlocalerrrry:szXMLFilterBase.setLocalecCs|jj|�S)N)rf�
getFeature)rrrrrrz=szXMLFilterBase.getFeaturecCs|jj||�dS)N)rf�
setFeature)rr�staterrrr{@szXMLFilterBase.setFeaturecCs|jj|�S)N)rf�getProperty)rrrrrr}CszXMLFilterBase.getPropertycCs|jj||�dS)N)rf�setProperty)rrr
rrrr~FszXMLFilterBase.setPropertycCs|jS)N)rf)rrrr�	getParentKszXMLFilterBase.getParentcCs
||_dS)N)rf)rrgrrr�	setParentNszXMLFilterBase.setParent)N) r"r#r$�__doc__rDrirkrlrnrSrTrWrXrZrQr\r]r`rarcrprrrurvrwryrzr{r}r~rr�rrrrrd�s:
rd�cCst|t�rtj|�}n^t|d�rt|}tj�}t|jd�t�rH|j|�n
|j|�t|d�rtt|jt�rt|j	|j�|j
�dko�|j�dk�r|j�}t
jjt
jj|��}t
jj||�}t
jj|�r�|j	|�t|d�}n$|j	tjj||��tjj|j��}|j|�|S)z�This function takes an InputSource and an optional base URL and
    returns a fully resolved InputSource object ready for reading.�readrrN�rb)r/r^rZInputSource�hasattrr�ZsetCharacterStreamZ
setByteStreamrZsetSystemIdZgetCharacterStreamZ
getByteStreamZgetSystemId�os�path�dirname�normpath�join�isfile�open�urllibrwZurljoinZrequestZurlopen)rx�base�fZsysidZbaseheadZ
sysidfilenamerrr�prepare_input_sourceSs*




r�)r�)r�r�Zurllib.parser�Zurllib.requestr0r2r�rrr
rrrr?rCr@rerdr�rrrr�<module>s)soPK�"[_��&00&sax/__pycache__/handler.cpython-36.pycnu�[���3


 \b6�@s�dZdZGdd�d�ZGdd�d�ZGdd�d�ZGdd	�d	�Zd
ZdZdZd
Z	dZ
dZeeee	e
egZdZ
dZdZdZdZdZe
eeeeegZdS)a0
This module contains the core classes of version 2.0 of SAX for Python.
This file provides only default classes with absolutely minimum
functionality, from which drivers and applications can be subclassed.

Many of these classes are empty and are included only as documentation
of the interfaces.

$Id$
z2.0betac@s(eZdZdZdd�Zdd�Zdd�ZdS)	�ErrorHandlera�Basic interface for SAX error handlers.

    If you create an object that implements this interface, then
    register the object with your XMLReader, the parser will call the
    methods in your object to report all warnings and errors. There
    are three levels of errors available: warnings, (possibly)
    recoverable errors, and unrecoverable errors. All methods take a
    SAXParseException as the only parameter.cCs|�dS)zHandle a recoverable error.N�)�self�	exceptionrr�'/usr/lib64/python3.6/xml/sax/handler.py�error szErrorHandler.errorcCs|�dS)zHandle a non-recoverable error.Nr)rrrrr�
fatalError$szErrorHandler.fatalErrorcCst|�dS)zHandle a warning.N)�print)rrrrr�warning(szErrorHandler.warningN)�__name__�
__module__�__qualname__�__doc__rrr	rrrrrsrc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�ContentHandlerz�Interface for receiving logical document content events.

    This is the main callback interface in SAX, and the one most
    important to applications. The order of events in this interface
    mirrors the order of the information in the document.cCs
d|_dS)N)�_locator)rrrr�__init__6szContentHandler.__init__cCs
||_dS)a#Called by the parser to give the application a locator for
        locating the origin of document events.

        SAX parsers are strongly encouraged (though not absolutely
        required) to supply a locator: if it does so, it must supply
        the locator to the application by invoking this method before
        invoking any of the other methods in the DocumentHandler
        interface.

        The locator allows the application to determine the end
        position of any document-related event, even if the parser is
        not reporting an error. Typically, the application will use
        this information for reporting its own errors (such as
        character content that does not match an application's
        business rules). The information returned by the locator is
        probably not sufficient for use with a search engine.

        Note that the locator will return correct information only
        during the invocation of the events in this interface. The
        application should not attempt to use it at any other time.N)r)rZlocatorrrr�setDocumentLocator9sz!ContentHandler.setDocumentLocatorcCsdS)z�Receive notification of the beginning of a document.

        The SAX parser will invoke this method only once, before any
        other methods in this interface or in DTDHandler (except for
        setDocumentLocator).Nr)rrrr�
startDocumentPszContentHandler.startDocumentcCsdS)aQReceive notification of the end of a document.

        The SAX parser will invoke this method only once, and it will
        be the last method invoked during the parse. The parser shall
        not invoke this method until it has either abandoned parsing
        (because of an unrecoverable error) or reached the end of
        input.Nr)rrrr�endDocumentWszContentHandler.endDocumentcCsdS)aBegin the scope of a prefix-URI Namespace mapping.

        The information from this event is not necessary for normal
        Namespace processing: the SAX XML reader will automatically
        replace prefixes for element and attribute names when the
        http://xml.org/sax/features/namespaces feature is true (the
        default).

        There are cases, however, when applications need to use
        prefixes in character data or in attribute values, where they
        cannot safely be expanded automatically; the
        start/endPrefixMapping event supplies the information to the
        application to expand prefixes in those contexts itself, if
        necessary.

        Note that start/endPrefixMapping events are not guaranteed to
        be properly nested relative to each-other: all
        startPrefixMapping events will occur before the corresponding
        startElement event, and all endPrefixMapping events will occur
        after the corresponding endElement event, but their order is
        not guaranteed.Nr)r�prefixZurirrr�startPrefixMapping`sz!ContentHandler.startPrefixMappingcCsdS)z�End the scope of a prefix-URI mapping.

        See startPrefixMapping for details. This event will always
        occur after the corresponding endElement event, but the order
        of endPrefixMapping events is not otherwise guaranteed.Nr)rrrrr�endPrefixMappingwszContentHandler.endPrefixMappingcCsdS)aSignals the start of an element in non-namespace mode.

        The name parameter contains the raw XML 1.0 name of the
        element type as a string and the attrs parameter holds an
        instance of the Attributes class containing the attributes of
        the element.Nr)r�name�attrsrrr�startElement~szContentHandler.startElementcCsdS)z�Signals the end of an element in non-namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElement event.Nr)rrrrr�
endElement�szContentHandler.endElementcCsdS)a�Signals the start of an element in namespace mode.

        The name parameter contains the name of the element type as a
        (uri, localname) tuple, the qname parameter the raw XML 1.0
        name used in the source document, and the attrs parameter
        holds an instance of the Attributes class containing the
        attributes of the element.

        The uri part of the name tuple is None for elements which have
        no namespace.Nr)rr�qnamerrrr�startElementNS�szContentHandler.startElementNScCsdS)z�Signals the end of an element in namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElementNS event.Nr)rrrrrr�endElementNS�szContentHandler.endElementNScCsdS)a�Receive notification of character data.

        The Parser will call this method to report each chunk of
        character data. SAX parsers may return all contiguous
        character data in a single chunk, or they may split it into
        several chunks; however, all of the characters in any single
        event must come from the same external entity so that the
        Locator provides useful information.Nr)rZcontentrrr�
characters�szContentHandler.characterscCsdS)awReceive notification of ignorable whitespace in element content.

        Validating Parsers must use this method to report each chunk
        of ignorable whitespace (see the W3C XML 1.0 recommendation,
        section 2.10): non-validating parsers may also use this method
        if they are capable of parsing and using content models.

        SAX parsers may return all contiguous whitespace in a single
        chunk, or they may split it into several chunks; however, all
        of the characters in any single event must come from the same
        external entity, so that the Locator provides useful
        information.Nr)rZ
whitespacerrr�ignorableWhitespace�sz"ContentHandler.ignorableWhitespacecCsdS)a�Receive notification of a processing instruction.

        The Parser will invoke this method once for each processing
        instruction found: note that processing instructions may occur
        before or after the main document element.

        A SAX parser should never report an XML declaration (XML 1.0,
        section 2.8) or a text declaration (XML 1.0, section 4.3.1)
        using this method.Nr)r�target�datarrr�processingInstruction�sz$ContentHandler.processingInstructioncCsdS)aReceive notification of a skipped entity.

        The Parser will invoke this method once for each entity
        skipped. Non-validating processors may skip entities if they
        have not seen the declarations (because, for example, the
        entity was declared in an external DTD subset). All processors
        may skip external entities, depending on the values of the
        http://xml.org/sax/features/external-general-entities and the
        http://xml.org/sax/features/external-parameter-entities
        properties.Nr)rrrrr�
skippedEntity�szContentHandler.skippedEntityN)r
rrr
rrrrrrrrrrrrr"r#rrrrr/s	
rc@s eZdZdZdd�Zdd�ZdS)�
DTDHandlerz�Handle DTD events.

    This interface specifies only those DTD events required for basic
    parsing (unparsed entities and attributes).cCsdS)z$Handle a notation declaration event.Nr)rr�publicId�systemIdrrr�notationDecl�szDTDHandler.notationDeclcCsdS)z,Handle an unparsed entity declaration event.Nr)rrr%r&Zndatarrr�unparsedEntityDecl�szDTDHandler.unparsedEntityDeclN)r
rrr
r'r(rrrrr$�sr$c@seZdZdZdd�ZdS)�EntityResolvera7Basic interface for resolving entities. If you create an object
    implementing this interface, then register the object with your
    Parser, the parser will call the method in your object to
    resolve all external entities. Note that DefaultHandler implements
    this interface with the default behaviour.cCs|S)z�Resolve the system identifier of an entity and return either
        the system identifier to read from as a string, or an InputSource
        to read from.r)rr%r&rrr�
resolveEntity�szEntityResolver.resolveEntityN)r
rrr
r*rrrrr)�sr)z&http://xml.org/sax/features/namespacesz.http://xml.org/sax/features/namespace-prefixesz,http://xml.org/sax/features/string-interningz&http://xml.org/sax/features/validationz5http://xml.org/sax/features/external-general-entitiesz7http://xml.org/sax/features/external-parameter-entitiesz-http://xml.org/sax/properties/lexical-handlerz1http://xml.org/sax/properties/declaration-handlerz&http://xml.org/sax/properties/dom-nodez(http://xml.org/sax/properties/xml-stringz-http://www.python.org/sax/properties/encodingz3http://www.python.org/sax/properties/interning-dictN)r
�versionrrr$r)Zfeature_namespacesZfeature_namespace_prefixesZfeature_string_interningZfeature_validationZfeature_external_gesZfeature_external_pesZall_featuresZproperty_lexical_handlerZproperty_declaration_handlerZproperty_dom_nodeZproperty_xml_stringZproperty_encodingZproperty_interning_dictZall_propertiesrrrr�<module>
s<
"	PK�"[�)�[[*sax/__pycache__/_exceptions.cpython-36.pycnu�[���3


 \��@s�dZddlZejdd�dkr*ddlmZ[Gdd�de�ZGdd	�d	e�ZGd
d�de�ZGdd
�d
e�ZGdd�de�Z	dS)z!Different kinds of SAX Exceptions�N��java)�	Exceptionc@s:eZdZdZd
dd�Zdd�Zdd�Zd	d
�Zdd�ZdS)�SAXExceptiona�Encapsulate an XML error or warning. This class can contain
    basic error or warning information from either the XML parser or
    the application: you can subclass it to provide additional
    functionality, or to add localization. Note that although you will
    receive a SAXException as the argument to the handlers in the
    ErrorHandler interface, you are not actually required to raise
    the exception; instead, you can simply read the information in
    it.NcCs||_||_tj||�dS)zUCreates an exception. The message is required, but the exception
        is optional.N)�_msg�
_exceptionr�__init__)�self�msg�	exception�r�+/usr/lib64/python3.6/xml/sax/_exceptions.pyrszSAXException.__init__cCs|jS)z$Return a message for this exception.)r)r	rrr
�
getMessageszSAXException.getMessagecCs|jS)z9Return the embedded exception, or None if there was none.)r)r	rrr
�getExceptionszSAXException.getExceptioncCs|jS)z0Create a string representation of the exception.)r)r	rrr
�__str__"szSAXException.__str__cCstd��dS)zvAvoids weird error messages if someone does exception[ix] by
        mistake, since Exception has __getitem__ defined.�__getitem__N)�AttributeError)r	Zixrrr
r&szSAXException.__getitem__)N)	�__name__�
__module__�__qualname__�__doc__rrrrrrrrr
r	s
rc@s@eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�SAXParseExceptiona#Encapsulate an XML parse error or warning.

    This exception will include information for locating the error in
    the original XML document. Note that although the application will
    receive a SAXParseException as the argument to the handlers in the
    ErrorHandler interface, the application is not actually required
    to raise the exception; instead, it can simply read the
    information in it and take a different action.

    Since this exception is a subclass of SAXException, it inherits
    the ability to wrap another exception.cCs<tj|||�||_|jj�|_|jj�|_|jj�|_dS)zECreates the exception. The exception parameter is allowed to be None.N)	rr�_locator�getSystemId�	_systemId�getColumnNumber�_colnum�
getLineNumber�_linenum)r	r
rZlocatorrrr
r;s
zSAXParseException.__init__cCs|jS)zNThe column number of the end of the text where the exception
        occurred.)r)r	rrr
rHsz!SAXParseException.getColumnNumbercCs|jS)zDThe line number of the end of the text where the exception occurred.)r)r	rrr
rMszSAXParseException.getLineNumbercCs
|jj�S)zEGet the public identifier of the entity where the exception occurred.)r�getPublicId)r	rrr
rQszSAXParseException.getPublicIdcCs|jS)zEGet the system identifier of the entity where the exception occurred.)r)r	rrr
rUszSAXParseException.getSystemIdcCsN|j�}|dkrd}|j�}|dkr(d}|j�}|dkr<d}d||||jfS)z0Create a string representation of the exception.Nz	<unknown>�?z%s:%s:%s: %s)rrrr)r	ZsysidZlinenumZcolnumrrr
rYszSAXParseException.__str__N)
rrrrrrrrrrrrrr
r.s
rc@seZdZdZdS)�SAXNotRecognizedExceptionz�Exception class for an unrecognized identifier.

    An XMLReader will raise this exception when it is confronted with an
    unrecognized feature or property. SAX applications and extensions may
    use this class for similar purposes.N)rrrrrrrr
r!isr!c@seZdZdZdS)�SAXNotSupportedExceptionaException class for an unsupported operation.

    An XMLReader will raise this exception when a service it cannot
    perform is requested (specifically setting a state or value). SAX
    applications and extensions may use this class for similar
    purposes.N)rrrrrrrr
r"ssr"c@seZdZdZdS)�SAXReaderNotAvailableaException class for a missing driver.

    An XMLReader module (driver) should raise this exception when it
    is first imported, e.g. when a support module cannot be imported.
    It also may be raised during parsing, e.g. if executing an external
    program is not permitted.N)rrrrrrrr
r#}sr#)
r�sys�platformZ	java.langrrrr!r"r#rrrr
�<module>s%;

PK�"[_��&00,sax/__pycache__/handler.cpython-36.opt-1.pycnu�[���3


 \b6�@s�dZdZGdd�d�ZGdd�d�ZGdd�d�ZGdd	�d	�Zd
ZdZdZd
Z	dZ
dZeeee	e
egZdZ
dZdZdZdZdZe
eeeeegZdS)a0
This module contains the core classes of version 2.0 of SAX for Python.
This file provides only default classes with absolutely minimum
functionality, from which drivers and applications can be subclassed.

Many of these classes are empty and are included only as documentation
of the interfaces.

$Id$
z2.0betac@s(eZdZdZdd�Zdd�Zdd�ZdS)	�ErrorHandlera�Basic interface for SAX error handlers.

    If you create an object that implements this interface, then
    register the object with your XMLReader, the parser will call the
    methods in your object to report all warnings and errors. There
    are three levels of errors available: warnings, (possibly)
    recoverable errors, and unrecoverable errors. All methods take a
    SAXParseException as the only parameter.cCs|�dS)zHandle a recoverable error.N�)�self�	exceptionrr�'/usr/lib64/python3.6/xml/sax/handler.py�error szErrorHandler.errorcCs|�dS)zHandle a non-recoverable error.Nr)rrrrr�
fatalError$szErrorHandler.fatalErrorcCst|�dS)zHandle a warning.N)�print)rrrrr�warning(szErrorHandler.warningN)�__name__�
__module__�__qualname__�__doc__rrr	rrrrrsrc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�ContentHandlerz�Interface for receiving logical document content events.

    This is the main callback interface in SAX, and the one most
    important to applications. The order of events in this interface
    mirrors the order of the information in the document.cCs
d|_dS)N)�_locator)rrrr�__init__6szContentHandler.__init__cCs
||_dS)a#Called by the parser to give the application a locator for
        locating the origin of document events.

        SAX parsers are strongly encouraged (though not absolutely
        required) to supply a locator: if it does so, it must supply
        the locator to the application by invoking this method before
        invoking any of the other methods in the DocumentHandler
        interface.

        The locator allows the application to determine the end
        position of any document-related event, even if the parser is
        not reporting an error. Typically, the application will use
        this information for reporting its own errors (such as
        character content that does not match an application's
        business rules). The information returned by the locator is
        probably not sufficient for use with a search engine.

        Note that the locator will return correct information only
        during the invocation of the events in this interface. The
        application should not attempt to use it at any other time.N)r)rZlocatorrrr�setDocumentLocator9sz!ContentHandler.setDocumentLocatorcCsdS)z�Receive notification of the beginning of a document.

        The SAX parser will invoke this method only once, before any
        other methods in this interface or in DTDHandler (except for
        setDocumentLocator).Nr)rrrr�
startDocumentPszContentHandler.startDocumentcCsdS)aQReceive notification of the end of a document.

        The SAX parser will invoke this method only once, and it will
        be the last method invoked during the parse. The parser shall
        not invoke this method until it has either abandoned parsing
        (because of an unrecoverable error) or reached the end of
        input.Nr)rrrr�endDocumentWszContentHandler.endDocumentcCsdS)aBegin the scope of a prefix-URI Namespace mapping.

        The information from this event is not necessary for normal
        Namespace processing: the SAX XML reader will automatically
        replace prefixes for element and attribute names when the
        http://xml.org/sax/features/namespaces feature is true (the
        default).

        There are cases, however, when applications need to use
        prefixes in character data or in attribute values, where they
        cannot safely be expanded automatically; the
        start/endPrefixMapping event supplies the information to the
        application to expand prefixes in those contexts itself, if
        necessary.

        Note that start/endPrefixMapping events are not guaranteed to
        be properly nested relative to each-other: all
        startPrefixMapping events will occur before the corresponding
        startElement event, and all endPrefixMapping events will occur
        after the corresponding endElement event, but their order is
        not guaranteed.Nr)r�prefixZurirrr�startPrefixMapping`sz!ContentHandler.startPrefixMappingcCsdS)z�End the scope of a prefix-URI mapping.

        See startPrefixMapping for details. This event will always
        occur after the corresponding endElement event, but the order
        of endPrefixMapping events is not otherwise guaranteed.Nr)rrrrr�endPrefixMappingwszContentHandler.endPrefixMappingcCsdS)aSignals the start of an element in non-namespace mode.

        The name parameter contains the raw XML 1.0 name of the
        element type as a string and the attrs parameter holds an
        instance of the Attributes class containing the attributes of
        the element.Nr)r�name�attrsrrr�startElement~szContentHandler.startElementcCsdS)z�Signals the end of an element in non-namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElement event.Nr)rrrrr�
endElement�szContentHandler.endElementcCsdS)a�Signals the start of an element in namespace mode.

        The name parameter contains the name of the element type as a
        (uri, localname) tuple, the qname parameter the raw XML 1.0
        name used in the source document, and the attrs parameter
        holds an instance of the Attributes class containing the
        attributes of the element.

        The uri part of the name tuple is None for elements which have
        no namespace.Nr)rr�qnamerrrr�startElementNS�szContentHandler.startElementNScCsdS)z�Signals the end of an element in namespace mode.

        The name parameter contains the name of the element type, just
        as with the startElementNS event.Nr)rrrrrr�endElementNS�szContentHandler.endElementNScCsdS)a�Receive notification of character data.

        The Parser will call this method to report each chunk of
        character data. SAX parsers may return all contiguous
        character data in a single chunk, or they may split it into
        several chunks; however, all of the characters in any single
        event must come from the same external entity so that the
        Locator provides useful information.Nr)rZcontentrrr�
characters�szContentHandler.characterscCsdS)awReceive notification of ignorable whitespace in element content.

        Validating Parsers must use this method to report each chunk
        of ignorable whitespace (see the W3C XML 1.0 recommendation,
        section 2.10): non-validating parsers may also use this method
        if they are capable of parsing and using content models.

        SAX parsers may return all contiguous whitespace in a single
        chunk, or they may split it into several chunks; however, all
        of the characters in any single event must come from the same
        external entity, so that the Locator provides useful
        information.Nr)rZ
whitespacerrr�ignorableWhitespace�sz"ContentHandler.ignorableWhitespacecCsdS)a�Receive notification of a processing instruction.

        The Parser will invoke this method once for each processing
        instruction found: note that processing instructions may occur
        before or after the main document element.

        A SAX parser should never report an XML declaration (XML 1.0,
        section 2.8) or a text declaration (XML 1.0, section 4.3.1)
        using this method.Nr)r�target�datarrr�processingInstruction�sz$ContentHandler.processingInstructioncCsdS)aReceive notification of a skipped entity.

        The Parser will invoke this method once for each entity
        skipped. Non-validating processors may skip entities if they
        have not seen the declarations (because, for example, the
        entity was declared in an external DTD subset). All processors
        may skip external entities, depending on the values of the
        http://xml.org/sax/features/external-general-entities and the
        http://xml.org/sax/features/external-parameter-entities
        properties.Nr)rrrrr�
skippedEntity�szContentHandler.skippedEntityN)r
rrr
rrrrrrrrrrrrr"r#rrrrr/s	
rc@s eZdZdZdd�Zdd�ZdS)�
DTDHandlerz�Handle DTD events.

    This interface specifies only those DTD events required for basic
    parsing (unparsed entities and attributes).cCsdS)z$Handle a notation declaration event.Nr)rr�publicId�systemIdrrr�notationDecl�szDTDHandler.notationDeclcCsdS)z,Handle an unparsed entity declaration event.Nr)rrr%r&Zndatarrr�unparsedEntityDecl�szDTDHandler.unparsedEntityDeclN)r
rrr
r'r(rrrrr$�sr$c@seZdZdZdd�ZdS)�EntityResolvera7Basic interface for resolving entities. If you create an object
    implementing this interface, then register the object with your
    Parser, the parser will call the method in your object to
    resolve all external entities. Note that DefaultHandler implements
    this interface with the default behaviour.cCs|S)z�Resolve the system identifier of an entity and return either
        the system identifier to read from as a string, or an InputSource
        to read from.r)rr%r&rrr�
resolveEntity�szEntityResolver.resolveEntityN)r
rrr
r*rrrrr)�sr)z&http://xml.org/sax/features/namespacesz.http://xml.org/sax/features/namespace-prefixesz,http://xml.org/sax/features/string-interningz&http://xml.org/sax/features/validationz5http://xml.org/sax/features/external-general-entitiesz7http://xml.org/sax/features/external-parameter-entitiesz-http://xml.org/sax/properties/lexical-handlerz1http://xml.org/sax/properties/declaration-handlerz&http://xml.org/sax/properties/dom-nodez(http://xml.org/sax/properties/xml-stringz-http://www.python.org/sax/properties/encodingz3http://www.python.org/sax/properties/interning-dictN)r
�versionrrr$r)Zfeature_namespacesZfeature_namespace_prefixesZfeature_string_interningZfeature_validationZfeature_external_gesZfeature_external_pesZall_featuresZproperty_lexical_handlerZproperty_declaration_handlerZproperty_dom_nodeZproperty_xml_stringZproperty_encodingZproperty_interning_dictZall_propertiesrrrr�<module>
s<
"	PK�"[�b�.�.0sax/__pycache__/expatreader.cpython-36.opt-2.pycnu�[���3


 \X=�@s�dZddlTddlmZmZddlmZddlmZmZddlmZddlm	Z	m
Z
ddlZejdd	�d
krxe
dd��[yddlmZWnek
r�e
d
d��YnXeed�s�e
d
d��ddlmZmZmZejZejZyddlZWnek
�rdd�ZYnXddlZejZ[[Gdd�d�ZGdd�dej�ZGdd�dejej�Z dd�Z!e"dk�r�ddl#Z$e!�Z%e%j&e$j'jj(��e%j)e$j'j*��e%j+d�dS)z0.20�)�*)�feature_validation�feature_namespaces)�feature_namespace_prefixes)�feature_external_ges�feature_external_pes)�feature_string_interning)�property_xml_string�property_interning_dictN��javazexpat not available in Java)�expatzexpat not supported�ParserCreate)�	xmlreader�saxutils�handlercCs|S)N�)�orr�+/usr/lib64/python3.6/xml/sax/expatreader.py�_mkproxy'src@seZdZdS)�
_ClosedParserN)�__name__�
__module__�__qualname__rrrrr.src@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�ExpatLocatorcCst|�|_dS)N)r�_ref)�self�parserrrr�__init__9szExpatLocator.__init__cCs|j}|jdkrdS|jjS)N)r�_parser�ErrorColumnNumber)rrrrr�getColumnNumber<s
zExpatLocator.getColumnNumbercCs|j}|jdkrdS|jjS)N�)rr�ErrorLineNumber)rrrrr�
getLineNumberBs
zExpatLocator.getLineNumbercCs|j}|dkrdS|jj�S)N)r�_source�getPublicId)rrrrrr&HszExpatLocator.getPublicIdcCs|j}|dkrdS|jj�S)N)rr%�getSystemId)rrrrrr'NszExpatLocator.getSystemIdN)rrrrr!r$r&r'rrrrr3s
rc@seZdZdFdd�Zdd�Zd	d
�Zdd�Zd
d�Zdd�Zdd�Z	dd�Z
dGdd�Zdd�Zdd�Z
dd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;d<�Zd=d>�Zd?d@�Z dAdB�Z!dCS)H�ExpatParserr���cCsFtjj||�tj�|_d|_||_d|_d|_g|_	d|_
d|_dS)Nr)r�IncrementalParserrZInputSourcer%r�_namespaces�_lex_handler_prop�_parsing�
_entity_stack�
_external_ges�
_interning)rZnamespaceHandling�bufsizerrrrZs
zExpatParser.__init__c	CsVtj|�}||_y*|j�|jjt|��tjj	||�Wn|j
��YnXdS)N)r�prepare_input_sourcer%�reset�
_cont_handlerZsetDocumentLocatorrrr,�parse�
_close_source)r�sourcerrrr7gs
zExpatParser.parsecCs |j�dk	r|jj|j��dS)N)r'rZSetBase)rr9rrr�
prepareParserwszExpatParser.prepareParsercCs tjj||�|jr|j�dS)N)rr,�setContentHandlerr/�_reset_cont_handler)rrrrrr;}szExpatParser.setContentHandlercCsP|tkr|jS|tkr |jdk	S|tttfkr2dS|tkr@|jSt	d|��dS)NrzFeature '%s' not recognized)
rr-rr2rrrrr1�SAXNotRecognizedException)r�namerrr�
getFeature�s
zExpatParser.getFeaturecCs�|jrtd��|tkr||_n�|tkr.||_nt|tkrT|rL|jdkrRi|_q�d|_nN|tkrj|r�td��n8|t	kr�|r�td��n"|t
kr�|r�td��ntd|��dS)Nz!Cannot set features while parsingz!expat does not support validationz/expat does not read external parameter entitiesz(expat does not report namespace prefixeszFeature '%s' not recognized)r/�SAXNotSupportedExceptionrr-rr1rr2rrrr=)rr>�staterrr�
setFeature�s2
zExpatParser.setFeaturecCsd|tjkr|jS|tkr|jS|tkrT|jrLt|jd�rB|jj�St	d��nt
d��t	d|��dS)N�GetInputContextz=This version of expat does not support getting the XML stringz.XML string cannot be returned when not parsingzProperty '%s' not recognized)r�property_lexical_handlerr.r
r2r	r�hasattrrCr=r@)rr>rrr�getProperty�s

zExpatParser.getPropertycCsV|tjkr ||_|jrR|j�n2|tkr0||_n"|tkrFtd|��nt	d|��dS)NzProperty '%s' cannot be setzProperty '%s' not recognized)
rrDr.r/�_reset_lex_handler_propr
r2r	r@r=)rr>�valuerrr�setProperty�s


zExpatParser.setPropertycCsz|js|j�d|_|jj�y|jj||�WnDtjk
rt}z&ttj	|j
�||�}|jj|�WYdd}~XnXdS)Nr")
r/r5r6Z
startDocumentrZParser
�errorZSAXParseExceptionZErrorString�codeZ_err_handlerZ
fatalError)r�data�isFinal�e�excrrr�feed�s
zExpatParser.feedcCsB|j}z|j�}|dk	r |j�Wd|j�}|dk	r<|j�XdS)N)r%ZgetCharacterStream�closeZ
getByteStream)rr9�filerrrr8�szExpatParser._close_sourcecCs�|js|jdkst|jt�r dSz(|jddd�|jj�d|_d|_Wdd|_|jdk	rzt�}|jj|_|jj	|_	||_|j
�XdS)N�r")rMr)r0r�
isinstancerrPr6ZendDocumentr/r r#r8)rrrrrrQ�s




zExpatParser.closecCs|jj|j_|jj|j_dS)N)r6�processingInstructionrZProcessingInstructionHandler�
charactersZCharacterDataHandler)rrrrr<�szExpatParser._reset_cont_handlercCs`|j}|j}|dkr4d|_d|_d|_d|_d|_n(|j|_|j|_|j	|_|j
|_|j|_dS)N)r.rZCommentHandlerZStartCdataSectionHandlerZEndCdataSectionHandlerZStartDoctypeDeclHandlerZEndDoctypeDeclHandlerZcommentZ
startCDATAZendCDATA�start_doctype_declZendDTD)rZlexrrrrrGsz#ExpatParser._reset_lex_handler_propcCs�|jr>tj|jj�d|jd�|_d|j_|j|j_	|j
|j_n,tj|jj�|jd�|_|j|j_	|j
|j_|j�|j|j_|j|j_|j|j_|j|j_d|_|jr�|j�|j|j_y|j|j_Wntk
r�YnX|jjtj �d|_!g|_"dS)N� )�internr"r)#r-r
rr%ZgetEncodingr2rZnamespace_prefixes�start_element_nsZStartElementHandler�end_element_nsZEndElementHandler�
start_element�end_elementr<�unparsed_entity_declZUnparsedEntityDeclHandler�
notation_declZNotationDeclHandler�start_namespace_declZStartNamespaceDeclHandler�end_namespace_declZEndNamespaceDeclHandlerZ_decl_handler_propr.rG�external_entity_refZExternalEntityRefHandler�skipped_entity_handlerZSkippedEntityHandler�AttributeErrorZSetParamEntityParsingZ*XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONEr/r0)rrrrr5s6







zExpatParser.resetcCs|jdkrdS|jjS)N)rr )rrrrr!;s
zExpatParser.getColumnNumbercCs|jdkrdS|jjS)Nr")rr#)rrrrr$@s
zExpatParser.getLineNumbercCs
|jj�S)N)r%r&)rrrrr&EszExpatParser.getPublicIdcCs
|jj�S)N)r%r')rrrrr'HszExpatParser.getSystemIdcCs|jj|t|��dS)N)r6ZstartElement�AttributesImpl)rr>�attrsrrrr\LszExpatParser.start_elementcCs|jj|�dS)N)r6Z
endElement)rr>rrrr]OszExpatParser.end_elementcCs�|j�}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}i}i}x�|j�D]|\}}|j�}t|�}	|	dkr�|}
d|f}n>|	dkr�d|d|df}
|d|df}n|d}
t|�}|||<|
||<qVW|jj|dt||��dS)Nr"�rz%s:%sr))�split�len�tuple�itemsr6ZstartElementNS�AttributesNSImpl)rr>rf�pairZnewattrsZqnamesZanamerH�partsZlengthZqnameZapairrrrrZRs.


zExpatParser.start_element_nscCsV|j�}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}|jj|d�dS)Nr"rgr)rhrirjr6ZendElementNS)rr>rmrrrr[ts
zExpatParser.end_element_nscCs|jj||�dS)N)r6rU)r�targetrLrrr�processing_instruction�sz"ExpatParser.processing_instructioncCs|jj|�dS)N)r6rV)rrLrrr�character_data�szExpatParser.character_datacCs|jj||�dS)N)r6ZstartPrefixMapping)r�prefixZurirrrr`�sz ExpatParser.start_namespace_declcCs|jj|�dS)N)r6ZendPrefixMapping)rrrrrrra�szExpatParser.end_namespace_declcCs|jj|||�dS)N)r.ZstartDTD)rr>�sysid�pubidZhas_internal_subsetrrrrW�szExpatParser.start_doctype_declcCs|jj||||�dS)N)�_dtd_handlerZunparsedEntityDecl)rr>�basersrtZ
notation_namerrrr^�sz ExpatParser.unparsed_entity_declcCs|jj|||�dS)N)ruZnotationDecl)rr>rvrsrtrrrr_�szExpatParser.notation_declc	Cs�|js
dS|jj||�}tj||jj�p*d�}|jj|j	|jf�|j	j
|�|_	||_ytjj
||�Wn
dS|jd\|_	|_|jd=dS)Nr"rSr���rw)r1Z_ent_handlerZ
resolveEntityrr4r%r'r0�appendrZExternalEntityParserCreaterr,r7)r�contextrvrsrtr9rrrrb�s 
zExpatParser.external_entity_refcCs|rd|}|jj|�dS)N�%)r6Z
skippedEntity)rr>Zis_perrrrc�sz"ExpatParser.skipped_entity_handlerNi��)rr{)r)"rrrrr7r:r;r?rBrFrIrPr8rQr<rGr5r!r$r&r'r\r]rZr[rprqr`rarWr^r_rbrcrrrrr(Ws>


'"r(cOs
t||�S)N)r()�args�kwargsrrr�
create_parser�sr~�__main__z:http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml),�versionZxml.sax._exceptionsZxml.sax.handlerrrrrrrr	r
�sys�platformZSAXReaderNotAvailableZxml.parsersr
�ImportErrorrEZxml.saxrrrrerl�_weakrefr�weakref�proxyrZLocatorrr,r(r~rZxml.sax.saxutilsZxml�pr;ZsaxZXMLGeneratorZsetErrorHandlerZErrorHandlerr7rrrr�<module>sL


$_
PK�"[P�'�
�
0sax/__pycache__/_exceptions.cpython-36.opt-2.pycnu�[���3


 \��@s|ddlZejdd�dkr&ddlmZ[Gdd�de�ZGdd�de�ZGd	d
�d
e�ZGdd�de�ZGd
d�de�ZdS)�N��java)�	Exceptionc@s6eZdZddd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�SAXExceptionNcCs||_||_tj||�dS)N)�_msg�
_exceptionr�__init__)�self�msg�	exception�r�+/usr/lib64/python3.6/xml/sax/_exceptions.pyrszSAXException.__init__cCs|jS)N)r)r	rrr
�
getMessageszSAXException.getMessagecCs|jS)N)r)r	rrr
�getExceptionszSAXException.getExceptioncCs|jS)N)r)r	rrr
�__str__"szSAXException.__str__cCstd��dS)N�__getitem__)�AttributeError)r	Zixrrr
r&szSAXException.__getitem__)N)�__name__�
__module__�__qualname__rrrrrrrrr
r	s


rc@s<eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�SAXParseExceptioncCs<tj|||�||_|jj�|_|jj�|_|jj�|_dS)N)	rr�_locator�getSystemId�	_systemId�getColumnNumber�_colnum�
getLineNumber�_linenum)r	r
rZlocatorrrr
r;s
zSAXParseException.__init__cCs|jS)N)r)r	rrr
rHsz!SAXParseException.getColumnNumbercCs|jS)N)r)r	rrr
rMszSAXParseException.getLineNumbercCs
|jj�S)N)r�getPublicId)r	rrr
rQszSAXParseException.getPublicIdcCs|jS)N)r)r	rrr
rUszSAXParseException.getSystemIdcCsN|j�}|dkrd}|j�}|dkr(d}|j�}|dkr<d}d||||jfS)Nz	<unknown>�?z%s:%s:%s: %s)rrrr)r	ZsysidZlinenumZcolnumrrr
rYszSAXParseException.__str__N)	rrrrrrrrrrrrr
r.s

rc@seZdZdS)�SAXNotRecognizedExceptionN)rrrrrrr
r isr c@seZdZdS)�SAXNotSupportedExceptionN)rrrrrrr
r!ssr!c@seZdZdS)�SAXReaderNotAvailableN)rrrrrrr
r"}sr")	�sys�platformZ	java.langrrrr r!r"rrrr
�<module>s%;

PK�"[��}>>-sax/__pycache__/__init__.cpython-36.opt-2.pycnu�[���3


 \.�@s
ddlmZddlmZmZddlmZmZmZm	Z	m
Z
e�fdd�Ze�fdd�ZdgZ
d	Zerjd	d
lZd	d
lZd	d
lZejjr�dejkr�ejdjd�Z
[d
Zejd
d�dkr�ejje�r�ejje�jd�Z
gfdd�Zejd
d�dkr�dd�Zndd�Z[d
S)�)�InputSource)�ContentHandler�ErrorHandler)�SAXException�SAXNotRecognizedException�SAXParseException�SAXNotSupportedException�SAXReaderNotAvailablecCs(t�}|j|�|j|�|j|�dS)N)�make_parser�setContentHandler�setErrorHandler�parse)�source�handler�errorHandler�parser�r�(/usr/lib64/python3.6/xml/sax/__init__.pyr
s

r
cCspddl}|dkrt�}t�}|j|�|j|�t�}t|t�rR|j|j	|��n|j
|j|��|j|�dS)N�)
�iorr
rrr�
isinstance�strZsetCharacterStream�StringIOZ
setByteStream�BytesIOr
)�stringrrrrZinpsrcrrr�parseString#s


rzxml.sax.expatreaderrNZ
PY_SAX_PARSER�,zpython.xml.sax.parser��javacCsrxb|tD]V}yt|�Stk
rL}zddl}||jkr<�WYdd}~Xq
tk
r^Yq
Xq
Wtdd��dS)NrzNo parsers found)�default_parser_list�_create_parser�ImportError�sys�modulesr	)Zparser_list�parser_name�er"rrrr
Fs

r
cCs$ddlm}|j|dt��}|j�S)Nr)�imp)Zorg.python.corer&Z
importName�globals�
create_parser)r$r&�
drv_modulerrrr asr cCst|iidg�}|j�S)Nr()�
__import__r()r$r)rrrr gs)Z	xmlreaderrrrr�_exceptionsrrrrr	r
rr�_falseZxml.sax.expatreaderZxml�osr"�flags�ignore_environment�environ�splitZ_key�platform�registryZcontainsKeyZgetPropertyr
r rrrr�<module>s(
PK�"[��VZZ'sax/__pycache__/__init__.cpython-36.pycnu�[���3


 \.�@sdZddlmZddlmZmZddlmZmZm	Z	m
Z
mZe�fdd�Ze�fdd�Z
d	gZd
Zernd
dlZd
dlZd
dlZejjr�dejkr�ejdjd
�Z[dZejdd�dkr�ejje�r�ejje�jd
�Zgfdd�Zejdd�dk�rdd�Zndd�Z[dS)a�Simple API for XML (SAX) implementation for Python.

This module provides an implementation of the SAX 2 interface;
information about the Java version of the interface can be found at
http://www.megginson.com/SAX/.  The Python version of the interface is
documented at <...>.

This package contains the following modules:

handler -- Base classes and constants which define the SAX 2 API for
           the 'client-side' of SAX for Python.

saxutils -- Implementation of the convenience classes commonly used to
            work with SAX.

xmlreader -- Base classes and constants which define the SAX 2 API for
             the parsers used with SAX for Python.

expatreader -- Driver that allows use of the Expat parser with SAX.
�)�InputSource)�ContentHandler�ErrorHandler)�SAXException�SAXNotRecognizedException�SAXParseException�SAXNotSupportedException�SAXReaderNotAvailablecCs(t�}|j|�|j|�|j|�dS)N)�make_parser�setContentHandler�setErrorHandler�parse)�source�handler�errorHandler�parser�r�(/usr/lib64/python3.6/xml/sax/__init__.pyr
s

r
cCspddl}|dkrt�}t�}|j|�|j|�t�}t|t�rR|j|j	|��n|j
|j|��|j|�dS)N�)
�iorr
rrr�
isinstance�strZsetCharacterStream�StringIOZ
setByteStream�BytesIOr
)�stringrrrrZinpsrcrrr�parseString#s


rzxml.sax.expatreaderrNZ
PY_SAX_PARSER�,zpython.xml.sax.parser��javacCsrxb|tD]V}yt|�Stk
rL}zddl}||jkr<�WYdd}~Xq
tk
r^Yq
Xq
Wtdd��dS)a&Creates and returns a SAX parser.

    Creates the first parser it is able to instantiate of the ones
    given in the list created by doing parser_list +
    default_parser_list.  The lists must contain the names of Python
    modules containing both a SAX parser and a create_parser function.rNzNo parsers found)�default_parser_list�_create_parser�ImportError�sys�modulesr	)Zparser_list�parser_name�er"rrrr
Fs

r
cCs$ddlm}|j|dt��}|j�S)Nr)�imp)Zorg.python.corer&Z
importName�globals�
create_parser)r$r&�
drv_modulerrrr asr cCst|iidg�}|j�S)Nr()�
__import__r()r$r)rrrr gs)�__doc__Z	xmlreaderrrrr�_exceptionsrrrrr	r
rr�_falseZxml.sax.expatreaderZxml�osr"�flags�ignore_environment�environ�splitZ_key�platform�registryZcontainsKeyZgetPropertyr
r rrrr�<module>s*
PK�"[���+�(�(.sax/__pycache__/xmlreader.cpython-36.opt-2.pycnu�[���3


 \�1�@s�ddlmZddlmZmZGdd�d�ZGdd�de�ZGdd�d�ZGd	d
�d
�ZGdd�d�Z	Gd
d�de	�Z
dd�Zedkr�e�dS)�)�handler)�SAXNotSupportedException�SAXNotRecognizedExceptionc@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS) �	XMLReadercCs,tj�|_tj�|_tj�|_tj�|_dS)N)	rZContentHandler�
_cont_handlerZ
DTDHandler�_dtd_handlerZEntityResolver�_ent_handlerZErrorHandler�_err_handler)�self�r�)/usr/lib64/python3.6/xml/sax/xmlreader.py�__init__s


zXMLReader.__init__cCstd��dS)Nz This method must be implemented!)�NotImplementedError)r
�sourcerrr�parseszXMLReader.parsecCs|jS)N)r)r
rrr�getContentHandler"szXMLReader.getContentHandlercCs
||_dS)N)r)r
rrrr�setContentHandler&szXMLReader.setContentHandlercCs|jS)N)r)r
rrr�
getDTDHandler*szXMLReader.getDTDHandlercCs
||_dS)N)r)r
rrrr�
setDTDHandler.szXMLReader.setDTDHandlercCs|jS)N)r)r
rrr�getEntityResolver2szXMLReader.getEntityResolvercCs
||_dS)N)r)r
Zresolverrrr�setEntityResolver6szXMLReader.setEntityResolvercCs|jS)N)r	)r
rrr�getErrorHandler:szXMLReader.getErrorHandlercCs
||_dS)N)r	)r
rrrr�setErrorHandler>szXMLReader.setErrorHandlercCstd��dS)NzLocale support not implemented)r)r
Zlocalerrr�	setLocaleBszXMLReader.setLocalecCstd|��dS)NzFeature '%s' not recognized)r)r
�namerrr�
getFeatureKszXMLReader.getFeaturecCstd|��dS)NzFeature '%s' not recognized)r)r
r�staterrr�
setFeatureOszXMLReader.setFeaturecCstd|��dS)NzProperty '%s' not recognized)r)r
rrrr�getPropertySszXMLReader.getPropertycCstd|��dS)NzProperty '%s' not recognized)r)r
r�valuerrr�setPropertyWszXMLReader.setPropertyN)�__name__�
__module__�__qualname__r
rrrrrrrrrrrrrr rrrrrs
	rc@s>eZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�ZdS)�IncrementalParser��cCs||_tj|�dS)N)�_bufsizerr
)r
�bufsizerrrr
oszIncrementalParser.__init__cCspddlm}|j|�}|j|�|j�}|dkr8|j�}|j|j�}x|rb|j|�|j|j�}qFW|j	�dS)Nr)�saxutils)
�r)Zprepare_input_source�
prepareParser�getCharacterStream�
getByteStream�readr'�feed�close)r
rr)�file�bufferrrrrss


zIncrementalParser.parsecCstd��dS)Nz This method must be implemented!)r)r
�datarrrr/�szIncrementalParser.feedcCstd��dS)Nz!prepareParser must be overridden!)r)r
rrrrr+�szIncrementalParser.prepareParsercCstd��dS)Nz This method must be implemented!)r)r
rrrr0�szIncrementalParser.closecCstd��dS)Nz This method must be implemented!)r)r
rrr�reset�szIncrementalParser.resetN�)r5)	r!r"r#r
rr/r+r0r4rrrrr$[s
	
r$c@s,eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�LocatorcCsdS)Nr���r)r
rrr�getColumnNumber�szLocator.getColumnNumbercCsdS)Nrr7r)r
rrr�
getLineNumber�szLocator.getLineNumbercCsdS)Nr)r
rrr�getPublicId�szLocator.getPublicIdcCsdS)Nr)r
rrr�getSystemId�szLocator.getSystemIdN)r!r"r#r8r9r:r;rrrrr6�sr6c@sfeZdZddd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
dS)�InputSourceNcCs"||_d|_d|_d|_d|_dS)N)�_InputSource__system_id�_InputSource__public_id�_InputSource__encoding�_InputSource__bytefile�_InputSource__charfile)r
�	system_idrrrr
�s
zInputSource.__init__cCs
||_dS)N)r>)r
Z	public_idrrr�setPublicId�szInputSource.setPublicIdcCs|jS)N)r>)r
rrrr:�szInputSource.getPublicIdcCs
||_dS)N)r=)r
rBrrr�setSystemId�szInputSource.setSystemIdcCs|jS)N)r=)r
rrrr;�szInputSource.getSystemIdcCs
||_dS)N)r?)r
�encodingrrr�setEncoding�szInputSource.setEncodingcCs|jS)N)r?)r
rrr�getEncoding�szInputSource.getEncodingcCs
||_dS)N)r@)r
Zbytefilerrr�
setByteStream�szInputSource.setByteStreamcCs|jS)N)r@)r
rrrr-�szInputSource.getByteStreamcCs
||_dS)N)rA)r
Zcharfilerrr�setCharacterStreamszInputSource.setCharacterStreamcCs|jS)N)rA)r
rrrr,szInputSource.getCharacterStream)N)r!r"r#r
rCr:rDr;rFrGrHr-rIr,rrrrr<�s



r<c@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zd$dd�Zdd�Zd d!�Zd"d#�ZdS)%�AttributesImplcCs
||_dS)N)�_attrs)r
�attrsrrrr
szAttributesImpl.__init__cCs
t|j�S)N)�lenrK)r
rrr�	getLengthszAttributesImpl.getLengthcCsdS)NZCDATAr)r
rrrr�getType!szAttributesImpl.getTypecCs
|j|S)N)rK)r
rrrr�getValue$szAttributesImpl.getValuecCs
|j|S)N)rK)r
rrrr�getValueByQName'szAttributesImpl.getValueByQNamecCs||jkrt|��|S)N)rK�KeyError)r
rrrr�getNameByQName*s
zAttributesImpl.getNameByQNamecCs||jkrt|��|S)N)rKrR)r
rrrr�getQNameByName/s
zAttributesImpl.getQNameByNamecCst|jj��S)N)�listrK�keys)r
rrr�getNames4szAttributesImpl.getNamescCst|jj��S)N)rUrKrV)r
rrr�	getQNames7szAttributesImpl.getQNamescCs
t|j�S)N)rMrK)r
rrr�__len__:szAttributesImpl.__len__cCs
|j|S)N)rK)r
rrrr�__getitem__=szAttributesImpl.__getitem__cCst|jj��S)N)rUrKrV)r
rrrrV@szAttributesImpl.keyscCs
||jkS)N)rK)r
rrrr�__contains__CszAttributesImpl.__contains__NcCs|jj||�S)N)rK�get)r
r�alternativerrrr\FszAttributesImpl.getcCs|j|j�S)N)�	__class__rK)r
rrr�copyIszAttributesImpl.copycCst|jj��S)N)rUrK�items)r
rrrr`LszAttributesImpl.itemscCst|jj��S)N)rUrK�values)r
rrrraOszAttributesImpl.values)N)r!r"r#r
rNrOrPrQrSrTrWrXrYrZrVr[r\r_r`rarrrrrJs"
rJc@s<eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�AttributesNSImplcCs||_||_dS)N)rK�_qnames)r
rLZqnamesrrrr
VszAttributesNSImpl.__init__cCs6x(|jj�D]\}}||kr|j|SqWt|��dS)N)rcr`rKrR)r
r�nsname�qnamerrrrQ^sz AttributesNSImpl.getValueByQNamecCs0x"|jj�D]\}}||kr|SqWt|��dS)N)rcr`rR)r
rrdrerrrrSeszAttributesNSImpl.getNameByQNamecCs
|j|S)N)rc)r
rrrrrTlszAttributesNSImpl.getQNameByNamecCst|jj��S)N)rUrcra)r
rrrrXoszAttributesNSImpl.getQNamescCs|j|j|j�S)N)r^rKrc)r
rrrr_rszAttributesNSImpl.copyN)	r!r"r#r
rQrSrTrXr_rrrrrbTsrbcCst�t�t�dS)N)rr$r6rrrr�_testvsrf�__main__N)
r*r�_exceptionsrrrr$r6r<rJrbrfr!rrrr�<module>sPJY>"PK�"[����k0k00sax/__pycache__/expatreader.cpython-36.opt-1.pycnu�[���3


 \X=�@s�dZdZddlTddlmZmZddlmZddlmZmZddlm	Z	ddlm
Z
mZdd	lZej
d	d
�dkr|edd	��[ydd
lmZWnek
r�edd	��YnXeed�s�edd	��ddlmZmZmZejZejZydd	lZWnek
�rdd�ZYnXdd	lZejZ[[Gdd�d�ZGdd�dej�ZGdd�dej ej�Z!dd�Z"e#dk�r�dd	l$Z%e"�Z&e&j'e%j(jj)��e&j*e%j(j+��e&j,d�d	S)z]
SAX driver for the pyexpat C module.  This driver works with
pyexpat.__version__ == '2.22'.
z0.20�)�*)�feature_validation�feature_namespaces)�feature_namespace_prefixes)�feature_external_ges�feature_external_pes)�feature_string_interning)�property_xml_string�property_interning_dictN��javazexpat not available in Java)�expatzexpat not supported�ParserCreate)�	xmlreader�saxutils�handlercCs|S)N�)�orr�+/usr/lib64/python3.6/xml/sax/expatreader.py�_mkproxy'src@seZdZdS)�
_ClosedParserN)�__name__�
__module__�__qualname__rrrrr.src@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�ExpatLocatorz�Locator for use with the ExpatParser class.

    This uses a weak reference to the parser object to avoid creating
    a circular reference between the parser and the content handler.
    cCst|�|_dS)N)r�_ref)�self�parserrrr�__init__9szExpatLocator.__init__cCs|j}|jdkrdS|jjS)N)r�_parser�ErrorColumnNumber)rrrrr�getColumnNumber<s
zExpatLocator.getColumnNumbercCs|j}|jdkrdS|jjS)N�)rr�ErrorLineNumber)rrrrr�
getLineNumberBs
zExpatLocator.getLineNumbercCs|j}|dkrdS|jj�S)N)r�_source�getPublicId)rrrrrr&HszExpatLocator.getPublicIdcCs|j}|dkrdS|jj�S)N)rr%�getSystemId)rrrrrr'NszExpatLocator.getSystemIdN)	rrr�__doc__rr!r$r&r'rrrrr3src@seZdZdZdGdd�Zdd	�Zd
d�Zdd
�Zdd�Zdd�Z	dd�Z
dd�ZdHdd�Zdd�Z
dd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Zd:d;�Zd<d=�Zd>d?�Z d@dA�Z!dBdC�Z"dDS)I�ExpatParserz$SAX driver for the pyexpat C module.r���cCsFtjj||�tj�|_d|_||_d|_d|_g|_	d|_
d|_dS)Nr)r�IncrementalParserrZInputSourcer%r�_namespaces�_lex_handler_prop�_parsing�
_entity_stack�
_external_ges�
_interning)rZnamespaceHandling�bufsizerrrrZs
zExpatParser.__init__c	CsVtj|�}||_y*|j�|jjt|��tjj	||�Wn|j
��YnXdS)z3Parse an XML document from a URL or an InputSource.N)r�prepare_input_sourcer%�reset�
_cont_handlerZsetDocumentLocatorrrr-�parse�
_close_source)r�sourcerrrr8gs
zExpatParser.parsecCs |j�dk	r|jj|j��dS)N)r'rZSetBase)rr:rrr�
prepareParserwszExpatParser.prepareParsercCs tjj||�|jr|j�dS)N)rr-�setContentHandlerr0�_reset_cont_handler)rrrrrr<}szExpatParser.setContentHandlercCsP|tkr|jS|tkr |jdk	S|tttfkr2dS|tkr@|jSt	d|��dS)NrzFeature '%s' not recognized)
rr.rr3rrrrr2�SAXNotRecognizedException)r�namerrr�
getFeature�s
zExpatParser.getFeaturecCs�|jrtd��|tkr||_n�|tkr.||_nt|tkrT|rL|jdkrRi|_q�d|_nN|tkrj|r�td��n8|t	kr�|r�td��n"|t
kr�|r�td��ntd|��dS)Nz!Cannot set features while parsingz!expat does not support validationz/expat does not read external parameter entitiesz(expat does not report namespace prefixeszFeature '%s' not recognized)r0�SAXNotSupportedExceptionrr.rr2rr3rrrr>)rr?�staterrr�
setFeature�s2
zExpatParser.setFeaturecCsd|tjkr|jS|tkr|jS|tkrT|jrLt|jd�rB|jj�St	d��nt
d��t	d|��dS)N�GetInputContextz=This version of expat does not support getting the XML stringz.XML string cannot be returned when not parsingzProperty '%s' not recognized)r�property_lexical_handlerr/r
r3r	r�hasattrrDr>rA)rr?rrr�getProperty�s

zExpatParser.getPropertycCsV|tjkr ||_|jrR|j�n2|tkr0||_n"|tkrFtd|��nt	d|��dS)NzProperty '%s' cannot be setzProperty '%s' not recognized)
rrEr/r0�_reset_lex_handler_propr
r3r	rAr>)rr?�valuerrr�setProperty�s


zExpatParser.setPropertycCsz|js|j�d|_|jj�y|jj||�WnDtjk
rt}z&ttj	|j
�||�}|jj|�WYdd}~XnXdS)Nr")
r0r6r7Z
startDocumentrZParser
�errorZSAXParseExceptionZErrorString�codeZ_err_handlerZ
fatalError)r�data�isFinal�e�excrrr�feed�s
zExpatParser.feedcCsB|j}z|j�}|dk	r |j�Wd|j�}|dk	r<|j�XdS)N)r%ZgetCharacterStream�closeZ
getByteStream)rr:�filerrrr9�szExpatParser._close_sourcecCs�|js|jdkst|jt�r dSz(|jddd�|jj�d|_d|_Wdd|_|jdk	rzt�}|jj|_|jj	|_	||_|j
�XdS)N�r")rNr)r1r�
isinstancerrQr7ZendDocumentr0r r#r9)rrrrrrR�s




zExpatParser.closecCs|jj|j_|jj|j_dS)N)r7�processingInstructionrZProcessingInstructionHandler�
charactersZCharacterDataHandler)rrrrr=�szExpatParser._reset_cont_handlercCs`|j}|j}|dkr4d|_d|_d|_d|_d|_n(|j|_|j|_|j	|_|j
|_|j|_dS)N)r/rZCommentHandlerZStartCdataSectionHandlerZEndCdataSectionHandlerZStartDoctypeDeclHandlerZEndDoctypeDeclHandlerZcommentZ
startCDATAZendCDATA�start_doctype_declZendDTD)rZlexrrrrrHsz#ExpatParser._reset_lex_handler_propcCs�|jr>tj|jj�d|jd�|_d|j_|j|j_	|j
|j_n,tj|jj�|jd�|_|j|j_	|j
|j_|j�|j|j_|j|j_|j|j_|j|j_d|_|jr�|j�|j|j_y|j|j_Wntk
r�YnX|jjtj �d|_!g|_"dS)N� )�internr"r)#r.r
rr%ZgetEncodingr3rZnamespace_prefixes�start_element_nsZStartElementHandler�end_element_nsZEndElementHandler�
start_element�end_elementr=�unparsed_entity_declZUnparsedEntityDeclHandler�
notation_declZNotationDeclHandler�start_namespace_declZStartNamespaceDeclHandler�end_namespace_declZEndNamespaceDeclHandlerZ_decl_handler_propr/rH�external_entity_refZExternalEntityRefHandler�skipped_entity_handlerZSkippedEntityHandler�AttributeErrorZSetParamEntityParsingZ*XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONEr0r1)rrrrr6s6







zExpatParser.resetcCs|jdkrdS|jjS)N)rr )rrrrr!;s
zExpatParser.getColumnNumbercCs|jdkrdS|jjS)Nr")rr#)rrrrr$@s
zExpatParser.getLineNumbercCs
|jj�S)N)r%r&)rrrrr&EszExpatParser.getPublicIdcCs
|jj�S)N)r%r')rrrrr'HszExpatParser.getSystemIdcCs|jj|t|��dS)N)r7ZstartElement�AttributesImpl)rr?�attrsrrrr]LszExpatParser.start_elementcCs|jj|�dS)N)r7Z
endElement)rr?rrrr^OszExpatParser.end_elementcCs�|j�}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}i}i}x�|j�D]|\}}|j�}t|�}	|	dkr�|}
d|f}n>|	dkr�d|d|df}
|d|df}n|d}
t|�}|||<|
||<qVW|jj|dt||��dS)Nr"�rz%s:%sr*)�split�len�tuple�itemsr7ZstartElementNS�AttributesNSImpl)rr?rg�pairZnewattrsZqnamesZanamerI�partsZlengthZqnameZapairrrrr[Rs.


zExpatParser.start_element_nscCsV|j�}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}|jj|d�dS)Nr"rhr)rirjrkr7ZendElementNS)rr?rnrrrr\ts
zExpatParser.end_element_nscCs|jj||�dS)N)r7rV)r�targetrMrrr�processing_instruction�sz"ExpatParser.processing_instructioncCs|jj|�dS)N)r7rW)rrMrrr�character_data�szExpatParser.character_datacCs|jj||�dS)N)r7ZstartPrefixMapping)r�prefixZurirrrra�sz ExpatParser.start_namespace_declcCs|jj|�dS)N)r7ZendPrefixMapping)rrsrrrrb�szExpatParser.end_namespace_declcCs|jj|||�dS)N)r/ZstartDTD)rr?�sysid�pubidZhas_internal_subsetrrrrX�szExpatParser.start_doctype_declcCs|jj||||�dS)N)�_dtd_handlerZunparsedEntityDecl)rr?�basertruZ
notation_namerrrr_�sz ExpatParser.unparsed_entity_declcCs|jj|||�dS)N)rvZnotationDecl)rr?rwrtrurrrr`�szExpatParser.notation_declc	Cs�|js
dS|jj||�}tj||jj�p*d�}|jj|j	|jf�|j	j
|�|_	||_ytjj
||�Wn
dS|jd\|_	|_|jd=dS)Nr"rTr���rx)r2Z_ent_handlerZ
resolveEntityrr5r%r'r1�appendrZExternalEntityParserCreaterr-r8)r�contextrwrtrur:rrrrc�s 
zExpatParser.external_entity_refcCs|rd|}|jj|�dS)N�%)r7Z
skippedEntity)rr?Zis_perrrrd�sz"ExpatParser.skipped_entity_handlerNi��)rr|)r)#rrrr(rr8r;r<r@rCrGrJrQr9rRr=rHr6r!r$r&r'r]r^r[r\rqrrrarbrXr_r`rcrdrrrrr)Ws@


'"r)cOs
t||�S)N)r))�args�kwargsrrr�
create_parser�sr�__main__z:http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml)-r(�versionZxml.sax._exceptionsZxml.sax.handlerrrrrrrr	r
�sys�platformZSAXReaderNotAvailableZxml.parsersr
�ImportErrorrFZxml.saxrrrrfrm�_weakrefr�weakref�proxyrZLocatorrr-r)rrZxml.sax.saxutilsZxml�pr<ZsaxZXMLGeneratorZsetErrorHandlerZErrorHandlerr8rrrr�<module>sN


$_
PK�"[&�y�	2	2'sax/__pycache__/saxutils.cpython-36.pycnu�[���3


 \�/�@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&x |j�D]\}}|j||�}q
W|S)z2Replace substrings of a string using a dictionary.)�items�replace)�s�d�key�value�r�(/usr/lib64/python3.6/xml/sax/saxutils.py�__dict_replacesr
cCs6|jdd�}|jdd�}|jdd�}|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.
    �&z&amp;�>z&gt;�<z&lt;)rr
)�data�entitiesrrr�escapes	
rcCs2|jdd�}|jdd�}|r&t||�}|jdd�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.
    z&lt;rz&gt;rz&amp;r)rr
)rrrrr�unescape"s

rcCs\|j�}|jdddd��t||�}d|krPd|krFd|jdd�}qXd	|}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')�copy�updaterr)rrrrr�	quoteattr0s

rcs��dkrddl}|jSt�tj�r&�St�tjtjf�r<�St�tj�rlG�fdd�d�}|�}dd�|_	nDtj
�}dd�|_�j|_y�j
|_
�j|_Wntk
r�YnXtj||ddd	d
�S)NrcseZdZ�jZ�fdd�ZdS)z _gettextwriter.<locals>._wrappercs
t�|�S)N)�getattr)�self�name)�outrr�__getattr__[sz,_gettextwriter.<locals>._wrapper.__getattr__N)�__name__�
__module__�__qualname__�	__class__r!r)r rr�_wrapperYsr&cSsdS)Nrrrrr�<lambda>^sz _gettextwriter.<locals>.<lambda>cSsdS)NTrrrrrr'cs�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)r-r&�bufferr)r r�_gettextwriterHs.
r?c@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-1FcCsVtjj|�t||�}|j|_|j|_ig|_|jd|_	g|_
||_||_d|_
dS)NrF���)r�ContentHandler�__init__r?r9�_write�flush�_flush�_ns_contexts�_current_context�_undeclared_ns_maps�	_encoding�_short_empty_elements�_pending_start_element)rr r)Zshort_empty_elementsrrrrDss
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�:)rI)rr�prefixrrr�_qnameszXMLGenerator._qnamecCs|jr|jd�d|_dS)NrF)rMrE)r�
endElementrrr�_finish_pending_start_element�s
z*XMLGenerator._finish_pending_start_elementcCs|jd|j�dS)Nz$<?xml version="1.0" encoding="%s"?>
)rErK)rrrr�
startDocument�szXMLGenerator.startDocumentcCs|j�dS)N)rG)rrrr�endDocument�szXMLGenerator.endDocumentcCs0|jj|jj��||j|<|jj||f�dS)N)rH�appendrIrrJ)rrO�urirrr�startPrefixMapping�s
zXMLGenerator.startPrefixMappingcCs|jd|_|jd=dS)NrrBrB)rHrI)rrOrrr�endPrefixMapping�szXMLGenerator.endPrefixMappingcCs^|j�|jd|�x*|j�D]\}}|jd|t|�f�q W|jrPd|_n
|jd�dS)Nrz %s=%sTr)rRrErrrLrM)rr�attrsr
rrr�startElement�szXMLGenerator.startElementcCs*|jr|jd�d|_n|jd|�dS)Nz/>Fz</%s>)rMrE)rrrrrrQ�s
zXMLGenerator.endElementcCs�|j�|jd|j|��x8|jD].\}}|rD|jd||f�q$|jd|�q$Wg|_x0|j�D]$\}}|jd|j|�t|�f�qfW|jr�d|_n
|jd�dS)Nrz xmlns:%s="%s"z xmlns="%s"z %s=%sTr)rRrErPrJrrrLrM)rr�qnamerYrOrVr
rrr�startElementNS�s zXMLGenerator.startElementNScCs0|jr|jd�d|_n|jd|j|��dS)Nz/>Fz</%s>)rMrErP)rrr[rrr�endElementNS�s
zXMLGenerator.endElementNScCs4|r0|j�t|t�s"t||j�}|jt|��dS)N)rRr/�strrKrEr)r�contentrrr�
characters�s

zXMLGenerator.characterscCs0|r,|j�t|t�s"t||j�}|j|�dS)N)rRr/r^rKrE)rr_rrr�ignorableWhitespace�s

z XMLGenerator.ignorableWhitespacecCs|j�|jd||f�dS)Nz	<?%s %s?>)rRrE)r�targetrrrr�processingInstruction�sz"XMLGenerator.processingInstruction)NrAF)F)r"r#r$rDrPrRrSrTrWrXrZrQr\r]r`rarcrrrrr@qs


r@c@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.NcCstjj|�||_dS)N)r�	XMLReaderrD�_parent)r�parentrrrrD�szXMLFilterBase.__init__cCs|jj|�dS)N)�_err_handler�error)r�	exceptionrrrri�szXMLFilterBase.errorcCs|jj|�dS)N)rh�
fatalError)rrjrrrrk�szXMLFilterBase.fatalErrorcCs|jj|�dS)N)rh�warning)rrjrrrrl�szXMLFilterBase.warningcCs|jj|�dS)N)�
_cont_handler�setDocumentLocator)rZlocatorrrrrn�sz XMLFilterBase.setDocumentLocatorcCs|jj�dS)N)rmrS)rrrrrSszXMLFilterBase.startDocumentcCs|jj�dS)N)rmrT)rrrrrTszXMLFilterBase.endDocumentcCs|jj||�dS)N)rmrW)rrOrVrrrrWsz XMLFilterBase.startPrefixMappingcCs|jj|�dS)N)rmrX)rrOrrrrX	szXMLFilterBase.endPrefixMappingcCs|jj||�dS)N)rmrZ)rrrYrrrrZszXMLFilterBase.startElementcCs|jj|�dS)N)rmrQ)rrrrrrQszXMLFilterBase.endElementcCs|jj|||�dS)N)rmr\)rrr[rYrrrr\szXMLFilterBase.startElementNScCs|jj||�dS)N)rmr])rrr[rrrr]szXMLFilterBase.endElementNScCs|jj|�dS)N)rmr`)rr_rrrr`szXMLFilterBase.characterscCs|jj|�dS)N)rmra)r�charsrrrrasz!XMLFilterBase.ignorableWhitespacecCs|jj||�dS)N)rmrc)rrbrrrrrcsz#XMLFilterBase.processingInstructioncCs|jj|�dS)N)rm�
skippedEntity)rrrrrrp!szXMLFilterBase.skippedEntitycCs|jj|||�dS)N)�_dtd_handler�notationDecl)rr�publicId�systemIdrrrrr&szXMLFilterBase.notationDeclcCs|jj||||�dS)N)rq�unparsedEntityDecl)rrrsrtZndatarrrru)sz XMLFilterBase.unparsedEntityDeclcCs|jj||�S)N)Z_ent_handler�
resolveEntity)rrsrtrrrrv.szXMLFilterBase.resolveEntitycCs@|jj|�|jj|�|jj|�|jj|�|jj|�dS)N)rfZsetContentHandlerZsetErrorHandlerZsetEntityResolverZ
setDTDHandler�parse)r�sourcerrrrw3s
zXMLFilterBase.parsecCs|jj|�dS)N)rf�	setLocale)rZlocalerrrry:szXMLFilterBase.setLocalecCs|jj|�S)N)rf�
getFeature)rrrrrrz=szXMLFilterBase.getFeaturecCs|jj||�dS)N)rf�
setFeature)rr�staterrrr{@szXMLFilterBase.setFeaturecCs|jj|�S)N)rf�getProperty)rrrrrr}CszXMLFilterBase.getPropertycCs|jj||�dS)N)rf�setProperty)rrr
rrrr~FszXMLFilterBase.setPropertycCs|jS)N)rf)rrrr�	getParentKszXMLFilterBase.getParentcCs
||_dS)N)rf)rrgrrr�	setParentNszXMLFilterBase.setParent)N) r"r#r$�__doc__rDrirkrlrnrSrTrWrXrZrQr\r]r`rarcrprrrurvrwryrzr{r}r~rr�rrrrrd�s:
rd�cCst|t�rtj|�}n^t|d�rt|}tj�}t|jd�t�rH|j|�n
|j|�t|d�rtt|jt�rt|j	|j�|j
�dko�|j�dk�r|j�}t
jjt
jj|��}t
jj||�}t
jj|�r�|j	|�t|d�}n$|j	tjj||��tjj|j��}|j|�|S)z�This function takes an InputSource and an optional base URL and
    returns a fully resolved InputSource object ready for reading.�readrrN�rb)r/r^rZInputSource�hasattrr�ZsetCharacterStreamZ
setByteStreamrZsetSystemIdZgetCharacterStreamZ
getByteStreamZgetSystemId�os�path�dirname�normpath�join�isfile�open�urllibrwZurljoinZrequestZurlopen)rx�base�fZsysidZbaseheadZ
sysidfilenamerrr�prepare_input_sourceSs*




r�)r�)r�r�Zurllib.parser�Zurllib.requestr0r2r�rrr
rrrr?rCr@rerdr�rrrr�<module>s)soPK�"[�)�[[0sax/__pycache__/_exceptions.cpython-36.opt-1.pycnu�[���3


 \��@s�dZddlZejdd�dkr*ddlmZ[Gdd�de�ZGdd	�d	e�ZGd
d�de�ZGdd
�d
e�ZGdd�de�Z	dS)z!Different kinds of SAX Exceptions�N��java)�	Exceptionc@s:eZdZdZd
dd�Zdd�Zdd�Zd	d
�Zdd�ZdS)�SAXExceptiona�Encapsulate an XML error or warning. This class can contain
    basic error or warning information from either the XML parser or
    the application: you can subclass it to provide additional
    functionality, or to add localization. Note that although you will
    receive a SAXException as the argument to the handlers in the
    ErrorHandler interface, you are not actually required to raise
    the exception; instead, you can simply read the information in
    it.NcCs||_||_tj||�dS)zUCreates an exception. The message is required, but the exception
        is optional.N)�_msg�
_exceptionr�__init__)�self�msg�	exception�r�+/usr/lib64/python3.6/xml/sax/_exceptions.pyrszSAXException.__init__cCs|jS)z$Return a message for this exception.)r)r	rrr
�
getMessageszSAXException.getMessagecCs|jS)z9Return the embedded exception, or None if there was none.)r)r	rrr
�getExceptionszSAXException.getExceptioncCs|jS)z0Create a string representation of the exception.)r)r	rrr
�__str__"szSAXException.__str__cCstd��dS)zvAvoids weird error messages if someone does exception[ix] by
        mistake, since Exception has __getitem__ defined.�__getitem__N)�AttributeError)r	Zixrrr
r&szSAXException.__getitem__)N)	�__name__�
__module__�__qualname__�__doc__rrrrrrrrr
r	s
rc@s@eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�SAXParseExceptiona#Encapsulate an XML parse error or warning.

    This exception will include information for locating the error in
    the original XML document. Note that although the application will
    receive a SAXParseException as the argument to the handlers in the
    ErrorHandler interface, the application is not actually required
    to raise the exception; instead, it can simply read the
    information in it and take a different action.

    Since this exception is a subclass of SAXException, it inherits
    the ability to wrap another exception.cCs<tj|||�||_|jj�|_|jj�|_|jj�|_dS)zECreates the exception. The exception parameter is allowed to be None.N)	rr�_locator�getSystemId�	_systemId�getColumnNumber�_colnum�
getLineNumber�_linenum)r	r
rZlocatorrrr
r;s
zSAXParseException.__init__cCs|jS)zNThe column number of the end of the text where the exception
        occurred.)r)r	rrr
rHsz!SAXParseException.getColumnNumbercCs|jS)zDThe line number of the end of the text where the exception occurred.)r)r	rrr
rMszSAXParseException.getLineNumbercCs
|jj�S)zEGet the public identifier of the entity where the exception occurred.)r�getPublicId)r	rrr
rQszSAXParseException.getPublicIdcCs|jS)zEGet the system identifier of the entity where the exception occurred.)r)r	rrr
rUszSAXParseException.getSystemIdcCsN|j�}|dkrd}|j�}|dkr(d}|j�}|dkr<d}d||||jfS)z0Create a string representation of the exception.Nz	<unknown>�?z%s:%s:%s: %s)rrrr)r	ZsysidZlinenumZcolnumrrr
rYszSAXParseException.__str__N)
rrrrrrrrrrrrrr
r.s
rc@seZdZdZdS)�SAXNotRecognizedExceptionz�Exception class for an unrecognized identifier.

    An XMLReader will raise this exception when it is confronted with an
    unrecognized feature or property. SAX applications and extensions may
    use this class for similar purposes.N)rrrrrrrr
r!isr!c@seZdZdZdS)�SAXNotSupportedExceptionaException class for an unsupported operation.

    An XMLReader will raise this exception when a service it cannot
    perform is requested (specifically setting a state or value). SAX
    applications and extensions may use this class for similar
    purposes.N)rrrrrrrr
r"ssr"c@seZdZdZdS)�SAXReaderNotAvailableaException class for a missing driver.

    An XMLReader module (driver) should raise this exception when it
    is first imported, e.g. when a support module cannot be imported.
    It also may be raised during parsing, e.g. if executing an external
    program is not permitted.N)rrrrrrrr
r#}sr#)
r�sys�platformZ	java.langrrrr!r"r#rrrr
�<module>s%;

PK�"[����k0k0*sax/__pycache__/expatreader.cpython-36.pycnu�[���3


 \X=�@s�dZdZddlTddlmZmZddlmZddlmZmZddlm	Z	ddlm
Z
mZdd	lZej
d	d
�dkr|edd	��[ydd
lmZWnek
r�edd	��YnXeed�s�edd	��ddlmZmZmZejZejZydd	lZWnek
�rdd�ZYnXdd	lZejZ[[Gdd�d�ZGdd�dej�ZGdd�dej ej�Z!dd�Z"e#dk�r�dd	l$Z%e"�Z&e&j'e%j(jj)��e&j*e%j(j+��e&j,d�d	S)z]
SAX driver for the pyexpat C module.  This driver works with
pyexpat.__version__ == '2.22'.
z0.20�)�*)�feature_validation�feature_namespaces)�feature_namespace_prefixes)�feature_external_ges�feature_external_pes)�feature_string_interning)�property_xml_string�property_interning_dictN��javazexpat not available in Java)�expatzexpat not supported�ParserCreate)�	xmlreader�saxutils�handlercCs|S)N�)�orr�+/usr/lib64/python3.6/xml/sax/expatreader.py�_mkproxy'src@seZdZdS)�
_ClosedParserN)�__name__�
__module__�__qualname__rrrrr.src@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�ExpatLocatorz�Locator for use with the ExpatParser class.

    This uses a weak reference to the parser object to avoid creating
    a circular reference between the parser and the content handler.
    cCst|�|_dS)N)r�_ref)�self�parserrrr�__init__9szExpatLocator.__init__cCs|j}|jdkrdS|jjS)N)r�_parser�ErrorColumnNumber)rrrrr�getColumnNumber<s
zExpatLocator.getColumnNumbercCs|j}|jdkrdS|jjS)N�)rr�ErrorLineNumber)rrrrr�
getLineNumberBs
zExpatLocator.getLineNumbercCs|j}|dkrdS|jj�S)N)r�_source�getPublicId)rrrrrr&HszExpatLocator.getPublicIdcCs|j}|dkrdS|jj�S)N)rr%�getSystemId)rrrrrr'NszExpatLocator.getSystemIdN)	rrr�__doc__rr!r$r&r'rrrrr3src@seZdZdZdGdd�Zdd	�Zd
d�Zdd
�Zdd�Zdd�Z	dd�Z
dd�ZdHdd�Zdd�Z
dd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Zd:d;�Zd<d=�Zd>d?�Z d@dA�Z!dBdC�Z"dDS)I�ExpatParserz$SAX driver for the pyexpat C module.r���cCsFtjj||�tj�|_d|_||_d|_d|_g|_	d|_
d|_dS)Nr)r�IncrementalParserrZInputSourcer%r�_namespaces�_lex_handler_prop�_parsing�
_entity_stack�
_external_ges�
_interning)rZnamespaceHandling�bufsizerrrrZs
zExpatParser.__init__c	CsVtj|�}||_y*|j�|jjt|��tjj	||�Wn|j
��YnXdS)z3Parse an XML document from a URL or an InputSource.N)r�prepare_input_sourcer%�reset�
_cont_handlerZsetDocumentLocatorrrr-�parse�
_close_source)r�sourcerrrr8gs
zExpatParser.parsecCs |j�dk	r|jj|j��dS)N)r'rZSetBase)rr:rrr�
prepareParserwszExpatParser.prepareParsercCs tjj||�|jr|j�dS)N)rr-�setContentHandlerr0�_reset_cont_handler)rrrrrr<}szExpatParser.setContentHandlercCsP|tkr|jS|tkr |jdk	S|tttfkr2dS|tkr@|jSt	d|��dS)NrzFeature '%s' not recognized)
rr.rr3rrrrr2�SAXNotRecognizedException)r�namerrr�
getFeature�s
zExpatParser.getFeaturecCs�|jrtd��|tkr||_n�|tkr.||_nt|tkrT|rL|jdkrRi|_q�d|_nN|tkrj|r�td��n8|t	kr�|r�td��n"|t
kr�|r�td��ntd|��dS)Nz!Cannot set features while parsingz!expat does not support validationz/expat does not read external parameter entitiesz(expat does not report namespace prefixeszFeature '%s' not recognized)r0�SAXNotSupportedExceptionrr.rr2rr3rrrr>)rr?�staterrr�
setFeature�s2
zExpatParser.setFeaturecCsd|tjkr|jS|tkr|jS|tkrT|jrLt|jd�rB|jj�St	d��nt
d��t	d|��dS)N�GetInputContextz=This version of expat does not support getting the XML stringz.XML string cannot be returned when not parsingzProperty '%s' not recognized)r�property_lexical_handlerr/r
r3r	r�hasattrrDr>rA)rr?rrr�getProperty�s

zExpatParser.getPropertycCsV|tjkr ||_|jrR|j�n2|tkr0||_n"|tkrFtd|��nt	d|��dS)NzProperty '%s' cannot be setzProperty '%s' not recognized)
rrEr/r0�_reset_lex_handler_propr
r3r	rAr>)rr?�valuerrr�setProperty�s


zExpatParser.setPropertycCsz|js|j�d|_|jj�y|jj||�WnDtjk
rt}z&ttj	|j
�||�}|jj|�WYdd}~XnXdS)Nr")
r0r6r7Z
startDocumentrZParser
�errorZSAXParseExceptionZErrorString�codeZ_err_handlerZ
fatalError)r�data�isFinal�e�excrrr�feed�s
zExpatParser.feedcCsB|j}z|j�}|dk	r |j�Wd|j�}|dk	r<|j�XdS)N)r%ZgetCharacterStream�closeZ
getByteStream)rr:�filerrrr9�szExpatParser._close_sourcecCs�|js|jdkst|jt�r dSz(|jddd�|jj�d|_d|_Wdd|_|jdk	rzt�}|jj|_|jj	|_	||_|j
�XdS)N�r")rNr)r1r�
isinstancerrQr7ZendDocumentr0r r#r9)rrrrrrR�s




zExpatParser.closecCs|jj|j_|jj|j_dS)N)r7�processingInstructionrZProcessingInstructionHandler�
charactersZCharacterDataHandler)rrrrr=�szExpatParser._reset_cont_handlercCs`|j}|j}|dkr4d|_d|_d|_d|_d|_n(|j|_|j|_|j	|_|j
|_|j|_dS)N)r/rZCommentHandlerZStartCdataSectionHandlerZEndCdataSectionHandlerZStartDoctypeDeclHandlerZEndDoctypeDeclHandlerZcommentZ
startCDATAZendCDATA�start_doctype_declZendDTD)rZlexrrrrrHsz#ExpatParser._reset_lex_handler_propcCs�|jr>tj|jj�d|jd�|_d|j_|j|j_	|j
|j_n,tj|jj�|jd�|_|j|j_	|j
|j_|j�|j|j_|j|j_|j|j_|j|j_d|_|jr�|j�|j|j_y|j|j_Wntk
r�YnX|jjtj �d|_!g|_"dS)N� )�internr"r)#r.r
rr%ZgetEncodingr3rZnamespace_prefixes�start_element_nsZStartElementHandler�end_element_nsZEndElementHandler�
start_element�end_elementr=�unparsed_entity_declZUnparsedEntityDeclHandler�
notation_declZNotationDeclHandler�start_namespace_declZStartNamespaceDeclHandler�end_namespace_declZEndNamespaceDeclHandlerZ_decl_handler_propr/rH�external_entity_refZExternalEntityRefHandler�skipped_entity_handlerZSkippedEntityHandler�AttributeErrorZSetParamEntityParsingZ*XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONEr0r1)rrrrr6s6







zExpatParser.resetcCs|jdkrdS|jjS)N)rr )rrrrr!;s
zExpatParser.getColumnNumbercCs|jdkrdS|jjS)Nr")rr#)rrrrr$@s
zExpatParser.getLineNumbercCs
|jj�S)N)r%r&)rrrrr&EszExpatParser.getPublicIdcCs
|jj�S)N)r%r')rrrrr'HszExpatParser.getSystemIdcCs|jj|t|��dS)N)r7ZstartElement�AttributesImpl)rr?�attrsrrrr]LszExpatParser.start_elementcCs|jj|�dS)N)r7Z
endElement)rr?rrrr^OszExpatParser.end_elementcCs�|j�}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}i}i}x�|j�D]|\}}|j�}t|�}	|	dkr�|}
d|f}n>|	dkr�d|d|df}
|d|df}n|d}
t|�}|||<|
||<qVW|jj|dt||��dS)Nr"�rz%s:%sr*)�split�len�tuple�itemsr7ZstartElementNS�AttributesNSImpl)rr?rg�pairZnewattrsZqnamesZanamerI�partsZlengthZqnameZapairrrrr[Rs.


zExpatParser.start_element_nscCsV|j�}t|�dkrd|f}n&t|�dkr<|d|df}nt|�}|jj|d�dS)Nr"rhr)rirjrkr7ZendElementNS)rr?rnrrrr\ts
zExpatParser.end_element_nscCs|jj||�dS)N)r7rV)r�targetrMrrr�processing_instruction�sz"ExpatParser.processing_instructioncCs|jj|�dS)N)r7rW)rrMrrr�character_data�szExpatParser.character_datacCs|jj||�dS)N)r7ZstartPrefixMapping)r�prefixZurirrrra�sz ExpatParser.start_namespace_declcCs|jj|�dS)N)r7ZendPrefixMapping)rrsrrrrb�szExpatParser.end_namespace_declcCs|jj|||�dS)N)r/ZstartDTD)rr?�sysid�pubidZhas_internal_subsetrrrrX�szExpatParser.start_doctype_declcCs|jj||||�dS)N)�_dtd_handlerZunparsedEntityDecl)rr?�basertruZ
notation_namerrrr_�sz ExpatParser.unparsed_entity_declcCs|jj|||�dS)N)rvZnotationDecl)rr?rwrtrurrrr`�szExpatParser.notation_declc	Cs�|js
dS|jj||�}tj||jj�p*d�}|jj|j	|jf�|j	j
|�|_	||_ytjj
||�Wn
dS|jd\|_	|_|jd=dS)Nr"rTr���rx)r2Z_ent_handlerZ
resolveEntityrr5r%r'r1�appendrZExternalEntityParserCreaterr-r8)r�contextrwrtrur:rrrrc�s 
zExpatParser.external_entity_refcCs|rd|}|jj|�dS)N�%)r7Z
skippedEntity)rr?Zis_perrrrd�sz"ExpatParser.skipped_entity_handlerNi��)rr|)r)#rrrr(rr8r;r<r@rCrGrJrQr9rRr=rHr6r!r$r&r'r]r^r[r\rqrrrarbrXr_r`rcrdrrrrr)Ws@


'"r)cOs
t||�S)N)r))�args�kwargsrrr�
create_parser�sr�__main__z:http://www.ibiblio.org/xml/examples/shakespeare/hamlet.xml)-r(�versionZxml.sax._exceptionsZxml.sax.handlerrrrrrrr	r
�sys�platformZSAXReaderNotAvailableZxml.parsersr
�ImportErrorrFZxml.saxrrrrfrm�_weakrefr�weakref�proxyrZLocatorrr-r)rrZxml.sax.saxutilsZxml�pr<ZsaxZXMLGeneratorZsetErrorHandlerZErrorHandlerr8rrrr�<module>sN


$_
PK�"[b=�n��,sax/__pycache__/handler.cpython-36.opt-2.pycnu�[���3


 \b6�@s�dZGdd�d�ZGdd�d�ZGdd�d�ZGdd�d�Zd	Zd
ZdZdZd
Z	dZ
eeeee	e
gZdZdZ
dZdZdZdZeee
eeegZdS)z2.0betac@s$eZdZdd�Zdd�Zdd�ZdS)�ErrorHandlercCs|�dS)N�)�self�	exceptionrr�'/usr/lib64/python3.6/xml/sax/handler.py�error szErrorHandler.errorcCs|�dS)Nr)rrrrr�
fatalError$szErrorHandler.fatalErrorcCst|�dS)N)�print)rrrrr�warning(szErrorHandler.warningN)�__name__�
__module__�__qualname__rrr	rrrrrs
rc@s|eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�ZdS)�ContentHandlercCs
d|_dS)N)�_locator)rrrr�__init__6szContentHandler.__init__cCs
||_dS)N)r)rZlocatorrrr�setDocumentLocator9sz!ContentHandler.setDocumentLocatorcCsdS)Nr)rrrr�
startDocumentPszContentHandler.startDocumentcCsdS)Nr)rrrr�endDocumentWszContentHandler.endDocumentcCsdS)Nr)r�prefixZurirrr�startPrefixMapping`sz!ContentHandler.startPrefixMappingcCsdS)Nr)rrrrr�endPrefixMappingwszContentHandler.endPrefixMappingcCsdS)Nr)r�name�attrsrrr�startElement~szContentHandler.startElementcCsdS)Nr)rrrrr�
endElement�szContentHandler.endElementcCsdS)Nr)rr�qnamerrrr�startElementNS�szContentHandler.startElementNScCsdS)Nr)rrrrrr�endElementNS�szContentHandler.endElementNScCsdS)Nr)rZcontentrrr�
characters�szContentHandler.characterscCsdS)Nr)rZ
whitespacerrr�ignorableWhitespace�sz"ContentHandler.ignorableWhitespacecCsdS)Nr)r�target�datarrr�processingInstruction�sz$ContentHandler.processingInstructioncCsdS)Nr)rrrrr�
skippedEntity�szContentHandler.skippedEntityN)r
rrrrrrrrrrrrrrr!r"rrrrr
/s	
r
c@seZdZdd�Zdd�ZdS)�
DTDHandlercCsdS)Nr)rr�publicId�systemIdrrr�notationDecl�szDTDHandler.notationDeclcCsdS)Nr)rrr$r%Zndatarrr�unparsedEntityDecl�szDTDHandler.unparsedEntityDeclN)r
rrr&r'rrrrr#�sr#c@seZdZdd�ZdS)�EntityResolvercCs|S)Nr)rr$r%rrr�
resolveEntity�szEntityResolver.resolveEntityN)r
rrr)rrrrr(�sr(z&http://xml.org/sax/features/namespacesz.http://xml.org/sax/features/namespace-prefixesz,http://xml.org/sax/features/string-interningz&http://xml.org/sax/features/validationz5http://xml.org/sax/features/external-general-entitiesz7http://xml.org/sax/features/external-parameter-entitiesz-http://xml.org/sax/properties/lexical-handlerz1http://xml.org/sax/properties/declaration-handlerz&http://xml.org/sax/properties/dom-nodez(http://xml.org/sax/properties/xml-stringz-http://www.python.org/sax/properties/encodingz3http://www.python.org/sax/properties/interning-dictN)�versionrr
r#r(Zfeature_namespacesZfeature_namespace_prefixesZfeature_string_interningZfeature_validationZfeature_external_gesZfeature_external_pesZall_featuresZproperty_lexical_handlerZproperty_declaration_handlerZproperty_dom_nodeZproperty_xml_stringZproperty_encodingZproperty_interning_dictZall_propertiesrrrr�<module>s:
"	PK�"[�leBB(sax/__pycache__/xmlreader.cpython-36.pycnu�[���3


 \�1�@s�dZddlmZddlmZmZGdd�d�ZGdd�de�ZGdd	�d	�ZGd
d�d�Z	Gdd
�d
�Z
Gdd�de
�Zdd�Ze
dkr�e�dS)z]An XML Reader is the SAX 2 name for an XML parser. XML Parsers
should be based on this code. �)�handler)�SAXNotSupportedException�SAXNotRecognizedExceptionc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd S)!�	XMLReadera%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.cCs,tj�|_tj�|_tj�|_tj�|_dS)N)	rZContentHandler�
_cont_handlerZ
DTDHandler�_dtd_handlerZEntityResolver�_ent_handlerZErrorHandler�_err_handler)�self�r�)/usr/lib64/python3.6/xml/sax/xmlreader.py�__init__s


zXMLReader.__init__cCstd��dS)zAParse an XML document from a system identifier or an InputSource.z This method must be implemented!N)�NotImplementedError)r
�sourcerrr�parseszXMLReader.parsecCs|jS)z#Returns the current ContentHandler.)r)r
rrr�getContentHandler"szXMLReader.getContentHandlercCs
||_dS)z:Registers a new object to receive document content events.N)r)r
rrrr�setContentHandler&szXMLReader.setContentHandlercCs|jS)z Returns the current DTD handler.)r)r
rrr�
getDTDHandler*szXMLReader.getDTDHandlercCs
||_dS)z7Register an object to receive basic DTD-related events.N)r)r
rrrr�
setDTDHandler.szXMLReader.setDTDHandlercCs|jS)z#Returns the current EntityResolver.)r)r
rrr�getEntityResolver2szXMLReader.getEntityResolvercCs
||_dS)z0Register an object to resolve external entities.N)r)r
Zresolverrrr�setEntityResolver6szXMLReader.setEntityResolvercCs|jS)z!Returns the current ErrorHandler.)r	)r
rrr�getErrorHandler:szXMLReader.getErrorHandlercCs
||_dS)z3Register an object to receive error-message events.N)r	)r
rrrr�setErrorHandler>szXMLReader.setErrorHandlercCstd��dS)aHAllow 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.zLocale support not implementedN)r)r
Zlocalerrr�	setLocaleBszXMLReader.setLocalecCstd|��dS)z1Looks up and returns the state of a SAX2 feature.zFeature '%s' not recognizedN)r)r
�namerrr�
getFeatureKszXMLReader.getFeaturecCstd|��dS)z!Sets the state of a SAX2 feature.zFeature '%s' not recognizedN)r)r
r�staterrr�
setFeatureOszXMLReader.setFeaturecCstd|��dS)z2Looks up and returns the value of a SAX2 property.zProperty '%s' not recognizedN)r)r
rrrr�getPropertySszXMLReader.getPropertycCstd|��dS)z"Sets the value of a SAX2 property.zProperty '%s' not recognizedN)r)r
r�valuerrr�setPropertyWszXMLReader.setPropertyN)�__name__�
__module__�__qualname__�__doc__r
rrrrrrrrrrrrrr rrrrrs 	rc@sBeZdZdZddd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dS)�IncrementalParserasThis 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.��cCs||_tj|�dS)N)�_bufsizerr
)r
�bufsizerrrr
oszIncrementalParser.__init__cCspddlm}|j|�}|j|�|j�}|dkr8|j�}|j|j�}x|rb|j|�|j|j�}qFW|j	�dS)Nr)�saxutils)
�r*Zprepare_input_source�
prepareParser�getCharacterStream�
getByteStream�readr(�feed�close)r
rr*�file�bufferrrrrss


zIncrementalParser.parsecCstd��dS)aThis 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.z This method must be implemented!N)r)r
�datarrrr0�szIncrementalParser.feedcCstd��dS)ztThis method is called by the parse implementation to allow
        the SAX 2.0 driver to prepare itself for parsing.z!prepareParser must be overridden!N)r)r
rrrrr,�szIncrementalParser.prepareParsercCstd��dS)a�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.z This method must be implemented!N)r)r
rrrr1�szIncrementalParser.closecCstd��dS)z�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.z This method must be implemented!N)r)r
rrr�reset�szIncrementalParser.resetN�)r6)
r!r"r#r$r
rr0r,r1r5rrrrr%[s
	
r%c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�Locatorz�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.cCsdS)z6Return the column number where the current event ends.r���r)r
rrr�getColumnNumber�szLocator.getColumnNumbercCsdS)z4Return the line number where the current event ends.rr8r)r
rrr�
getLineNumber�szLocator.getLineNumbercCsdS)z3Return the public identifier for the current event.Nr)r
rrr�getPublicId�szLocator.getPublicIdcCsdS)z3Return the system identifier for the current event.Nr)r
rrr�getSystemId�szLocator.getSystemIdN)r!r"r#r$r9r:r;r<rrrrr7�s
r7c@sjeZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�ZdS)�InputSourceanEncapsulation 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.NcCs"||_d|_d|_d|_d|_dS)N)�_InputSource__system_id�_InputSource__public_id�_InputSource__encoding�_InputSource__bytefile�_InputSource__charfile)r
�	system_idrrrr
�s
zInputSource.__init__cCs
||_dS)z/Sets the public identifier of this InputSource.N)r?)r
Z	public_idrrr�setPublicId�szInputSource.setPublicIdcCs|jS)z2Returns the public identifier of this InputSource.)r?)r
rrrr;�szInputSource.getPublicIdcCs
||_dS)z/Sets the system identifier of this InputSource.N)r>)r
rCrrr�setSystemId�szInputSource.setSystemIdcCs|jS)z2Returns the system identifier of this InputSource.)r>)r
rrrr<�szInputSource.getSystemIdcCs
||_dS)a4Sets 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.N)r@)r
�encodingrrr�setEncoding�szInputSource.setEncodingcCs|jS)z/Get the character encoding of this InputSource.)r@)r
rrr�getEncoding�szInputSource.getEncodingcCs
||_dS)a�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.N)rA)r
Zbytefilerrr�
setByteStream�szInputSource.setByteStreamcCs|jS)z�Get the byte stream for this input source.

        The getEncoding method will return the character encoding for
        this byte stream, or None if unknown.)rA)r
rrrr.�szInputSource.getByteStreamcCs
||_dS)a^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.N)rB)r
Zcharfilerrr�setCharacterStreamszInputSource.setCharacterStreamcCs|jS)z/Get the character stream for this input source.)rB)r
rrrr-szInputSource.getCharacterStream)N)r!r"r#r$r
rDr;rEr<rGrHrIr.rJr-rrrrr=�s



r=c@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zd$dd�Zdd�Zd d!�Zd"d#�ZdS)%�AttributesImplcCs
||_dS)zQNon-NS-aware implementation.

        attrs should be of the form {name : value}.N)�_attrs)r
�attrsrrrr
szAttributesImpl.__init__cCs
t|j�S)N)�lenrL)r
rrr�	getLengthszAttributesImpl.getLengthcCsdS)NZCDATAr)r
rrrr�getType!szAttributesImpl.getTypecCs
|j|S)N)rL)r
rrrr�getValue$szAttributesImpl.getValuecCs
|j|S)N)rL)r
rrrr�getValueByQName'szAttributesImpl.getValueByQNamecCs||jkrt|��|S)N)rL�KeyError)r
rrrr�getNameByQName*s
zAttributesImpl.getNameByQNamecCs||jkrt|��|S)N)rLrS)r
rrrr�getQNameByName/s
zAttributesImpl.getQNameByNamecCst|jj��S)N)�listrL�keys)r
rrr�getNames4szAttributesImpl.getNamescCst|jj��S)N)rVrLrW)r
rrr�	getQNames7szAttributesImpl.getQNamescCs
t|j�S)N)rNrL)r
rrr�__len__:szAttributesImpl.__len__cCs
|j|S)N)rL)r
rrrr�__getitem__=szAttributesImpl.__getitem__cCst|jj��S)N)rVrLrW)r
rrrrW@szAttributesImpl.keyscCs
||jkS)N)rL)r
rrrr�__contains__CszAttributesImpl.__contains__NcCs|jj||�S)N)rL�get)r
r�alternativerrrr]FszAttributesImpl.getcCs|j|j�S)N)�	__class__rL)r
rrr�copyIszAttributesImpl.copycCst|jj��S)N)rVrL�items)r
rrrraLszAttributesImpl.itemscCst|jj��S)N)rVrL�values)r
rrrrbOszAttributesImpl.values)N)r!r"r#r
rOrPrQrRrTrUrXrYrZr[rWr\r]r`rarbrrrrrKs"
rKc@s<eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�AttributesNSImplcCs||_||_dS)z�NS-aware implementation.

        attrs should be of the form {(ns_uri, lname): value, ...}.
        qnames of the form {(ns_uri, lname): qname, ...}.N)rL�_qnames)r
rMZqnamesrrrr
VszAttributesNSImpl.__init__cCs6x(|jj�D]\}}||kr|j|SqWt|��dS)N)rdrarLrS)r
r�nsname�qnamerrrrR^sz AttributesNSImpl.getValueByQNamecCs0x"|jj�D]\}}||kr|SqWt|��dS)N)rdrarS)r
rrerfrrrrTeszAttributesNSImpl.getNameByQNamecCs
|j|S)N)rd)r
rrrrrUlszAttributesNSImpl.getQNameByNamecCst|jj��S)N)rVrdrb)r
rrrrYoszAttributesNSImpl.getQNamescCs|j|j|j�S)N)r_rLrd)r
rrrr`rszAttributesNSImpl.copyN)	r!r"r#r
rRrTrUrYr`rrrrrcTsrccCst�t�t�dS)N)rr%r7rrrr�_testvsrg�__main__N)r$r+r�_exceptionsrrrr%r7r=rKrcrgr!rrrr�<module>sPJY>"PK�"[�leBB.sax/__pycache__/xmlreader.cpython-36.opt-1.pycnu�[���3


 \�1�@s�dZddlmZddlmZmZGdd�d�ZGdd�de�ZGdd	�d	�ZGd
d�d�Z	Gdd
�d
�Z
Gdd�de
�Zdd�Ze
dkr�e�dS)z]An XML Reader is the SAX 2 name for an XML parser. XML Parsers
should be based on this code. �)�handler)�SAXNotSupportedException�SAXNotRecognizedExceptionc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd S)!�	XMLReadera%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.cCs,tj�|_tj�|_tj�|_tj�|_dS)N)	rZContentHandler�
_cont_handlerZ
DTDHandler�_dtd_handlerZEntityResolver�_ent_handlerZErrorHandler�_err_handler)�self�r�)/usr/lib64/python3.6/xml/sax/xmlreader.py�__init__s


zXMLReader.__init__cCstd��dS)zAParse an XML document from a system identifier or an InputSource.z This method must be implemented!N)�NotImplementedError)r
�sourcerrr�parseszXMLReader.parsecCs|jS)z#Returns the current ContentHandler.)r)r
rrr�getContentHandler"szXMLReader.getContentHandlercCs
||_dS)z:Registers a new object to receive document content events.N)r)r
rrrr�setContentHandler&szXMLReader.setContentHandlercCs|jS)z Returns the current DTD handler.)r)r
rrr�
getDTDHandler*szXMLReader.getDTDHandlercCs
||_dS)z7Register an object to receive basic DTD-related events.N)r)r
rrrr�
setDTDHandler.szXMLReader.setDTDHandlercCs|jS)z#Returns the current EntityResolver.)r)r
rrr�getEntityResolver2szXMLReader.getEntityResolvercCs
||_dS)z0Register an object to resolve external entities.N)r)r
Zresolverrrr�setEntityResolver6szXMLReader.setEntityResolvercCs|jS)z!Returns the current ErrorHandler.)r	)r
rrr�getErrorHandler:szXMLReader.getErrorHandlercCs
||_dS)z3Register an object to receive error-message events.N)r	)r
rrrr�setErrorHandler>szXMLReader.setErrorHandlercCstd��dS)aHAllow 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.zLocale support not implementedN)r)r
Zlocalerrr�	setLocaleBszXMLReader.setLocalecCstd|��dS)z1Looks up and returns the state of a SAX2 feature.zFeature '%s' not recognizedN)r)r
�namerrr�
getFeatureKszXMLReader.getFeaturecCstd|��dS)z!Sets the state of a SAX2 feature.zFeature '%s' not recognizedN)r)r
r�staterrr�
setFeatureOszXMLReader.setFeaturecCstd|��dS)z2Looks up and returns the value of a SAX2 property.zProperty '%s' not recognizedN)r)r
rrrr�getPropertySszXMLReader.getPropertycCstd|��dS)z"Sets the value of a SAX2 property.zProperty '%s' not recognizedN)r)r
r�valuerrr�setPropertyWszXMLReader.setPropertyN)�__name__�
__module__�__qualname__�__doc__r
rrrrrrrrrrrrrr rrrrrs 	rc@sBeZdZdZddd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dS)�IncrementalParserasThis 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.��cCs||_tj|�dS)N)�_bufsizerr
)r
�bufsizerrrr
oszIncrementalParser.__init__cCspddlm}|j|�}|j|�|j�}|dkr8|j�}|j|j�}x|rb|j|�|j|j�}qFW|j	�dS)Nr)�saxutils)
�r*Zprepare_input_source�
prepareParser�getCharacterStream�
getByteStream�readr(�feed�close)r
rr*�file�bufferrrrrss


zIncrementalParser.parsecCstd��dS)aThis 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.z This method must be implemented!N)r)r
�datarrrr0�szIncrementalParser.feedcCstd��dS)ztThis method is called by the parse implementation to allow
        the SAX 2.0 driver to prepare itself for parsing.z!prepareParser must be overridden!N)r)r
rrrrr,�szIncrementalParser.prepareParsercCstd��dS)a�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.z This method must be implemented!N)r)r
rrrr1�szIncrementalParser.closecCstd��dS)z�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.z This method must be implemented!N)r)r
rrr�reset�szIncrementalParser.resetN�)r6)
r!r"r#r$r
rr0r,r1r5rrrrr%[s
	
r%c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�Locatorz�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.cCsdS)z6Return the column number where the current event ends.r���r)r
rrr�getColumnNumber�szLocator.getColumnNumbercCsdS)z4Return the line number where the current event ends.rr8r)r
rrr�
getLineNumber�szLocator.getLineNumbercCsdS)z3Return the public identifier for the current event.Nr)r
rrr�getPublicId�szLocator.getPublicIdcCsdS)z3Return the system identifier for the current event.Nr)r
rrr�getSystemId�szLocator.getSystemIdN)r!r"r#r$r9r:r;r<rrrrr7�s
r7c@sjeZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�ZdS)�InputSourceanEncapsulation 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.NcCs"||_d|_d|_d|_d|_dS)N)�_InputSource__system_id�_InputSource__public_id�_InputSource__encoding�_InputSource__bytefile�_InputSource__charfile)r
�	system_idrrrr
�s
zInputSource.__init__cCs
||_dS)z/Sets the public identifier of this InputSource.N)r?)r
Z	public_idrrr�setPublicId�szInputSource.setPublicIdcCs|jS)z2Returns the public identifier of this InputSource.)r?)r
rrrr;�szInputSource.getPublicIdcCs
||_dS)z/Sets the system identifier of this InputSource.N)r>)r
rCrrr�setSystemId�szInputSource.setSystemIdcCs|jS)z2Returns the system identifier of this InputSource.)r>)r
rrrr<�szInputSource.getSystemIdcCs
||_dS)a4Sets 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.N)r@)r
�encodingrrr�setEncoding�szInputSource.setEncodingcCs|jS)z/Get the character encoding of this InputSource.)r@)r
rrr�getEncoding�szInputSource.getEncodingcCs
||_dS)a�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.N)rA)r
Zbytefilerrr�
setByteStream�szInputSource.setByteStreamcCs|jS)z�Get the byte stream for this input source.

        The getEncoding method will return the character encoding for
        this byte stream, or None if unknown.)rA)r
rrrr.�szInputSource.getByteStreamcCs
||_dS)a^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.N)rB)r
Zcharfilerrr�setCharacterStreamszInputSource.setCharacterStreamcCs|jS)z/Get the character stream for this input source.)rB)r
rrrr-szInputSource.getCharacterStream)N)r!r"r#r$r
rDr;rEr<rGrHrIr.rJr-rrrrr=�s



r=c@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zd$dd�Zdd�Zd d!�Zd"d#�ZdS)%�AttributesImplcCs
||_dS)zQNon-NS-aware implementation.

        attrs should be of the form {name : value}.N)�_attrs)r
�attrsrrrr
szAttributesImpl.__init__cCs
t|j�S)N)�lenrL)r
rrr�	getLengthszAttributesImpl.getLengthcCsdS)NZCDATAr)r
rrrr�getType!szAttributesImpl.getTypecCs
|j|S)N)rL)r
rrrr�getValue$szAttributesImpl.getValuecCs
|j|S)N)rL)r
rrrr�getValueByQName'szAttributesImpl.getValueByQNamecCs||jkrt|��|S)N)rL�KeyError)r
rrrr�getNameByQName*s
zAttributesImpl.getNameByQNamecCs||jkrt|��|S)N)rLrS)r
rrrr�getQNameByName/s
zAttributesImpl.getQNameByNamecCst|jj��S)N)�listrL�keys)r
rrr�getNames4szAttributesImpl.getNamescCst|jj��S)N)rVrLrW)r
rrr�	getQNames7szAttributesImpl.getQNamescCs
t|j�S)N)rNrL)r
rrr�__len__:szAttributesImpl.__len__cCs
|j|S)N)rL)r
rrrr�__getitem__=szAttributesImpl.__getitem__cCst|jj��S)N)rVrLrW)r
rrrrW@szAttributesImpl.keyscCs
||jkS)N)rL)r
rrrr�__contains__CszAttributesImpl.__contains__NcCs|jj||�S)N)rL�get)r
r�alternativerrrr]FszAttributesImpl.getcCs|j|j�S)N)�	__class__rL)r
rrr�copyIszAttributesImpl.copycCst|jj��S)N)rVrL�items)r
rrrraLszAttributesImpl.itemscCst|jj��S)N)rVrL�values)r
rrrrbOszAttributesImpl.values)N)r!r"r#r
rOrPrQrRrTrUrXrYrZr[rWr\r]r`rarbrrrrrKs"
rKc@s<eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�AttributesNSImplcCs||_||_dS)z�NS-aware implementation.

        attrs should be of the form {(ns_uri, lname): value, ...}.
        qnames of the form {(ns_uri, lname): qname, ...}.N)rL�_qnames)r
rMZqnamesrrrr
VszAttributesNSImpl.__init__cCs6x(|jj�D]\}}||kr|j|SqWt|��dS)N)rdrarLrS)r
r�nsname�qnamerrrrR^sz AttributesNSImpl.getValueByQNamecCs0x"|jj�D]\}}||kr|SqWt|��dS)N)rdrarS)r
rrerfrrrrTeszAttributesNSImpl.getNameByQNamecCs
|j|S)N)rd)r
rrrrrUlszAttributesNSImpl.getQNameByNamecCst|jj��S)N)rVrdrb)r
rrrrYoszAttributesNSImpl.getQNamescCs|j|j|j�S)N)r_rLrd)r
rrrr`rszAttributesNSImpl.copyN)	r!r"r#r
rRrTrUrYr`rrrrrcTsrccCst�t�t�dS)N)rr%r7rrrr�_testvsrg�__main__N)r$r+r�_exceptionsrrrr%r7r=rKrcrgr!rrrr�<module>sPJY>"PK�"[o��ڐ+�+-sax/__pycache__/saxutils.cpython-36.opt-2.pycnu�[���3


 \�/�@s�ddlZddlZddlZddlZddlZddlmZddlmZdd�Z	ifdd�Z
ifd	d
�Zifdd�Zd
d�Z
Gdd�dej�ZGdd�dej�Zddd�ZdS)�N�)�handler)�	xmlreadercCs&x |j�D]\}}|j||�}q
W|S)N)�items�replace)�s�d�key�value�r�(/usr/lib64/python3.6/xml/sax/saxutils.py�__dict_replacesr
cCs6|jdd�}|jdd�}|jdd�}|r2t||�}|S)N�&z&amp;�>z&gt;�<z&lt;)rr
)�data�entitiesrrr�escapes	
rcCs2|jdd�}|jdd�}|r&t||�}|jdd�S)Nz&lt;rz&gt;rz&amp;r)rr
)rrrrr�unescape"s

rcCs\|j�}|jdddd��t||�}d|krPd|krFd|jdd�}qXd	|}nd|}|S)
Nz&#10;z&#13;z&#9;)�
�
�	�"�'z"%s"z&quot;z'%s')�copy�updaterr)rrrrr�	quoteattr0s

rcs��dkrddl}|jSt�tj�r&�St�tjtjf�r<�St�tj�rlG�fdd�d�}|�}dd�|_	nDtj
�}dd�|_�j|_y�j
|_
�j|_Wntk
r�YnXtj||ddd	d
�S)NrcseZdZ�jZ�fdd�ZdS)z _gettextwriter.<locals>._wrappercs
t�|�S)N)�getattr)�self�name)�outrr�__getattr__[sz,_gettextwriter.<locals>._wrapper.__getattr__N)�__name__�
__module__�__qualname__�	__class__r!r)r rr�_wrapperYsr&cSsdS)Nrrrrr�<lambda>^sz _gettextwriter.<locals>.<lambda>cSsdS)NTrrrrrr'cs�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)r-r&�bufferr)r r�_gettextwriterHs.
r?c@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-1FcCsVtjj|�t||�}|j|_|j|_ig|_|jd|_	g|_
||_||_d|_
dS)NrF���)r�ContentHandler�__init__r?r9�_write�flush�_flush�_ns_contexts�_current_context�_undeclared_ns_maps�	_encoding�_short_empty_elements�_pending_start_element)rr r)Zshort_empty_elementsrrrrDss
zXMLGenerator.__init__cCsJ|drBd|dkr d|dS|j|d}|rB|d|dS|dS)Nrz$http://www.w3.org/XML/1998/namespacezxml:r�:)rI)rr�prefixrrr�_qnameszXMLGenerator._qnamecCs|jr|jd�d|_dS)NrF)rMrE)r�
endElementrrr�_finish_pending_start_element�s
z*XMLGenerator._finish_pending_start_elementcCs|jd|j�dS)Nz$<?xml version="1.0" encoding="%s"?>
)rErK)rrrr�
startDocument�szXMLGenerator.startDocumentcCs|j�dS)N)rG)rrrr�endDocument�szXMLGenerator.endDocumentcCs0|jj|jj��||j|<|jj||f�dS)N)rH�appendrIrrJ)rrO�urirrr�startPrefixMapping�s
zXMLGenerator.startPrefixMappingcCs|jd|_|jd=dS)NrrBrB)rHrI)rrOrrr�endPrefixMapping�szXMLGenerator.endPrefixMappingcCs^|j�|jd|�x*|j�D]\}}|jd|t|�f�q W|jrPd|_n
|jd�dS)Nrz %s=%sTr)rRrErrrLrM)rr�attrsr
rrr�startElement�szXMLGenerator.startElementcCs*|jr|jd�d|_n|jd|�dS)Nz/>Fz</%s>)rMrE)rrrrrrQ�s
zXMLGenerator.endElementcCs�|j�|jd|j|��x8|jD].\}}|rD|jd||f�q$|jd|�q$Wg|_x0|j�D]$\}}|jd|j|�t|�f�qfW|jr�d|_n
|jd�dS)Nrz xmlns:%s="%s"z xmlns="%s"z %s=%sTr)rRrErPrJrrrLrM)rr�qnamerYrOrVr
rrr�startElementNS�s zXMLGenerator.startElementNScCs0|jr|jd�d|_n|jd|j|��dS)Nz/>Fz</%s>)rMrErP)rrr[rrr�endElementNS�s
zXMLGenerator.endElementNScCs4|r0|j�t|t�s"t||j�}|jt|��dS)N)rRr/�strrKrEr)r�contentrrr�
characters�s

zXMLGenerator.characterscCs0|r,|j�t|t�s"t||j�}|j|�dS)N)rRr/r^rKrE)rr_rrr�ignorableWhitespace�s

z XMLGenerator.ignorableWhitespacecCs|j�|jd||f�dS)Nz	<?%s %s?>)rRrE)r�targetrrrr�processingInstruction�sz"XMLGenerator.processingInstruction)NrAF)F)r"r#r$rDrPrRrSrTrWrXrZrQr\r]r`rarcrrrrr@qs


r@c@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);�
XMLFilterBaseNcCstjj|�||_dS)N)r�	XMLReaderrD�_parent)r�parentrrrrD�szXMLFilterBase.__init__cCs|jj|�dS)N)�_err_handler�error)r�	exceptionrrrri�szXMLFilterBase.errorcCs|jj|�dS)N)rh�
fatalError)rrjrrrrk�szXMLFilterBase.fatalErrorcCs|jj|�dS)N)rh�warning)rrjrrrrl�szXMLFilterBase.warningcCs|jj|�dS)N)�
_cont_handler�setDocumentLocator)rZlocatorrrrrn�sz XMLFilterBase.setDocumentLocatorcCs|jj�dS)N)rmrS)rrrrrSszXMLFilterBase.startDocumentcCs|jj�dS)N)rmrT)rrrrrTszXMLFilterBase.endDocumentcCs|jj||�dS)N)rmrW)rrOrVrrrrWsz XMLFilterBase.startPrefixMappingcCs|jj|�dS)N)rmrX)rrOrrrrX	szXMLFilterBase.endPrefixMappingcCs|jj||�dS)N)rmrZ)rrrYrrrrZszXMLFilterBase.startElementcCs|jj|�dS)N)rmrQ)rrrrrrQszXMLFilterBase.endElementcCs|jj|||�dS)N)rmr\)rrr[rYrrrr\szXMLFilterBase.startElementNScCs|jj||�dS)N)rmr])rrr[rrrr]szXMLFilterBase.endElementNScCs|jj|�dS)N)rmr`)rr_rrrr`szXMLFilterBase.characterscCs|jj|�dS)N)rmra)r�charsrrrrasz!XMLFilterBase.ignorableWhitespacecCs|jj||�dS)N)rmrc)rrbrrrrrcsz#XMLFilterBase.processingInstructioncCs|jj|�dS)N)rm�
skippedEntity)rrrrrrp!szXMLFilterBase.skippedEntitycCs|jj|||�dS)N)�_dtd_handler�notationDecl)rr�publicId�systemIdrrrrr&szXMLFilterBase.notationDeclcCs|jj||||�dS)N)rq�unparsedEntityDecl)rrrsrtZndatarrrru)sz XMLFilterBase.unparsedEntityDeclcCs|jj||�S)N)Z_ent_handler�
resolveEntity)rrsrtrrrrv.szXMLFilterBase.resolveEntitycCs@|jj|�|jj|�|jj|�|jj|�|jj|�dS)N)rfZsetContentHandlerZsetErrorHandlerZsetEntityResolverZ
setDTDHandler�parse)r�sourcerrrrw3s
zXMLFilterBase.parsecCs|jj|�dS)N)rf�	setLocale)rZlocalerrrry:szXMLFilterBase.setLocalecCs|jj|�S)N)rf�
getFeature)rrrrrrz=szXMLFilterBase.getFeaturecCs|jj||�dS)N)rf�
setFeature)rr�staterrrr{@szXMLFilterBase.setFeaturecCs|jj|�S)N)rf�getProperty)rrrrrr}CszXMLFilterBase.getPropertycCs|jj||�dS)N)rf�setProperty)rrr
rrrr~FszXMLFilterBase.setPropertycCs|jS)N)rf)rrrr�	getParentKszXMLFilterBase.getParentcCs
||_dS)N)rf)rrgrrr�	setParentNszXMLFilterBase.setParent)N)r"r#r$rDrirkrlrnrSrTrWrXrZrQr\r]r`rarcrprrrurvrwryrzr{r}r~rr�rrrrrd�s8
rd�cCst|t�rtj|�}n^t|d�rt|}tj�}t|jd�t�rH|j|�n
|j|�t|d�rtt|jt�rt|j	|j�|j
�dko�|j�dk�r|j�}t
jjt
jj|��}t
jj||�}t
jj|�r�|j	|�t|d�}n$|j	tjj||��tjj|j��}|j|�|S)N�readrr�rb)r/r^rZInputSource�hasattrr�ZsetCharacterStreamZ
setByteStreamrZsetSystemIdZgetCharacterStreamZ
getByteStreamZgetSystemId�os�path�dirname�normpath�join�isfile�open�urllibrwZurljoinZrequestZurlopen)rx�base�fZsysidZbaseheadZ
sysidfilenamerrr�prepare_input_sourceSs*




r�)r�)r�Zurllib.parser�Zurllib.requestr0r2r�rrr
rrrr?rCr@rerdr�rrrr�<module>s)soPK0![Q
�PP.parsers/__pycache__/expat.cpython-38.opt-1.pycnu�[���PK0![����1�parsers/__pycache__/__init__.cpython-38.opt-2.pycnu�[���PK0![Q
�PP(�parsers/__pycache__/expat.cpython-38.pycnu�[���PK0![,t��331>parsers/__pycache__/__init__.cpython-38.opt-1.pycnu�[���PK0![,t��33+�parsers/__pycache__/__init__.cpython-38.pycnu�[���PK0![V�W�.`parsers/__pycache__/expat.cpython-38.opt-2.pycnu�[���PK0![�v��rr�parsers/expat.pynu�[���PK0![;�|���~	parsers/__init__.pynu�[���PK0![�df��h
dom/minidom.pynu�[���PK0![�);�

�
dom/minicompat.pynu�[���PK0![l$ń1010�dom/xmlbuilder.pynu�[���PK0![��Cp��YKdom/expatbuilder.pynu�[���PK0![`���.�.��dom/pulldom.pynu�[���PK0![�Cxr�
�

�dom/domreg.pynu�[���PK0![��rr+�dom/__pycache__/domreg.cpython-38.opt-2.pycnu�[���PK0![�{$$+�dom/__pycache__/domreg.cpython-38.opt-1.pycnu�[���PK0![�˯<����,)dom/__pycache__/minidom.cpython-38.opt-1.pycnu�[���PK0![��z���-Udom/__pycache__/__init__.cpython-38.opt-2.pycnu�[���PK0![�}��\
\
/3dom/__pycache__/minicompat.cpython-38.opt-1.pycnu�[���PK0![2@RD�0�0/�dom/__pycache__/xmlbuilder.cpython-38.opt-1.pycnu�[���PK0![�{$$%�Odom/__pycache__/domreg.cpython-38.pycnu�[���PK0![Qf�((,x[dom/__pycache__/pulldom.cpython-38.opt-2.pycnu�[���PK0![��S�h�h1�dom/__pycache__/expatbuilder.cpython-38.opt-1.pycnu�[���PK0![D�>W��-��dom/__pycache__/__init__.cpython-38.opt-1.pycnu�[���PK0![^���)�)&�dom/__pycache__/pulldom.cpython-38.pycnu�[���PK0![D�>W��'-dom/__pycache__/__init__.cpython-38.pycnu�[���PK0![> �P�P�&Cdom/__pycache__/minidom.cpython-38.pycnu�[���PK0![�Dll/�dom/__pycache__/NodeFilter.cpython-38.opt-2.pycnu�[���PK0![����
�
)vdom/__pycache__/minicompat.cpython-38.pycnu�[���PK0![K�c�^�^1�*dom/__pycache__/expatbuilder.cpython-38.opt-2.pycnu�[���PK0![6[z(�j�j+s�dom/__pycache__/expatbuilder.cpython-38.pycnu�[���PK0![£ߝ�	�	/��dom/__pycache__/minicompat.cpython-38.opt-2.pycnu�[���PK0![�`ZT///��dom/__pycache__/xmlbuilder.cpython-38.opt-2.pycnu�[���PK0![��}�0�0)
.dom/__pycache__/xmlbuilder.cpython-38.pycnu�[���PK0![^���)�),3_dom/__pycache__/pulldom.cpython-38.opt-1.pycnu�[���PK0![�_���)T�dom/__pycache__/NodeFilter.cpython-38.pycnu�[���PK0![�,
O����,v�dom/__pycache__/minidom.cpython-38.opt-2.pycnu�[���PK0![�_���/�_dom/__pycache__/NodeFilter.cpython-38.opt-1.pycnu�[���PK0![XB���cdom/__init__.pynu�[���PK0![�Cc���sdom/NodeFilter.pynu�[���PK0![E��g%%�wetree/ElementPath.pynu�[���PK0![����Ϝetree/ElementInclude.pynu�[���PK0![�%�'��/�etree/__pycache__/__init__.cpython-38.opt-2.pycnu�[���PK0![�b�2��3αetree/__pycache__/cElementTree.cpython-38.opt-2.pycnu�[���PK0![��J--5�etree/__pycache__/ElementInclude.cpython-38.opt-2.pycnu�[���PK0![�r�� � 2r�etree/__pycache__/ElementPath.cpython-38.opt-2.pycnu�[���PK0![�b�2��-��etree/__pycache__/cElementTree.cpython-38.pycnu�[���PK0![�%�'��/��etree/__pycache__/__init__.cpython-38.opt-1.pycnu�[���PK0![�%�'��)��etree/__pycache__/__init__.cpython-38.pycnu�[���PK0![�r�� � 2��etree/__pycache__/ElementPath.cpython-38.opt-1.pycnu�[���PK0![n=mE��2�etree/__pycache__/ElementTree.cpython-38.opt-1.pycnu�[���PK0![4��1�1�2\�etree/__pycache__/ElementTree.cpython-38.opt-2.pycnu�[���PK0![�r�� � ,�g	etree/__pycache__/ElementPath.cpython-38.pycnu�[���PK0![�b�2��3?�	etree/__pycache__/cElementTree.cpython-38.opt-1.pycnu�[���PK0![��J--5Q�	etree/__pycache__/ElementInclude.cpython-38.opt-1.pycnu�[���PK0![��H�H�,�	etree/__pycache__/ElementTree.cpython-38.pycnu�[���PK0![��J--/�j
etree/__pycache__/ElementInclude.cpython-38.pycnu�[���PK0![W�Z�DDq
etree/__init__.pynu�[���PK0![�"/������w
etree/ElementTree.pynu�[���PK0![�>)>>�Vetree/cElementTree.pynu�[���PK0![U�2��)'W__pycache__/__init__.cpython-38.opt-2.pycnu�[���PK0![�^���)+X__pycache__/__init__.cpython-38.opt-1.pycnu�[���PK0![�^���#:[__pycache__/__init__.cpython-38.pycnu�[���PK0![16���C^__init__.pynu�[���PK0![ <bX1X1Rbsax/xmlreader.pynu�[���PK0![�b�B$-$-�sax/saxutils.pynu�[���PK0![�-�y2y2-M�sax/__pycache__/saxutils.cpython-38.opt-1.pycnu�[���PK0![d�Tۈ0�0&#�sax/__pycache__/handler.cpython-38.pycnu�[���PK0![�-�y2y2'%sax/__pycache__/saxutils.cpython-38.pycnu�[���PK0![�(��0�00�Wsax/__pycache__/expatreader.cpython-38.opt-1.pycnu�[���PK0![�nn-�sax/__pycache__/__init__.cpython-38.opt-2.pycnu�[���PK0![�Z�;�A�A.͑sax/__pycache__/xmlreader.cpython-38.opt-1.pycnu�[���PK0![e=�--,��sax/__pycache__/handler.cpython-38.opt-2.pycnu�[���PK0![��FF*��sax/__pycache__/_exceptions.cpython-38.pycnu�[���PK0![���6/6/0"�sax/__pycache__/expatreader.cpython-38.opt-2.pycnu�[���PK0![G�2&��-�+
sax/__pycache__/__init__.cpython-38.opt-1.pycnu�[���PK0![�Z�;�A�A(�8
sax/__pycache__/xmlreader.cpython-38.pycnu�[���PK0![G�2&��'�z
sax/__pycache__/__init__.cpython-38.pycnu�[���PK0![��FF0��
sax/__pycache__/_exceptions.cpython-38.opt-1.pycnu�[���PK0![d�Tۈ0�0,b�
sax/__pycache__/handler.cpython-38.opt-1.pycnu�[���PK0![s�`0F�
sax/__pycache__/_exceptions.cpython-38.opt-2.pycnu�[���PK0![b�к�(�(.��
sax/__pycache__/xmlreader.cpython-38.opt-2.pycnu�[���PK0![|Ik-,,-�sax/__pycache__/saxutils.cpython-38.opt-2.pycnu�[���PK0![�(��0�0*'/sax/__pycache__/expatreader.cpython-38.pycnu�[���PK0![~b���=�=R`sax/expatreader.pynu�[���PK0![,���""X�sax/__init__.pynu�[���PK0![}F������sax/_exceptions.pynu�[���PK0![sE(�a6a6��sax/handler.pynu�[���PK�"[�0�K�parsers/expat.pyonu�[���PK�"[�0���parsers/expat.pycnu�[���PK�"[-l��::�parsers/__init__.pyonu�[���PK�"[-l��::��parsers/__init__.pycnu�[���PK�"[]�C�n~n~�dom/expatbuilder.pyonu�[���PK�"["��i�����zdom/minidom.pyonu�[���PK�"[#@����zdom/minicompat.pyonu�[���PK�"[���}ff�dom/NodeFilter.pyonu�[���PK�"[�H�J8
8
��dom/domreg.pycnu�[���PK�"[[s#33�dom/pulldom.pycnu�[���PK�"[sk�EEd�dom/minidom.pycnu�[���PK�"[o���;�;��dom/xmlbuilder.pyonu�[���PK�"[�VY�f
f
�	dom/minicompat.pycnu�[���PK�"[��iOO�dom/__init__.pyonu�[���PK�"[���}ff!1dom/NodeFilter.pycnu�[���PK�"[�H�J8
8
�5dom/domreg.pyonu�[���PK�"[ �.���?Cdom/expatbuilder.pycnu�[���PK�"[��iOOg�dom/__init__.pycnu�[���PK�"[S�p�;�;��dom/xmlbuilder.pycnu�[���PK�"[[s#33$dom/pulldom.pyonu�[���PK�"[���G|�|�yMetree/ElementTree.pycnu�[���PK�"[�Y檯�:�etree/ElementInclude.pyonu�[���PK�"[hNwW��1�etree/__init__.pyonu�[���PK�"[�Y檯���etree/ElementInclude.pycnu�[���PK�"[P��^����etree/cElementTree.pyonu�[���PK�"[�B�u����etree/ElementPath.pyonu�[���PK�"[hNwW���etree/__init__.pycnu�[���PK�"[[��	���etree/ElementTree.pyonu�[���PK�"[�B�u���etree/ElementPath.pycnu�[���PK�"[P��^����etree/cElementTree.pycnu�[���PK�"[=p�66�__init__.pyonu�[���PK�"[=p�66`�__init__.pycnu�[���PK�"[�'�ZE;E;ҷsax/expatreader.pyonu�[���PK�"[����9�9Z�sax/saxutils.pyonu�[���PK�"[�'�ZE;E;k-sax/expatreader.pycnu�[���PK�"[�hj���hsax/__init__.pyonu�[���PK�"[deq�2�2�wsax/handler.pycnu�[���PK�"[��/���sax/_exceptions.pyonu�[���PK�"[deq�2�2S�sax/handler.pyonu�[���PK�"[ȳ�KKv�sax/xmlreader.pyonu�[���PK�"[�hj���Asax/__init__.pycnu�[���PK�"[ȳ�KK�Psax/xmlreader.pycnu�[���PK�"[��/��sax/_exceptions.pycnu�[���PK�"[����9�9a�sax/saxutils.pycnu�[���PK�"[��@s++1r�parsers/__pycache__/__init__.cpython-36.opt-1.pycnu�[���PK�"[d��GHH(��parsers/__pycache__/expat.cpython-36.pycnu�[���PK�"[P\}(��1��parsers/__pycache__/__init__.cpython-36.opt-2.pycnu�[���PK�"[��@s+++��parsers/__pycache__/__init__.cpython-36.pycnu�[���PK�"[d��GHH.�parsers/__pycache__/expat.cpython-36.opt-1.pycnu�[���PK�"[��9:.��parsers/__pycache__/expat.cpython-36.opt-2.pycnu�[���PK�"[����99-�dom/__pycache__/__init__.cpython-36.opt-1.pycnu�[���PK�"[qm3(�(�&�dom/__pycache__/minidom.cpython-36.pycnu�[���PK�"[�AP�	�	/$�dom/__pycache__/minicompat.cpython-36.opt-2.pycnu�[���PK�"[�S�����,\�dom/__pycache__/minidom.cpython-36.opt-2.pycnu�[���PK�"[��=&3&3/T�dom/__pycache__/xmlbuilder.cpython-36.opt-2.pycnu�[���PK�"[�{ΑUU+�dom/__pycache__/domreg.cpython-36.opt-2.pycnu�[���PK�"[H��^��)��dom/__pycache__/NodeFilter.cpython-36.pycnu�[���PK�"[H��^��/�dom/__pycache__/NodeFilter.cpython-36.opt-1.pycnu�[���PK�"[R�������,�dom/__pycache__/minidom.cpython-36.opt-1.pycnu�[���PK�"[�a��4�4/��dom/__pycache__/xmlbuilder.cpython-36.opt-1.pycnu�[���PK�"[�)<*-dom/__pycache__/__init__.cpython-36.opt-2.pycnu�[���PK�"[����99'~)dom/__pycache__/__init__.cpython-36.pycnu�[���PK�"[Wd!))))&?dom/__pycache__/pulldom.cpython-36.pycnu�[���PK�"[>�Mpw'w',�hdom/__pycache__/pulldom.cpython-36.opt-2.pycnu�[���PK�"[���%`�dom/__pycache__/domreg.cpython-36.pycnu�[���PK�"[��9�4�4)��dom/__pycache__/xmlbuilder.cpython-36.pycnu�[���PK�"[ɵ�	�
�
/�dom/__pycache__/minicompat.cpython-36.opt-1.pycnu�[���PK�"[�|�6�
�
)��dom/__pycache__/minicompat.cpython-36.pycnu�[���PK�"[�Jꃺ]�]10�dom/__pycache__/expatbuilder.cpython-36.opt-2.pycnu�[���PK�"[�$YG
j
j+KEdom/__pycache__/expatbuilder.cpython-36.pycnu�[���PK�"[.�o�\\/��dom/__pycache__/NodeFilter.cpython-36.opt-2.pycnu�[���PK�"[Wd!)))),k�dom/__pycache__/pulldom.cpython-36.opt-1.pycnu�[���PK�"[�M+�g�g1��dom/__pycache__/expatbuilder.cpython-36.opt-1.pycnu�[���PK�"[���+MEdom/__pycache__/domreg.cpython-36.opt-1.pycnu�[���PK�"[#�}P��3�Petree/__pycache__/cElementTree.cpython-36.opt-1.pycnu�[���PK�"[�A�3}}/�Qetree/__pycache__/__init__.cpython-36.opt-1.pycnu�[���PK�"[��xr5�Retree/__pycache__/ElementInclude.cpython-36.opt-1.pycnu�[���PK�"[�Ib}��2Yetree/__pycache__/ElementPath.cpython-36.opt-2.pycnu�[���PK�"[��xr/nqetree/__pycache__/ElementInclude.cpython-36.pycnu�[���PK�"[�Ib}��,�wetree/__pycache__/ElementPath.cpython-36.pycnu�[���PK�"[��.����,;�etree/__pycache__/ElementTree.cpython-36.pycnu�[���PK�"[�A�3}}/Q?etree/__pycache__/__init__.cpython-36.opt-2.pycnu�[���PK�"[�A�3}})-@etree/__pycache__/__init__.cpython-36.pycnu�[���PK�"[�1�b�m�m2Aetree/__pycache__/ElementTree.cpython-36.opt-2.pycnu�[���PK�"[��xr5U�etree/__pycache__/ElementInclude.cpython-36.opt-2.pycnu�[���PK�"[#�}P��3ӵetree/__pycache__/cElementTree.cpython-36.opt-2.pycnu�[���PK�"[�Ib}��2ݶetree/__pycache__/ElementPath.cpython-36.opt-1.pycnu�[���PK�"[tH������28�etree/__pycache__/ElementTree.cpython-36.opt-1.pycnu�[���PK�"[#�}P��-%}etree/__pycache__/cElementTree.cpython-36.pycnu�[���PK�"[ �J��))~__pycache__/__init__.cpython-36.opt-1.pycnu�[���PK�"[!�����)0�__pycache__/__init__.cpython-36.opt-2.pycnu�[���PK�"[ �J��#,�__pycache__/__init__.cpython-36.pycnu�[���PK�"[��VZZ--�sax/__pycache__/__init__.cpython-36.opt-1.pycnu�[���PK�"[&�y�	2	2-�sax/__pycache__/saxutils.cpython-36.opt-1.pycnu�[���PK�"[_��&00&J�sax/__pycache__/handler.cpython-36.pycnu�[���PK�"[�)�[[*��sax/__pycache__/_exceptions.cpython-36.pycnu�[���PK�"[_��&00,p
sax/__pycache__/handler.cpython-36.opt-1.pycnu�[���PK�"[�b�.�.0�:sax/__pycache__/expatreader.cpython-36.opt-2.pycnu�[���PK�"[P�'�
�
0jsax/__pycache__/_exceptions.cpython-36.opt-2.pycnu�[���PK�"[��}>>-^usax/__pycache__/__init__.cpython-36.opt-2.pycnu�[���PK�"[��VZZ'�}sax/__pycache__/__init__.cpython-36.pycnu�[���PK�"[���+�(�(.��sax/__pycache__/xmlreader.cpython-36.opt-2.pycnu�[���PK�"[����k0k00�sax/__pycache__/expatreader.cpython-36.opt-1.pycnu�[���PK�"[&�y�	2	2'��sax/__pycache__/saxutils.cpython-36.pycnu�[���PK�"[�)�[[0 sax/__pycache__/_exceptions.cpython-36.opt-1.pycnu�[���PK�"[����k0k0*�, sax/__pycache__/expatreader.cpython-36.pycnu�[���PK�"[b=�n��,�] sax/__pycache__/handler.cpython-36.opt-2.pycnu�[���PK�"[�leBB(�o sax/__pycache__/xmlreader.cpython-36.pycnu�[���PK�"[�leBB.�� sax/__pycache__/xmlreader.cpython-36.opt-1.pycnu�[���PK�"[o��ڐ+�+-t� sax/__pycache__/saxutils.cpython-36.opt-2.pycnu�[���PK��Ma !