File Explorer

1"""Facility to use the Expat parser to load a minidom instance2from a string or file.3 4This avoids all the overhead of SAX and pulldom to gain performance.5"""6 7# Warning!8#9# This module is tightly bound to the implementation details of the10# minidom DOM and can't be used with other DOM implementations.  This11# is due, in part, to a lack of appropriate methods in the DOM (there is12# no way to create Entity and Notation nodes via the DOM Level 213# interface), and for performance.  The latter is the cause of some fairly14# cryptic code.15#16# Performance hacks:17#18#   -  .character_data_handler() has an extra case in which continuing19#      data is appended to an existing Text node; this can be a20#      speedup since pyexpat can break up character data into multiple21#      callbacks even though we set the buffer_text attribute on the22#      parser.  This also gives us the advantage that we don't need a23#      separate normalization pass.24#25#   -  Determining that a node exists is done using an identity comparison26#      with None rather than a truth test; this avoids searching for and27#      calling any methods on the node object if it exists.  (A rather28#      nice speedup is achieved this way as well!)29 30from xml.dom import xmlbuilder, minidom, Node31from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE32from xml.parsers import expat33from xml.dom.minidom import _append_child, _set_attribute_node34from xml.dom.NodeFilter import NodeFilter35 36TEXT_NODE = Node.TEXT_NODE37CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE38DOCUMENT_NODE = Node.DOCUMENT_NODE39 40FILTER_ACCEPT = xmlbuilder.DOMBuilderFilter.FILTER_ACCEPT41FILTER_REJECT = xmlbuilder.DOMBuilderFilter.FILTER_REJECT42FILTER_SKIP = xmlbuilder.DOMBuilderFilter.FILTER_SKIP43FILTER_INTERRUPT = xmlbuilder.DOMBuilderFilter.FILTER_INTERRUPT44 45theDOMImplementation = minidom.getDOMImplementation()46 47# Expat typename -> TypeInfo48_typeinfo_map = {49    "CDATA":    minidom.TypeInfo(None, "cdata"),50    "ENUM":     minidom.TypeInfo(None, "enumeration"),51    "ENTITY":   minidom.TypeInfo(None, "entity"),52    "ENTITIES": minidom.TypeInfo(None, "entities"),53    "ID":       minidom.TypeInfo(None, "id"),54    "IDREF":    minidom.TypeInfo(None, "idref"),55    "IDREFS":   minidom.TypeInfo(None, "idrefs"),56    "NMTOKEN":  minidom.TypeInfo(None, "nmtoken"),57    "NMTOKENS": minidom.TypeInfo(None, "nmtokens"),58    }59 60class ElementInfo(object):61    __slots__ = '_attr_info', '_model', 'tagName'62 63    def __init__(self, tagName, model=None):64        self.tagName = tagName65        self._attr_info = []66        self._model = model67 68    def __getstate__(self):69        return self._attr_info, self._model, self.tagName70 71    def __setstate__(self, state):72        self._attr_info, self._model, self.tagName = state73 74    def getAttributeType(self, aname):75        for info in self._attr_info:76            if info[1] == aname:77                t = info[-2]78                if t[0] == "(":79                    return _typeinfo_map["ENUM"]80                else:81                    return _typeinfo_map[info[-2]]82        return minidom._no_type83 84    def getAttributeTypeNS(self, namespaceURI, localName):85        return minidom._no_type86 87    def isElementContent(self):88        if self._model:89            type = self._model[0]90            return type not in (expat.model.XML_CTYPE_ANY,91                                expat.model.XML_CTYPE_MIXED)92        else:93            return False94 95    def isEmpty(self):96        if self._model:97            return self._model[0] == expat.model.XML_CTYPE_EMPTY98        else:99            return False100 101    def isId(self, aname):102        for info in self._attr_info:103            if info[1] == aname:104                return info[-2] == "ID"105        return False106 107    def isIdNS(self, euri, ename, auri, aname):108        # not sure this is meaningful109        return self.isId((auri, aname))110 111def _intern(builder, s):112    return builder._intern_setdefault(s, s)113 114def _parse_ns_name(builder, name):115    assert ' ' in name116    parts = name.split(' ')117    intern = builder._intern_setdefault118    if len(parts) == 3:119        uri, localname, prefix = parts120        prefix = intern(prefix, prefix)121        qname = "%s:%s" % (prefix, localname)122        qname = intern(qname, qname)123        localname = intern(localname, localname)124    elif len(parts) == 2:125        uri, localname = parts126        prefix = EMPTY_PREFIX127        qname = localname = intern(localname, localname)128    else:129        raise ValueError("Unsupported syntax: spaces in URIs not supported: %r" % name)130    return intern(uri, uri), localname, prefix, qname131 132 133class ExpatBuilder:134    """Document builder that uses Expat to build a ParsedXML.DOM document135    instance."""136 137    def __init__(self, options=None):138        if options is None:139            options = xmlbuilder.Options()140        self._options = options141        if self._options.filter is not None:142            self._filter = FilterVisibilityController(self._options.filter)143        else:144            self._filter = None145            # This *really* doesn't do anything in this case, so146            # override it with something fast & minimal.147            self._finish_start_element = id148        self._parser = None149        self.reset()150 151    def createParser(self):152        """Create a new parser object."""153        return expat.ParserCreate()154 155    def getParser(self):156        """Return the parser object, creating a new one if needed."""157        if not self._parser:158            self._parser = self.createParser()159            self._intern_setdefault = self._parser.intern.setdefault160            self._parser.buffer_text = True161            self._parser.ordered_attributes = True162            self._parser.specified_attributes = True163            self.install(self._parser)164        return self._parser165 166    def reset(self):167        """Free all data structures used during DOM construction."""168        self.document = theDOMImplementation.createDocument(169            EMPTY_NAMESPACE, None, None)170        self.curNode = self.document171        self._elem_info = self.document._elem_info172        self._cdata = False173 174    def install(self, parser):175        """Install the callbacks needed to build the DOM into the parser."""176        # This creates circular references!177        parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler178        parser.StartElementHandler = self.first_element_handler179        parser.EndElementHandler = self.end_element_handler180        parser.ProcessingInstructionHandler = self.pi_handler181        if self._options.entities:182            parser.EntityDeclHandler = self.entity_decl_handler183        parser.NotationDeclHandler = self.notation_decl_handler184        if self._options.comments:185            parser.CommentHandler = self.comment_handler186        if self._options.cdata_sections:187            parser.StartCdataSectionHandler = self.start_cdata_section_handler188            parser.EndCdataSectionHandler = self.end_cdata_section_handler189            parser.CharacterDataHandler = self.character_data_handler_cdata190        else:191            parser.CharacterDataHandler = self.character_data_handler192        parser.ExternalEntityRefHandler = self.external_entity_ref_handler193        parser.XmlDeclHandler = self.xml_decl_handler194        parser.ElementDeclHandler = self.element_decl_handler195        parser.AttlistDeclHandler = self.attlist_decl_handler196 197    def parseFile(self, file):198        """Parse a document from a file object, returning the document199        node."""200        parser = self.getParser()201        first_buffer = True202        try:203            while 1:204                buffer = file.read(16*1024)205                if not buffer:206                    break207                parser.Parse(buffer, False)208                if first_buffer and self.document.documentElement:209                    self._setup_subset(buffer)210                first_buffer = False211            parser.Parse(b"", True)212        except ParseEscape:213            pass214        doc = self.document215        self.reset()216        self._parser = None217        return doc218 219    def parseString(self, string):220        """Parse a document from a string, returning the document node."""221        parser = self.getParser()222        try:223            parser.Parse(string, True)224            self._setup_subset(string)225        except ParseEscape:226            pass227        doc = self.document228        self.reset()229        self._parser = None230        return doc231 232    def _setup_subset(self, buffer):233        """Load the internal subset if there might be one."""234        if self.document.doctype:235            extractor = InternalSubsetExtractor()236            extractor.parseString(buffer)237            subset = extractor.getSubset()238            self.document.doctype.internalSubset = subset239 240    def start_doctype_decl_handler(self, doctypeName, systemId, publicId,241                                   has_internal_subset):242        doctype = self.document.implementation.createDocumentType(243            doctypeName, publicId, systemId)244        doctype.ownerDocument = self.document245        _append_child(self.document, doctype)246        self.document.doctype = doctype247        if self._filter and self._filter.acceptNode(doctype) == FILTER_REJECT:248            self.document.doctype = None249            del self.document.childNodes[-1]250            doctype = None251            self._parser.EntityDeclHandler = None252            self._parser.NotationDeclHandler = None253        if has_internal_subset:254            if doctype is not None:255                doctype.entities._seq = []256                doctype.notations._seq = []257            self._parser.CommentHandler = None258            self._parser.ProcessingInstructionHandler = None259            self._parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler260 261    def end_doctype_decl_handler(self):262        if self._options.comments:263            self._parser.CommentHandler = self.comment_handler264        self._parser.ProcessingInstructionHandler = self.pi_handler265        if not (self._elem_info or self._filter):266            self._finish_end_element = id267 268    def pi_handler(self, target, data):269        node = self.document.createProcessingInstruction(target, data)270        _append_child(self.curNode, node)271        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:272            self.curNode.removeChild(node)273 274    def character_data_handler_cdata(self, data):275        childNodes = self.curNode.childNodes276        if self._cdata:277            if (  self._cdata_continue278                  and childNodes[-1].nodeType == CDATA_SECTION_NODE):279                childNodes[-1].appendData(data)280                return281            node = self.document.createCDATASection(data)282            self._cdata_continue = True283        elif childNodes and childNodes[-1].nodeType == TEXT_NODE:284            node = childNodes[-1]285            value = node.data + data286            node.data = value287            return288        else:289            node = minidom.Text()290            node.data = data291            node.ownerDocument = self.document292        _append_child(self.curNode, node)293 294    def character_data_handler(self, data):295        childNodes = self.curNode.childNodes296        if childNodes and childNodes[-1].nodeType == TEXT_NODE:297            node = childNodes[-1]298            node.data = node.data + data299            return300        node = minidom.Text()301        node.data = node.data + data302        node.ownerDocument = self.document303        _append_child(self.curNode, node)304 305    def entity_decl_handler(self, entityName, is_parameter_entity, value,306                            base, systemId, publicId, notationName):307        if is_parameter_entity:308            # we don't care about parameter entities for the DOM309            return310        if not self._options.entities:311            return312        node = self.document._create_entity(entityName, publicId,313                                            systemId, notationName)314        if value is not None:315            # internal entity316            # node *should* be readonly, but we'll cheat317            child = self.document.createTextNode(value)318            node.childNodes.append(child)319        self.document.doctype.entities._seq.append(node)320        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:321            del self.document.doctype.entities._seq[-1]322 323    def notation_decl_handler(self, notationName, base, systemId, publicId):324        node = self.document._create_notation(notationName, publicId, systemId)325        self.document.doctype.notations._seq.append(node)326        if self._filter and self._filter.acceptNode(node) == FILTER_ACCEPT:327            del self.document.doctype.notations._seq[-1]328 329    def comment_handler(self, data):330        node = self.document.createComment(data)331        _append_child(self.curNode, node)332        if self._filter and self._filter.acceptNode(node) == FILTER_REJECT:333            self.curNode.removeChild(node)334 335    def start_cdata_section_handler(self):336        self._cdata = True337        self._cdata_continue = False338 339    def end_cdata_section_handler(self):340        self._cdata = False341        self._cdata_continue = False342 343    def external_entity_ref_handler(self, context, base, systemId, publicId):344        return 1345 346    def first_element_handler(self, name, attributes):347        if self._filter is None and not self._elem_info:348            self._finish_end_element = id349        self.getParser().StartElementHandler = self.start_element_handler350        self.start_element_handler(name, attributes)351 352    def start_element_handler(self, name, attributes):353        node = self.document.createElement(name)354        _append_child(self.curNode, node)355        self.curNode = node356 357        if attributes:358            for i in range(0, len(attributes), 2):359                a = minidom.Attr(attributes[i], EMPTY_NAMESPACE,360                                 None, EMPTY_PREFIX)361                value = attributes[i+1]362                a.value = value363                a.ownerDocument = self.document364                _set_attribute_node(node, a)365 366        if node is not self.document.documentElement:367            self._finish_start_element(node)368 369    def _finish_start_element(self, node):370        if self._filter:371            # To be general, we'd have to call isSameNode(), but this372            # is sufficient for minidom:373            if node is self.document.documentElement:374                return375            filt = self._filter.startContainer(node)376            if filt == FILTER_REJECT:377                # ignore this node & all descendents378                Rejecter(self)379            elif filt == FILTER_SKIP:380                # ignore this node, but make it's children become381                # children of the parent node382                Skipper(self)383            else:384                return385            self.curNode = node.parentNode386            node.parentNode.removeChild(node)387            node.unlink()388 389    # If this ever changes, Namespaces.end_element_handler() needs to390    # be changed to match.391    #392    def end_element_handler(self, name):393        curNode = self.curNode394        self.curNode = curNode.parentNode395        self._finish_end_element(curNode)396 397    def _finish_end_element(self, curNode):398        info = self._elem_info.get(curNode.tagName)399        if info:400            self._handle_white_text_nodes(curNode, info)401        if self._filter:402            if curNode is self.document.documentElement:403                return404            if self._filter.acceptNode(curNode) == FILTER_REJECT:405                self.curNode.removeChild(curNode)406                curNode.unlink()407 408    def _handle_white_text_nodes(self, node, info):409        if (self._options.whitespace_in_element_content410            or not info.isElementContent()):411            return412 413        # We have element type information and should remove ignorable414        # whitespace; identify for text nodes which contain only415        # whitespace.416        L = []417        for child in node.childNodes:418            if child.nodeType == TEXT_NODE and not child.data.strip():419                L.append(child)420 421        # Remove ignorable whitespace from the tree.422        for child in L:423            node.removeChild(child)424 425    def element_decl_handler(self, name, model):426        info = self._elem_info.get(name)427        if info is None:428            self._elem_info[name] = ElementInfo(name, model)429        else:430            assert info._model is None431            info._model = model432 433    def attlist_decl_handler(self, elem, name, type, default, required):434        info = self._elem_info.get(elem)435        if info is None:436            info = ElementInfo(elem)437            self._elem_info[elem] = info438        info._attr_info.append(439            [None, name, None, None, default, 0, type, required])440 441    def xml_decl_handler(self, version, encoding, standalone):442        self.document.version = version443        self.document.encoding = encoding444        # This is still a little ugly, thanks to the pyexpat API. ;-(445        if standalone >= 0:446            if standalone:447                self.document.standalone = True448            else:449                self.document.standalone = False450 451 452# Don't include FILTER_INTERRUPT, since that's checked separately453# where allowed.454_ALLOWED_FILTER_RETURNS = (FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP)455 456class FilterVisibilityController(object):457    """Wrapper around a DOMBuilderFilter which implements the checks458    to make the whatToShow filter attribute work."""459 460    __slots__ = 'filter',461 462    def __init__(self, filter):463        self.filter = filter464 465    def startContainer(self, node):466        mask = self._nodetype_mask[node.nodeType]467        if self.filter.whatToShow & mask:468            val = self.filter.startContainer(node)469            if val == FILTER_INTERRUPT:470                raise ParseEscape471            if val not in _ALLOWED_FILTER_RETURNS:472                raise ValueError(473                      "startContainer() returned illegal value: " + repr(val))474            return val475        else:476            return FILTER_ACCEPT477 478    def acceptNode(self, node):479        mask = self._nodetype_mask[node.nodeType]480        if self.filter.whatToShow & mask:481            val = self.filter.acceptNode(node)482            if val == FILTER_INTERRUPT:483                raise ParseEscape484            if val == FILTER_SKIP:485                # move all child nodes to the parent, and remove this node486                parent = node.parentNode487                for child in node.childNodes[:]:488                    parent.appendChild(child)489                # node is handled by the caller490                return FILTER_REJECT491            if val not in _ALLOWED_FILTER_RETURNS:492                raise ValueError(493                      "acceptNode() returned illegal value: " + repr(val))494            return val495        else:496            return FILTER_ACCEPT497 498    _nodetype_mask = {499        Node.ELEMENT_NODE:                NodeFilter.SHOW_ELEMENT,500        Node.ATTRIBUTE_NODE:              NodeFilter.SHOW_ATTRIBUTE,501        Node.TEXT_NODE:                   NodeFilter.SHOW_TEXT,502        Node.CDATA_SECTION_NODE:          NodeFilter.SHOW_CDATA_SECTION,503        Node.ENTITY_REFERENCE_NODE:       NodeFilter.SHOW_ENTITY_REFERENCE,504        Node.ENTITY_NODE:                 NodeFilter.SHOW_ENTITY,505        Node.PROCESSING_INSTRUCTION_NODE: NodeFilter.SHOW_PROCESSING_INSTRUCTION,506        Node.COMMENT_NODE:                NodeFilter.SHOW_COMMENT,507        Node.DOCUMENT_NODE:               NodeFilter.SHOW_DOCUMENT,508        Node.DOCUMENT_TYPE_NODE:          NodeFilter.SHOW_DOCUMENT_TYPE,509        Node.DOCUMENT_FRAGMENT_NODE:      NodeFilter.SHOW_DOCUMENT_FRAGMENT,510        Node.NOTATION_NODE:               NodeFilter.SHOW_NOTATION,511        }512 513 514class FilterCrutch(object):515    __slots__ = '_builder', '_level', '_old_start', '_old_end'516 517    def __init__(self, builder):518        self._level = 0519        self._builder = builder520        parser = builder._parser521        self._old_start = parser.StartElementHandler522        self._old_end = parser.EndElementHandler523        parser.StartElementHandler = self.start_element_handler524        parser.EndElementHandler = self.end_element_handler525 526class Rejecter(FilterCrutch):527    __slots__ = ()528 529    def __init__(self, builder):530        FilterCrutch.__init__(self, builder)531        parser = builder._parser532        for name in ("ProcessingInstructionHandler",533                     "CommentHandler",534                     "CharacterDataHandler",535                     "StartCdataSectionHandler",536                     "EndCdataSectionHandler",537                     "ExternalEntityRefHandler",538                     ):539            setattr(parser, name, None)540 541    def start_element_handler(self, *args):542        self._level = self._level + 1543 544    def end_element_handler(self, *args):545        if self._level == 0:546            # restore the old handlers547            parser = self._builder._parser548            self._builder.install(parser)549            parser.StartElementHandler = self._old_start550            parser.EndElementHandler = self._old_end551        else:552            self._level = self._level - 1553 554class Skipper(FilterCrutch):555    __slots__ = ()556 557    def start_element_handler(self, *args):558        node = self._builder.curNode559        self._old_start(*args)560        if self._builder.curNode is not node:561            self._level = self._level + 1562 563    def end_element_handler(self, *args):564        if self._level == 0:565            # We're popping back out of the node we're skipping, so we566            # shouldn't need to do anything but reset the handlers.567            self._builder._parser.StartElementHandler = self._old_start568            self._builder._parser.EndElementHandler = self._old_end569            self._builder = None570        else:571            self._level = self._level - 1572            self._old_end(*args)573 574 575# framework document used by the fragment builder.576# Takes a string for the doctype, subset string, and namespace attrs string.577 578_FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID = \579    "http://xml.python.org/entities/fragment-builder/internal"580 581_FRAGMENT_BUILDER_TEMPLATE = (582    '''\583<!DOCTYPE wrapper584  %%s [585  <!ENTITY fragment-builder-internal586    SYSTEM "%s">587%%s588]>589<wrapper %%s590>&fragment-builder-internal;</wrapper>'''591    % _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID)592 593 594class FragmentBuilder(ExpatBuilder):595    """Builder which constructs document fragments given XML source596    text and a context node.597 598    The context node is expected to provide information about the599    namespace declarations which are in scope at the start of the600    fragment.601    """602 603    def __init__(self, context, options=None):604        if context.nodeType == DOCUMENT_NODE:605            self.originalDocument = context606            self.context = context607        else:608            self.originalDocument = context.ownerDocument609            self.context = context610        ExpatBuilder.__init__(self, options)611 612    def reset(self):613        ExpatBuilder.reset(self)614        self.fragment = None615 616    def parseFile(self, file):617        """Parse a document fragment from a file object, returning the618        fragment node."""619        return self.parseString(file.read())620 621    def parseString(self, string):622        """Parse a document fragment from a string, returning the623        fragment node."""624        self._source = string625        parser = self.getParser()626        doctype = self.originalDocument.doctype627        ident = ""628        if doctype:629            subset = doctype.internalSubset or self._getDeclarations()630            if doctype.publicId:631                ident = ('PUBLIC "%s" "%s"'632                         % (doctype.publicId, doctype.systemId))633            elif doctype.systemId:634                ident = 'SYSTEM "%s"' % doctype.systemId635        else:636            subset = ""637        nsattrs = self._getNSattrs() # get ns decls from node's ancestors638        document = _FRAGMENT_BUILDER_TEMPLATE % (ident, subset, nsattrs)639        try:640            parser.Parse(document, True)641        except:642            self.reset()643            raise644        fragment = self.fragment645        self.reset()646##         self._parser = None647        return fragment648 649    def _getDeclarations(self):650        """Re-create the internal subset from the DocumentType node.651 652        This is only needed if we don't already have the653        internalSubset as a string.654        """655        doctype = self.context.ownerDocument.doctype656        s = ""657        if doctype:658            for i in range(doctype.notations.length):659                notation = doctype.notations.item(i)660                if s:661                    s = s + "\n  "662                s = "%s<!NOTATION %s" % (s, notation.nodeName)663                if notation.publicId:664                    s = '%s PUBLIC "%s"\n             "%s">' \665                        % (s, notation.publicId, notation.systemId)666                else:667                    s = '%s SYSTEM "%s">' % (s, notation.systemId)668            for i in range(doctype.entities.length):669                entity = doctype.entities.item(i)670                if s:671                    s = s + "\n  "672                s = "%s<!ENTITY %s" % (s, entity.nodeName)673                if entity.publicId:674                    s = '%s PUBLIC "%s"\n             "%s"' \675                        % (s, entity.publicId, entity.systemId)676                elif entity.systemId:677                    s = '%s SYSTEM "%s"' % (s, entity.systemId)678                else:679                    s = '%s "%s"' % (s, entity.firstChild.data)680                if entity.notationName:681                    s = "%s NOTATION %s" % (s, entity.notationName)682                s = s + ">"683        return s684 685    def _getNSattrs(self):686        return ""687 688    def external_entity_ref_handler(self, context, base, systemId, publicId):689        if systemId == _FRAGMENT_BUILDER_INTERNAL_SYSTEM_ID:690            # this entref is the one that we made to put the subtree691            # in; all of our given input is parsed in here.692            old_document = self.document693            old_cur_node = self.curNode694            parser = self._parser.ExternalEntityParserCreate(context)695            # put the real document back, parse into the fragment to return696            self.document = self.originalDocument697            self.fragment = self.document.createDocumentFragment()698            self.curNode = self.fragment699            try:700                parser.Parse(self._source, True)701            finally:702                self.curNode = old_cur_node703                self.document = old_document704                self._source = None705            return -1706        else:707            return ExpatBuilder.external_entity_ref_handler(708                self, context, base, systemId, publicId)709 710 711class Namespaces:712    """Mix-in class for builders; adds support for namespaces."""713 714    def _initNamespaces(self):715        # list of (prefix, uri) ns declarations.  Namespace attrs are716        # constructed from this and added to the element's attrs.717        self._ns_ordered_prefixes = []718 719    def createParser(self):720        """Create a new namespace-handling parser."""721        parser = expat.ParserCreate(namespace_separator=" ")722        parser.namespace_prefixes = True723        return parser724 725    def install(self, parser):726        """Insert the namespace-handlers onto the parser."""727        ExpatBuilder.install(self, parser)728        if self._options.namespace_declarations:729            parser.StartNamespaceDeclHandler = (730                self.start_namespace_decl_handler)731 732    def start_namespace_decl_handler(self, prefix, uri):733        """Push this namespace declaration on our storage."""734        self._ns_ordered_prefixes.append((prefix, uri))735 736    def start_element_handler(self, name, attributes):737        if ' ' in name:738            uri, localname, prefix, qname = _parse_ns_name(self, name)739        else:740            uri = EMPTY_NAMESPACE741            qname = name742            localname = None743            prefix = EMPTY_PREFIX744        node = minidom.Element(qname, uri, prefix, localname)745        node.ownerDocument = self.document746        _append_child(self.curNode, node)747        self.curNode = node748 749        if self._ns_ordered_prefixes:750            for prefix, uri in self._ns_ordered_prefixes:751                if prefix:752                    a = minidom.Attr(_intern(self, 'xmlns:' + prefix),753                                     XMLNS_NAMESPACE, prefix, "xmlns")754                else:755                    a = minidom.Attr("xmlns", XMLNS_NAMESPACE,756                                     "xmlns", EMPTY_PREFIX)757                a.value = uri758                a.ownerDocument = self.document759                _set_attribute_node(node, a)760            del self._ns_ordered_prefixes[:]761 762        if attributes:763            node._ensure_attributes()764            _attrs = node._attrs765            _attrsNS = node._attrsNS766            for i in range(0, len(attributes), 2):767                aname = attributes[i]768                value = attributes[i+1]769                if ' ' in aname:770                    uri, localname, prefix, qname = _parse_ns_name(self, aname)771                    a = minidom.Attr(qname, uri, localname, prefix)772                    _attrs[qname] = a773                    _attrsNS[(uri, localname)] = a774                else:775                    a = minidom.Attr(aname, EMPTY_NAMESPACE,776                                     aname, EMPTY_PREFIX)777                    _attrs[aname] = a778                    _attrsNS[(EMPTY_NAMESPACE, aname)] = a779                a.ownerDocument = self.document780                a.value = value781                a.ownerElement = node782 783    if __debug__:784        # This only adds some asserts to the original785        # end_element_handler(), so we only define this when -O is not786        # used.  If changing one, be sure to check the other to see if787        # it needs to be changed as well.788        #789        def end_element_handler(self, name):790            curNode = self.curNode791            if ' ' in name:792                uri, localname, prefix, qname = _parse_ns_name(self, name)793                assert (curNode.namespaceURI == uri794                        and curNode.localName == localname795                        and curNode.prefix == prefix), \796                        "element stack messed up! (namespace)"797            else:798                assert curNode.nodeName == name, \799                       "element stack messed up - bad nodeName"800                assert curNode.namespaceURI == EMPTY_NAMESPACE, \801                       "element stack messed up - bad namespaceURI"802            self.curNode = curNode.parentNode803            self._finish_end_element(curNode)804 805 806class ExpatBuilderNS(Namespaces, ExpatBuilder):807    """Document builder that supports namespaces."""808 809    def reset(self):810        ExpatBuilder.reset(self)811        self._initNamespaces()812 813 814class FragmentBuilderNS(Namespaces, FragmentBuilder):815    """Fragment builder that supports namespaces."""816 817    def reset(self):818        FragmentBuilder.reset(self)819        self._initNamespaces()820 821    def _getNSattrs(self):822        """Return string of namespace attributes from this element and823        ancestors."""824        # XXX This needs to be re-written to walk the ancestors of the825        # context to build up the namespace information from826        # declarations, elements, and attributes found in context.827        # Otherwise we have to store a bunch more data on the DOM828        # (though that *might* be more reliable -- not clear).829        attrs = ""830        context = self.context831        L = []832        while context:833            if hasattr(context, '_ns_prefix_uri'):834                for prefix, uri in context._ns_prefix_uri.items():835                    # add every new NS decl from context to L and attrs string836                    if prefix in L:837                        continue838                    L.append(prefix)839                    if prefix:840                        declname = "xmlns:" + prefix841                    else:842                        declname = "xmlns"843                    if attrs:844                        attrs = "%s\n    %s='%s'" % (attrs, declname, uri)845                    else:846                        attrs = " %s='%s'" % (declname, uri)847            context = context.parentNode848        return attrs849 850 851class ParseEscape(Exception):852    """Exception raised to short-circuit parsing in InternalSubsetExtractor."""853    pass854 855class InternalSubsetExtractor(ExpatBuilder):856    """XML processor which can rip out the internal document type subset."""857 858    subset = None859 860    def getSubset(self):861        """Return the internal subset as a string."""862        return self.subset863 864    def parseFile(self, file):865        try:866            ExpatBuilder.parseFile(self, file)867        except ParseEscape:868            pass869 870    def parseString(self, string):871        try:872            ExpatBuilder.parseString(self, string)873        except ParseEscape:874            pass875 876    def install(self, parser):877        parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler878        parser.StartElementHandler = self.start_element_handler879 880    def start_doctype_decl_handler(self, name, publicId, systemId,881                                   has_internal_subset):882        if has_internal_subset:883            parser = self.getParser()884            self.subset = []885            parser.DefaultHandler = self.subset.append886            parser.EndDoctypeDeclHandler = self.end_doctype_decl_handler887        else:888            raise ParseEscape()889 890    def end_doctype_decl_handler(self):891        s = ''.join(self.subset).replace('\r\n', '\n').replace('\r', '\n')892        self.subset = s893        raise ParseEscape()894 895    def start_element_handler(self, name, attrs):896        raise ParseEscape()897 898 899def parse(file, namespaces=True):900    """Parse a document, returning the resulting Document node.901 902    'file' may be either a file name or an open file object.903    """904    if namespaces:905        builder = ExpatBuilderNS()906    else:907        builder = ExpatBuilder()908 909    if isinstance(file, str):910        with open(file, 'rb') as fp:911            result = builder.parseFile(fp)912    else:913        result = builder.parseFile(file)914    return result915 916 917def parseString(string, namespaces=True):918    """Parse a document from a string, returning the resulting919    Document node.920    """921    if namespaces:922        builder = ExpatBuilderNS()923    else:924        builder = ExpatBuilder()925    return builder.parseString(string)926 927 928def parseFragment(file, context, namespaces=True):929    """Parse a fragment of a document, given the context from which it930    was originally extracted.  context should be the parent of the931    node(s) which are in the fragment.932 933    'file' may be either a file name or an open file object.934    """935    if namespaces:936        builder = FragmentBuilderNS(context)937    else:938        builder = FragmentBuilder(context)939 940    if isinstance(file, str):941        with open(file, 'rb') as fp:942            result = builder.parseFile(fp)943    else:944        result = builder.parseFile(file)945    return result946 947 948def parseFragmentString(string, context, namespaces=True):949    """Parse a fragment of a document from a string, given the context950    from which it was originally extracted.  context should be the951    parent of the node(s) which are in the fragment.952    """953    if namespaces:954        builder = FragmentBuilderNS(context)955    else:956        builder = FragmentBuilder(context)957    return builder.parseString(string)958 959 960def makeBuilder(options):961    """Create a builder based on an Options object."""962    if options.namespaces:963        return ExpatBuilderNS(options)964    else:965        return ExpatBuilder(options)966