Differences between revisions 2 and 10 (spanning 8 versions)
Revision 2 as of 2007-10-18 21:04:01
Size: 73693
Editor: DaveKuhlman
Comment:
Revision 10 as of 2008-01-22 16:55:22
Size: 87622
Editor: status
Comment: typo: ...attr does not exit. ==> attr does not exist. [shoulda kept reading :) ]
Deletions are marked like this. Additions are marked like this.
Line 12: Line 12:
:date: Oct. 18, 2007 :date: Nov 12, 2007
Line 35: Line 35:
But, if you do know know Python **or** Jython, then here are good But, if you do not know Python **or** Jython, then here are good
Line 299: Line 299:
Intergrating Java into Jython/Python Integrating Java into Jython/Python
Line 938: Line 938:
                throw new PyException(Py.KeyError, "The attr does not exit.");                 throw new PyException(Py.KeyError, "The attr does not exist.");
Line 956: Line 956:
      KeyError: The attr does not exit.       KeyError: The attr does not exist.
Line 1055: Line 1055:
  -- Note that the example that follow was developed from this   -- Note that the following examples were developed from this
Line 1063: Line 1063:
  classes.   classes. Or, perhaps this code already exists.
Line 1073: Line 1073:
    classes; (3) retrieve and save the Jython classes from the     classes; (3) retrieves and saves the Jython classes from the
Line 1079: Line 1079:
- Implement the Java code that uses the Jython classes: (1) create a
 
factory object; (2) call the "createX" methods to create Java
 
objects that give access to the Jython classes; (3) call the
 
Jython methods through the Jython "proxies".
- Implement the Java code that uses the Jython classes. This Java
  code will typically do the following
:

  
1. Create a factory object.

  
2. Call the "createX" methods to create Java objects that give
     access to the Jython classes.

  
3. Call the Jython methods through these Jython "proxies".
Line 1095: Line 1101:
    | |-- DependentType.java # The Java interface
    | `-- EmployeeType.java # The Java interface
    | |-- DependentType.java # A Java interface
    | `-- EmployeeType.java # A Java interface
Line 1101: Line 1107:
  your Jython/Python path. See ``python.path``.in your registry   your Jython/Python path. See ``python.path`` in your registry
Line 1107: Line 1113:
Line 1276: Line 1283:
Line 1515: Line 1523:

An interpreter with an initial system state
+++++++++++++++++++++++++++++++++++++++++++
Line 1545: Line 1557:
A system state and a custom class loader
++++++++++++++++++++++++++++++++++++++++
Line 1549: Line 1564:
    MyClassLoader classLoader = new MyClassLoader();     RestrictedClassLoader classLoader = new RestrictedClassLoader();
Line 1589: Line 1604:
Line 1673: Line 1687:
Here is an example::

    xxxx
There is an example in section `A system state and a custom class loader`_.

Embedding a Jython console
~~~~~~~~~~~~~~~~~~~~~~~~~~

This example shows how to embed a Jython interactive console into a
Java program::

    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.");
        }
    }

Notes:

- For more information see:
  `API information on Class InteractiveConsole --
  http://jython.org/docs/javadoc/org/python/util/InteractiveConsole.html
  <http://jython.org/docs/javadoc/org/python/util/InteractiveConsole.html>`_.
