Jython Course Outline

dkuhlman@rexx.com
http://www.rexx.com/~dkuhlman

$ java -jar jython_installer-2.2.jar

$ jython --help

>>> from java.lang import System
>>> props = System.getProperties()

>>> import sys
>>> r = sys.registry
>>> for k in r:
...   print k, r[k]

>>> from java.lang import System
>>> props = System.getProperties()
>>> names = []
>>> for name in props.keys():
...     names.append(name)
...
>>> names.sort()    # now you can list the keys in alpha order
>>> for val in props['java.class.path'].split(':'):
...     print val
...
/home/dkuhlman/a1/Python/Jython/Tmp1/Jython-2.1/jython.jar
/usr/share/jython/jython.jar

$ python setup.py install --prefix /path/to/install/directory

>>> from java.util import Vector
>>> v = Vector()
>>> dir(v)
['__init__', 'add', 'addAll', 'addElement', 'capacity', 'class', 'clear', 'clone', 'contains', 'containsAll', 'copyInto', 'elementAt', 'elements', 'empty', 'ensureCapacity', 'equals', 'firstElement', 'get', 'getClass', 'hashCode', 'indexOf', 'insertElementAt', 'isEmpty', 'iterator', 'lastElement', 'lastIndexOf', 'listIterator', 'notify', 'notifyAll', 'remove', 'removeAll', 'removeAllElements', 'removeElement', 'removeElementAt', 'retainAll', 'set', 'setElementAt', 'setSize', 'size', 'subList', 'toArray', 'toString', 'trimToSize', 'wait']
>>>
>>> v.add('aaa')
1
>>> v.add('bbb')
1
>>> for val in v:
...     print val
...
aaa
bbb

>>> from java.util import Hashtable
>>> impl_language = Hashtable()
>>> impl_language.put('jython', 'java')
>>> impl_language.put('python', 'c')
>>> for key in impl_language.keys():
...     print '%s is implemented in %s' % (key, impl_language[key])
...
python is implemented in c
jython is implemented in java

Name         Description              Rating
====         ===========              ======
tomato       red and tasty            8
peach        sweet and succulent      8
tangerine    sweet but tart           7

• Import a Java class, for example, java.util.Vector. Create and use an instance of that class.

Running Jython scripts:

• From the command line, run a script with jython. For example:

  $ jython myscript.py

• For help, run:

  $ jython --help

• For debugging, use something similar to the following:

  import pdb
  pdb.run('main()')

  Or:

  import pdb
  pdb.set_trace()

  For example:

  def main():
      util101()
  
  if __name__ == '__main__':
      import pdb; pdb.set_trace()
      main()

• To "set a breakpoint" in your code so that it will drop into debugger, either (1) use the b command at the pdb prompt or (2) add the following to your code at the location where you wish to drop into the debugger:

  import pdb; pdb.set_trace()

  For more information on the Python debugger, see The Python Debugger in the Python standard documentation, or while in the debugger, type help.

• To make a script both "run-able" and "import-able", use the following idiom:

  if __name__ == '__main__':
      main()

Don't forget to include a doc string at the top of your module for documentation.

Exercise -- Create a small Jython script:

• Include a class in your script that creates an instance of java.util.Vector.
• Make the script both "run-able" and "import-able".
• From the Jython interpreter, import the script and create an instance of the class.
• From the command line, use jython to run the script.
• Add pdb debugging to your script. Run the script again from the command line. Step through several lines of code.

Installing Jython/Python packages
---------------------------------

Some Jython packages will be distributed as a Java jar file. If that is the case, add the jar file to your classpath.

If the package is distributed as a standard Python package with a setup.py installer file and if there are no C/C++ files in the package, then you might try something like the following:

$ python setup.py install --prefix /path/to/install/directory

And, then put that install directory on your classpath.

>>> from java.util import Vector
>>> v = Vector()
>>> dir(v)
['__init__', 'add', 'addAll', 'addElement', 'capacity', 'class', 'clear', 'clone', 'contains', 'containsAll', 'copyInto', 'elementAt', 'elements', 'empty', 'ensureCapacity', 'equals', 'firstElement', 'get', 'getClass', 'hashCode', 'indexOf', 'insertElementAt', 'isEmpty', 'iterator', 'lastElement', 'lastIndexOf', 'listIterator', 'notify', 'notifyAll', 'remove', 'removeAll', 'removeAllElements', 'removeElement', 'removeElementAt', 'retainAll', 'set', 'setElementAt', 'setSize', 'size', 'subList', 'toArray', 'toString', 'trimToSize', 'wait']
>>>
>>> v.add('aaa')
1
>>> v.add('bbb')
1
>>> for val in v:
...     print val
...
aaa
bbb

>>> from java.util import Hashtable
>>> impl_language = Hashtable()
>>> impl_language.put('jython', 'java')
>>> impl_language.put('python', 'c')
>>> for key in impl_language.keys():
...     print '%s is implemented in %s' % (key, impl_language[key])
...
python is implemented in c
jython is implemented in java

