http://swpat.ffii.org/Action against software patents http://www.gnome.org/Gnome2 Logo http://www.w3.org/StatusW3C logo http://www.redhat.comRed Hat Logo http://xmlsoft.org/XSLT/Made with Libxslt Logo The XSLT C library for Gnome
Python and bindings
Main Menu index.htmlHome http://xmlsoft.org/wikiWiki intro.htmlIntroduction docs.htmlDocumentation bugs.htmlReporting bugs and getting help help.htmlHow to help downloads.htmlDownloads FAQ.htmlFAQ news.htmlNews xsltproc2.htmlThe xsltproc tool docbook.htmlDocBook API.htmlThe programming API python.htmlPython and bindings internals.htmlLibrary internals extensions.htmlWriting extensions contribs.htmlContributions EXSLT/index.htmllibexslt xslt.htmlflat page , site.xslstylesheet html/index.htmlAPI Menu ChangeLog.htmlChangeLog Related links tutorial/libxslttutorial.htmlTutorial ,
          
tutorial2/libxslt_pipes.htmlTutorial2 xsltproc.htmlMan page for xsltproc http://mail.gnome.org/archives/xslt/Mail archive http://xmlsoft.org/XML libxml2 ftp://xmlsoft.org/FTP http://www.zlatkovic.com/projects/libxml/Windows binaries http://garypennington.net/libxml2/Solaris binaries http://www.zveno.com/open_source/libxml2xslt.htmlMacOsX binaries http://bugzilla.gnome.org/buglist.cgi?product=libxsltBug Tracker http://www.zend.com/php5/articles/php5-xmlphp.php#Heading17XSLT with PHP http://www.mod-xslt2.com/Apache module http://sourceforge.net/projects/libxml2-pas/Pascal bindings http://xsldbg.sourceforge.net/Xsldbg Debugger API Indexes APIchunk0.htmlAlphabetic APIconstructors.htmlConstructors APIfunctions.htmlFunctions/Types APIfiles.htmlModules APIsymbols.htmlSymbols There is a number of language bindings and wrappers available for libxml2,
the list below is not exhaustive. Please contact the 
http://mail.gnome.org/mailman/listinfo/xml-bindingsxml-bindings@gnome.org (
http://mail.gnome.org/archives/xml-bindings/archives ) in
order to get updates to this list or to discuss the specific topic of libxml2
or libxslt wrappers or bindings:
http://mail.gnome.org/archives/xml/2001-March/msg00014.htmlMatt
    Sergeant
 developped http://axkit.org/download/XML::LibXML
    and XML::LibXSLT
, Perl wrappers for libxml2/libxslt as part of the http://axkit.com/AxKit XML application server   
mailto:dkuhlman@cutter.rexx.comDave Kuhlman  provides and
    earlier version of the libxml/libxslt 
http://www.rexx.com/~dkuhlmanwrappers for Python   
Petr Kozelka provides http://sourceforge.net/projects/libxml2-pasPascal units to glue
    libxml2
 with Kylix, Delphi and other Pascal compilers  
Wai-Sun "Squidster" Chia provides http://www.rubycolor.org/arc/redist/bindings for Ruby   and
    libxml2 bindings are also available in Ruby through the 
http://libgdome-ruby.berlios.de/libgdome-ruby  module
    maintained by Tobias Peters.
  
Steve Ball and contributors maintains http://tclxml.sourceforge.net/libxml2 and libxslt bindings for
    Tcl
  
mailto:xmlwrapp@pmade.orgPeter Jones  maintains C++
    bindings for libxslt within 
http://pmade.org/pjones/software/xmlwrapp/xmlwrapp   
phillim2@comcast.netMike Phillips  provides a module
    using 
http://siasl.dyndns.org/projects/projects.htmllibxslt
    for PHP
.  
http://savannah.gnu.org/projects/classpathx/LibxmlJ  is
    an effort to create a 100% JAXP-compatible Java wrapper for libxml2 and
    libxslt as part of GNU ClasspathX project.
  
Patrick McPhee provides Rexx bindings fof libxml2 and libxslt, look for
    
http://www.interlog.com/~ptjm/software.htmlRexxXML .  
http://www.satimage.fr/software/en/xml_suite.htmlSatimage     provides 
http://www.satimage.fr/software/en/downloads_osaxen.htmlXMLLib
    osax
. This is an osax for Mac OS X with a set of commands to
    implement in AppleScript the XML DOM, XPATH and XSLT.
The libxslt Python module depends on the http://xmlsoft.org/python.htmllibxml2 Python  module.
The distribution includes a set of Python bindings, which are garanteed to
be maintained as part of the library in the future, though the Python
interface have not yet reached the completeness of the C API.
mailto:stephane.bidoul@softwareag.comStphane Bidoul maintains 
http://users.skynet.be/sbi/libxml-python/a Windows port
of the Python bindings
.
Note to people interested in building bindings, the API is formalized as
libxslt-api.xmlan XML API description file  which allows to
automate a large part of the Python bindings, this includes function
descriptions, enums, structures, typedefs, etc... The Python script used to
build the bindings is python/generator.py in the source distribution.
To install the Python bindings there are 2 options:
If you use an RPM based distribution, simply install the http://rpmfind.net/linux/rpm2html/search.php?query=libxml2-pythonlibxml2-python
    RPM
 and the http://rpmfind.net/linux/rpm2html/search.php?query=libxslt-pythonlibxslt-python
    RPM
