Paul Prescod <paul@prescod.net>:

W3C DOM implementation for Python.

2 files changed, 652 insertions, 0 deletions

diff --git a/Lib/xml/dom/minidom.py b/Lib/xml/dom/minidom.py
new file mode 100644
index 0000000..32d2d2b
--- /dev/null
+++ b/Lib/xml/dom/minidom.py
@@ -0,0 +1,385 @@
+import pulldom
+import string
+from StringIO import StringIO
+import types
+
+"""
+minidom.py -- a lightweight DOM implementation based on SAX.
+
+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
+"""
+
+class Node:
+    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
+
+    allnodes=[]
+
+    def __init__( self ):
+        self.childNodes=[]
+        Node.allnodes.append( repr( id( self ))+repr( self.__class__ ))
+
+    def __getattr__( self, key ):
+        if key[0:2]=="__": raise AttributeError
+        # getattr should never call getattr!
+        if self.__dict__.has_key("inGetAttr"): 
+            del self.inGetAttr
+            raise AttributeError, key
+
+        prefix,attrname=key[:5],key[5:]
+        if prefix=="_get_":
+            self.inGetAttr=1
+            if hasattr( self, attrname ): 
+                del self.inGetAttr
+                return (lambda self=self, attrname=attrname: 
+                                getattr( self, attrname ))
+            else:
+                del self.inGetAttr
+                raise AttributeError, key
+        else:
+            self.inGetAttr=1
+            try:
+                func = getattr( self, "_get_"+key )
+            except AttributeError:
+                raise AttributeError, key
+            del self.inGetAttr
+            return func()
+
+    def __nonzero__(self): return 1
+
+    def toxml( self ):
+        writer=StringIO()
+        self.writexml( writer )
+        return writer.getvalue()
+
+    def hasChildNodes( self ):
+        if self.childNodes: return 1
+        else: return 0
+
+    def insertBefore( self, newChild, refChild):
+        index=self.childNodes.index( refChild )
+        self.childNodes.insert( index, newChild )
+
+    def appendChild( self, node ):
+        self.childNodes.append( node )
+
+    def unlink( self ):
+        self.parentNode=None
+        while self.childNodes:
+            self.childNodes[-1].unlink()
+            del self.childNodes[-1] # probably not most efficient!
+        self.childNodes=None
+        if self.attributes:
+            for attr in self.attributes.values():
+                attr.unlink()
+        self.attributes=None
+        index=Node.allnodes.index( repr( id( self ))+repr( self.__class__ ))
+        del Node.allnodes[index]
+
+def _write_data( writer, data):
+    "Writes datachars to writer."
+    data=string.replace(data,"&","&")
+    data=string.replace(data,"<","&lt;")
+    data=string.replace(data,"\"","&quot;")
+    data=string.replace(data,">","&gt;")
+    writer.write(data)
+
+def _closeElement( element ):
+    del element.parentNode
+    for node in element.elements:
+        _closeElement( node )
+
+def _getElementsByTagNameHelper( parent, name, rc ):
+    for node in parent.childNodes:
+        if node.nodeType==Node.ELEMENT_NODE and\
+            (name=="*" or node.tagName==name):
+            rc.append( node )
+        _getElementsByTagNameHelper( node, name, rc )
+    return rc
+
+def _getElementsByTagNameNSHelper( parent, nsURI, localName, rc ):
+    for node in parent.childNodes:
+        if (node.nodeType==Node.ELEMENT_NODE ):
+            if ((localName=="*" or node.tagName==localName) and
+            (nsURI=="*" or node.namespaceURI==nsURI)):
+                rc.append( node )
+            _getElementsByTagNameNSHelper( node, name, rc )
+
+class Attr(Node):
+    nodeType=Node.ATTRIBUTE_NODE
+    def __init__( self, qName, namespaceURI="", prefix="",
+                  localName=None ):
+        Node.__init__( self )
+        assert qName
+        # skip setattr for performance
+        self.__dict__["nodeName"] = self.__dict__["name"] = qName
+        self.__dict__["localName"]=localName or qName
+        self.__dict__["prefix"]=prefix
+        self.__dict__["namespaceURI"]=namespaceURI
+        # nodeValue and value are set elsewhere
+        self.attributes=None
+
+    def __setattr__( self, name, value ):
+        if name in ("value", "nodeValue" ):
+            self.__dict__["value"]=self.__dict__["nodeValue"]=value
+        else:
+            self.__dict__[name]=value
+
+class AttributeList:
+    # the attribute list is a transient interface to the underlying dictionaries
+    # mutations here will change the underlying element's dictionary
+    def __init__( self, attrs, attrsNS ):
+        self.__attrs=attrs
+        self.__attrsNS=attrs
+        self.length=len( self.__attrs.keys() )
+
+    def item( self, index ):
+        try:
+            return self[self.keys()[index]]
+        except IndexError:
+            return None
+        
+    def items( self ):
+        return map( lambda node: (node.tagName, node.value),
+                    self.__attrs.values() )
+
+    def itemsNS( self ):
+        return map( lambda node: ((node.URI, node.localName), node.value),
+                    self.__attrs.values() )
+    
+    def keys( self ):
+        return self.__attrs.keys()
+
+    def keysNS( self ):
+        return self.__attrsNS.keys()
+
+    def values( self ):
+        return self.__attrs.values()
+
+    def __len__( self ):
+        return self.length
+
+    def __cmp__( self, other ):
+        if self.__attrs is other.__attrs: 
+            return 0
+        else: 
+            return cmp( id( self ), id( other ) )
+
+    #FIXME: is it appropriate to return .value?
+    def __getitem__( self, attname_or_tuple ):
+        if type( attname_or_tuple ) == type( (1,2) ):
+            return self.__attrsNS[attname_or_tuple].value
+        else:
+            return self.__attrs[attname_or_tuple].value
+
+    def __setitem__( self, attname ):
+        raise TypeError, "object does not support item assignment"
+        
+class Element( Node ):
+    nodeType=Node.ELEMENT_NODE
+    def __init__( self, tagName, namespaceURI="", prefix="",
+                  localName=None ):
+        Node.__init__( self )
+        self.tagName = self.nodeName = tagName
+        self.localName=localName or tagName
+        self.prefix=prefix
+        self.namespaceURI=namespaceURI
+        self.nodeValue=None
+
+        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 getAttribute( self, attname ):
+        return self.__attrs[attname].value
+
+    def getAttributeNS( self, namespaceURI, localName ):
+        return self.__attrsNS[(namespaceURI, localName)].value
+    
+    def setAttribute( self, attname, value ):
+        attr=Attr( attname )
+        # for performance
+        attr.__dict__["value"]=attr.__dict__["nodeValue"]=value
+        self.setAttributeNode( attr )
+
+    def setAttributeNS( self, namespaceURI, qualifiedName, value ):
+        attr=createAttributeNS( namespaceURI, qualifiedName )
+        # for performance
+        attr.__dict__["value"]=attr.__dict__["nodeValue"]=value
+        self.setAttributeNode( attr )
+
+    def setAttributeNode( self, attr ):
+        self.__attrs[attr.name]=attr
+        self.__attrsNS[(attr.namespaceURI,attr.localName)]=attr
+
+    def removeAttribute( self, name ):
+        attr = self.__attrs[name]
+        self.removeAttributeNode( attr )
+
+    def removeAttributeNS( self, namespaceURI, localName ):
+        attr = self.__attrsNS[(uri, localName)]
+        self.removeAttributeNode( attr )
+
+    def removeAttributeNode( self, node ):
+        del self.__attrs[node.name]
+        del self.__attrsNS[(node.namespaceURI, node.localName)]
+        
+    def getElementsByTagName( self, name ):
+        return _getElementsByTagNameHelper( self, name, [] )
+
+    def getElementsByTagNameNS(self,namespaceURI,localName):
+        _getElementsByTagNameNSHelper( self, namespaceURI, localName, [] )
+
+    def __repr__( self ):
+        return "<DOM Element:"+self.tagName+" at "+`id( self )` +" >"
+
+    def writexml(self, writer):
+        writer.write("<"+self.tagName)
+            
+        a_names=self._get_attributes().keys()
+        a_names.sort()
+
+        for a_name in a_names:
+            writer.write(" "+a_name+"=\"")
+            _write_data(writer, self._get_attributes()[a_name])
+            writer.write("\"")
+        if self.childNodes:
+            writer.write(">")
+            for node in self.childNodes:
+                node.writexml( writer )
+            writer.write("</"+self.tagName+">")
+        else:
+            writer.write("/>")
+
+    def _get_attributes( self ):
+        return AttributeList( self.__attrs, self.__attrsNS )
+
+class Comment( Node ):
+    nodeType=Node.COMMENT_NODE
+    def __init__(self, data ):
+        Node.__init__( self )
+        self.data=self.nodeValue=data
+        self.nodeName="#comment"
+        self.attributes=None
+
+    def writexml( self, writer ):
+        writer.write( "<!--" + self.data + "-->" )
+
+class ProcessingInstruction( Node ):
+    nodeType=Node.PROCESSING_INSTRUCTION_NODE
+    def __init__(self, target, data ):
+        Node.__init__( self )
+        self.target = self.nodeName = target
+        self.data = self.nodeValue = data
+        self.attributes=None
+
+    def writexml( self, writer ):
+        writer.write( "<?" + self.target +" " + self.data+ "?>" )
+
+class Text( Node ):
+    nodeType=Node.TEXT_NODE
+    nodeName="#text"
+    def __init__(self, data ):
+        Node.__init__( self )
+        self.data = self.nodeValue = data
+        self.attributes=None
+
+    def __repr__(self):
+        if len( self.data )> 10:
+            dotdotdot="..."
+        else:
+            dotdotdot=""
+        return "<DOM Text node \"" + self.data[0:10] + dotdotdot+"\">"
+
+    def writexml( self, writer ):
+        _write_data( writer, self.data )
+
+class Document( Node ):
+    nodeType=Node.DOCUMENT_NODE
+    def __init__( self ):
+        Node.__init__( self )
+        self.documentElement=None
+        self.attributes=None
+        self.nodeName="#document"
+        self.nodeValue=None
+
+    createElement=Element
+
+    createTextNode=Text
+
+    createComment=Comment
+
+    createProcessingInstruction=ProcessingInstruction
+
+    createAttribute=Attr
+
+    def createElementNS(self, namespaceURI, qualifiedName):
+        fields = string.split(qualifiedName, ':')
+        if len(fields) == 2:
+            prefix = fields[0]
+            localName = fields[1]
+        elif len(fields) == 1:
+            prefix = ''
+            localName = fields[0]            
+        return Element(self, qualifiedName, namespaceURI, prefix, localName)
+
+    def createAttributeNS(self, namespaceURI, qualifiedName):
+        fields = string.split(qualifiedName,':')
+        if len(fields) == 2:
+            localName = fields[1]
+            prefix = fields[0]
+        elif len(fields) == 1:
+            localName = fields[0]
+            prefix = None
+        return Attr(qualifiedName, namespaceURI, prefix, localName)
+
+    def getElementsByTagNameNS(self,namespaceURI,localName):
+        _getElementsByTagNameNSHelper( self, namespaceURI, localName )
+
+    def close( self ):
+        for node in self.elements:
+            _closeElement( node )
+
+    def unlink( self ):
+        self.documentElement=None
+        Node.unlink( self )
+
+    def getElementsByTagName( self, name ):
+        rc=[]
+        _getElementsByTagNameHelper( self, name, rc )
+        return rc
+
+    def writexml( self, writer ):
+        for node in self.childNodes:
+            node.writexml( writer )
+
+def _doparse( func, args, kwargs ):
+    events=apply( func, args, kwargs )
+    (toktype, rootNode)=events.getEvent()
+    events.expandNode( rootNode )
+    return rootNode
+
+def parse( *args, **kwargs ):
+    return _doparse( pulldom.parse, args, kwargs )
+
+def parseString( *args, **kwargs ):
+    return _doparse( pulldom.parseString, args, kwargs )
diff --git a/Lib/xml/dom/pulldom.py b/Lib/xml/dom/pulldom.py
new file mode 100644
index 0000000..9c85646
--- /dev/null
+++ b/Lib/xml/dom/pulldom.py
@@ -0,0 +1,267 @@
+import minidom
+import types
+import string
+import sys
+import pyexpat
+from xml.sax import ExpatParser
+
+#todo: SAX2/namespace handling
+
+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:
+    def __init__( self ):
+        self.firstEvent=[None,None]
+        self.lastEvent=self.firstEvent
+
+    def setDocumentLocator( self, locator ): pass
+
+    def startElement( self, tagName , attrs  ):
+        if not hasattr( self, "curNode" ):
+            # FIXME: hack!
+            self.startDocument( )
+
+        node = self.document.createElement( tagName ) #FIXME namespaces!
+        for attr in attrs.keys():
+            node.setAttribute( attr, attrs[attr] )
+        
+        parent=self.curNode
+        node.parentNode = parent
+        if parent.childNodes:
+            node.previousSibling=parent.childNodes[-1]
+            node.previousSibling.nextSibling=node
+        self.curNode = node
+        # FIXME: do I have to screen namespace attributes
+        self.lastEvent[1]=[(START_ELEMENT, node), None ]
+        self.lastEvent=self.lastEvent[1]
+        #self.events.append( (START_ELEMENT, node) )
+
+    def endElement( self, name ):
+        node = self.curNode
+        self.lastEvent[1]=[(END_ELEMENT, node), None ]
+        self.lastEvent=self.lastEvent[1]
+        #self.events.append( (END_ELEMENT, node ))
+        self.curNode = node.parentNode
+
+    def comment( self, s):
+        node = self.document.createComment ( s )
+        parent=self.curNode
+        node.parentNode=parent
+        if parent.childNodes:
+            node.previousSibling=parent.childNodes[-1]
+            node.previousSibling.nextSibling=node
+        self.lastEvent[1]=[(COMMENT, node), None ]
+        self.lastEvent=self.lastEvent[1]
+        #self.events.append( (COMMENT, node ))
+
+    def processingInstruction( self, target, data ):
+        node = self.document.createProcessingInstruction( target, data )
+        #self.appendChild( node )
+        
+        parent=self.curNode
+        node.parentNode=parent
+        if parent.childNodes:
+            node.previousSibling=parent.childNodes[-1]
+            node.previousSibling.nextSibling=node
+        self.lastEvent[1]=[(PROCESSING_INSTRUCTION, node), None ]
+        self.lastEvent=self.lastEvent[1]
+        #self.events.append( (PROCESSING_INSTRUCTION, node) )
+
+    def ignorableWhitespace( self, chars ):
+        node = self.document.createTextNode( chars[start:start+length] )
+        parent=self.curNode
+        node.parentNode=parent
+        if parent.childNodes:
+            node.previousSibling=parent.childNodes[-1]
+            node.previousSibling.nextSibling=node
+        self.lastEvent[1]=[(IGNORABLE_WHITESPACE, node), None ]
+        self.lastEvent=self.lastEvent[1]
+        #self.events.append( (IGNORABLE_WHITESPACE, node))
+
+    def characters( self, chars ):
+        node = self.document.createTextNode( chars )
+        node.parentNode=self.curNode
+        self.lastEvent[1]=[(CHARACTERS, node), None ]
+        self.lastEvent=self.lastEvent[1]
+
+    def startDocument( self ):
+        node = self.curNode = self.document = minidom.Document()
+        node.parentNode=None
+        self.lastEvent[1]=[(START_DOCUMENT, node), None ]
+        self.lastEvent=self.lastEvent[1]
+        #self.events.append( (START_DOCUMENT, node) )
+            
+    def endDocument( self ):
+        assert( not self.curNode.parentNode )
+        for node in self.curNode.childNodes:
+                if node.nodeType==node.ELEMENT_NODE:
+                        self.document.documentElement = node
+        #if not self.document.documentElement:
+        #        raise Error, "No document element"
+
+        self.lastEvent[1]=[(END_DOCUMENT, node), None ]
+        #self.events.append( (END_DOCUMENT, self.curNode) )
+
+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
+        self.reset()
+
+    def reset( self ):
+        self.pulldom = PullDOM()
+        self.parser.setContentHandler( self.pulldom )
+
+    def __getitem__( self, pos ):
+        rc=self.getEvent()
+        if rc: return rc
+        raise IndexError
+
+    def expandNode( self, node ):
+        event=self.getEvent()
+        while event:
+            token,cur_node=event
+            if cur_node is node: return
+            
+            if token !=END_ELEMENT:
+                cur_node.parentNode.childNodes.append( cur_node )
+            event=self.getEvent()
+        if node.nodeType==minidom.Node.DOCUMENT_NODE:
+            for child in node.childNodes:
+                if child.nodeType==minidom.Node.ELEMENT_NODE:
+                    node.documentElement=child
+
+    def getEvent( self ):
+        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:
+                #FIXME: why doesn't Expat close work?
+                #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
+
+# FIXME: sax2
+#def _getParser( ):
+ #   from xml.sax.saxexts import make_parser
+    # expat doesn't report errors properly! Figure it out
+  #  return make_parser()
+   # return make_parser("xml.sax.drivers.drv_xmllib")
+
+
+        
+def _getParser():
+     return ExpatParser()
+
+default_bufsize=(2**14)-20
+# FIXME: move into sax package for common usage
+def parse( stream_or_string, parser=None, bufsize=default_bufsize ):
+    if type( stream_or_string ) == type( "" ):
+        stream=open( stream_or_string )
+    else:
+        stream=stream_or_string
+    if not parser: 
+        parser=_getParser()
+    return DOMEventStream( stream, parser, bufsize )
+
+def parseString( string, parser=None ):
+    try:
+        import cStringIO
+        stringio=cStringIO.StringIO
+    except ImportError:
+        import StringIO
+        stringio=StringIO.StringIO
+        
+    bufsize=len( string )
+    stringio( string )
+    parser=_getParser()
+    return DOMEventStream( buf, parser, bufsize )
+
+#FIXME: Use Lars' instead!!!
+class SAX_expat:
+    "SAX driver for the Pyexpat C module."
+
+    def __init__(self):
+        self.parser=pyexpat.ParserCreate()
+        self.started=0
+
+    def setDocumentHandler( self, handler ):
+        self.parser.StartElementHandler = handler.startElement
+        self.parser.EndElementHandler = handler.endElement
+        self.parser.CharacterDataHandler = handler.datachars
+        self.parser.ProcessingInstructionHandler = handler.processingInstruction
+        self.doc_handler=handler
+
+    def setErrorHandler( self, handler ):
+        self.err_handler=handler
+
+    # --- Locator methods. Only usable after errors.
+
+    def getLineNumber(self):
+        return self.parser.ErrorLineNumber
+
+    def getColumnNumber(self):
+        return self.parser.ErrorColumnNumber    
+
+    # --- Internal
+
+    def __report_error(self):
+        msg=pyexpat.ErrorString(self.parser.ErrorCode)
+        self.err_handler.fatalError(msg)
+
+    # --- EXPERIMENTAL PYTHON SAX EXTENSIONS
+        
+    def get_parser_name(self):
+        return "pyexpat"
+
+    def get_parser_version(self):
+        return "Unknown"
+
+    def get_driver_version(self):
+        return version
+    
+    def is_validating(self):
+        return 0
+
+    def is_dtd_reading(self):
+        return 0
+
+    def reset(self):
+        self.parser=pyexpat.ParserCreate()
+        self.parser.StartElementHandler = self.startElement
+        self.parser.EndElementHandler = self.endElement
+        self.parser.CharacterDataHandler = self.characters
+        self.parser.ProcessingInstructionHandler = self.processingInstruction
+    
+    def feed(self,data):
+        if not self.started:
+            self.doc_handler.startDocument()
+            self.started=1  
+        if not self.parser.Parse(data):
+            self.__report_error()
+
+    def close(self):
+        if not self.parser.Parse("",1):
+            self.__report_error()
+        self.doc_handler.endDocument()
+        self.parser = None