import sys
from java.io import FileOutputStream

class UppercaseFileOutputStream(FileOutputStream):
    def write_upper(self, text):
        text = text.upper()
        self.write(text)

def test(outfilename):
    fos = UppercaseFileOutputStream(outfilename)
    for idx in range(10):
        fos.write_upper('This is line # %d\n' % idx)
    fos.close()
    infile = open(outfilename, 'r')
    for line in infile:
        line = line.rstrip()
        print 'Line: %s' % line

def main():
    args = sys.argv[1:]
    if len(args) != 1:
        print 'usage: extend_fileoutputstream.py <infilename>'
        sys.exit(1)
    test(args[0])

if __name__ == '__main__':
    main()

import java.util.Vector;

// Implement selected part of the Jython container interface.
public class CustomContainer {

    private Vector data;

    public CustomContainer() {
        data = new Vector();
    }

    // Implement the len() operator.
    public int __len__() {
        return data.size();
    }

    // Implement the append() method.
    public int append(String item) {
        data.add(item);
        return 1;
    }

    // Implement the [] operator.
    public String __getitem__(int index) {
        return (String)data.elementAt(index);
    }
}

$ jython
Jython 2.2.1rc1 on java1.4.2_10
Type "copyright", "credits" or "license" for more information.
>>>
>>> import CustomContainer as cc
>>> container = cc()
>>> container.append('item number one')
1
>>> container.append('item number two')
1
>>> container.append('item number three')
1
>>> len(container)
3
>>> for index in range(len(container)):
...     print container[index]
...
item number one
item number two
item number three

// Showme.java

import org.python.core.*;

public class ShowMe
{
    public static PyString __doc__ =
        new PyString("Simple Jython extension #1");

    public String name;

    public ShowMe(String newName)
    {
        name = newName;
    }
    public static PyString __doc__set_name = new PyString(
        "Set the name attribute");
    public void set_name(String newName)
    {
        name = newName;
    }
    public static PyString __doc__get_name = new PyString(
        "Get the name attribute");
    public String get_name()
    {
        return name;
    }

    public static PyString  __doc__Show = new PyString(
        "Show the name attribute");
    public void Show()
    {
        System.out.println("My name is \"" + name + "\".");
    }
}

// DemoArgs.java

import org.python.core.*;

public class DemoArgs
{
    public static PyString __doc__ =
        new PyString("Demonstrate the use of complex arguments.");

    public String name;
    public String value;

    public DemoArgs(String newName, String newValue)
    {
        name = newName;
        value = newValue;
    }

    public static PyString __doc__set_name = new PyString(
        "Set the name attribute");
    public void set_name(PyObject[] args, String[] kwargs)
    {
        System.out.println("length(args): " +
            String.valueOf(args.length) +
            " length(kwargs): " +
            String.valueOf(kwargs.length)
            );
        ArgParser ap = new ArgParser("set_name", args, kwargs,
            new String[] {"name", "value"});
        String newName = ap.getString(0, "");
        String newValue = ap.getString(1, "<empty>");
        if (newName.compareTo("") != 0)
        {
            name = newName;
        }
        value = newValue;
    }
    public static PyString __doc__get_name = new PyString(
        "Get the name attribute");
    public String get_name()
    {
        return name;
    }

    public static PyString __doc__get_value = new PyString(
        "Get the value attribute");
    public String get_value()
    {
        return value;
    }

    public static PyString  __doc__Show = new PyString(
        "Show the name and value attributes");
    public void Show()
    {
        System.out.println("My name is \"" + name +
            "\" and my value is \"" + value + "\".");
    }
}

import DemoArgs

class Fancy(DemoArgs):
    def __init__(self, name, value):
        DemoArgs.__init__(self, name, value)
    def ShowFancy(self):
        print "I'm fancy and my name is %s and my value is %s" % \
            (self.name, self.value)

def test():
    f = Fancy('dave', 'funny')
    f.ShowFancy()
    f.set_name('daniel', 'cute')
    f.ShowFancy()

test()

$ jython tmp.py
I'm fancy and my name is dave and my value is funny
length(args): 2 length(kwargs): 0
I'm fancy and my name is daniel and my value is cute

__getitem__()
__finditem()
__setitem__()
__delitem__()
...

// TestDict.java

import org.python.core.*;
import java.util.*;

public class TestDict
{
    public Hashtable data;

    public TestDict()
    {
            data = new Hashtable();
    }
    public void __setitem__(String key, String value)
    {
            data.put(key, value);
            System.out.println("Added key \"" + key + "\"  value: \"" +
                                               value + "\"");
    }
    public String __getitem__(String key)
    {
            if (data.containsKey(key))
            {
                    String value = (String)data.get(key);
                    System.out.println("Found key \"" + key + "\"  value: \"" +
                                               value + "\"");
                    return value;
            }
            else
            {
                    throw new PyException(Py.KeyError, "The key does not exit.");
            }
    }
    public boolean __contains__(String key)
    {
            if (data.containsKey(key))
            {
                    System.out.println("Found key \"" + key + "\"");
                    return true;
            }
            else
            {
                    System.out.println("Did not find key \"" + key + "\"");
                    return false;
            }
    }
}

