[XML-SIG] ANN: Amara XML Toolkit 0.9.4

Uche Ogbuji uche.ogbuji at fourthought.com
Wed Feb 2 23:57:04 CET 2005


Changes in this release:

* Add binderytools.type_inference rule which automatically converts XML
  nodes to native Python objects such as int, float and datetime
* Improve threading and signal behavior of pushdom and pushbind
* Add support for attributes() method on nodes.
  Can now call Ft.Xml.Domlette.PrettyPrint on bindery nodes
* Add lazy attributes support by default.
  amara.binderytools.preserve_attribute_details rule now obsolete
  XPath always supports attribute access, now
* rename prefixes node property to xmlns_prefixes
* Update demos and tests
* Add CherryPy demo (CherryPy rocks: http://www.cherrypy.org/)
* Bug fixes

The new binderytools.type_inference is similar to what's popularly
called "XML marshalling":

    TYPE_MIX = """\
    <?xml version="1.0" encoding="utf-8"?>
    <a a1="1">
      <b b1="2.1"/>
      <c c1="2005-01-31">

    doc = binderytools.bind_string(TYPE_MIX, rules=rules)
    doc.a.a1 == 1     #type int
    doc.a.b.b1 == 2.1 #type float
    doc.a.c.c1 == datetime.datetime(2005, 1, 31) #type datetime.

So wherever it's reasonable to interpret an XML node as one of these
simple Python types, this new rule will work them naturally into the
data binding.

Amara XML Toolkit is a collection of Python tools for XML processing--
not just tools that happen to be written in Python, but tools built from
the ground up to use Python idioms and take advantage of the many
advantages of Python.

Amara builds on 4Suite [http://4Suite.org], but whereas 4Suite focuses
more on literal implementation of XML standards in Python, Amara
focuses on Pythonic idiom.  It provides tools you can trust to conform
with XML standards without losing the familiar Python feel.

The components of Amara are:

* Bindery: data binding tool (a very Pythonic XML API)
* Scimitar: implementation of the ISO Schematron schema language for
            XML; converts Schematron files to Python scripts
* domtools: set of tools to augment Python DOMs
* saxtools: set of tools to make SAX easier to use in Python
* Flextyper: user-defined datatypes in Python for XML processing

There's a lot in Amara, but here are highlights:

Amara Bindery: XML as easy as py

Based on the retired project Anobind, but updated to use SAX rather than
DOM to create bindings.  Bindery reads an XML document and returns a
data structure of Python objects corresponding to the vocabulary used
in the XML document, for maximum clarity.

Bindery turns the document

  <python spam="eggs">What do you mean "bleh"</python>
  <python ministry="abuse">But I was looking for argument</python>

Into a set of objects such that you can write


In order to get the value "eggs" or


In order to get the value "But I was looking for argument".

There are other such tools for Python, and what makes Anobind unique is
that it's driven by a very declarative rules-based system for binding
XML to the Python data.  You can register rules that are triggered by
XPattern expressions specialized binding behavior.  It includes XPath
support and supports mutation.  Bindery is very efficient, using SAX
to generate bindings.

Scimitar: Schematron for Python

Merged in from a separate project, Scimitar is an implementation of ISO
Schematron that compiles a Schematron schema into a Python validator

You typically use scimitar in two phases.  Say you have a schematron
schema schema1.stron and you want to validate multiple XML files
against it, instance1.xml, instance2.xml, instance3.xml.

First you run schema1.stron through the scimitar compiler script,

scimitar.py schema1.stron

The generated file, schema1.py, can be used to validate XML instances:

python schema1.py instance1.xml

Which emits a validation report.

Amara DOM Tools: giving DOM a more Pythonic face

DOM came from the Java world, hardly the most Pythonic API possible.
Some DOM-like implementations such as 4Suite's Domlettes mix in some
Pythonic idiom. Amara DOM Tools goes even further.

Amara DOM Tools feature pushdom, similar to xml.dom.pulldom, but
easier to use.  It also includes Python generator-based tools for
DOM processing, and a function to return an XPath location for
any DOM node.

Amara SAX Tools: SAX without the brain explosion

Tenorsax (amara.saxtools.tenorsax) is a framework for "linerarizing" SAX
logic so that it flows more naturally, and needs a lot less state
machine wizardry.


Amara is open source, provided under the 4Suite variant of the Apache
license.  See the file COPYING for details.


Amara requires Python 2.3 or more recent and 4Suite 1.0a4 or more
recent.  Make sure these are installed, unpack Amara to a convenient
location and run

python setup.py install

Uche Ogbuji                                    Fourthought, Inc.
http://uche.ogbuji.net    http://4Suite.org    http://fourthought.com
Use CSS to display XML - http://www.ibm.com/developerworks/edu/x-dw-x-xmlcss-i.html
Introducing the Amara XML Toolkit - http://www.xml.com/pub/a/2005/01/19/amara.html
Be humble, not imperial (in design) - http://www.adtmag.com/article.asp?id=10286
Querying WordNet as XML - http://www.ibm.com/developerworks/xml/library/x-think29.html
Manage XML collections with XAPI - http://www-106.ibm.com/developerworks/xml/library/x-xapi.html
Default and error handling in XSLT lookup tables - http://www.ibm.com/developerworks/xml/library/x-tiplook.html
Packaging XSLT lookup tables as EXSLT functions - http://www.ibm.com/developerworks/xml/library/x-tiplook2.html

More information about the XML-SIG mailing list