Jython Journeys » java scripting

Transforming with XSLT on Google AppEngine and jython.

alan.kennedy — Tue, 01 Dec 2009 18:42:26 +0000

I’m writing this post in response to a challenge. I wrote a post entitled Jython on Google AppEngine: Why bother?, which was a reply to a statement made by a Google engineer about not seeing the point of running jython on AppEngine. And a similar statement was repeated in a comment on that blog post (i.e. “the gist of what I intended to say was that while it was possible to run Jython on App Engine, I couldn’t think why you’d want to.”)

So rather than get into a back-and-forth of yes-it-is-no-it-isnt-yes-it-is, I thought I’d reply with some simple code that demonstrates something that cannot (currently) be done in cpython on AppEngine, but is easy with jython on AppEngine: XSLT transforms.

So, without further ado, here is the jython source code for running an XSLT transform on Google AppEngine. It is implemented as a jython WSGI application, using xhaus.com’s modjy WSGI gateway for java servlets that was contributed to the jython project a few months back.

In order to get this code running, I suggest you download the modjy on google appengine demo from our downloads site. In that download, there is a jython file called “demo_app.py”. Simply replace the entire contents of that file with the code below, and you’re good to go. If you need help with getting the modjy demo application working on Google AppEngine, see the documentation on the modjy wiki: Running jython WSGI applications on Google AppEngine, with modjy.

__doc__ = """
A demonstration of how to run XSLT transforms on Google AppEngine with jython (not cpython).
Please feel free to use this code in whatever way you wish.
"""
from java.io import StringReader, StringWriter
from javax.xml.transform import Transformer, TransformerFactory
from javax.xml.transform.stream import StreamResult, StreamSource
 
xml_data = """

  
    2001 - A Space Odyssey
    Arthur C Clarke
  
  
    I, Robot
    Isaac Asimov
  
  
    Kil'n people
    David Brin
  

"""
 
xslt_source = """

 


  A list of books, transformed into html from xml using xslt and jython.
  
    
      
      A list of books, transformed into html from xml using xslt and jython.
      Title Author
    
    
    
  


 

"""
 
def generate_html(xml_data, xslt_source):
  transformer = TransformerFactory.newInstance().newTransformer(StreamSource(StringReader(xslt_source)))
  output_buffer = StringWriter()
  transformer.transform(StreamSource(StringReader(xml_data)), StreamResult(output_buffer))
  return output_buffer.buffer.toString()
 
def handler(environ, start_response):
  result = generate_html(xml_data, xslt_source)
  start_response("200 Hoopy", [ ('content-type', 'text/html') ])
  return [result]

Happy Transforming!

Jython on Google AppEngine: Why bother?

alan.kennedy — Mon, 30 Nov 2009 14:40:09 +0000

Why on earth would you want to run jython applications on Google Appengine?

First off, I must apologise for the flippant nature of the attention grabbing title. I’m a jython committer, and a jython user, so I believe that there are very good reasons for running jython on Google AppEngine. (You can read how to do so on the modjy wiki: how to run jython applications on Google AppEngine).

The title is essentially a paraphrase of a statement made by a Google AppEngine Evangelist, at a talk about AppEngine that I attended here in Dublin. The speaker was of the opinion that there was no valid reason for running jython on AppEngine, a statement which I couldn’t let pass.

I think that the core of his reasoning for making that statement was a simple misunderstanding, but a misunderstanding that is common among users who are familiar with python, or users of cpython, but who are not familiar with jython’s use as a JVM scripting language. The misunderstanding is that the only reason for running jython is so that one can run python applications on the JVM, using python’s wealth of "batteries included" APIs. If that is the case, then why bother running jython, when one can simply use the cpython support on AppEngine directly?

To explain, when writing a cpython application that processes email, for example, one can make use of the python’s email module, which provides a wealth of features for dealing with the many complexities of parsing, processing and generating email messages, MIME, etc. Users of jython can also use the python email modules, since those modules are written in pure python. But since jython runs on the Java Virtual Machine(JVM) and permits seamless integration of java and python code, jython users writing email processing also have the option of using the excellent JavaMail APIs, which are just as robust as the pure python modules, and arguably more efficient. So jython users have the best of both worlds: they can use either python APIs or java APIs, with equal ease.

Processing email is perhaps too straightforward an example, in that both python and java have excellent email processing support. But due to the more widespread use of java in the development community in general, java generally has far more support for any given technology need, since there are often multiple options available. A good example of this is cryptography: there is a wealth of java cryptography libraries available, including the excellent Bouncy Castle, Cryptix, Flexiprovider, etc. The choice of crypto libraries in python is generally narrower, supports less functionality, and is sometimes abandon-ware.

