Paul Prescod <paul@prescod.net>:
W3C DOM implementation for Python.
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,"<","<")
+ data=string.replace(data,"\"",""")
+ data=string.replace(data,">",">")
+ 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