# test_TestDict.py

import TestDict

def test():
    d = TestDict()
    d['aa'] = 'AAAA'
    d['bb'] = 'BBBB'
    d['cc'] = 'CCCC'
    print d.data
    if 'bb' in d:
        print 'present'

test()

$ jython test_TestDict.py
Added key "aa"  value: "AAAA"
Added key "bb"  value: "BBBB"
Added key "cc"  value: "CCCC"
{aa=AAAA, bb=BBBB, cc=CCCC}
Found key "bb"
present

// TestDictSub.java

import org.python.core.*;
import java.util.*;

public class TestDictSub extends PyDictionary
{
    public void __setitem__(PyObject key, PyObject value)
    {
        super.__setitem__(key, value);
        System.out.println("Added key \"" + key + "\"  value: \"" +
                           value + "\"");
    }
    public PyObject __getitem__(PyObject key)
    {
        if (super.has_key(key))
        {
            PyObject value = super.__getitem__(key);
            System.out.println("Found key \"" + key + "\"  value: \"" +
                           value + "\"");
            return value;
        }
        else
        {
            throw new PyException(Py.KeyError, "The key does not exit.");
        }
    }
}

__findattr__()
__setattr__()
__delattr__()

// TestDictSub.java

import org.python.core.*;
import java.util.*;

public class TestDictAttr extends PyDictionary
{
    public PyObject __findattr__(String key)
    {
        PyString objkey = new PyString(key);
        if (super.has_key(objkey))
        {
            PyObject value = super.__getitem__(objkey);
            System.out.println("Found attr \"" + key + "\"  value: \"" +
                           value + "\"");
            return value;
        }
        else
        {
            throw new PyException(Py.KeyError, "The attr does not exist.");
        }
    }
}

|-- Employee.py                     # The Jython classes
|-- jyinterface
|   |-- Main.java                   # The client code
|   |-- factories
|   |   |-- EmployeeFactory.java    # The factory
|   `-- interfaces
|       |-- DependentType.java      # A Java interface
|       `-- EmployeeType.java       # A Java interface

# Employee.py

from jyinterface.interfaces import EmployeeType
from jyinterface.interfaces import DependentType


class Employee(EmployeeType):
    def __init__(self, first, last, id):
        self.first = first
        self.last  =  last
        self.id = id
        deps = self.create_dependents()
        self.deps = deps

    def create_dependents(self):
        d1 = Dependent('Sally', 'Serious', 11)
        d2 = Dependent('Larry', 'Lighthearted', 12)
        return [d1, d2]

    def getEmployeeFirst(self):
        return self.first

    def getEmployeeLast(self):
        return self.last

    def getEmployeeId(self):
        return self.id

    def getDependents(self):
        return self.deps

    def addDependent(self, dependent):
        self.deps.append(dependent)


class Dependent(DependentType):
    def __init__(self, first, last, id):
        self.first = first
        self.last  =  last
        self.id = id

    def getDependentFirst(self):
        return '<<%s>>' % self.first

    def getDependentLast(self):
        return '<<%s>>' % self.last

    def getDependentId(self):
        return self.id * 4

// EmployeeType.java

package jyinterface.interfaces;
import org.python.core.PyList;
import jyinterface.interfaces.DependentType;


public interface EmployeeType {
    public String getEmployeeFirst();
    public String getEmployeeLast();
    public String getEmployeeId();
    public PyList getDependents();
    public void addDependent(DependentType dependent);
}

// DependentType.java

package jyinterface.interfaces;

public interface DependentType {
        public String getDependentFirst();
        public String getDependentLast();
        public Integer getDependentId();
}

// EmployeeFactory.java

package jyinterface.factory;

import jyinterface.interfaces.EmployeeType;
import jyinterface.interfaces.DependentType;
import org.python.core.PyObject;
import org.python.core.PyString;
import org.python.core.PyInteger;
import org.python.util.PythonInterpreter;

public class EmployeeFactory {

    public EmployeeFactory() {
        String cmd = "from Employee import Employee\nfrom Employee import Dependent";
        PythonInterpreter interpreter = new PythonInterpreter();
        //interpreter.exec("from Employee import Employee");
        //interpreter.exec("from Employee import Dependent");
        interpreter.exec(cmd);
        jyEmployeeClass = interpreter.get("Employee");
        jyDependentClass = interpreter.get("Dependent");
    }

    public EmployeeType createEmployee(String first, String last, String id) {
        PyObject employeeObj = jyEmployeeClass.__call__(
            new PyString(first),
            new PyString(last),
            new PyString(id));
        return (EmployeeType)employeeObj.__tojava__(EmployeeType.class);
    }