Line 2157: Line 2207:
Example::


    """

    To run this example, add the following to your CLASSPATH:

        ${path-to-dom4j}/dom4j-1.6.1.jar


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

- Download ``dom4j`` from:
  `dom4j: the flexible XML framework for Java --
  http://www.dom4j.org/
  <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/
  <http://jaxen.codehaus.org/>`_.


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

There are examples at:

- `dom4j - Quick Start Guide --
  http://www.dom4j.org/guide.html
  <http://www.dom4j.org/guide.html>`_

- `dom4j cookbook --
  http://www.dom4j.org/cookbook.html
  <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::
Line 2181: Line 2252:
            print '%sNode: %s' % (show_indent(level), name, )             print '%sElement node: %s' % (show_indent(level), name, )
Line 2186: Line 2257:
                print ' %sAttr -- %s: %s' % (show_indent(level), aName, aValue,)
        if node.getName() == 'interest':
            val = node.getText()
            print '%sinterest: "%s"' % (show_indent(level+1), val, )
        elif node.getName() == 'name':
            val = node.getText()
            print '%sname : "%s"' % (show_indent(level+1), val, )
        #
        # Note that there are *no* TEXT_NODE's.
        # dom4j does not seem to produce any.
        #
        if node.getNodeType() == node.TEXT_NODE:
            print '**** text node'
                print ' %sAttr -- %s: %s' % (show_indent(level), aName, aValue,)
            if node.text:
                print ' %sText: "%s"' % (show_indent(level), node.text,)
Line 2204: Line 2264:
        children = node.elements()
        for child in children:
            show_tree(child, level1)

    def test():
        if node.getNodeType() == node.ELEMENT_NODE:
    
children = node.elements()
            for child in children:
     show_tree(child, level1)

    def test(infilename):
Line 2211: Line 2272:
        doc = reader.read('file:///home/dkuhlman/a1/Python/Jython/Test/people.xml')         doc = reader.read(infilename)
Line 2216: Line 2277:
        test()         args = sys.argv[1:]
        if len(args) != 1:
            print 'usage: test_dom4j_2.py in_xml_file'
            sys.exit(1)
        test(args[0])
Line 2222: Line 2287:
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.
Line 2229: Line 2426:

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
  <http://xmlbeans.apache.org/index.html>`_.

- `XMLBeans at Wikipedia --
  http://en.wikipedia.org/wiki/XMLBeans
  <http://en.wikipedia.org/wiki/XMLBeans>`_.


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

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

To install XMLBeans, follow the instructions at:
`Installing XMLBeans --
http://xmlbeans.apache.org/documentation/conInstallGuide.html
<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
<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
Line 2293: Line 2696:
        postgresql-8.1-407.jdbc3.jar         postgresql-8.2-506.jdbc4.jar
Line 2345: Line 2748:
- Python Tabular Databases SIG: Status
  <http://www.python.org/community/sigs/current/db-sig/status/>`_
  (http://www.python.org/community/sigs/current/db-sig/status/).

- The Python `Database Topic Guide
  <http://www.python.org/doc/topics/database/>`_
  (http://www.python.org/doc/topics/database/).
Line 2354: Line 2749:
  http://sourceforge.net/projects/zxjdbc   http://jython.org/Project/userguide.html#database-connectivity-in-jython
Line 2360: Line 2755:

- `Python Tabular Databases SIG: Status --
  http://www.python.org/community/sigs/current/db-sig/status/
  <http://www.python.org/community/sigs/current/db-sig/status/>`_

- The Python `Database Topic Guide --
  http://www.python.org/doc/topics/database/
  <http://www.python.org/doc/topics/database/>`_

Jython Course Outline

Author: Dave Kuhlman
Address:
dkuhlman@rexx.com
http://www.rexx.com/~dkuhlman
Revision: 1.1a
Date: Nov 12, 2007
Copyright: Copyright (c) 2006 Dave Kuhlman. All Rights Reserved. This software is subject to the provisions of the MIT License http://www.opensource.org/licenses/mit-license.php.

Abstract

This document provides an outline of an introductory course on programming in Jython and connecting Jython to Java

Contents

1   How-to Write Jython Code

Jython is Python. That's one of its big advantages: you get two for the price of one. If your learn Python, then you have also learned Jython, and vice versa. If you already know Python, then you know Jython.

But, if you do not know Python or Jython, then here are good training aids:

2   Installing and Running Jython

2.1   Install Jython

You will need Java installed, of course. And, since you are likely to want to use Jython class libraries from Jython, it is also likely that you will want the Java SDK. Important: If more than one version of Java is installed on your machine, make sure that when you install Jython using the version of Java for which the SDK is installed and the version of Java that you will be using when you run Jython.

Download the Jython installation jar file -- You can file the Jython distribution here: Jython downloads -- http://jython.org/Project/download.html.

Install Jython -- Follow the instructions at: Jython installation -- http://jython.org/Project/installation.html:

$ java -jar jython_installer-2.2.jar

Command line history -- On MS Windows, command line history for the Jython interactive interpreter comes built-in. On Linux, to get command line history, command line editing, and readline support, follow the instructions here: ReadlineSetup -- http://wiki.python.org/jython/ReadlineSetup.

2.2   Configuration

There are several places to configure Jython.

2.2.1   Command-line options

To display the options for jython, type:

$ jython --help
2.2.2   Jython configuration files

For explanation of configuration options and values, see:

2.2.3   Checking configuration values

From within the Jython interactive interpreter or from within your Jython application, you can display the values of configuration properties.

To get the system properties as a dictionary-like object, do:

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

Of particular interest are the following:

  • props['java.class.path'] -- Location of the Jython jar file.
  • props['java.library.path'] -- Locations of Java class libraries.

Other properties are in sys.registry:

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

Here is a script that you may find useful when interactively inspecting system properties:

>>> 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
2.2.4   Classpath and python path

Jython can pick up Java class files from locations on either the Jython/Python path (see sys.path) or the Java classpath. Set these with the following:

  • The Python/Jython path can be set in your registry file. See registry variable python.path.

    Or, at runtime, you could do:

    >>> import sys
    >>> sys.path.append('/path/to/module')

    But, you must do the above before trying to import the module.

  • Set the classpath by setting the CLASSPATH environment variable. Note that (on my Linux machine, at least) the CLASSPATH environment variable is picked up and added to the Java -classpath flag.

A few rules about CLASSPATH and python.path:

  • sys.path in the registry file -- Add here to enable importing from Java classes (.java), Java class libraries (.jar), and Jython/Python (.py).
  • CLASSPATH -- Add paths to this environment variable in order to enable importing from Java classes (.java) and Java class libraries (.jar), but not Jython/Python (.py).

2.3   Running Jython

The Jython interactive, command-line interpreter: jython.

Jython IDEs (interactive development environments) -- There is a Jython plug-in for Eclipse. See: http://pydev.sourceforge.net/.

Exercises -- Start the Jython interpreter. Then do each of the following:

  • Print "hello".
  • Define an empty class.
  • Import a Python/Jython file containing a class definition. Create an instance of that class.
  • Import a module from the standard Python/Jython library, for example, re or os.path. Use a method from that module.
  • 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.

2.4   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.

3   Integrating Java into Jython/Python

3.1   Calling existing Java code

In order to call Java code from Jython do the following:

  1. Import the Java module.
  2. Use the Java module to create an instance/object.
  3. Call functions and objects in it.

It works the way you would hope and expect it to. Here is an example:

>>> 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

In some cases you will need to pass Java objects to Java methods.

Special treatment for some overloaded Java methods -- Explicitly create and pass Jython objects. For more on this, see: Overloaded Java Method Signatures -- http://www.jython.org/Project/userguide.html#overloaded-java-method-signatures.

Often you can use Python/Jython style and idioms to process Java objects. For example: the Jython for statement can be applied to Java collection objects.

Exercise -- Use the class java.util.Hashtable to create a dictionary with several keys and values, then print out the keys and their values. Solution:

>>> 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

3.2   Extending a Java class in Jython

You can import and then extend (sub-class) a Java class.

Example -- This sample extends the Java filestream class by adding a method that converts all characters to upper case::

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()

3.3   Emulating Jython classes in Java

You can make a Java class "act like" one of the built-in Jython classes. In order to do so, you would implement one or more of Jython's special methods. You can find descriptions of the special methods in the "Python Reference Manual": 3.4 Special method names -- http://docs.python.org/ref/specialnames.html.

Example: This module implements a class that acts like a sequence in certain ways, specifically (1) it responds to the len() operator by returning a length; (2) it supports an append method; and (3) it supports the use of the [] operator to get a value:

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);
    }
}

And here is an example of the use of this custom container class:

$ 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

Notes:

3.4   Preparing Java code to be called from Jython

Another view: Java is the extension language for Jython.

No special work is required. Jython can call normal Java classes.

Need to pay attention to data types, for example, on the Jython side. Use an explicit cast, for example, float(5).

For additional help, see:

You can also customize a Java class to make it more "Jythonic".

3.4.1   Adding doc strings to a Java class

This first, simple example adds doc strings:

// 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 + "\".");
    }
}

Notes:

  • Doc strings for the class and methods are defined with public static Strings. You can, alternatively, use PyString.
  • For more complex control over doc strings (for example, in a Java files that contains multiple classes) your class can implement the ClassDictInit interface and implement the classDictInit method. See "Jython for Java Programmers", pp. 276 ff.
3.4.2   Working with Jython arguments

The ArgParser class helps us handle Jython keyword arguments. If helps us support the analog of Jython's *args and **kwargs in Java methods.

How to do it -- An overview:

  1. Define your Java method with the following prototype:

    public PyObject foo(PyObject[] args, String[] keywords);
  2. Parse the arguments with class ArgParser.
  3. Access individual arguments with ArgParser methods getInt(), getString(), getList(), and getPyObject().
  4. Since both args and keywords are arrays, check the number of arguments actually passed with args.length and keywords.length.

For more information, see: org.python.core Class ArgParser.

Exercise -- (1) Write a Java class containing a method that prints all its arguments and all the keyword arguments passed to it. (2) Then call that method from Jython.

Solution:

// 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 + "\".");
    }
}

Compile the above file with javac or some other Java compiler. To do so, you will need to add jython.jar to your CLASSPATH.

Notes:

  • Use class ArgParser to capture the arguments.
  • Use ArgParser methods getInt, getString, getPyObject, and getList to retrieve arguments.
  • Notice that in method get_name, we print the length of the args and kwargs. This demonstrates that you can check the length of these arrays and can throw an exception if, for example, too few arguments are passed.

Also see the Jython FAQ: 5.3 Supporting *args and **kw in Java methods -- http://jython.org/Project/userfaq.html#supporting-args-and-kw-in-java-methods.

3.4.3   Sub-classing a Java class

Notice that, in Jython, we can extend a class written in Java:

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()

When you run the above, you should see something like the following:

$ 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
3.4.4   Emulating Jython Dictionaries, Sequences, Etc.

Extend class org.python.core.PyObject and its sub-classes. See: org.python.core Class PyObject.

Implement the following methods:

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

getitem() vs. finditem():

  • If the index is not found or out of range, finditem() returns null, whereas __getitem() should throw an exception.
  • The Jython API documentation says to override finditem() and not getitem(). See: org.python.core Class PyObject.

See 3.3.5 Emulating container types -- http://docs.python.org/ref/sequence-types.html in the Python Reference Manual for more information on customizing dictionaries and sequences.

Exercise -- (1) Write a Java class that emulates or imitates a Jython dictionary. (2) In addition, each access method should print a message. (3) Test your Java class from Jython by creating an instance of it, then setting and retrieving a key-value pair.

3.4.4.1   Solution #1 -- Emulating a dictionary

This solution is for educational purposes only (see Solution #2 -- Extending PyDictionary):

// 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;
            }
    }
}

Notes:

  • The above class implements a limited part of the Jython dictionary protocol, in particular __setitem__, __getitem__, and __contains__.

  • This above solution also illustrates how to throw ("raise" in Jython terms) an exception from Java that can be caught in Jython. Here is an example of catching that exception on the Jython side:

    >>> try:
    ...   x = b['xyz']
    ... except KeyError, e:
    ...   print '*** error: %s' % e
    ...
    *** error: The key does not exit.
  • The Jython FAQ recommends that your Jython class extends PyObject. (see 5. Extending Jython -- http://jython.org/Project/userfaq.html#extending-jython) I've found that it is not strictly necessary to extend PyObect in your Java class (the one that emulates a Jython built-in). But, if you do, you will need to follow the signature of the methods that implement operators (for example __setitem__, __getitem__, etc) exactly. To learn those signatures, see the API documentation in the Doc/ directory under your Jython installation.

Here is an example that uses the above solution:

# 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()

And, here is the result of running this 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
3.4.4.2   Solution #2 -- Extending PyDictionary

This solution shows how you most likely would start if you wanted to extend the dictionary type or implement a custom dictionary type:

// 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.");
        }
    }
}

Notes:

  • This class inherits the methods in the PyDictionary class. It overrides several of those methods, specifically __setitem__ and __getitem__.
  • The Java class could also extend the dictionary type by implementing additional, new methods.

Also see the Jython FAQ: 5.1 Java classes that emulate Jython Dictionaries and Sequences -- http://jython.org/Project/userfaq.html#java-classes-that-emulate-jython-dictionaries-and-sequences.

3.4.5   Emulating Jython object attribute access

We can implement and override object attribute access in a Java class:

Extend class org.python.core.PyObject and its sub-classes.

Implement the following methods:

__findattr__()
__setattr__()
__delattr__()

__findattr__() is called only if an attribute is not found in an object.

Exercise -- (1) Write a Java class class that supports access to attributes. (2) In addition, each access method should print a message. (3) Test your Java class from Jython by creating an instance of it, then setting and getting an attribute.

Solution:

// 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.");
        }
    }
}

Notes:

  • Test this solution with the following:

    $ jython
    Jython 2.2a1 on java1.4.2 (JIT: null)
    Type "copyright", "credits" or "license" for more information.
    >>>
    >>> import TestDictAttr
    >>> a = TestDictAttr()
    >>> print a.dave
    Traceback (innermost last):
      File "<console>", line 1, in ?
    KeyError: The attr does not exist.
    >>> a['dave'] = 'some little value'
    >>> print a.dave
    Found attr "dave"  value: "some little value"
    some little value
  • Arguments to __findattr__ and __finditem__ must be interned strings. Literal strings are automatically interned. For other strings, use intern(s).

Also see the Jython FAQ: 5.2 Emulating Jython object attribute access with a Java class -- http://jython.org/Project/userfaq.html#emulating-jython-object-attribute-access-with-a-java-class.

3.5   Extending a built-in Jython class in Java

In Java, you can inherit from an extend the built-in Jython classes.

Some of the classes that you can consider extending are:

  • PyDictionary
  • PyInteger
  • PyList
  • PyString
  • PyStringMap
  • PyTuple

An example that extends the PyDictionary class is in section Solution #2 -- Extending PyDictionary.

4   Integrating Jython/Python into Java

4.1   Calling Jython from Java

4.1.1   Run Jython code on an interpreter embedded in Java

jythonc is currently unsupported and is deprecated, although it might reappear in some future version of Jython. So, using jythonc to compile your Jython code to Java for use in your Java code may not appeal to you. An embedded Jython interpreter may be a solution.

Overview -- Here is the general approach:

  1. Create a Jython interpreter object.
  2. Insert (set) values in your embedded interpreter, if needed.
  3. Use that interpreter to either:

    1. Run several lines of code that import and use your Jython module, or
    2. Run a small wrapper script that imports and uses your Jython modules.
  4. Retrieve values from your embedded interpreter, if necessary.

Each of these topics has been covered above.

Disadvantages of this approach:

  • It's a little clumsy. Requires a small amount of Java code.

Advantages of this approach:

  • jythonc is not required. jythonc is deprecated and is not planned for Jython 2.3.
  • No need for a separate compile step.
  • No need to re-compile your script each time it is modified.
4.1.2   How to run Jython code on an interpreter embedded in Java

Resources -- For instructions on how to call Jython code from Java, see:

Description -- In order to implement this approach, here is what you will do:

  • Implement one or more Jython/Python modules containing one or more classes. Or, perhaps this code already exists.
  • Create a Java interface for each Jython class that you want to expose to Java. The interface should describe each method that you wish to expose to Java.
  • Create a single Java "factory" class:
    • The constructor (1) creates a Jython interpreter; (2) runs a script that imports the Jython modules containing the Jython classes; (3) retrieves and saves the Jython classes from the intrepreter.
    • Implement one "createX" method for each Jython/Python class/type to be used from Java.
  • Implement the Java code that uses the Jython classes. This Java code will typically do the following:
    1. Create a factory object.
    2. Call the "createX" methods to create Java objects that give access to the Jython classes.
    3. Call the Jython methods through these Jython "proxies".
4.1.2.1   Example -- a possible organization on disk
|-- 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

Notes:

4.1.2.2   Example -- the Jython classes

These are the Jython classes that we wish to expose to and call from Java:

# 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
4.1.2.3   Example -- A Java interface class

This (jyinterface/interfaces/EmployeeType.java) describes the interface to our Java (client) code:

// 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);
}
4.1.2.4   Example -- another interface class

This (jyinterface/interfaces/DependentType.java) is another interface. It describes and helps to expose another Jython class.

// DependentType.java

package jyinterface.interfaces;

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

Notes:

  • We only describe the portions of the interface that we wish to expose to Java. It is likely that this will be a proper subset of the methods in our Jython class.
4.1.2.5   Example -- the factory class

This (jyinterface/factories/EmployeeFactory.java) is the factory that creates (proxy) instances of our Jython classes. These instances are Java instances with an underlying Jython implementation:

// 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;
}

Notes:

  • The Jython interpreter is created only once, when the factory object is created.
  • The Java classes that are proxies for the Jython classes exposed to Java (jyEmployeeClass amd jyDependentClass) are also only created once.
  • Each "creater" method (createEmployee and createDependent) uses the __call__ method to create an instance. This is the same as using obj = Employee(), for example, in Jython. Then the result is converted to a Java object and returned.
4.1.2.6   Example -- the Java consumer code

This (jyinterface/Main.java) is the Java code that uses our Jython classes:

// 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);
    }
}

Notes:

  • This client code creates a factory object, then uses that factory object to create several Java objects that are proxies for the Jython Employee and Dependent objects.

  • Then the client code calls several of the methods that are implemented in the Jython code and exposed to Java through the Java interfaces.

  • On the Java side, we apply operators to a list object (and other Jython built-in types) by calling their methods directly, for example:

    • len() -- obj.__len__()
    • obj[idx] -- obj.__getitem__(idx)

    For descriptions of these "special" methods, see the following section in the Python language reference: 3.4 Special method names -- http://docs.python.org/ref/specialnames.html.

  • On the Java side, we use a Jython object by

    1. Retrieving it as a generic PyObject.

    2. Converting it to a Java object with:

      obj.__tojava__(XXType.class)

      where XXType is the Java interface that describes the Jython object.

    3. Casting the object to the appropriate Java type.

    4. Calling its "Java" methods.

  • We can pass a Jython object back to Jython from Java. Notice the call to method addDependent().

4.1.3   Additional support for running Jython code on an interpreter embedded in Java

In what follows, we provide and describe scripts that assist in using the above strategy.

4.2   Embedding Jython into Java

4.2.1   Why embedded Jython

There are several reasons and purposes for embedding the Jython interpreter into your Java application:

  • You want to offer your users the flexibility and power of customizing and extending your application. An embedded Jython interpreter enables them to run Jython scripts in your application and to communicate with it.
  • You have existing Jython code, and you want to use that code in your Java application. Note that this is a capability that might have been handled by using the jythonc compiler to compile your Jython script into Java code, but jythonc is deprecated. For an example of this technique and information on how to do it, see section Calling Jython from Java.
4.2.2   Embedding Jython into Java is simple

Embedding the Jython interpreter can be as simple as this:

// 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");
    }
}
4.2.3   Passing values into a Jython script

Notice the call interp.set("a", new PyInteger (42)); in the above example.

You can also retrieve the dictionary object representing the namespace for the interpreter, then retrieve objects from that dictionary. Example:

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

You can also create a Jython interpreter with an initial global namespace:

// 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");
    }
}
4.2.4.1   An interpreter with an initial system state

And, you can create an interpreter with an initial system state:

// 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");
    }
}
4.2.4.2   A system state and a custom class loader

This is of interest because the system state can be used to provide a custom class loader:

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

And here is a sample class loader. This one merely restricts the classes that can be loaded to a small set:

// 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.");
    }
}
4.2.5   Retrieving values from a Jython script

Notice the call PyObject x = interp.get("x"); in the above example.

You can also retrieve the dictionary object representing the namespace for the interpreter, then add and modify the names and their values in that dictionary. Example:

PyDictionary namespace = interp.getLocals();
PyInteger value = new PyInteger(144);
namespace.__setitem__("x", value);
4.2.6   There are also a few complexities

You will want to selectively expose capabilities from your Java application to scripts run by/on the embedded Jython interpreter.

You will want to protect your application from malicious or erroneous scripts.

Here are a few suggestions:

  • Describe your possible classes of users (those who will write scripts) with respect to (1) trusted vs. untrusted and (2) error tolerant vs. non-tolerant.
  • For users who are trusted and error tolerant, provide transparent objects from your application.
  • For users who are trusted and not error tolerant, provide opaque objects, i.e. wrappers for real objects from your application.
  • For users who are not trusted, implement a security policy, or do not expose a scripting interface at all.
4.2.7   Exposing transparent objects

Java application objects and values can be passed through to scripts executed or evaluated by the embedded interpreter.

Some mechanisms for passing objects:

  • set and get -- Use these to set or retrieve values in the local namespace for the scripts that your embedded interpreter will run or has run.
  • setLocals and getLocals -- Using these methods, you can pass or retrieve the entire namespace. If you are inserting values to be used (or shared) by scripts, you may want to retrieve and, possibly, copy the initial namespace. Remember that is a Jython dictionary, so modifying it without copying may affect other scripts running in the same interpreter.
4.2.8   Exposing opaque objects

This is similar to the strategy for transparent objects, except that you must implement wrapper classes, then provide instances of these classes instead of instances of transparent objects.

4.2.9   Type conversion

Mostly, Jython takes care of this for you.

However, at times it may help to know what conversions are performed.

And, you can also perform explicit conversions.

4.2.10   Using a custom class loader

You can control access to Java classes with a custom class loader. There is an example in section A system state and a custom class loader.

4.2.11   Embedding a Jython console

This example shows how to embed a Jython interactive console into a Java program:

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.");
    }
}

Notes:

5   Deployment and Distribution

Suppose we would like to package our Jython application in a Java jar file, then deploy our application by distributing that jar file so that our users can run it. And, furthermore, suppose we would like our users to be able to run our Jython application on machines where Jython is not installed.

This section explains how to do that. This explanation is also at: Distributing Jython Scripts -- http://wiki.python.org/jython/JythonFaq/DistributingJythonScripts.

So, this boils down to:

  • Having your scripts (*.py) inside standalone jython.jar in the /lib directory

  • Having all the classes (*.class) in the /org or /com directory

  • Having all the jar files you need on the classpath (including standalone jython.jar)

  • Start java with the -jar option. For example:

    $ java -jar jython.jar {optional .py file}

5.1   Building jars - some samples

The following examples assume that you want to build and run your Jython application from a jar file in a way that is '''not''' dependent on files in your Jython installation. This will enable your users to run your Jython application (packaged in a jar file) without installing Jython. They will, of course, need Java installed on their machines.

The following example scripts were developed on Linux (and the bash shell), but with minor modifications, you should be able to do the same thing in an MS DOS box on MS Windows. I use the zip/unzip tools available from Info-Zip (http://www.info-zip.org/), but other tools that support the zip format should also work.

5.1.1   Add Jython install stuff to our jar

To build our jar, we first make a copy of jython.jar, then add the contents of the Lib/ directory to it:

$ cd $JYTHON_HOME
$ cp jython.jar jythonlib.jar
$ zip -r jythonlib.jar Lib
5.1.2   Add modules and paths to the jar file

Then we copy this expanded jar file, and add modules that are specific to our application. I'm also going to add a path to an additional jar file to the manifest:

$ cd $MY_APP_DIRECTORY
$ cp $JYTHON_HOME/jythonlib.jar myapp.jar
$ zip myapp.jar Lib/showobjs.py
# Add path to additional jar file.
$ jar ufm myapp.jar othermanifest.mf

Where, othermanifest.mf contains the following:

Class-Path: ./otherjar.jar
5.1.3   Run the script/jar

Now I have a self-contained jar file that I can run by executing the following:

$ java -jar myapp.jar testmyapp.py

The file testmyapp.py imports modules that I have added to myapp.jar and otherjar.jar, then starts my application.

5.1.4   A more self-contained jar file

Now suppose you want to package your "start-up" script in the (main) jar itself. In order to do so, follow the above instructions plus:

  • Rename (or copy) your start-up script to __run__.py. Add it to the (main) jar file at the root. (On Linux/UNIX you could also do this by using the ln -s command to create a symbolic link.) For example, you might do something like this:

    $ zip myapp.jar __run__.py
  • Add the path to your jar to your CLASSPATH environment variable.

Now you can run your application with the following:

$ java org.python.util.jython -jar myapp.jar

Notice how, when we start the application, we specify the jython class (org.python.util.jython) on the command line. That starts the Jython interpreter, which looks for and runs our __run__.py script.

5.1.5   A summary

Create the basic jar:

$ cd $JYTHON_HOME
$ cp jython.jar jythonlib.jar
$ zip -r jythonlib.jar Lib

Add other modules to the jar:

$ cd $MY_APP_DIRECTORY
$ cp $JYTHON_HOME/jythonlib.jar myapp.jar
$ zip myapp.jar Lib/showobjs.py
# Add path to additional jar file.
$ jar ufm myapp.jar othermanifest.mf

For a more self-contained jar, add the {{{__run__.py}}} module:

# Copy or rename your start-up script.
$ cp mymainscript.py __run__.py
# Add your start-up script (__run__.py) ot the jar.
$ zip myapp.jar __run__.py
# Add path to main jar to the CLASSPATH environment variable.
$ export CLASSPATH=/path/to/my/app/myapp.jar:$CLASSPATH

On MS Windows, that last line, setting the CLASSPATH environment variable, would look something like this:

set CLASSPATH=C:\path\to\my\app\myapp.jar;%CLASSPATH%

Or, again on MS Windows, use the Control Panel and the System properties to set the CLASSPATH environment variable.

Run the application:

$ java -jar myapp.jar mymainscript.py arg1 arg2

Or, if you have added your start-up script to the jar:

$ java org.python.util.jython -jar myapp.jar arg1 arg2

6   Integrating, Embedding, and Extending -- A Summary

Here is what we have learned to do:

  • Import and use Java classes in Jython.
  • Extend a Java class in Jython.
  • Implement Java classes that are more "Jythonic" and that expose Jython features such as doc-strings, inherit and extend Jython classes (for example, PyList, PyDict, etc.).
  • Call Jython code from Java.
  • Embed a Jython interpreter in a Java application.
  • Package and deploy a Jython application as a jar file.

7   Jython+Java -- Other Advanced Topics

7.1   Event handling

Events are easy in Jython.

Here is an example taken from "An Introduction to Jython" (http://www.javalobby.org/articles/jython/):

from javax.swing import *

def hello(event):
    print "Hello.  I'm an event."

def test():
    frame = JFrame("Hello Jython")
    button = JButton("Hello", actionPerformed = hello)
    frame.add(button)
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
    frame.setSize(300, 300)
    frame.show()

test()

7.2   XML

7.2.1   jaxp

Note: Tested with jython-2.2a.

Example:

"""

