Upgrade to Jython 2.5

Up to HIPE 7, we have been using the Jython 2.1 library, which mostly uses the syntax of Python 2.1
Starting from HIPE 8 we will upgrade to Jython 2.5, which uses the same syntax rules as Python 2.5.

In most cases, your scripts will run fine; however, in certain cases you may need to adapt them. This page lists the known differences between Jython 2.1 and Jython 2.5

Wrong locations of global import statements

You may have written code where global import statements are done within a Jython function. As of Jython 2.5, this is not allowed anymore (in fact, it was not allowed in Python 2.1 but Jython 2.1 inadvertently allowed for it).

When executing the code against Jython 2.5, you will get messages such as:

SyntaxWarning: import * only allowed at module level

To fix your code, you have two options:

• Move the global import statement out of the function and to the top of your script.
• Make the import statement specific.

See below for examples of fixes to incorrect code.

Current: wrong use of global import

:
def foo():
    from herschel.ia.foo.banana import * # global import statement, to access SomeThing
    x=SomeThing()
    return

Fix 1: global import statement at start of script

from herschel.ia.foo.banana import *
:
def foo():
    x=SomeThing()
    return

Fix 2: make import statement specific

:
def foo():
    from herschel.ia.foo.banana import SomeThing
    x=SomeThing()
    return

Known jython module changes

The following modules changed their names:

Jython 2.1	Jython 2.5
import javaos	import os

Known jython behavioral changes

__name__

$ from foo import Bar
$ print Bar.__name__
Bar
#Jython 2.1: foo.Bar

$ print Bar.__module__
foo

$ print Bar.__module__ + "." + Bar.__name__
foo.Bar

$ print Bar.name   # if Bar is a Java class
foo.Bar

$ import foo.Bar
$ print foo.Bar.__name__
foo.Bar

If you always want the full name, use: Bar.canonicalName

Numeric types

In Jython 2.1 numeric types were Py objects like PyInteger or PyFloat and as such had methods like toString(). In Jython 2.5 numeric types are more like native types and do not have these basic Object methods available. The difference was discovered when passing an integer into a jython function and then printing this value using the toString() method. In Jython 2.5 this results in the following error:

  <type 'exceptions.AttributeError'>: 'int' object has no attribute 'toString'

The solution is very simple and is also recommended to use in all Jython versions, i.e. replace the toString() with a format string, for example:

HIPE> foo = 3.1415
HIPE> print "foo =", foo.toString()  # DO NOT USE THIS !!
HIPE> print "foo = %f" % foo
foo = 3.141500

Some other Java methods can no longer be applied to numbers (which may require changing some client code). In general, when using Jython we should just use Jython functionality if available to avoid this type of problems. The following example shows what happens when you try to move from "long" to "double" using java.lang.Number methods (to make a floating point division for example).

This works with Jython 2.1:

HIPE> i = 3L
HIPE> print i.__class__
org.python.core.PyLong
HIPE> d = i.doubleValue()
HIPE> print d
3.0

While it no longer works with Jython 2.5 (HIPE 8):

HIPE> i = 3L
HIPE> print i.__class__
<type 'long'>
HIPE> d = i.doubleValue()
<type 'exceptions.AttributeError'>: 'long' object has no attribute 'doubleValue'
HIPE> print d
<type 'exceptions.NameError'>: name 'd' is not defined

In this particular case the following alternatives can be used to promote to floating point:

• Add a float literal to the expression ( + 0.0 )
• Use an explicit cast to float (float(i))