    public DependentType createDependent(String first, String last, int id) {
        PyObject dependentObj = jyDependentClass.__call__(
            new PyString(first),
            new PyString(last),
            new PyInteger(id));
        return (DependentType)dependentObj.__tojava__(DependentType.class);
    }

    private PyObject jyEmployeeClass;
    private PyObject jyDependentClass;
}

// Main.java

package jyinterface;

import jyinterface.factories.EmployeeFactory;
import jyinterface.interfaces.EmployeeType;
import jyinterface.interfaces.DependentType;
import org.python.core.PyObject;
import org.python.core.PyList;

public class Main {

    private static void printEmployee(EmployeeType employee) {
        System.out.println("Name: " + employee.getEmployeeFirst() + " "
                + employee.getEmployeeLast());
        System.out.println("Id: " + employee.getEmployeeId());
        PyList deplist = employee.getDependents();
        int count = deplist.__len__();
        System.out.println("count: " + Integer.toString(count));
        for (int idx = 0; idx < count; idx++) {
            PyObject obj = deplist.__getitem__(idx);
            DependentType dep = (DependentType)obj.__tojava__(DependentType.class);
            printDependent(dep);
        }
    }

    private static void printDependent(DependentType dependent) {
        System.out.println("Dep Name: " + dependent.getDependentFirst() + " "
                + dependent.getDependentLast());
        System.out.println("Dep Id: " + dependent.getDependentId().toString());
    }

    public static void main(String[] args) {
        EmployeeFactory factory = new EmployeeFactory();
        EmployeeType emp = factory.createEmployee("Josh", "Juneau", "1");
        printEmployee(emp);
        printEmployee(factory.createEmployee("Charlie", "Groves", "2"));
        System.out.println("------------------");
        DependentType dependent = factory.createDependent(
            "Dave", "Kuhlman", 4);
        printDependent(dependent);
        System.out.println("------------------");
        emp.addDependent(dependent);
        printEmployee(emp);
    }
}

// File: SimpleEmbedded.java
import org.python.util.PythonInterpreter;
import org.python.core.*;
import java.io.*;

