Francesco Garelli Department of Information Engineering
University of Padua - Italy
The XML language is becoming quickly an important protocol to exchange information and services in wide-area networks. Unfortunately popular solutions to manage XML  documents seem to be little suitable. Technologies, such as DOM  and SAX , have proven to be effective for short and simple documents but they are really complex when documents size and variety is pretty large. XML data binding is a new approach that looks very promising. Through the data binding, any XML document is translated to an internal data of the programming language the application is developed with. As a result, the developer doesn't treat XML, but a corresponding representation in the environment he has chosen for his application.
This paper describes a XML data binding technology for Python, namely Satine XML data binding. The solution we propose takes benefit from Python weak types and it is definitely simpler than similar approaches in the Java  or .NET environments .
Emerging distributed middlewares aim to provide large interoperability
among applications spread over wide-area networks, in particular over
the Internet. The standard candidate protocols the industry is relying
on, are based on XML dialects, such as SOAP or WSDL.
At the same time, most recent applications choose XML as data format to define their documents and configuration parameters. This growing interest needs easy and effective ways to treat XML.
As the XML language has been available since some years, many techniques to manage the documents have been developed. The most used ones are probably the SAX and DOM interfaces that are uniform among different development environments and programming languages. This consistency is desirable because it cuts down the effort when a developer deals with different platforms. Unfortunately well-known solutions impose a complex interface that, although tolerable when documents are few and small, is time expensive to be used, when applications save most of their data in XML.
Among the new approaches to face this problem, a very interesting one is XML data binding. Data binding is a technique that translates a document to a simple data structure in the application programming language. The translation is quite automatic and needs a minimal support.
As a result, the programmer has not to deal with the call-back parsing from SAX or with the complex structure of a DOM tree, but only with objects and methods of his favorite language. An appropriate library attends to the conversion: the library depends on the XML dialect and it is often produced from a XML schema without any effort.
XML data binding techniques for Java  and .NET  are under development. We propose an analogous technique for Python. In our experience, the Python environment has proved to be ideal: the data binding is easy and it doesn't necessarily depend on a XML schema.
In order to test our approach, we developed a very simple web server that accepts both SOAP and usual HTTP requests.
XML documents are composed by XML elements. Each XML element is an information
that is difficult to describe in usual programming languages. In fact
a XML element has named attributes like objects, but it has also items
like lists. Moreover a XML element has a type identifier, the tag, and
a namespace. No Python native type shows all those properties. This assumption
suggests to introduce a new type with the required features. In our project
we defined a new type we named xlist. An xlist inherits
from the native type list the capability of containing items and
its methods such as append, remove, index.
Unlike its parent, a xlist support named attributes. An example definition might be as follows:
import satine #import the extension
l = xlist() #define the xlist
l.append("hello world") #insert an item
l.language = "english" #add an attribute
Interestingly, at line 6 object l behaves like a Python list and accepts a new item to be added. Indeed at line 7, l accepts a new attribute like a normal Python object does. An other relevant difference between xlists and lists is their representation as string. The representation of the xlist shows both the items that come from its base type list, and its attributes. Figure 2 shows the representation for the object l defined in previous example.
Evidently, this representation suggests a natural binding between a XML element and a xlist: element attributes correspond to xlist attributes and nested items correspond to xlist items. Unfortunately this binding is not complete because it is valid only when the prefix and the tag are respectively satine and xlist. Of course usual XML documents allow elements from any namespace and with any tag.
A trivial solution is to define some special attributes,
tag, prefix and uri, that complete the binding
for each xlist instance. Indeed we decided for a different approach.
Elements that have the same tag in the same XML namespace, describe
an identical concept; for example, in XHTML , any element with tag table
introduces always a table. Of course the particular element often depends
on other properties besides the tag: in XHTML, a table content and aspect
depend on the attributes and items of the corresponding element.
This consideration shows that a tag groups different elements in a single class. In object oriented programming languages, the same relation exists between objects and their classes. Hence we figure that the most appropriate binding for a tag is the name of a Python class. An example of how to define an element with tag Envelope is:
class Envelope(xlist): pass
e = Envelope()
Its representation is:
A similar argument is valid for the uri and the prefix properties, too. In this case, elements are grouped according to a namespace. In the data binding, a Python module, grouping classes with the same intention, shows a similar effect. This fact shows that the uri and prefix might correspond to a module name. Unfortunately, a uri is rarely a valid module name. Satine faces this problem with a special function xspace that binds a uri to the module where the function is. For instance in a module that contains the expression
any objects from class Envelope would be represented as <soap:Envelope/>.
XML schemas are documents that define the structure and the elements of a XML namespace. A technology for XML data binding can really take advantages of XML schemas. In fact, while translating XML to objects, the converter can check if the document is compliant with its schemas. In case of violation, the converter stops and notifies the error. The process of checking if a document is compliant to its schemas, is named XML validation.
Satine provides a very flexible validation that covers many of the features
defined in the XMLSchema specification. When defining a new class that
the type xlist, the developer can specify what are the valid attributes,
their type and their default value. Moreover he can decide what types
are valid as items. These constraints are set using two optional class
The field __attrs__ is a XML string defining the accepted attributes. This field has a fixed syntax: for each attribute to be defined, a XML element suggests the XML datatype in accordance with XMLSchema datatypes , and the string that follows, is the name of the attribute. Figure 5 shows a simplified class definition for the SOAP  element Envelope; line 2 defines an attribute encodingStyle: the element <xsd:string> imposes the type string from the XMLSchema namespace.
In a similar fashion, the field __items__ defines
what items are valid. Again the field is a XML string with a special
syntax, similar to the regular expression syntax, that we name XML Regular
Expressions (XRE). Unlike in regular expressions, the atomic item is
not a character but a XML
such as '?', '*'..., have the same meaning than in regular expressions,
that is they define the valid repetitions of the previous element. In
figure 5, line 3 states that any Envelope object may have an optional
Header element and a single mandatory Body element.
We decided to use those special syntax instead of XMLSchema syntax both for performance and for producing a compact code. Anyway we provide a tool that generates Python classes from XMLSchema documents.
At the moment we have developed a basic implementation of Satine that
supports all major features. This implementation is a Python library
on both Python and C code. The C extension module provides the fundamental
classes and functions. In particular, the module satine defines
the type xlist that we described above. Also it defines the
two functions xml2py and py2xml that respectively convert
XML to xlists and xlists to XML.
Satine allows queries on the information stored in a xlist through the method query. This method has the signature:
The second parameter sets the language for the query. The default style is XRE. When this style is used, the parameter pattern is defined as follows:
<pattern> := """<XML regular expression>|<id>[,<id>]*"""
The statement before the pipe is the comparison pattern and
the statement after the pipe is the extraction pattern. The
former is compared with the items of the xlist. For each match,
the function stores all the attributes whose identifiers are in the
If the extraction pattern is empty, the function stores the matching
An example query might be:
This query extracts the attribute mustUnderstand from an XML
Header inside a SOAP message. Other supported styles are 'tag' and
'pyfun'; the former allows to retrieve all items with a particular
tag, the latter uses a programmer defined function for the comparison.
Similar features are provided in the method visit. This method visits a xlist and executes a callback function each time a match is found. Through the method visit, Satine offers a callback parser similar to SAX. But, while SAX deals with the document structure only (start tags, end tags and text), the function visit operates on the document content.
The other modules offer further interesting features. The module satine.dt contains appropriate bindings to validate any XML datatype . The module satine.stream supports data binding from streams, such as files. Interestingly, Satine allows to convert fragments of a file at random positions. A developer is not required to convert an entire document, that could be really large, but only the parts that are in use. Other modules and features are described in  and .
The current implementation has proved to be very efficient. We compared the data binding performances of Satine, xml_objectify , Java DOM . Satine is much faster then xml_objectify . Often Satine is also comparable with the DOM implementation provided in Xerces 2.3 for Java. The following data turns out when translating the novel "The Jungle Book" by Rudyard Kipling in XML format on an Pentium 4 1600MHz:
After a first prototype was available, we tried to develop a typical
application. Our aim was to test the library interface in a possible
environment and to understand how Satine could enhance productivity.
The result of this effort is a toy framework, named Satine WS, that makes development of web services pretty easy. Satine WS has inside a HTTP server that processes SOAP requests with document-style. The SOAP request is converted into a Python object and it is processed using Satine queries. Also the server accepts requests from Internet browser and converts them into XML code using predefined templates. As a result, developers could access to a web service using a friendly web interface both for testing and administration reasons.
Figures 7 and 8 show a very simple application that manages some online reviews of restaurants from different cuisines. The web service has been implemented in about 60 lines of Python code. The application supports both HTTP/html access (figure 7) and SOAP access (figure 8). In case of SOAP requests, the system is able to validate the request before it is processed by the web service.
A comprehensive description of Satine WS is besides the intentions of this paper. Further information is available at .
XML data binding makes management of XML easy and efficient. Satine is a data binding technology for Python, that offers an easy interface with interesting performances. At the moment we are improving the XMLSchema support and we are working on storage in relational databases. Finally we are working on a possible integration between Software Architectures and Python.
The library and its documentation are available at http://satine.sourceforge.net. The project is under the GNU LGPL license.
 Francesco Garelli, Carlo Ferrari: A Dynamic Model for Mapping
