The last few days I tried to figure out how to create Jython annotations. A Jython annotation <\/em>is defined here as a Java annotation lifted from Jython to Java. <\/em>So one essentially defines a Java annotation in a Jython class. A Jython annotation shall not be confused with a decorator. A Python ( or Jython ) decorator is just a higher order function ( or callable ). It might create attributes in Jython objects but those are not the same as Java annotations reflected by the Java runtime. Without Jython annotations Jython is right now essentially stuck in a pre version 1.5 Javaverse and Jython classes are disconnected from modern Java frameworks and cannot be plugged.<\/p>\n Jython annotations in Jython 2.5 don’t work out of the box. It is not much known yet about how or when Jython annotations will be supported by core Jython. The lead Jython developer Frank Wierzbicki announced something along the lines in his 2008 PyCon conference talk<\/a> but this is now about 16 months ago. I could temper my impatience if Jython annotations were just around the corner but what can we expect after those 16 months?<\/p>\n In this article I introduce a library that enables lifting of meta-data from Jython to Java and loading Java back into Jython. One key element is Java code generation and dynamic compilation using the Java 6 Compilation API<\/a>. Another one is interface extraction of Jython classes using the rich reflection API provided by core Jython.<\/p>\n For every Jython class `JyClass` one can generate a Java class `JaFromJyClass` by means of interface extraction. We assume `JyClass` to be a subclass of a Java class, e.g. `Object`, and translate the Jython class<\/p>\n into a corresponding Java class<\/p>\n This class is basically a proxy for the `jyobject` member variable of type PyObject which is a Jython API type. Once we have generated the Java code from Jython we can dynamically compile and load the Java code into Jython:<\/p>\n This was straightforward and hints on our translation strategy. Next we review the Jython to Java translations in more detail.<\/p>\n We cannot be glad with the way the `jyobject` was assigned to the `jainstance` in the previous example. The particular assignment protocol implies that the Jython script has always control over the instantiation of Jython classes. But once we plug the class into a framework the framework takes over. A better solution is to inject the PyObject using a factory mechanism.<\/p>\n The factory is called `JyGateway`. The `JyGateway` is a Java class which defines HashMap called registry<\/p>\n The keys of the Java HashMap are Strings that represent class names. The `PyDictionary` is a dictionary of Jython functions. Right now two functions are defined: `newInstance` and `callStatic`. Both of them correspond to static methods of `JyGateway`. If `JyGateway.newInstance(“JyClass”, this, null)` is called the `newInstance` Jython function is fetched from the registry using “JyClass” as a key. The third argument of `JyGateway.newInstance` contains an array of Java objects passed as arguments to the `newInstance` function which returns a new PyObject. If the constructor doesn’t take an argument `null` is passed as in the example. The particular `JyClass` will never be exposed to Java code.<\/p>\n Aside from `jyobject` we have also defined `jaobject` in the `JaFromJyClass` constructor which has the type `Object`. Here `Object` is just the superclass of both `JaFromJyClass` and `JyClass`. The `jaobject`is defined for the purpose of overriding superclass methods: we cannot simply change the signature of superclass methods in particular not the return value.<\/p>\n If `public void foo(int x)` is a method defined in the superclass of `JyClass`, the Java method generated from `JyClass` is<\/p>\n The method `foo` called from `jaobject` is still the method implemented in Jython. The Jython method is just called with Java arguments and returns a Java value ( if any ) that gets converted back to Jython.<\/p>\n Calling static or classmethods of Jython objects from Java is similar to calling `JyGateway.newInstance`:<\/p>\n There are three kinds of meta-data which can be added to Jython classes which are extracted for dynamic Java generation. Those are called `jproperty`, `annotation` and `signature`. They serve different purposes.<\/p>\n A `signature` decorator is defined to assign Java argument and the return types to a Jython method. Without the signature decorator a default translation is applied:<\/p>\n —–><\/p>\n If we decorate `foo` with the following `signature` decorator<\/p>\n we get the translation<\/p>\n The name of the function in the signature declaration string is of no relevance. That’s why we have used a single underscore.<\/p>\n The `annotation` decorator applies to methods and classes. We have to wait for Jython 2.6 for proper class decorator syntax but the semantics is the same when we write<\/p>\n The value passed to `annotation` is a string which must conform Java annotation syntax with the leading `@` character being stripped.<\/p>\n is a valid annotation which corresponds to the Java method<\/p>\n Annotations can be stacked and also combined with the signature decorator. So we can define three new decorators<\/p>\n and use them within e.g. JUnit 4<\/p>\n The `jproperty` object is a descriptor which assigns a Java type and zero or more annotations to a Jython attribute.<\/p>\n This is how it translates<\/p>\n A `JyClass` instance reads ( and sets ) `jproperty` values from the corresponding Java class instances it was assigned to. Remember that the `jyobject` instance construction looked like this<\/p>\n With `this` an instance of the Java class was passed to the `newInstance` factory function. Not only holds a `javaobject` a `jyobject` but also a `jyobject` holds a `javaobject`. Reading \/ writing `jproperty` values is the primary reason for this cyclic dependence.<\/p>\n Whenever a Java class gets compiled, names have to be imported from classes\/packages using the import-statement. Jython applies some heuristics to extract class and package names from annotations\/Jython code and creates Java import statements accordingly. An important precondition for a class\/package to be found is that it has been imported in Jython code. This isn’t particularly cumbersome. When you define an annotation<\/p>\n the name `SupportedAnnotationTypes` has to be made public using a normal Jython import:<\/p>\n This is not much different from considering an evaluation of the parameter string using Pythons `eval`.<\/p>\n The `annotation` class has a class attribute `namespace` which is used for Jython class and annotation extraction. If the heuristics fails to extract a class the `namespace` can be manually updated:<\/p>\n Within the next few days I’ll launch a new project on `code.google.com` called jynx<\/strong> which will contain tools particularly suited for Jython utilization of modern Java frameworks and APIs. The relevant source code for this article can be found here<\/a> and you can examine and play with it.<\/p>\n","protected":false},"excerpt":{"rendered":" Jython annotations – anyone? The last few days I tried to figure out how to create Jython annotations. A Jython annotation is defined here as a Java annotation lifted from Jython to Java. So one essentially defines a Java annotation … Continue reading Lifting up Jython classes<\/h3>\n
class JyClass(Object):\r\n def foo(self, *args):\r\n print \"foo\", args<\/pre>\n
public class JaFromJyClass extends Object{\r\n PyObject jyobject;\r\n\r\n public PyObject foo(PyObject[] args)\r\n {\r\n return jyobject.invoke(\"foo\", args);\r\n }\r\n}<\/pre>\nJaFromJyClass = createJavaClass(\"JaFromJyClass\", source)\r\njainstance = JaFromJyClass()\r\njainstance.jyobject = JyClass()\r\njainstance.foo(9) # prints 'foo 9'<\/pre>\n
Jython to Java translations<\/h3>\n
PyObject Injections<\/h4>\n
public JaFromJyClass() {\r\n super();\r\n jyobject = JyGateway.newInstance(\"JyClass\", this, null);\r\n jaobject = (Object)jyobject.__tojava__(Object.class);\r\n}<\/pre>\npublic static HashMap<String, PyDictionary> registry = new HashMap<String, PyDictionary>();<\/pre>\n
Overrdiding superclass methods<\/h4>\n
public void foo(int arg) { jaobject.foo(arg) }<\/pre>\nCalling static methods<\/h4>\n
public static PyObject bar(PyObject args[])\r\n{\r\n return JyGateway.callStatic(\"JyClass\", \"bar\", args);\r\n}<\/pre>\nDefining Jython metadata<\/h3>\n
signature<\/h4>\n
def foo(self, arg):\r\n ...<\/pre>\n
public PyObject foo(PyObject[] args) {\r\n return jyobject.invoke(\"foo\", args);\r\n}<\/pre>\n@signature(\"public int _(char)\")\r\ndef foo(self, arg):\r\n ...<\/pre>\n
public int foo(char arg0){\r\n PyObject args[] = new PyObject[1];\r\n for(int i=0;i<1;i++) {\r\n args[0] = Py.java2py(arg0);\r\n }\r\n return (Integer)jyobject.invoke(\"foo\", args).__tojava__(int.class);\r\n}<\/pre>\nannotation<\/h4>\n
cls = annotation(value)(cls)<\/pre>\n
@annotation(\"Override\")\r\ndef foo(self, arg):\r\n ...<\/pre>\n
@Override\r\npublic PyObject foo(PyObject[] args) {\r\n return jyobject.invoke(\"foo\", args);\r\n}<\/pre>\ntest = annotation(\"Test\")(signature(\"public void _()\"))\r\nsetUp = annotation(\"Before\")(signature(\"public void _()\"))\r\nbeforeClass = annotation(\"BeforeClass\")(signature(\"public static void _()\"))<\/pre>\n
from org.junit import*\r\nfrom org.junit.Assert import*\r\n\r\nclass TestClass(Object):\r\n @beforeClass\r\n def start(self):\r\n print \"Run 'TestClass' tests ...\"\r\n\r\n @test\r\n def test_epoweripi(self):\r\n from math import e, pi\r\n assertTrue( abs( e**(pi*1j) + 1 ) < 10**-10 )<\/pre>\n
jproperty<\/h4>\n
class JyClass(Object):\r\n x = jproperty(\"private int\", \"X\", \"Y\")<\/pre>\n
pubic class JyClassBase(Object)\r\n{\r\n @Y @X\r\n private int x;\r\n}<\/pre>\njyobject = JyGateway.newInstance(\"JyClass\", this, null);<\/pre>\n
Class import heuristics<\/h3>\n
annotation('SupportedAnnotationTypes(\"*\")')<\/pre>\nfrom javax.annotation.processing import SupportedAnnotationTypes<\/pre>\n
annotation.namespace.update(locals())<\/pre>\n
Jynx<\/h3>\n