To run this example, set your CLASSPATH with something like the following:

    export CLASSPATH=\
    ${path-to-xerces}/xerces-2_8_0/xercesImpl.jar:\
    ${path-to-xerces}/xerces-2_8_0/xml-apis.jar


"""


import sys
import java.lang.Boolean
from javax.xml.parsers import DocumentBuilderFactory


def test(infilename):
    """Parse XML document and show attributes and names.
    """
    dbf = DocumentBuilderFactory.newInstance()
    t = java.lang.Boolean(1)
    dbf.setNamespaceAware(t)
    db = dbf.newDocumentBuilder();
    doc = db.parse(infilename)
    # print dir(doc)
    node = doc.getDocumentElement()
    print 'Attributes:'
    show_attrs(node)
    print 'Names:'
    show_names(node)


def show_attrs(node):
    """Show the attributes and their values.
    """
    node = node.getFirstChild()
    while node:
        if node.getNodeType() == node.ELEMENT_NODE:
            print '   %s:' % (node.getTagName(), )
            attrs = node.getAttributes()
            count = attrs.getLength()
            for idx in range(count):
                attr = attrs.item(idx)
                print '        %s: %s' % (
                    attr.getNodeName(), attr.getNodeValue(), )
        node = node.getNextSibling()


def show_names(node):
    """Show the value of the name element for each person element.
    """
    node = node.getFirstChild()
    while node:
        if (node.getNodeType() == node.ELEMENT_NODE and
            node.getTagName() == 'person'):
                show_person_name(node)
        node = node.getNextSibling()


def show_person_name(node):
    node = node.getFirstChild()
    while node:
        if (node.getNodeType() == node.ELEMENT_NODE and
            node.getTagName() == 'name'):
                show_text('name: ', node)
        node = node.getNextSibling()


def show_text(msg, node):
    """Show a message and the value of a text node.
    """
    node = node.getFirstChild()
    while node:
        if node.getNodeType() == node.TEXT_NODE:
            print '    %s %s' % (msg, node.getNodeValue(), )
        node = node.getNextSibling()


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


def main():
    args = sys.argv[1:]
    if len(args) != 1:
        usage()
    test(args[0])


if __name__ == '__main__':
    main()

Resources:

7.2.2   Xerces

Xerces is an implementation of XML parsers and a lot more. The JAXP API is also implemented in Xerces2.

Obtain Xerces here: http://xerces.apache.org/xerces2-j/download.cgi.

Installation instructions are here: Installation Instructions.

Set-up -- Set your CLASSPATH. After unpacking the Xerces distribution, add the following jar files to your CLASSPATH:

  • xercesImpl.jar
  • xml-apis.jar

Here is an example that uses the Xerces DOM parser to parse an XML document, then print out information about the top level nodes in the document:

from org.apache.xerces.parsers import DOMParser as dp

def test():
    parser = dp()
    parser.parse('people.xml')
    doc = parser.getDocument()
    node = doc.getFirstChild()
    node = node.getFirstChild()
    while node:
        if node.getNodeType() == node.ELEMENT_NODE:
            print node.getTagName()
            attrs = node.getAttributes()
            count = attrs.getLength()
            for idx in range(count):
                attr = attrs.item(idx)
                print '    %s: %s' % (attr.getNodeName(), attr.getNodeValue(),)
        node = node.getNextSibling()

if __name__ == '__main__':
    test()

Here is another example. This one also prints out the text values of the name elements:

"""

