Preserving the Java-type of an object when passing it from Java to Jython

Question

I wonder if it possible to not have jython automagicaly transform java objects to python types when you put them in a Java ArrayList.

Example copied from a jython-console:

>>> b = java.lang.Boolean("True");
>>> type(b)
<type 'javainstance'>
>>> isinstance(b, java.lang.Boolean);
1

So far, everything is fine but if I put the object in an ArrayList

>>> l = java.util.ArrayList();
>>> l.add(b)
1
>>> type(l.get(0))
<type 'int'>

the object is transformed into a python-like boolean (i.e. an int) and...

>>> isinstance(l.get(0), java.lang.Boolean)
0

which means that I can no longer see that this was once a java.lang.Boolean.

Clarification

I guess what really want to achieve is to get rid of the implicit conversion from Java-types to Python-types when passing objects from Java to Python. I will give another example for clarification.

A Python module:

import java

import IPythonModule

class PythonModule(IPythonModule):

    def method(self, data):
        print type(data);

And a Java-Class that uses this module:

import java.util.ArrayList;

import org.python.core.PyList;
import org.testng.annotations.*;

import static org.testng.AssertJUnit.*;

public class Test1 {

    IPythonModule m;

    @BeforeClass
    public void setUp() {
     JythonFactory jf = JythonFactory.getInstance();
     m = (IPythonModule) jf.getJythonObject(
       "IPythonModule",
     "/Users/sg/workspace/JythonTests/src/PythonModule.py");
    }

    @Test
    public void testFirst() {
     m.method(new Boolean("true"));
    } 
}

Here I will see the output 'bool' because of the implicit conversion, but what I would really like is to see 'javainstance' or 'java.lang.Boolean'. If you want to run this code you will also need the JythonFactory-class that can be found here.

Answer 1

You appear to be using an old version of Jython. In current Jython versions, the Python bool type corresponds to a Java Boolean.

Jython is not transforming the Java type to a Python type on the way into the ArrayList - on the contrary, it will transform a primitive Python type to a primitive or wrapper Java type when passing it to a Java method, and a Java type to a Python type on the way out.

You can observe this by printing the contents of the array. Note that the Python bool is capitalized (True); the Java Boolean is not.

>>> from java.lang import Boolean
>>> b = Boolean('True')
>>> b      
true
>>> from java.util import ArrayList
>>> l = ArrayList()
>>> l.add(b)
True
>>> l
[true]
>>> l.add(True)
True
>>> l
[true, true]
>>> list(l) 
[True, True]

If this still doesn't do what you want, consider writing a small Java helper function that examines the array for you without conversion. It's arguably a bug that Jython doesn't automatically convert the Boolean you constructed into a Python bool, and in this case it gives you no advantage over using Boolean.TRUE or the Python True.