com.googler.python 1.1.2 → 1.1.4

package/python3.6.2/lib/python3.6/xml/dom/expatbuilder.py

@@ -1,965 +0,0 @@
-"""Facility to use the Expat parser to load a minidom instance
-from a string or file.
-
-This avoids all the overhead of SAX and pulldom to gain performance.
-"""
-
-# Warning!
-#
-# This module is tightly bound to the implementation details of the
-# minidom DOM and can't be used with other DOM implementations.  This
-# is due, in part, to a lack of appropriate methods in the DOM (there is
-# no way to create Entity and Notation nodes via the DOM Level 2
-# interface), and for performance.  The latter is the cause of some fairly
-# cryptic code.
-#
-# Performance hacks:
-#
-#   -  .character_data_handler() has an extra case in which continuing
-#      data is appended to an existing Text node; this can be a
-#      speedup since pyexpat can break up character data into multiple
-#      callbacks even though we set the buffer_text attribute on the
-#      parser.  This also gives us the advantage that we don't need a
-#      separate normalization pass.
-#
-#   -  Determining that a node exists is done using an identity comparison
-#      with None rather than a truth test; this avoids searching for and
-#      calling any methods on the node object if it exists.  (A rather
-#      nice speedup is achieved this way as well!)
-
-from xml.dom import xmlbuilder, minidom, Node
-from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE
-from xml.parsers import expat
-from xml.dom.minidom import _append_child, _set_attribute_node
-from xml.dom.NodeFilter import NodeFilter
-
-TEXT_NODE = Node.TEXT_NODE
-CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE
-DOCUMENT_NODE = Node.DOCUMENT_NODE
-
-FILTER_ACCEPT = xmlbuilder.DOMBuilderFilter.FILTER_ACCEPT
-FILTER_REJECT = xmlbuilder.DOMBuilderFilter.FILTER_REJECT
-FILTER_SKIP = xmlbuilder.DOMBuilderFilter.FILTER_SKIP
-FILTER_INTERRUPT = xmlbuilder.DOMBuilderFilter.FILTER_INTERRUPT
-
-theDOMImplementation = minidom.getDOMImplementation()
-
-# Expat typename -> TypeInfo
-_typeinfo_map = {
-    "CDATA":    minidom.TypeInfo(None, "cdata"),
-    "ENUM":     minidom.TypeInfo(None, "enumeration"),
-    "ENTITY":   minidom.TypeInfo(None, "entity"),
-    "ENTITIES": minidom.TypeInfo(None, "entities"),
-    "ID":       minidom.TypeInfo(None, "id"),
-    "IDREF":    minidom.TypeInfo(None, "idref"),
-    "IDREFS":   minidom.TypeInfo(None, "idrefs"),
-    "NMTOKEN":  minidom.TypeInfo(None, "nmtoken"),
-    "NMTOKENS": minidom.TypeInfo(None, "nmtokens"),
-    }
-
-class ElementInfo(object):
-    __slots__ = '_attr_info', '_model', 'tagName'
-
-    def __init__(self, tagName, model=None):
-        self.tagName = tagName
-        self._attr_info = []
-        self._model = model
-
-    def __getstate__(self):
-        return self._attr_info, self._model, self.tagName
-
-    def __setstate__(self, state):
-        self._attr_info, self._model, self.tagName = state
-
-    def getAttributeType(self, aname):
-        for info in self._attr_info:
-            if info[1] == aname:
-                t = info[-2]
-                if t[0] == "(":
-                    return _typeinfo_map["ENUM"]
-                else:
-                    return _typeinfo_map[info[-2]]
-        return minidom._no_type
-
-    def getAttributeTypeNS(self, namespaceURI, localName):
-        return minidom._no_type
-
-    def isElementContent(self):
-        if self._model:
-            type = self._model[0]
-            return type not in (expat.model.XML_CTYPE_ANY,
-                                expat.model.XML_CTYPE_MIXED)
-        else:
-            return False
-
-    def isEmpty(self):
-        if self._model:
-            return self._model[0] == expat.model.XML_CTYPE_EMPTY
-        else:
-            return False
-
-    def isId(self, aname):
-        for info in self._attr_info:
-            if info[1] == aname:
-                return info[-2] == "ID"
-        return False
-
-    def isIdNS(self, euri, ename, auri, aname):
-        # not sure this is meaningful
-        return self.isId((auri, aname))
-
-def _intern(builder, s):
-    return builder._intern_setdefault(s, s)
-
-def _parse_ns_name(builder, name):
-    assert ' ' in name
-    parts = name.split(' ')
-    intern = builder._intern_setdefault
-    if len(parts) == 3:
-        uri, localname, prefix = parts
-        prefix = intern(prefix, prefix)
-        qname = "%s:%s" % (prefix, localname)
-        qname = intern(qname, qname)
-        localname = intern(localname, localname)
-    elif len(parts) == 2:
-        uri, localname = parts
-        prefix = EMPTY_PREFIX
-        qname = localname = intern(localname, localname)
-    else:
-        raise ValueError("Unsupported syntax: spaces in URIs not supported: %r" % name)
-    return intern(uri, uri), localname, prefix, qname
-
-
-class ExpatBuilder:
-    """Document builder that uses Expat to build a ParsedXML.DOM document
-    instance."""
-
-    def __init__(self, options=None):
-        if options is None:
-            options = xmlbuilder.Options()
-        self._options = options
-        if self._options.filter is not None:
-            self._filter = FilterVisibilityController(self._options.filter)
-        else:
-            self._filter = None
-            # This *really* doesn't do anything in this case, so
-            # override it with something fast & minimal.
-            self._finish_start_element = id
-        self._parser = None
-        self.reset()
-
-    def createParser(self):
-        """Create a new parser object."""
-        return expat.ParserCreate()
-
-    def getParser(self):
-        """Return the parser object, creating a new one if needed."""
-        if not self._parser:
-            self._parser = self.createParser()
-            self._intern_setdefault = self._parser.intern.setdefault
-            self._parser.buffer_text = True
-            self._parser.ordered_attributes = True
-            self._parser.specified_attributes = True
-            self.install(self._parser)
-        return self._parser
-
-    def reset(self):
-        """Free all data structures used during DOM construction."""
-        self.document = theDOMImplementation.createDocument(
-            EMPTY_NAMESPACE, None, None)
-        self.curNode = self.document
-        self._elem_info = self.document._elem_info
-        self._cdata = False
-
-    def install(self, parser):
-        """Install the callbacks needed to build the DOM into the parser."""
-        # This creates circular references!
-        parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler
-        parser.StartElementHandler = self.first_element_handler
-        parser.EndElementHandler = self.end_element_handler
-        parser.ProcessingInstructionHandler = self.pi_handler
-        if self._options.entities:
-            parser.EntityDeclHandler = self.entity_decl_handler
-        parser.NotationDeclHandler = self.notation_decl_handler
-        if self._options.comments:
-            parser.CommentHandler = self.comment_handler
-        if self._options.cdata_sections:
-            parser.StartCdataSectionHandler = self.start_cdata_section_handler
-            parser.EndCdataSectionHandler = self.end_cdata_section_handler
-            parser.CharacterDataHandler = self.character_data_handler_cdata
-        else:
-            parser.CharacterDataHandler = self.character_data_handler
-        parser.ExternalEntityRefHandler = self.external_entity_ref_handler
-        parser.XmlDeclHandler = self.xml_decl_handler
-        parser.ElementDeclHandler = self.element_decl_handler
-        parser.AttlistDeclHandler = self.attlist_decl_handler
-
-    def parseFile(self, file):
-        """Parse a document from a file object, returning the document
-        node."""
-        parser = self.getParser()
-        first_buffer = True
-        try:
-            while 1:
-                buffer = file.read(16*1024)
-                if not buffer:
-                    break
-                parser.Parse(buffer, 0)
-                if first_buffer and self.document.documentElement:
-                    self._setup_subset(buffer)
-                first_buffer = False
-            parser.Parse("", True)
-        except ParseEscape:
-            pass
-        doc = self.document
-        self.reset()
-        self._parser = None
-        return doc
-
-    def parseString(self, string):
-        """Parse a document from a string, returning the document node."""
-        parser = self.getParser()
-        try:
-            parser.Parse(string, True)
-            self._setup_subset(string)
-        except ParseEscape:
-            pass
-        doc = self.document
-        self.reset()
-        self._parser = None
-        return doc
-
-    def _setup_subset(self, buffer):
-        """Load the internal subset if there might be one."""
-        if self.document.doctype:
-            extractor = InternalSubsetExtractor()
-            extractor.parseString(buffer)
-            subset = extractor.getSubset()
-            self.document.doctype.internalSubset = subset
-
-    def start_doctype_decl_handler(self, doctypeName, systemId, publicId,
-                                   has_internal_subset):
-        doctype = self.document.implementation.createDocumentType(
-            doctypeName, publicId, systemId)
-        doctype.ownerDocument = self.document
-        _append_child(self.document, doctype)
-        self.document.doctype = doctype
-        if self._filter and self._filter.acceptNode(doctype) == FILTER_REJECT:
-            self.document.doctype = None
-            del self.document.childNodes[-1]
-            doctype = None
-            self._parser.EntityDeclHandler = None
-            self._parser.NotationDeclHandler = None
-        if has_internal_subset:
-            if doctype is not None:
-                doctype.entities._seq = []
-                doctype.notations._seq = []
-            self._parser.CommentHandler = None
-            self._parser.ProcessingInstructionHandler = None
-            self._parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler
-
-    def end_doctype_decl_handler(self):
-        if self._options.comments:
-            self._parser.CommentHandler = self.comment_handler
-        self._parser.ProcessingInstructionHandler = self.pi_handler
-        if not (self._elem_info or self._filter):
-            self._finish_end_element = id
-
-    def pi_handler(self, target, data):
-        node = self.document.createProcessingInstruction(target, data)
-        _append_child(self.curNode, node)
-        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:
-            self.curNode.removeChild(node)
-
-    def character_data_handler_cdata(self, data):
-        childNodes = self.curNode.childNodes
-        if self._cdata:
-            if (  self._cdata_continue
-                  and childNodes[-1].nodeType == CDATA_SECTION_NODE):
-                childNodes[-1].appendData(data)
-                return
-            node = self.document.createCDATASection(data)
-            self._cdata_continue = True
-        elif childNodes and childNodes[-1].nodeType == TEXT_NODE:
-            node = childNodes[-1]
-            value = node.data + data
-            node.data = value
-            return
-        else:
-            node = minidom.Text()
-            node.data = data
-            node.ownerDocument = self.document
-        _append_child(self.curNode, node)
-
-    def character_data_handler(self, data):
-        childNodes = self.curNode.childNodes
-        if childNodes and childNodes[-1].nodeType == TEXT_NODE:
-            node = childNodes[-1]
-            node.data = node.data + data
-            return
-        node = minidom.Text()
-        node.data = node.data + data
-        node.ownerDocument = self.document
-        _append_child(self.curNode, node)
-
-    def entity_decl_handler(self, entityName, is_parameter_entity, value,
-                            base, systemId, publicId, notationName):
-        if is_parameter_entity:
-            # we don't care about parameter entities for the DOM
-            return
-        if not self._options.entities:
-            return
-        node = self.document._create_entity(entityName, publicId,
-                                            systemId, notationName)
-        if value is not None:
-            # internal entity
-            # node *should* be readonly, but we'll cheat
-            child = self.document.createTextNode(value)
-            node.childNodes.append(child)
-        self.document.doctype.entities._seq.append(node)
-        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:
-            del self.document.doctype.entities._seq[-1]
-
-    def notation_decl_handler(self, notationName, base, systemId, publicId):
-        node = self.document._create_notation(notationName, publicId, systemId)
-        self.document.doctype.notations._seq.append(node)
-        if self._filter and self._filter.acceptNode(node) == FILTER_ACCEPT:
-            del self.document.doctype.notations._seq[-1]
-
-    def comment_handler(self, data):
-        node = self.document.createComment(data)
-        _append_child(self.curNode, node)
-        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:
-            self.curNode.removeChild(node)
-
-    def start_cdata_section_handler(self):
-        self._cdata = True
-        self._cdata_continue = False
-
-    def end_cdata_section_handler(self):
-        self._cdata = False
-        self._cdata_continue = False
-
-    def external_entity_ref_handler(self, context, base, systemId, publicId):
-        return 1
-
-    def first_element_handler(self, name, attributes):
-        if self._filter is None and not self._elem_info:
-            self._finish_end_element = id
-        self.getParser().StartElementHandler = self.start_element_handler
-        self.start_element_handler(name, attributes)
-
-    def start_element_handler(self, name, attributes):
-        node = self.document.createElement(name)
-        _append_child(self.curNode, node)
-        self.curNode = node
-
-        if attributes:
-            for i in range(0, len(attributes), 2):
-                a = minidom.Attr(attributes[i], EMPTY_NAMESPACE,
-                                 None, EMPTY_PREFIX)
-                value = attributes[i+1]
-                a.value = value
-                a.ownerDocument = self.document
-                _set_attribute_node(node, a)
-
-        if node is not self.document.documentElement:
-            self._finish_start_element(node)
-
-    def _finish_start_element(self, node):
-        if self._filter:
-            # To be general, we'd have to call isSameNode(), but this
-            # is sufficient for minidom:
-            if node is self.document.documentElement:
-                return
-            filt = self._filter.startContainer(node)
-            if filt == FILTER_REJECT:
-                # ignore this node & all descendents
-                Rejecter(self)
-            elif filt == FILTER_SKIP:
-                # ignore this node, but make it's children become
-                # children of the parent node
-                Skipper(self)
-            else:
-                return
-            self.curNode = node.parentNode
-            node.parentNode.removeChild(node)
-            node.unlink()
-
-    # If this ever changes, Namespaces.end_element_handler() needs to
-    # be changed to match.
-    #
-    def end_element_handler(self, name):
-        curNode = self.curNode
-        self.curNode = curNode.parentNode
-        self._finish_end_element(curNode)
-
-    def _finish_end_element(self, curNode):
-        info = self._elem_info.get(curNode.tagName)
-        if info:
-            self._handle_white_text_nodes(curNode, info)
-        if self._filter:
-            if curNode is self.document.documentElement:
-                return
-            if self._filter.acceptNode(curNode) == FILTER_REJECT:
-                self.curNode.removeChild(curNode)
-                curNode.unlink()
-
-    def _handle_white_text_nodes(self, node, info):
-        if (self._options.whitespace_in_element_content
-            or not info.isElementContent()):
-            return
-
-        # We have element type information and should remove ignorable
-        # whitespace; identify for text nodes which contain only
-        # whitespace.
-        L = []
-        for child in node.childNodes:
-            if child.nodeType == TEXT_NODE and not child.data.strip():
-                L.append(child)
-
-        # Remove ignorable whitespace from the tree.
-        for child in L:
-            node.removeChild(child)
-
-    def element_decl_handler(self, name, model):
-        info = self._elem_info.get(name)
-        if info is None:
-            self._elem_info[name] = ElementInfo(name, model)
-        else:
-            assert info._model is None
-            info._model = model
-
-    def attlist_decl_handler(self, elem, name, type, default, required):
-        info = self._elem_info.get(elem)
-        if info is None:
-            info = ElementInfo(elem)
-            self._elem_info[elem] = info
-        info._attr_info.append(
-            [None, name, None, None, default, 0, type, required])
-
-    def xml_decl_handler(self, version, encoding, standalone):
-        self.document.version = version
-        self.document.encoding = encoding
-        # This is still a little ugly, thanks to the pyexpat API. ;-(
-        if standalone >= 0:
-            if standalone:
-                self.document.standalone = True
-            else:
-                self.document.standalone = False
-
-
-# Don't include FILTER_INTERRUPT, since that's checked separately
-# where allowed.
-_ALLOWED_FILTER_RETURNS = (FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP)
-
-class FilterVisibilityController(object):
-    """Wrapper around a DOMBuilderFilter which implements the checks
-    to make the whatToShow filter attribute work."""
-
-    __slots__ = 'filter',
-
-    def __init__(self, filter):
-        self.filter = filter
-
-    def startContainer(self, node):
-        mask = self._nodetype_mask[node.nodeType]
-        if self.filter.whatToShow & mask:
-            val = self.filter.startContainer(node)
-            if val == FILTER_INTERRUPT:
-                raise ParseEscape
-            if val not in _ALLOWED_FILTER_RETURNS:
-                raise ValueError(
-                      "startContainer() returned illegal value: " + repr(val))
-            return val
-        else:
-            return FILTER_ACCEPT
-
-    def acceptNode(self, node):
-        mask = self._nodetype_mask[node.nodeType]
-        if self.filter.whatToShow & mask:
-            val = self.filter.acceptNode(node)
-            if val == FILTER_INTERRUPT:
-                raise ParseEscape
-            if val == FILTER_SKIP:
-                # move all child nodes to the parent, and remove this node
-                parent = node.parentNode
-                for child in node.childNodes[:]:
-                    parent.appendChild(child)
-                # node is handled by the caller
-                return FILTER_REJECT
-            if val not in _ALLOWED_FILTER_RETURNS:
-                raise ValueError(
-                      "acceptNode() returned illegal value: " + repr(val))
-            return val
-        else:
-            return FILTER_ACCEPT
-
-    _nodetype_mask = {
-        Node.ELEMENT_NODE:                NodeFilter.SHOW_ELEMENT,
-        Node.ATTRIBUTE_NODE:              NodeFilter.SHOW_ATTRIBUTE,
-        Node.TEXT_NODE:                   NodeFilter.SHOW_TEXT,
-        Node.CDATA_SECTION_NODE:          NodeFilter.SHOW_CDATA_SECTION,
-        Node.ENTITY_REFERENCE_NODE:       NodeFilter.SHOW_ENTITY_REFERENCE,
-        Node.ENTITY_NODE:                 NodeFilter.SHOW_ENTITY,
-        Node.PROCESSING_INSTRUCTION_NODE: NodeFilter.SHOW_PROCESSING_INSTRUCTION,
-        Node.COMMENT_NODE:                NodeFilter.SHOW_COMMENT,
-        Node.DOCUMENT_NODE:               NodeFilter.SHOW_DOCUMENT,
-        Node.DOCUMENT_TYPE_NODE:          NodeFilter.SHOW_DOCUMENT_TYPE,
-        Node.DOCUMENT_FRAGMENT_NODE:      NodeFilter.SHOW_DOCUMENT_FRAGMENT,
-        Node.NOTATION_NODE:               NodeFilter.SHOW_NOTATION,
-        }
-
-
-class FilterCrutch(object):
-    __slots__ = '_builder', '_level', '_old_start', '_old_end'
-
-    def __init__(self, builder):
-        self._level = 0
-        self._builder = builder
-        parser = builder._parser
-        self._old_start = parser.StartElementHandler
-        self._old_end = parser.EndElementHandler
-        parser.StartElementHandler = self.start_element_handler
-        parser.EndElementHandler = self.end_element_handler
-
-class Rejecter(FilterCrutch):
-    __slots__ = ()
-
-    def __init__(self, builder):
-        FilterCrutch.__init__(self, builder)
-        parser = builder._parser
-        for name in ("ProcessingInstructionHandler",
-                     "CommentHandler",
-                     "CharacterDataHandler",
-                     "StartCdataSectionHandler",
-                     "EndCdataSectionHandler",
-                     "ExternalEntityRefHandler",
-                     ):
-            setattr(parser, name, None)
-
-    def start_element_handler(self, *args):
-        self._level = self._level + 1
-
-    def end_element_handler(self, *args):
-        if self._level == 0:
-            # restore the old handlers
-            parser = self._builder._parser
-            self._builder.install(parser)
-            parser.StartElementHandler = self._old_start
-            parser.EndElementHandler = self._old_end
-        else:
-            self._level = self._level - 1
-
-class Skipper(FilterCrutch):
-    __slots__ = ()
-
-    def start_element_handler(self, *args):
-        node = self._builder.curNode
-        self._old_start(*args)
-        if self._builder.curNode is not node:
-            self._level = self._level + 1
-
-    def end_element_handler(self, *args):
-        if self._level == 0:
-            # We're popping back out of the node we're skipping, so we
-            # shouldn't need to do anything but reset the handlers.
-            self._builder._parser.StartElementHandler = self._old_start
-            self._builder._parser.EndElementHandler = self._old_end
-            self._builder = None
-        else:
-            self._level = self._level - 1
-            self._old_end(*args)
-
-
-# framework document used by the fragment builder.
-# Takes a string for the doctype, subset string, and namespace attrs string.
-
-_FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID = \
-    "http://xml.python.org/entities/fragment-builder/internal"
-
-_FRAGMENT_BUILDER_TEMPLATE = (
-    '''\
-<!DOCTYPE wrapper
-  %%s [
-  <!ENTITY fragment-builder-internal
-    SYSTEM "%s">
-%%s
-]>
-<wrapper %%s
->&fragment-builder-internal;</wrapper>'''
-    % _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID)
-
-
-class FragmentBuilder(ExpatBuilder):
-    """Builder which constructs document fragments given XML source
-    text and a context node.
-
-    The context node is expected to provide information about the
-    namespace declarations which are in scope at the start of the
-    fragment.
-    """
-
-    def __init__(self, context, options=None):
-        if context.nodeType == DOCUMENT_NODE:
-            self.originalDocument = context
-            self.context = context
-        else:
-            self.originalDocument = context.ownerDocument
-            self.context = context
-        ExpatBuilder.__init__(self, options)
-
-    def reset(self):
-        ExpatBuilder.reset(self)
-        self.fragment = None
-
-    def parseFile(self, file):
-        """Parse a document fragment from a file object, returning the
-        fragment node."""
-        return self.parseString(file.read())
-
-    def parseString(self, string):
-        """Parse a document fragment from a string, returning the
-        fragment node."""
-        self._source = string
-        parser = self.getParser()
-        doctype = self.originalDocument.doctype
-        ident = ""
-        if doctype:
-            subset = doctype.internalSubset or self._getDeclarations()
-            if doctype.publicId:
-                ident = ('PUBLIC "%s" "%s"'
-                         % (doctype.publicId, doctype.systemId))
-            elif doctype.systemId:
-                ident = 'SYSTEM "%s"' % doctype.systemId
-        else:
-            subset = ""
-        nsattrs = self._getNSattrs() # get ns decls from node's ancestors
-        document = _FRAGMENT_BUILDER_TEMPLATE % (ident, subset, nsattrs)
-        try:
-            parser.Parse(document, 1)
-        except:
-            self.reset()
-            raise
-        fragment = self.fragment
-        self.reset()
-##         self._parser = None
-        return fragment
-
-    def _getDeclarations(self):
-        """Re-create the internal subset from the DocumentType node.
-
-        This is only needed if we don't already have the
-        internalSubset as a string.
-        """
-        doctype = self.context.ownerDocument.doctype
-        s = ""
-        if doctype:
-            for i in range(doctype.notations.length):
-                notation = doctype.notations.item(i)
-                if s:
-                    s = s + "\n  "
-                s = "%s<!NOTATION %s" % (s, notation.nodeName)
-                if notation.publicId:
-                    s = '%s PUBLIC "%s"\n             "%s">' \
-                        % (s, notation.publicId, notation.systemId)
-                else:
-                    s = '%s SYSTEM "%s">' % (s, notation.systemId)
-            for i in range(doctype.entities.length):
-                entity = doctype.entities.item(i)
-                if s:
-                    s = s + "\n  "
-                s = "%s<!ENTITY %s" % (s, entity.nodeName)
-                if entity.publicId:
-                    s = '%s PUBLIC "%s"\n             "%s"' \
-                        % (s, entity.publicId, entity.systemId)
-                elif entity.systemId:
-                    s = '%s SYSTEM "%s"' % (s, entity.systemId)
-                else:
-                    s = '%s "%s"' % (s, entity.firstChild.data)
-                if entity.notationName:
-                    s = "%s NOTATION %s" % (s, entity.notationName)
-                s = s + ">"
-        return s
-
-    def _getNSattrs(self):
-        return ""
-
-    def external_entity_ref_handler(self, context, base, systemId, publicId):
-        if systemId == _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID:
-            # this entref is the one that we made to put the subtree
-            # in; all of our given input is parsed in here.
-            old_document = self.document
-            old_cur_node = self.curNode
-            parser = self._parser.ExternalEntityParserCreate(context)
-            # put the real document back, parse into the fragment to return
-            self.document = self.originalDocument
-            self.fragment = self.document.createDocumentFragment()
-            self.curNode = self.fragment
-            try:
-                parser.Parse(self._source, 1)
-            finally:
-                self.curNode = old_cur_node
-                self.document = old_document
-                self._source = None
-            return -1
-        else:
-            return ExpatBuilder.external_entity_ref_handler(
-                self, context, base, systemId, publicId)
-
-
-class Namespaces:
-    """Mix-in class for builders; adds support for namespaces."""
-
-    def _initNamespaces(self):
-        # list of (prefix, uri) ns declarations.  Namespace attrs are
-        # constructed from this and added to the element's attrs.
-        self._ns_ordered_prefixes = []
-
-    def createParser(self):
-        """Create a new namespace-handling parser."""
-        parser = expat.ParserCreate(namespace_separator=" ")
-        parser.namespace_prefixes = True
-        return parser
-
-    def install(self, parser):
-        """Insert the namespace-handlers onto the parser."""
-        ExpatBuilder.install(self, parser)
-        if self._options.namespace_declarations:
-            parser.StartNamespaceDeclHandler = (
-                self.start_namespace_decl_handler)
-
-    def start_namespace_decl_handler(self, prefix, uri):
-        """Push this namespace declaration on our storage."""
-        self._ns_ordered_prefixes.append((prefix, uri))
-
-    def start_element_handler(self, name, attributes):
-        if ' ' in name:
-            uri, localname, prefix, qname = _parse_ns_name(self, name)
-        else:
-            uri = EMPTY_NAMESPACE
-            qname = name
-            localname = None
-            prefix = EMPTY_PREFIX
-        node = minidom.Element(qname, uri, prefix, localname)
-        node.ownerDocument = self.document
-        _append_child(self.curNode, node)
-        self.curNode = node
-
-        if self._ns_ordered_prefixes:
-            for prefix, uri in self._ns_ordered_prefixes:
-                if prefix:
-                    a = minidom.Attr(_intern(self, 'xmlns:' + prefix),
-                                     XMLNS_NAMESPACE, prefix, "xmlns")
-                else:
-                    a = minidom.Attr("xmlns", XMLNS_NAMESPACE,
-                                     "xmlns", EMPTY_PREFIX)
-                a.value = uri
-                a.ownerDocument = self.document
-                _set_attribute_node(node, a)
-            del self._ns_ordered_prefixes[:]
-
-        if attributes:
-            node._ensure_attributes()
-            _attrs = node._attrs
-            _attrsNS = node._attrsNS
-            for i in range(0, len(attributes), 2):
-                aname = attributes[i]
-                value = attributes[i+1]
-                if ' ' in aname:
-                    uri, localname, prefix, qname = _parse_ns_name(self, aname)
-                    a = minidom.Attr(qname, uri, localname, prefix)
-                    _attrs[qname] = a
-                    _attrsNS[(uri, localname)] = a
-                else:
-                    a = minidom.Attr(aname, EMPTY_NAMESPACE,
-                                     aname, EMPTY_PREFIX)
-                    _attrs[aname] = a
-                    _attrsNS[(EMPTY_NAMESPACE, aname)] = a
-                a.ownerDocument = self.document
-                a.value = value
-                a.ownerElement = node
-
-    if __debug__:
-        # This only adds some asserts to the original
-        # end_element_handler(), so we only define this when -O is not
-        # used.  If changing one, be sure to check the other to see if
-        # it needs to be changed as well.
-        #
-        def end_element_handler(self, name):
-            curNode = self.curNode
-            if ' ' in name:
-                uri, localname, prefix, qname = _parse_ns_name(self, name)
-                assert (curNode.namespaceURI == uri
-                        and curNode.localName == localname
-                        and curNode.prefix == prefix), \
-                        "element stack messed up! (namespace)"
-            else:
-                assert curNode.nodeName == name, \
-                       "element stack messed up - bad nodeName"
-                assert curNode.namespaceURI == EMPTY_NAMESPACE, \
-                       "element stack messed up - bad namespaceURI"
-            self.curNode = curNode.parentNode
-            self._finish_end_element(curNode)
-
-
-class ExpatBuilderNS(Namespaces, ExpatBuilder):
-    """Document builder that supports namespaces."""
-
-    def reset(self):
-        ExpatBuilder.reset(self)
-        self._initNamespaces()
-
-
-class FragmentBuilderNS(Namespaces, FragmentBuilder):
-    """Fragment builder that supports namespaces."""
-
-    def reset(self):
-        FragmentBuilder.reset(self)
-        self._initNamespaces()
-
-    def _getNSattrs(self):
-        """Return string of namespace attributes from this element and
-        ancestors."""
-        # XXX This needs to be re-written to walk the ancestors of the
-        # context to build up the namespace information from
-        # declarations, elements, and attributes found in context.
-        # Otherwise we have to store a bunch more data on the DOM
-        # (though that *might* be more reliable -- not clear).
-        attrs = ""
-        context = self.context
-        L = []
-        while context:
-            if hasattr(context, '_ns_prefix_uri'):
-                for prefix, uri in context._ns_prefix_uri.items():
-                    # add every new NS decl from context to L and attrs string
-                    if prefix in L:
-                        continue
-                    L.append(prefix)
-                    if prefix:
-                        declname = "xmlns:" + prefix
-                    else:
-                        declname = "xmlns"
-                    if attrs:
-                        attrs = "%s\n    %s='%s'" % (attrs, declname, uri)
-                    else:
-                        attrs = " %s='%s'" % (declname, uri)
-            context = context.parentNode
-        return attrs
-
-
-class ParseEscape(Exception):
-    """Exception raised to short-circuit parsing in InternalSubsetExtractor."""
-    pass
-
-class InternalSubsetExtractor(ExpatBuilder):
-    """XML processor which can rip out the internal document type subset."""
-
-    subset = None
-
-    def getSubset(self):
-        """Return the internal subset as a string."""
-        return self.subset
-
-    def parseFile(self, file):
-        try:
-            ExpatBuilder.parseFile(self, file)
-        except ParseEscape:
-            pass
-
-    def parseString(self, string):
-        try:
-            ExpatBuilder.parseString(self, string)
-        except ParseEscape:
-            pass
-
-    def install(self, parser):
-        parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler
-        parser.StartElementHandler = self.start_element_handler
-
-    def start_doctype_decl_handler(self, name, publicId, systemId,
-                                   has_internal_subset):
-        if has_internal_subset:
-            parser = self.getParser()
-            self.subset = []
-            parser.DefaultHandler = self.subset.append
-            parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler
-        else:
-            raise ParseEscape()
-
-    def end_doctype_decl_handler(self):
-        s = ''.join(self.subset).replace('\r\n', '\n').replace('\r', '\n')
-        self.subset = s
-        raise ParseEscape()
-
-    def start_element_handler(self, name, attrs):
-        raise ParseEscape()
-
-
-def parse(file, namespaces=True):
-    """Parse a document, returning the resulting Document node.
-
-    'file' may be either a file name or an open file object.
-    """
-    if namespaces:
-        builder = ExpatBuilderNS()
-    else:
-        builder = ExpatBuilder()
-
-    if isinstance(file, str):
-        with open(file, 'rb') as fp:
-            result = builder.parseFile(fp)
-    else:
-        result = builder.parseFile(file)
-    return result
-
-
-def parseString(string, namespaces=True):
-    """Parse a document from a string, returning the resulting
-    Document node.
-    """
-    if namespaces:
-        builder = ExpatBuilderNS()
-    else:
-        builder = ExpatBuilder()
-    return builder.parseString(string)
-
-
-def parseFragment(file, context, namespaces=True):
-    """Parse a fragment of a document, given the context from which it
-    was originally extracted.  context should be the parent of the
-    node(s) which are in the fragment.
-
-    'file' may be either a file name or an open file object.
-    """
-    if namespaces:
-        builder = FragmentBuilderNS(context)
-    else:
-        builder = FragmentBuilder(context)
-
-    if isinstance(file, str):
-        with open(file, 'rb') as fp:
-            result = builder.parseFile(fp)
-    else:
-        result = builder.parseFile(file)
-    return result
-
-
-def parseFragmentString(string, context, namespaces=True):
-    """Parse a fragment of a document from a string, given the context
-    from which it was originally extracted.  context should be the
-    parent of the node(s) which are in the fragment.
-    """
-    if namespaces:
-        builder = FragmentBuilderNS(context)
-    else:
-        builder = FragmentBuilder(context)
-    return builder.parseString(string)
-
-
-def makeBuilder(options):
-    """Create a builder based on an Options object."""
-    if options.namespaces:
-        return ExpatBuilderNS(options)
-    else:
-        return ExpatBuilder(options)