So if one’s understanding of jython is simply that it is a way to run pure python modules on the JVM, then the above mentioned mis-understanding is forgivable. But it is simply not the case that the primary usage of jython is to run pure python modules: Jython excels as a dynamic/scripting language for the JVM, and permits the use of java APIs, without having to write java code.

In discussion with the Google engineer after the talk, he conceded that there was one possible use case for running jython on AppEngine, namely that of prototyping java applications. In this scenario, applications would

Be developed in jython, taking advantage of the enormous productivity increases gained by developing in python
Be translated to java once the functionality of the application is complete

My reply to this is: “Why bother with step 2″?

If you’ve got a running application that is fully functional and written in jython, then you don’t need to translate it to java. You should only consider translating it, or parts of it, into java if you really have to. For example, after profiling your jython application, you may find one or two core pieces that are performance bottlenecks: these are prime candidates for translation to java, to improve performance. But there’s no reason to translate the rest of the application: maintainability and productivity is best served by simply leaving the jython code exactly as is.

I suppose a part of the reason why this mis-perception of jython has come about is because python is such an excellent language that it is in the unique position of having two completely independent implementations of the language that run on Google AppEngine. But just because both cpython and jython run on AppEngine doesn’t mean that their usages should be identical. Jython’s place in the AppEngine ecosystem is primarily as a JVM dynamic language.

So, in summary, jython is more than just a mechanism for running pure python code on the JVM: it is an excellent JVM development platform in it’s own right.

I hope I’ve given you some good reasons to consider developing your next Google AppEngine project on jython.

Jython 2.5; it’s a beautiful day!

alan.kennedy — Tue, 16 Jun 2009 18:39:23 +0000

A fantastic thing happened today: Jython 2.5 was released! I’ve anticipated this day a long time, as have many others; it’s great that it’s finally happened.

I’ve been using jython since 1999, when it was known as jpython. That was back in the Finn Bock Errata days; Finn had been kind of maintaining jpython after Jim Hugunin left CNRI, and produced a series of upgrade patches and fixes he called Errata. For legal reasons relating to CNRI’s IP, the project name had to be changed to jython; after that Finn, Samuele Pedroni and Barry Warsaw powered forward, bringing jython through cpython 2.0 and 2.1 compatibility. The result was a fantastically robust product, which had completely seamless Java integration, and which went on to become the JVM scripting language for a wide range of applications.

However, after 2.1 had settled down, Finn moved on. Cpython moved onto version 2.2, which brought big changes to the language: metaclasses, descriptors, properties, iterators, generators and nested scopes, to mention a few. All of the new features required large changes in the sometimes complex interactions between cpython and java class designs.

Samuele continued as jython’s maintainer, and a jython 2.2 alpha was produced that provided many of the required new features, and much of which still remains in jython 2.5. But Samuele moved on to the greener pastures of the amazing PyPy project, which is developing a self-hosting python-in-python interpreter. Although that is where his main energies lie, Samuele continues to be a jython contributor and provide valued guidance to the other developers.

The project languished for a couple of years, and the version number did not advance; 2.2 alpha was the state of jython for a long time, principally because of the enormous work involved in implementing a full 2.2 version. Brian Zimmer was project lead for a while, but much of the time there was no clear leadership. Jython 2.1 continued and continues to be used in a lot of places; it’s stability was and is fantastic, and it always did the job. But there was some angst about it’s future, especially with the advance of other JVM scripting languages such as JRuby, and with changes in Java itself, such as Annotations, Generics, etc.

Then the project sprang back to life, with a complete 2.2 being published; Charlie Groves was the key person in that achievement. Charlie did, and still does, an enormous amount of work on jython, and I believe that his dedication to releasing a complete and robust 2.2 version was key to revitalising jython, both the language and the community.

And then came Frank Wierzbicki, the current BDFL, and the person who has done most to bring jython to the modern state it exists in today.

Initially, there was hesitation about which version of the python language to target; cpython had reached version 2.5, and ironpython was at version 2.4. Upgrading jython to 2.3, then 2.4 and then 2.5 seemed like an awful lot of work. Frank adopted a bold strategy: aim to get jython as up-to-date as possible, and bring jython directly to 2.5. And today we’ve seen that that strategy worked!

Congratulations Frank! Superb job!

And well done to a great group of people who’ve contributed fantastic work; Jim Baker, Charlie Groves, Otmar Humbel, Tobias Ivarsson, Philip Jenvey, Nicholas Riley, Leo Soto, among others.

Well done to all the jython development team; ye’ve achieved something wonderful!