To run this example, set your CLASSPATH with something like the following:

    export CLASSPATH=\
    ${path-to-jython2.2a}/jython.jar:\
    ${path-to-xerces}/xerces-2_8_0/xercesImpl.jar:\
    ${path-to-xerces}/xerces-2_8_0/xml-apis.jar


"""


import sys
from org.apache.xerces.parsers import DOMParser as dp


def test(infilename):
    """Parse XML document and show attributes and names.
    """
    parser = dp()
    parser.parse(infilename)
    doc = parser.getDocument()
    node = doc.getFirstChild()
    print 'Attributes:'
    show_attrs(node)
    print 'Names:'
    show_names(node)


def show_attrs(node):
    """Show the attributes and their values.
    """
    node = node.getFirstChild()
    while node:
        if node.getNodeType() == node.ELEMENT_NODE:
            print '   %s:' % (node.getTagName(), )
            attrs = node.getAttributes()
            count = attrs.getLength()
            for idx in range(count):
                attr = attrs.item(idx)
                print '        %s: %s' % (
                    attr.getNodeName(), attr.getNodeValue(), )
        node = node.getNextSibling()


def show_names(node):
    """Show the value of the name element for each person element.
    """
    node = node.getFirstChild()
    while node:
        if (node.getNodeType() == node.ELEMENT_NODE and
            node.getTagName() == 'person'):
                show_person_name(node)
        node = node.getNextSibling()


def show_person_name(node):
    node = node.getFirstChild()
    while node:
        if (node.getNodeType() == node.ELEMENT_NODE and
            node.getTagName() == 'name'):
                show_text('name: ', node)
        node = node.getNextSibling()


def show_text(msg, node):
    """Show a message and the value of a text node.
    """
    node = node.getFirstChild()
    while node:
        if node.getNodeType() == node.TEXT_NODE:
            print '    %s %s' % (msg, node.getNodeValue(), )
        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:
        usage()
    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:

7.2.3   dom4j
7.2.3.1   Installation and setup
7.2.3.2   Examples etc

There are examples at:

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:

7.2.4   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:

7.2.4.1   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.

7.2.4.2   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

7.3   Database access

7.3.1   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.

7.3.2   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:

9   References and Sources

Introductory articles:

Thanks to David Goodger for the following list or references. His "Code Like a Pythonista: Idiomatic Python" (http://python.net/~goodger/projects/pycon/2007/idiomatic/) is worth a careful reading:

LearningJython (last edited 2018-03-07 21:17:20 by JeffAllen)