Building a tree from SAX events

First of all, lxml has support for building a new tree given SAX events. To do this, we use the special SAX content handler defined by lxml named lxml.sax.ElementTreeContentHandler:

>>> import lxml.sax
>>> handler = lxml.sax.ElementTreeContentHandler()

Now let's fire some SAX events at it:

>>> handler.startElementNS((None, 'a'), 'a', {})
>>> handler.startElementNS((None, 'b'), 'b', {(None, 'foo'): 'bar'})
>>> handler.characters('Hello world')
>>> handler.endElementNS((None, 'b'), 'b')
>>> handler.endElementNS((None, 'a'), 'a')

This constructs an equivalent tree. You can access it through the etree property of the handler:

>>> tree = handler.etree
>>> lxml.etree.tostring(tree.getroot())
'<a><b foo="bar">Hello world</b></a>'

By passing a makeelement function the constructor of ElementTreeContentHandler, e.g. the one of a parser you configured, you can determine which element class lookup scheme should be used.

Producing SAX events from an ElementTree or Element

Let's make a tree we can generate SAX events for:

>>> from StringIO import StringIO
>>> f = StringIO('<a><b>Text</b></a>')
>>> tree = lxml.etree.parse(f)

To see whether the correct SAX events are produced, we'll write a custom content handler.:

>>> from xml.sax.handler import ContentHandler
>>> class MyContentHandler(ContentHandler):
...     def __init__(self):
...         self.a_amount = 0
...         self.b_amount = 0
...         self.text = None
...
...     def startElementNS(self, name, qname, attributes):
...         uri, localname = name
...         if localname == 'a':
...             self.a_amount += 1
...         if localname == 'b':
...             self.b_amount += 1
...
...     def characters(self, data):
...         self.text = data

Note that it only defines the startElementNS() method and not startElement(). The SAX event generator in lxml.sax currently only supports namespace-aware processing.

To test the content handler, we can produce SAX events from the tree:

>>> handler = MyContentHandler()
>>> lxml.sax.saxify(tree, handler)

This is what we expect:

>>> handler.a_amount
1
>>> handler.b_amount
1
>>> handler.text
'Text'

Interfacing with pulldom/minidom

lxml.sax is a simple way to interface with the standard XML support in the Python library. Note, however, that this is a one-way solution, as Python's DOM implementation connot generate SAX events from a DOM tree.

You can use xml.dom.pulldom to build a minidom from lxml:

>>> from xml.dom.pulldom import SAX2DOM
>>> handler = SAX2DOM()
>>> lxml.sax.saxify(tree, handler)

PullDOM makes the result available through the document attribute:

>>> dom = handler.document
>>> print dom.firstChild.localName
a