public class SimpleEmbedded
{
    public static void main(String[]args) throws PyException, IOException
    {
        BufferedReader terminal;
        PythonInterpreter interp;
        terminal = new BufferedReader(new InputStreamReader(System.in));
        System.out.println ("Hello");
        interp = new PythonInterpreter();
        interp.exec("import sys");
        interp.exec("print sys");
        interp.set("a", new PyInteger(42));
        interp.exec("print a");
        interp.exec("x = 2+2");
        PyObject x = interp.get("x");
        System.out.println("x: " + x);
        PyObject localvars = interp.getLocals();
        interp.set("localvars", localvars);
        String codeString = "";
        String prompt = ">> ";
        while (true)
        {
            System.out.print (prompt);
            try
            {
                codeString = terminal.readLine();
                if (codeString.compareTo("exit") == 0)
                {
                    System.exit(0);
                    break;
                }
                interp.exec(codeString);
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
        System.out.println("Goodbye");
    }
}

PyDictionary namespace = interp.getLocals();
PyObject obj = namespace.__getitem__("x");
Integer x = obj.__tojava__(Integer.class);

// File: TestInterp01.java

import org.python.util.PythonInterpreter;
import org.python.core.*;
import java.io.*;

public class TestInterp01
{
    public static void main(String[]args) throws PyException, IOException
    {
        PythonInterpreter interp;
        PyString key;
        PyInteger value;
        System.out.println ("Hello");
        PyDictionary table = new PyDictionary();
        key = new PyString("aaa");
        value = new PyInteger(111);
        table.__setitem__(key, value);
        key = new PyString("bbb");
        value = new PyInteger(222);
        table.__setitem__(key, value);
        interp = new PythonInterpreter(table);
        interp.exec("print 'aaa:', aaa");
        interp.exec("print 'bbb:', bbb");
    }
}

// File: TestInterp02.java

import org.python.util.PythonInterpreter;
import org.python.core.*;
import java.io.*;

public class TestInterp02
{
    public static void main(String[]args) throws PyException, IOException
    {
        PythonInterpreter interp;
        PyString key;
        PyInteger value;
        System.out.println ("Hello");
        PyDictionary table = new PyDictionary();
        key = new PyString("aaa");
        value = new PyInteger(111);
        table.__setitem__(key, value);
        key = new PyString("bbb");
        value = new PyInteger(222);
        table.__setitem__(key, value);
        PySystemState state = new PySystemState();
        interp = new PythonInterpreter(table, state);
        interp.exec("print 'aaa:', aaa");
        interp.exec("print 'bbb:', bbb");
    }
}

PyDictionary table = new PyDictionary();
RestrictedClassLoader classLoader = new RestrictedClassLoader();
PySystemState state = new PySystemState();
state.setClassLoader(classLoader);
PythonInterpreter interp = new PythonInterpreter(table, state);

// RestrictedClassLoader.java

import java.util.Vector;
import java.util.Enumeration;
import java.lang.ClassNotFoundException;

class RestrictedClassLoader extends ClassLoader {
    Vector goodnames;
    public RestrictedClassLoader () {
        goodnames = new Vector();
        goodnames.add("Goodclass1");
        goodnames.add("Goodclass2");
        goodnames.add("Goodclass3");
        goodnames.add("Goodclass4");
    }

    public Class findClass(String name)  throws ClassNotFoundException {
        Enumeration items = goodnames.elements();
        while (items.hasMoreElements())
        {
            String item = (String)items.nextElement();
            if (item.compareTo(name) == 0)
            {
                return super.findClass(name);
            }
        }
        throw new ClassNotFoundException("class loading restricted. " +
            name + " not allowed.");
    }
}

PyDictionary namespace = interp.getLocals();
PyInteger value = new PyInteger(144);
namespace.__setitem__("x", value);

import org.python.util.InteractiveConsole;
import java.util.Properties;
import java.io.*;

public class interactive_console1 {
    protected InteractiveConsole interp;

    public interactive_console1() {
        if (System.getProperty("python.home") == null) {
            System.setProperty("python.home", "");
        }
        InteractiveConsole.initialize(System.getProperties(),
                                      null, new String[0]);
        interp = new InteractiveConsole();
    }

    public static void main(String[] args) {
        interactive_console1 con = new interactive_console1();
        con.startConsole();
    }

    public void startConsole() {
        interp.interact("Hello from console.");
    }
}

attrs = node.getAttributes() count = attrs.getLength() for idx in range(count):

System Message: ERROR/3 (<string>, line 2137)

Unexpected indentation.

attr = attrs.item(idx) print ' %s: %s' % (

System Message: ERROR/3 (<string>, line 2139)

Unexpected indentation.

attr.getNodeName(), attr.getNodeValue(), )

System Message: WARNING/2 (<string>, line 2140)

Block quote ends without a blank line; unexpected unindent.

node = node.getNextSibling()

def show_names(node):

"""Show the value of the name element for each person element. """ node = node.getFirstChild() while node:

System Message: ERROR/3 (<string>, line 2148)

Unexpected indentation.

if (node.getNodeType() == node.ELEMENT_NODE and

node.getTagName() == 'person'):

show_person_name(node)

System Message: WARNING/2 (<string>, line 2151)

Definition list ends without a blank line; unexpected unindent.

node = node.getNextSibling()

def show_person_name(node):

node = node.getFirstChild() while node:

System Message: ERROR/3 (<string>, line 2157)

Unexpected indentation.

if (node.getNodeType() == node.ELEMENT_NODE and

node.getTagName() == 'name'):

show_text('name: ', node)

System Message: WARNING/2 (<string>, line 2160)

Definition list ends without a blank line; unexpected unindent.

node = node.getNextSibling()

def show_text(msg, node):

"""Show a message and the value of a text node. """ node = node.getFirstChild() while node:

System Message: ERROR/3 (<string>, line 2168)

Unexpected indentation.

if node.getNodeType() == node.TEXT_NODE:

print ' %s %s' % (msg, node.getNodeValue(), )

System Message: WARNING/2 (<string>, line 2170)

Definition list ends without a blank line; unexpected unindent.

node = node.getNextSibling()

def usage():

print 'Usage: jython test_xerces.py <infilename>' sys.exit(-1)

def main():

args = sys.argv[1:] if len(args) != 1:

System Message: ERROR/3 (<string>, line 2181)

Unexpected indentation.

usage()

System Message: WARNING/2 (<string>, line 2182)

Block quote ends without a blank line; unexpected unindent.

test(args[0])

if __name__ == '__main__':

main()

Notes:

• Except for the parser set-up (in function test), this example is almost the same as the JAXP example. For the most part, it uses the same API.

Resources:

• Xerces Java Parser
• Introduction to XML and XML With Java

dom4j
~~~~~

Installation and setup
++++++++++++++++++++++

• Download dom4j from: dom4j: the flexible XML framework for Java -- http://www.dom4j.org/
• Add the dom4j jar file to your CLASSPATH.
• In order to get some features to work, I also had to install the jaxen XPath engine. Add that to your CLASSPATH, too. See: jaxen: universal Java XPath engine -- http://jaxen.codehaus.org/.

Examples etc
++++++++++++

There are examples at:

• dom4j - Quick Start Guide -- http://www.dom4j.org/guide.html
• dom4j cookbook -- http://www.dom4j.org/cookbook.html

Example 1a -- This example parses an XML document (file), then walks the dom4j DOM element tree and prints out information on each node:

import sys
from org.dom4j.io import SAXReader

def show_indent(level):
    return '    ' * level

def show_node(node, level):
    """Display one node in the DOM tree.
    """
    if node.getNodeType() == node.ELEMENT_NODE:
        name = node.getName()
        print '%sElement node: %s' % (show_indent(level), name, )
        attrs = node.attributes()
        for attr in attrs:
            aName = attr.getQualifiedName()
            aValue = attr.getValue()
            print '    %sAttr -- %s: %s' % (show_indent(level), aName, aValue,)
        if node.text:
            print '    %sText: "%s"' % (show_indent(level), node.text,)

def show_tree(node, level):
    show_node(node, level)
    level1 = level + 1
    if node.getNodeType() == node.ELEMENT_NODE:
        children = node.elements()
        for child in children:
            show_tree(child, level1)

def test(infilename):
    print 'Version: %s' % (sys.version, )
    reader = SAXReader()
    doc = reader.read(infilename)
    root = doc.getRootElement()
    show_tree(root, 0)

def main():
    args = sys.argv[1:]
    if len(args) != 1:
        print 'usage: test_dom4j_2.py in_xml_file'
        sys.exit(1)
    test(args[0])

if __name__ == '__main__':
    #import pdb; pdb.set_trace()
    main()

Notes:

• We use node.elements() to get all children that are elements, but not, for example, text nodes.

Example 1b -- This example also parses an XML document (file), then walks the dom4j DOM element tree and prints out information on each node. However, at each node it iterates over all the content nodes, including text nodes:

import sys
from org.dom4j.io import SAXReader

def show_indent(level):
    return '    ' * level

def show_node(node, level):
    """Display one node in the DOM tree.
    """
    if node.getNodeType() == node.ELEMENT_NODE:
        name = node.getName()
        print '%sElement node: %s' % (show_indent(level), name, )
        attrs = node.attributes()
        for attr in attrs:
            aName = attr.getQualifiedName()
            aValue = attr.getValue()
            print '    %sAttr -- %s: %s' % (show_indent(level), aName, aValue,)
    elif node.getNodeType() == node.TEXT_NODE:
        print '%sText node: "%s"' % (show_indent(level), node.text, )

def show_tree(node, level):
    show_node(node, level)
    level1 = level + 1
    if node.getNodeType() == node.ELEMENT_NODE:
        children = node.content()
        for child in children:
            show_tree(child, level1)

def test(infilename):
    print 'Version: %s' % (sys.version, )
    reader = SAXReader()
    doc = reader.read(infilename)
    root = doc.getRootElement()
    show_tree(root, 0)

def main():
    args = sys.argv[1:]
    if len(args) != 1:
        print 'usage: test_dom4j_2.py in_xml_file'
        sys.exit(1)
    test(args[0])

if __name__ == '__main__':
    #import pdb; pdb.set_trace()
    main()

Notes:

• We use node.content() to get all child nodes, including text nodes.

• Use tests such as the following to determine whether a node is an element node or a text node:

  if node.getNodeType() == node.ELEMENT_NODE:
      o
      o
      o
  elif node.getNodeType() == node.TEXT_NODE:
      o
      o
      o

Example 2 -- This example creates an dom4j document object and adds element objects to it:

import sys
import org.dom4j.DocumentHelper
import org.dom4j.io.OutputFormat
from org.dom4j.io import XMLWriter
from org.dom4j.io import OutputFormat

def test():
    # 1.
    # Create a new document and add a few elements to it.
    doc = org.dom4j.DocumentHelper.createDocument()
    root = doc.addElement('specs')
    e1 = root.addElement('class1')
    e1.addAttribute('name', 'dave')
    e1.addAttribute('category', 'medium')
    e1.addText('some simple content')
    e1 = root.addElement('class2')
    e1.addAttribute('name', 'mona')
    e1.addAttribute('category', 'good')
    e1.addText('more content')
    # 2.
    # Print a text representation of the DOM tree.
    text = doc.asXML()
    print text
    print '\n', '-' * 40, '\n'
    # 3.
    # Print a formatted (pretty-print) representation.
    format = OutputFormat.createPrettyPrint()
    writer = XMLWriter(sys.stdout, format)
    writer.write(doc)
    print '\n', '-' * 40, '\n'
    print 'root:', root, '\n'
    # 4.
    # Iterate over the children of the root.
    # Print child and parent names, etc.
    itr = root.elementIterator()
    for idx, child in enumerate(itr):
        print idx, child
        parent = child.getParent()
        print 'parent:', parent.getName()
        print 'child:', child.getName()
        print 'text: "%s"' % child.getText()
        print

test()

Notes -- What this example does:

1. Creates a new document and adds a few elements to it.
2. Produces and prints a text representation of the DOM tree.
3. Prints a formatted (pretty-print) representation.
4. Iterates over the children of the root. Prints child and parent names, etc.

Resources:

• http://www.dom4j.org/
• http://www.dom4j.org/dom4j-1.4/apidocs/index.html

XMLBeans
~~~~~~~~

XMLBeans provides the ability to generate Java bindings for an XML document type from an XML Schema. Roughly speaking, XMLBeans generates a Java class for each element type defined in an XML Schema.

When used with Jython, those Java bindings become quite Jythonic.

You can read about XMLBeans here:

• Welcome to XMLBeans -- http://xmlbeans.apache.org/index.html.
• XMLBeans at Wikipedia -- http://en.wikipedia.org/wiki/XMLBeans.

Installation
++++++++++++

You can find XMLBeans at: Welcome to XMLBeans -- http://xmlbeans.apache.org/index.html.

To install XMLBeans, follow the instructions at: Installing XMLBeans -- http://xmlbeans.apache.org/documentation/conInstallGuide.html.

After unrolling the binary distribution, I added the following to my CLASSPATH:

• $XMLBEANS_HOME/lib/xbean.jar
• $XMLBEANS_HOME/lib/jsr173_1.0_api.jar

And, I added the following to my PATH:

• $XMLBEANS_HOME/bin

where XMLBEANS_HOME is the directory in which XMLBeans is installed.

An example
++++++++++

This example is copied from XMLBeans at Wikipedia -- http://en.wikipedia.org/wiki/XMLBeans and adapted to Jython.

The XML Schema:

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.openuri.org/domain/country/v1"
           xmlns:tns="http://www.openuri.org/domain/country/v1"
           xmlns:xs="http://www.w3.org/2001/XMLSchema"
           elementFormDefault="qualified"
           attributeFormDefault="unqualified"
           version="1.0">
  <xs:element name="Country" type="tns:Country"/>
  <xs:complexType name="Country">
    <xs:sequence>
      <xs:element name="Name" type="xs:string"/>
      <xs:element name="Population" type="xs:int"/>
      <xs:element name="Iso" type="tns:Iso"/>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="Iso">
    <xs:annotation><xs:documentation>ISO 3166</xs:documentation></xs:annotation>
    <xs:sequence>
      <xs:element name="Alpha2" type="tns:IsoAlpha2"/>
      <xs:element name="Alpha3" type="tns:IsoAlpha3"/>
      <xs:element name="CountryCode" type="tns:IsoCountryCode"/>
    </xs:sequence>
  </xs:complexType>
  <xs:simpleType name="IsoCountryCode">
    <xs:restriction base="xs:int">
      <xs:totalDigits value="3"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="IsoAlpha2">
    <xs:restriction base="xs:string">
      <xs:pattern value="[A-Z]{2}"/>
      <xs:whiteSpace value="collapse"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="IsoAlpha3">
    <xs:restriction base="xs:string">
      <xs:pattern value="[A-Z]{3}"/>
      <xs:whiteSpace value="collapse"/>
    </xs:restriction>
  </xs:simpleType>
</xs:schema>

Supposing that you name the above schema country.xsd, you can compile this with XMLBeans using something like the following:

$ scomp -out country.jar country.xsd

Here is a bit of Java code, copied from Wikipedia, that uses the generated Java classes:

import org.openuri.domain.country.v1.Country;
import org.openuri.domain.country.v1.Iso;
public class CountrySample
{
  public static void main(String[] args) {
    Country country = Country. Factory.newInstance();
    country.setName("Denmark");
    country.setPopulation(5450661);  // from wikipedia :-)
    // print out country XMLBean as XML
    System.out.println(country.xmlText());
    // check if document is valid - will print "Document is invalid"
    // because required Iso child element in not in the object
    System.out.println ("Document is " + (country.validate() ? "valid" : "invalid"));
    // add child with complex type Iso to make the document valid
    Iso iso = country.addNewIso();
    iso.setAlpha2("DK");
    iso.setAlpha3("DNK");
    iso.setCountryCode(208);
    // print out country XMLBean as XML
    System.out.println(country.xmlText());
    // check if document is valid - will print "Document is valid"
    System.out.println ("Document is " + (country.validate() ? "valid" : "invalid"));
  }
}

After translation to Jython, here is the equivalent code. Note that it uses the same generated Java classes as the above Java code:

from org.openuri.domain.country.v1 import Country
from org.openuri.domain.country.v1 import Iso
from org.apache.xmlbeans import XmlOptions

class CountrySample(object):

    def main(self, args):
        country = Country. Factory.newInstance()
        country.setName("Denmark")
        country.setPopulation(5450661);    # from wikipedia :-)
        # Print out country XMLBean as XML.
        print country.xmlText()
        # Print out country XMLBean as XML with indentation.
        opts = XmlOptions()
        opts.setSavePrettyPrint()
        opts.setSavePrettyPrintIndent(4)
        print country.xmlText(opts)
        # Check if document is valid - will print "Document is invalid"
        # because required Iso child element in not in the object.
        if country.validate():
            condition = "valid"
        else:
            condition = "invalid"
        print "Document is", condition
        # Add child with complex type Iso to make the document valid.
        iso = country.addNewIso();
        iso.setAlpha2("DK")
        iso.setAlpha3("DNK")
        iso.setCountryCode(208)
        # Print out country XMLBean as XML.
        print country.xmlText(opts)
        # Check if document is valid - will print "Document is valid".
        if country.validate():
            condition = "valid"
        else:
            condition = "invalid"
        print "Document is", condition

def test():
    country_sample = CountrySample()
    country_sample.main([])

test()

Add the generated jar file to your CLASSPATH. In Linux, I can do that with the following:

$ export CLASSPATH=$CLASSPATH:./country.jar

Now run it:

$ jython test_xml.py

And, that prints out:

<xml-fragment><v1:Name xmlns:v1="http://www.openuri.org/domain/country/v1">Denmark</v1:Name><v1:Population xmlns:v1="http://www.openuri.org/domain/country/v1">5450661</v1:Population></xml-fragment>
<xml-fragment>
    <v1:Name xmlns:v1="http://www.openuri.org/domain/country/v1">Denmark</v1:Name>
    <v1:Population xmlns:v1="http://www.openuri.org/domain/country/v1">5450661</v1:Population>
</xml-fragment>
Document is invalid
<xml-fragment>
    <v1:Name xmlns:v1="http://www.openuri.org/domain/country/v1">Denmark</v1:Name>
    <v1:Population xmlns:v1="http://www.openuri.org/domain/country/v1">5450661</v1:Population>
    <v1:Iso xmlns:v1="http://www.openuri.org/domain/country/v1">
        <v1:Alpha2>DK</v1:Alpha2>
        <v1:Alpha3>DNK</v1:Alpha3>
        <v1:CountryCode>208</v1:CountryCode>
    </v1:Iso>
</xml-fragment>
Document is valid

Database access
---------------

JDBC
~~~~

JDBC is Java classes. It is, therefore, usable from Jython.

You will need JDBC driver/adapters for your database.

But, JDBC is not very Pythonic.

zxJDBC
~~~~~~

zxJDBC is Pythonic. zxJDBC implements the Python DB API on top of JDBC. For more on the Python DB API, see SIG on Tabular Databases in Python and Python Database API Specification v2.0.

If zxJDBC is not already in your installed version of Jython, then you can:

1. Downloading the source from http://sourceforge.net/projects/zxjdbc.
2. Creating a directory (e.g. zxJDBC), then un-rolling it.
3. Add zxJDBC/lib/zxJDBC.jar to your CLASSPATH

You can get documentation on zxJDBC by:

1. Downloading the source from http://sourceforge.net/projects/zxjdbc.
2. Creating a directory (e.g. zxJDBC), then un-rolling it.
3. Pointing your browser at zxJDBC/doc/index.html.

Example -- The following example opens a connection to a PostgreSQL database, then prints out the rows in a table in that database. In order to make this example work, I put the following jar files on my CLASSPATH:

• zxJDBC.jar -- Not needed for Jython 2.2, and possibly not needed for the version of Jython 2.1 on your machine. JDBC support has been folded into Jython 2.1 and Jython 2.2a.
• postgresql-8.1-407.jdbc3.jar -- You will need a suitable driver for your database and version.

Here is the example implementation:

"""

For this test, add the JDBC driver to your CLASSPATH.  For example,
in my case I added:

    postgresql-8.2-506.jdbc4.jar

"""

from com.ziclix.python.sql import zxJDBC

def test():
    d, u, p, v = (
        "jdbc:postgresql://thrush:5432/test",   # ... host, port, database
        "postgres",                             # user name
        "mypassword",                           # pass word
        "org.postgresql.Driver",                # driver
        )
    db = zxJDBC.connect(d, u, p, v, CHARSET='iso_1')
    cur = db.cursor()
    cur.execute('select * from plant_db')
    rows = cur.fetchall()
    s1 = '%s %s %s' % (
        'Name'.ljust(12),
        'Description'.ljust(24),
        'Rating'.ljust(10),
        )
    print s1
    s1 = '%s %s %s' % (
        '===='.ljust(12),
        '==========='.ljust(24),
        '======'.ljust(10),
        )
    print s1
    for row in rows:
        rating = str(row[2])
        print '%s %s %s' % (
            row[0].ljust(12), row[1].ljust(24), rating.ljust(10), )
    cur.close()
    db.close()

if __name__ == '__main__':
    test()

Which, when connected to my trivial, little database, prints out the following:

Name         Description              Rating
====         ===========              ======
tomato       red and tasty            8
peach        sweet and succulent      8
tangerine    sweet but tart           7

Resources:

• More information on zxJDBC: http://jython.org/Project/userguide.html#database-connectivity-in-jython
• The JDBC driver for PostgreSQL: http://jdbc.postgresql.org/
• The JDBC driver for MySQL: http://www.mysql.com/products/connector/j/
• Python Tabular Databases SIG: Status -- http://www.python.org/community/sigs/current/db-sig/status/
• The Python Database Topic Guide -- http://www.python.org/doc/topics/database/