1 import xml.sax

     2 import xml.sax.handler

     3 import types

     4 

     5 try:

     6     _StringTypes = [types.StringType, types.UnicodeType]

     7 except AttributeError:

     8     _StringTypes = [types.StringType]

     9 

    10 START_ELEMENT = "START_ELEMENT"

    11 END_ELEMENT = "END_ELEMENT"

    12 COMMENT = "COMMENT"

    13 START_DOCUMENT = "START_DOCUMENT"

    14 END_DOCUMENT = "END_DOCUMENT"

    15 PROCESSING_INSTRUCTION = "PROCESSING_INSTRUCTION"

    16 IGNORABLE_WHITESPACE = "IGNORABLE_WHITESPACE"

    17 CHARACTERS = "CHARACTERS"

    18 

    19 class PullDOM(xml.sax.ContentHandler):

    20     _locator = None

    21     document = None

    22 

    23     def __init__(self, documentFactory=None):

    24         from xml.dom import XML_NAMESPACE

    25         self.documentFactory = documentFactory

    26         self.firstEvent = [None, None]

    27         self.lastEvent = self.firstEvent

    28         self.elementStack = []

    29         self.push = self.elementStack.append

    30         try:

    31             self.pop = self.elementStack.pop

    32         except AttributeError:

    33             # use class' pop instead

    34             pass

    35         self._ns_contexts = [{XML_NAMESPACE:'xml'}] # contains uri -> prefix dicts

    36         self._current_context = self._ns_contexts[-1]

    37         self.pending_events = []

    38 

    39     def pop(self):

    40         result = self.elementStack[-1]

    41         del self.elementStack[-1]

    42         return result

    43 

    44     def setDocumentLocator(self, locator):

    45         self._locator = locator

    46 

    47     def startPrefixMapping(self, prefix, uri):

    48         if not hasattr(self, '_xmlns_attrs'):

    49             self._xmlns_attrs = []

    50         self._xmlns_attrs.append((prefix or 'xmlns', uri))

    51         self._ns_contexts.append(self._current_context.copy())

    52         self._current_context[uri] = prefix or None

    53 

    54     def endPrefixMapping(self, prefix):

    55         self._current_context = self._ns_contexts.pop()

    56 

    57     def startElementNS(self, name, tagName , attrs):

    58         # Retrieve xml namespace declaration attributes.

    59         xmlns_uri = 'http://www.w3.org/2000/xmlns/'

    60         xmlns_attrs = getattr(self, '_xmlns_attrs', None)

    61         if xmlns_attrs is not None:

    62             for aname, value in xmlns_attrs:

    63                 attrs._attrs[(xmlns_uri, aname)] = value

    64             self._xmlns_attrs = []

    65         uri, localname = name

    66         if uri:

    67             # When using namespaces, the reader may or may not

    68             # provide us with the original name. If not, create

    69             # *a* valid tagName from the current context.

    70             if tagName is None:

    71                 prefix = self._current_context[uri]

    72                 if prefix:

    73                     tagName = prefix + ":" + localname

    74                 else:

    75                     tagName = localname

    76             if self.document:

    77                 node = self.document.createElementNS(uri, tagName)

    78             else:

    79                 node = self.buildDocument(uri, tagName)

    80         else:

    81             # When the tagname is not prefixed, it just appears as

    82             # localname

    83             if self.document:

    84                 node = self.document.createElement(localname)

    85             else:

    86                 node = self.buildDocument(None, localname)

    87 

    88         for aname,value in attrs.items():

    89             a_uri, a_localname = aname

    90             if a_uri == xmlns_uri:

    91                 if a_localname == 'xmlns':

    92                     qname = a_localname

    93                 else:

    94                     qname = 'xmlns:' + a_localname

    95                 attr = self.document.createAttributeNS(a_uri, qname)

    96                 node.setAttributeNodeNS(attr)

    97             elif a_uri:

    98                 prefix = self._current_context[a_uri]

    99                 if prefix:

   100                     qname = prefix + ":" + a_localname

   101                 else:

   102                     qname = a_localname

   103                 attr = self.document.createAttributeNS(a_uri, qname)

   104                 node.setAttributeNodeNS(attr)

   105             else:

   106                 attr = self.document.createAttribute(a_localname)

   107                 node.setAttributeNode(attr)

   108             attr.value = value

   109 

   110         self.lastEvent[1] = [(START_ELEMENT, node), None]

   111         self.lastEvent = self.lastEvent[1]

   112         self.push(node)

   113 

   114     def endElementNS(self, name, tagName):

   115         self.lastEvent[1] = [(END_ELEMENT, self.pop()), None]

   116         self.lastEvent = self.lastEvent[1]

   117 

   118     def startElement(self, name, attrs):

   119         if self.document:

   120             node = self.document.createElement(name)

   121         else:

   122             node = self.buildDocument(None, name)

   123 

   124         for aname,value in attrs.items():

   125             attr = self.document.createAttribute(aname)

   126             attr.value = value

   127             node.setAttributeNode(attr)

   128 

   129         self.lastEvent[1] = [(START_ELEMENT, node), None]

   130         self.lastEvent = self.lastEvent[1]

   131         self.push(node)

   132 

   133     def endElement(self, name):

   134         self.lastEvent[1] = [(END_ELEMENT, self.pop()), None]

   135         self.lastEvent = self.lastEvent[1]

   136 

   137     def comment(self, s):

   138         if self.document:

   139             node = self.document.createComment(s)

   140             self.lastEvent[1] = [(COMMENT, node), None]

   141             self.lastEvent = self.lastEvent[1]

   142         else:

   143             event = [(COMMENT, s), None]

   144             self.pending_events.append(event)

   145 

   146     def processingInstruction(self, target, data):

   147         if self.document:

   148             node = self.document.createProcessingInstruction(target, data)

   149             self.lastEvent[1] = [(PROCESSING_INSTRUCTION, node), None]

   150             self.lastEvent = self.lastEvent[1]

   151         else:

   152             event = [(PROCESSING_INSTRUCTION, target, data), None]

   153             self.pending_events.append(event)

   154 

   155     def ignorableWhitespace(self, chars):

   156         node = self.document.createTextNode(chars)

   157         self.lastEvent[1] = [(IGNORABLE_WHITESPACE, node), None]

   158         self.lastEvent = self.lastEvent[1]

   159 

   160     def characters(self, chars):

   161         node = self.document.createTextNode(chars)

   162         self.lastEvent[1] = [(CHARACTERS, node), None]

   163         self.lastEvent = self.lastEvent[1]

   164 

   165     def startDocument(self):

   166         if self.documentFactory is None:

   167             import xml.dom.minidom

   168             self.documentFactory = xml.dom.minidom.Document.implementation

   169 

   170     def buildDocument(self, uri, tagname):

   171         # Can't do that in startDocument, since we need the tagname

   172         # XXX: obtain DocumentType

   173         node = self.documentFactory.createDocument(uri, tagname, None)

   174         self.document = node

   175         self.lastEvent[1] = [(START_DOCUMENT, node), None]

   176         self.lastEvent = self.lastEvent[1]

   177         self.push(node)

   178         # Put everything we have seen so far into the document

   179         for e in self.pending_events:

   180             if e[0][0] == PROCESSING_INSTRUCTION:

   181                 _,target,data = e[0]

   182                 n = self.document.createProcessingInstruction(target, data)

   183                 e[0] = (PROCESSING_INSTRUCTION, n)

   184             elif e[0][0] == COMMENT:

   185                 n = self.document.createComment(e[0][1])

   186                 e[0] = (COMMENT, n)

   187             else:

   188                 raise AssertionError("Unknown pending event ",e[0][0])

   189             self.lastEvent[1] = e

   190             self.lastEvent = e

   191         self.pending_events = None

   192         return node.firstChild

   193 

   194     def endDocument(self):

   195         self.lastEvent[1] = [(END_DOCUMENT, self.document), None]

   196         self.pop()

   197 

   198     def clear(self):

   199         "clear(): Explicitly release parsing structures"

   200         self.document = None

   201 

   202 class ErrorHandler:

   203     def warning(self, exception):

   204         print exception

   205     def error(self, exception):

   206         raise exception

   207     def fatalError(self, exception):

   208         raise exception

   209 

   210 class DOMEventStream:

   211     def __init__(self, stream, parser, bufsize):

   212         self.stream = stream

   213         self.parser = parser

   214         self.bufsize = bufsize

   215         if not hasattr(self.parser, 'feed'):

   216             self.getEvent = self._slurp

   217         self.reset()

   218 

   219     def reset(self):

   220         self.pulldom = PullDOM()

   221         # This content handler relies on namespace support

   222         self.parser.setFeature(xml.sax.handler.feature_namespaces, 1)

   223         self.parser.setContentHandler(self.pulldom)

   224 

   225     def __getitem__(self, pos):

   226         rc = self.getEvent()

   227         if rc:

   228             return rc

   229         raise IndexError

   230 

   231     def next(self):

   232         rc = self.getEvent()

   233         if rc:

   234             return rc

   235         raise StopIteration

   236 

   237     def __iter__(self):

   238         return self

   239 

   240     def expandNode(self, node):

   241         event = self.getEvent()

   242         parents = [node]

   243         while event:

   244             token, cur_node = event

   245             if cur_node is node:

   246                 return

   247             if token != END_ELEMENT:

   248                 parents[-1].appendChild(cur_node)

   249             if token == START_ELEMENT:

   250                 parents.append(cur_node)

   251             elif token == END_ELEMENT:

   252                 del parents[-1]

   253             event = self.getEvent()

   254 

   255     def getEvent(self):

   256         # use IncrementalParser interface, so we get the desired

   257         # pull effect

   258         if not self.pulldom.firstEvent[1]:

   259             self.pulldom.lastEvent = self.pulldom.firstEvent

   260         while not self.pulldom.firstEvent[1]:

   261             buf = self.stream.read(self.bufsize)

   262             if not buf:

   263                 self.parser.close()

   264                 return None

   265             self.parser.feed(buf)

   266         rc = self.pulldom.firstEvent[1][0]

   267         self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]

   268         return rc

   269 

   270     def _slurp(self):

   271         """ Fallback replacement for getEvent() using the

   272             standard SAX2 interface, which means we slurp the

   273             SAX events into memory (no performance gain, but

   274             we are compatible to all SAX parsers).

   275         """

   276         self.parser.parse(self.stream)

   277         self.getEvent = self._emit

   278         return self._emit()

   279 

   280     def _emit(self):

   281         """ Fallback replacement for getEvent() that emits

   282             the events that _slurp() read previously.

   283         """

   284         rc = self.pulldom.firstEvent[1][0]

   285         self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]

   286         return rc

   287 

   288     def clear(self):

   289         """clear(): Explicitly release parsing objects"""

   290         self.pulldom.clear()

   291         del self.pulldom

   292         self.parser = None

   293         self.stream = None

   294 

   295 class SAX2DOM(PullDOM):

   296 

   297     def startElementNS(self, name, tagName , attrs):

   298         PullDOM.startElementNS(self, name, tagName, attrs)

   299         curNode = self.elementStack[-1]

   300         parentNode = self.elementStack[-2]

   301         parentNode.appendChild(curNode)

   302 

   303     def startElement(self, name, attrs):

   304         PullDOM.startElement(self, name, attrs)

   305         curNode = self.elementStack[-1]

   306         parentNode = self.elementStack[-2]

   307         parentNode.appendChild(curNode)

   308 

   309     def processingInstruction(self, target, data):

   310         PullDOM.processingInstruction(self, target, data)

   311         node = self.lastEvent[0][1]

   312         parentNode = self.elementStack[-1]

   313         parentNode.appendChild(node)

   314 

   315     def ignorableWhitespace(self, chars):

   316         PullDOM.ignorableWhitespace(self, chars)

   317         node = self.lastEvent[0][1]

   318         parentNode = self.elementStack[-1]

   319         parentNode.appendChild(node)

   320 

   321     def characters(self, chars):

   322         PullDOM.characters(self, chars)

   323         node = self.lastEvent[0][1]

   324         parentNode = self.elementStack[-1]

   325         parentNode.appendChild(node)

   326 

   327 

   328 default_bufsize = (2 ** 14) - 20

   329 

   330 def parse(stream_or_string, parser=None, bufsize=None):

   331     if bufsize is None:

   332         bufsize = default_bufsize

   333     if type(stream_or_string) in _StringTypes:

   334         stream = open(stream_or_string)

   335     else:

   336         stream = stream_or_string

   337     if not parser:

   338         parser = xml.sax.make_parser()

   339     return DOMEventStream(stream, parser, bufsize)

   340 

   341 def parseString(string, parser=None):

   342     try:

   343         from cStringIO import StringIO

   344     except ImportError:

   345         from StringIO import StringIO

   346 

   347     bufsize = len(string)

   348     buf = StringIO(string)

   349     if not parser:

   350         parser = xml.sax.make_parser()

   351     return DOMEventStream(buf, parser, bufsize)