XML Elements in a Object-Oriented Fashion. CoopIS/DOA/ODBASE 2002: 1255-1272.
 Francesco Garelli. Satine Cookbook. Technical Report at the Department of Information Engineering, University of Padua. December 2001
 Francesco Garelli. Satine WS: a Web Services application server for Python. December 2002. http://satine.sourceforge.net/ws.html
 Bray, T., Paoli, J., Sperberg-McQueen, C. M., Maler. Extensible Markup Language (XML) 1.0 (Second Edition). http://www.w3.org/TR/2000/REC-xml-20001006
 JDom.org. JDOM. http://www.jdom.org/
 Le Hors, A., ed. Document Object Model (DOM) Level 3 Core Specification. http://www.w3.org/TR/2001/WDDOM-Level-3-Core-20010126/.
 Megginson Technologies. SAX 2.0: The Simple API for XML. http://www.megginson.com/SAX/.
 Biron, P. and Malhotra. XML Schema Part 2: Datatypes.http://www.w3.org/TR/xmlschema-2/.
 Sun Microsystem. The Java Architecture for XML Binding. User's Guide. May 2001. http://java.sun.com/xml/jaxb/jaxb-docs.pdf
 Microsoft. XSD Compiler, .NET Development. http://msdn.microsoft.com
 David Mertz, Data Masseur. On the Pythonic Treatment of XML Documents As Objects. http://gnosis.cx/publish/programming/xml_matters_1.txt
 Don Box, David Ehnebuske , ed. Simple Object Access Protocol (SOAP) 1.1. http://www.w3.org/TR/SOAP/
 Steven Pemberton, Daniel Austin, ed. XHTML 1.0 The Extensible HyperText Markup Language. http://www.w3.org/TR/xhtml1
 Erik Christensen, Francisco Curbera, ed. Web Services Description Language (WSDL) 1.1. http://www.w3.org/TR/wsdl