.  
Otherwise use the ftp://xmlsoft.org/python/libxml2-python
    module distribution
 corresponding to your installed version of
    libxml2 and libxslt. Note that to install it you will need both libxml2
    and libxslt installed and run "python setup.py build install" in the
    module tree.
The distribution includes a set of examples and regression tests for the
python bindings in the 
python/tests directory. Here are some
excepts from those tests:
basic.py:
This is a basic test of XSLT interfaces: loading a stylesheet and a
document, transforming the document and saving the result.
import libxml2
import libxslt
styledoc = libxml2.parseFile("test.xsl")
style = libxslt.parseStylesheetDoc(styledoc)
doc = libxml2.parseFile("test.xml")
result = style.applyStylesheet(doc, None)
style.saveResultToFilename("foo", result, 0)
style.freeStylesheet()
doc.freeDoc()
result.freeDoc()
The Python module is called libxslt, you will also need the libxml2 module
for the operations on XML trees. Let's have a look at the objects manipulated
in that example and how is the processing done:
styledoc : is a libxml2 document tree. It is obtained by
    parsing the XML file "test.xsl" containing the stylesheet.
  
style : this is a precompiled stylesheet ready to be used
    by the following transformations (note the plural form, multiple
    transformations can resuse the same stylesheet).
  
doc : this is the document to apply the transformation to.
    In this case it is simply generated by parsing it from a file but any
    other processing is possible as long as one get a libxml2 Doc. Note that
    HTML tree are suitable for XSLT processing in libxslt. This is actually
    how this page is generated !
  
result : this is a document generated by applying the
    stylesheet to the document. Note that some of the stylesheet informations
    may be related to the serialization of that document and as in this
    example a specific saveResultToFilename() method of the stylesheet should
    be used to save it to a file (in that case to "foo").
Also note the need to explicitely deallocate documents with freeDoc()
except for the stylesheet document which is freed when its compiled form is
garbage collected.
extfunc.py:
This one is a far more complex test. It shows how to modify the behaviour
of an XSLT transformation by passing parameters and how to extend the XSLT
engine with functions defined in python:
import libxml2
import libxslt
import string
nodeName = None
def f(ctx, str):
    global nodeName
    #
    # Small check to verify the context is correcly accessed
    #
    try:
        pctxt = libxslt.xpathParserContext(_obj=ctx)
        ctxt = pctxt.context()
        tctxt = ctxt.transformContext()
        nodeName = tctxt.insertNode().name
    except:
        pass
    return string.upper(str)
libxslt.registerExtModuleFunction("foo", "http://example.com/foo", f)
This code defines and register an extension function. Note that the
function can be bound to any name (foo) and how the binding is also
associated to a namespace name "http://example.com/foo". From an XSLT point
of view the function just returns an upper case version of the string passed
as a parameter. But the first part of the function also read some contextual
information from the current XSLT processing environement, in that case it
looks for the current insertion node in the resulting output (either the
resulting document or the Result Value Tree being generated), and saves it to
a global variable for checking that the access actually worked.
For more informations on the xpathParserContext and transformContext
objects check the 
internals.htmllibray internals description .
The pctxt is actually an object from a class derived from the
libxml2.xpathParserContext() with just a couple more properties including the
possibility to look up the XSLT transformation context from the XPath
context.
styledoc = libxml2.parseDoc("""
<xsl:stylesheet version='1.0'
  xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
  xmlns:foo='http://example.com/foo'
  xsl:exclude-result-prefixes='foo'>
  <xsl:param name='bar'>failure</xsl:param>
  <xsl:template match='/'>
    <article><xsl:value-of select='foo:foo($bar)'/></article>
  </xsl:template>
</xsl:stylesheet>
""")
Here is a simple example of how to read an XML document from a python
string with libxml2. Note how this stylesheet:
Uses a global parameter bar  
Reference the extension function f  
how the Namespace name "http://example.com/foo" has to be bound to a
    prefix
  
how that prefix is excluded from the output  
how the function is called from the selectstyle = libxslt.parseStylesheetDoc(styledoc)
doc = libxml2.parseDoc("<doc/>")
result = style.applyStylesheet(doc, { "bar": "'success'" })
style.freeStylesheet()
doc.freeDoc()
that part is identical, to the basic example except that the
transformation is passed a dictionnary of parameters. Note that the string
passed "success" had to be quoted, otherwise it is interpreted as an XPath
query for the childs of root named "success".
root = result.children
if root.name != "article":
    print "Unexpected root node name"
    sys.exit(1)
if root.content != "SUCCESS":
    print "Unexpected root node content, extension function failed"
    sys.exit(1)
if nodeName != 'article':
    print "The function callback failed to access its context"
    sys.exit(1)
result.freeDoc()
That part just verifies that the transformation worked, that the parameter
got properly passed to the engine, that the function f() got called and that
it properly accessed the context to find the name of the insertion node.
pyxsltproc.py:
this module is a bit too long to be described there but it is basically a
rewrite of the xsltproc command line interface of libxslt in Python. It
provides nearly all the functionalities of xsltproc and can be used as a base
module to write Python customized XSLT processors. One of the thing to notice
are:
libxml2.lineNumbersDefault(1)
libxml2.substituteEntitiesDefault(1)
those two calls in the main() function are needed to force the libxml2
processor to generate DOM trees compliant with the XPath data model.
bugs.htmlDaniel Veillard 
