Langue: en

Version: July 7, 2001 (debian - 07/07/09)

Section: 1 (Commandes utilisateur)


jythonc - compile Python source to real Java classes


jythonc [ -p, --package package ] [ -j, --jar jarfile ] [ -d, --deep ] [ -c, --core ] [ -a, --all ] [ -b, --bean jarfile ] [ -A, --addpackages pkgs ] [ -w, --workdir directory ] [ -s, --skip modules ] [ -C, --compiler path ] [ -J, --compileropts options ] [ -f, --falsenames names ] module ...

jythonc --help


JythonC is a utility that compiles Python source code to real Java classes, and is used for building applets, servlets, beans and so on, as well as allowing for Python classes to be subclassed in Java.

JythonC generates actual Java source code, and then invokes a Java compiler over this source code to create the .class files. Thus you will need access to a Java compiler. The jythonc script will attempt to guess the specifics of the installed compiler; see jython.conf(5) for details on specifying these yourself.

In order to create a real Java class, the Python module must contain a Python class with the same name as the module, and that Python class must subclass exactly one Java class or interface. The real Java class created will be a subclass of whatever Java class is subclassed.

Compiling Python Methods

Normally, compiled Python methods are not directly callable from Java. There is simply not sufficient information in a Python method definition to create a useable Java method. There are however two ways a Python method can be made into real Java method. Both ways require that the Python class have a Java class or a Java interface as its base class.
Overriding / Implementing a Java method:
By overriding a Java method, the overridden method's signature is used for the real Java class. That includes return type, privacy modifier, arguments, argument types and throws clauses.
Adding a Java method signature to a Python method docstring:
Using a special convention in the method docstring allows for the creation of a corresponding Java method. The signature must be written on one line and must start with the text @sig. All class names (except those in java.lang) must be specified as fully qualified class names. An example is:
def setExpression(self, e):
"@sig public void setExpression(java.lang.String e)"


A summary of options is included below.
-p, --package package
Put all compiled code into the given Java package.
-j, --jar jarfile
Specifies a jar archive to create and put the results of the compilation into. Implies --deep.
-d, --deep
Compile all Python dependencies of the module. This is useful for creating applets.
-c, --core
Include the core Jython libraries (about 130K). Needed for applets since some browsers don't yet support multiple archives. Implies --deep.
-a, --all
Include all of the Jython libraries (core, compiler and parser). Implies --deep.
-b, --bean jarfile
Compile into the given jar archive, including the correct manifest for the Java bean.
-A, --addpackages pkgs
Include Java dependencies from the given list of packages. Default is org.python.modules and org.apache.oro.text.regex.
-w, --workdir directory
Specifies the working directory into which the generated code will be placed. Default is ./jpywork.
-s, --skip modules
Don't include any of the given modules in compilation. This should be a comma-separated list of modules.
-C, --compiler path
Use the specified Java compiler to turn generated Java sources into class files. If this is set to NONE then compilation ends with the generation of the Java source file(s). See jython.conf(5) for alternate ways of specifying the Java compiler.
-J, --compileropts options
Options to pass directly to the Java compiler. See jython.conf(5) for alternate ways of specifying Java compiler options.
-f, --falsenames names
A comma-separated list of names that are always false. Can be used to short-circuit if clauses.
module ...
A list of Python modules to compile. These can be either .py files or module names on the python path (see jython.conf(5) for further details on property python.path).
Print a usage message and exit.


JAVA (default: /usr/bin/java)
The Java interpreter to use when running Jython and JythonC.
JAVA_OPTIONS (default: empty)
Options to pass to the Java interpreter when running Jython and JythonC.
JAVAC (default: /usr/bin/javac)
The Java compiler to use when running JythonC.


To create the file appletdemo.jar containing all of the applet demos in the current directory as well as the core Jython libraries:
example$ jythonc --core --deep --jar appletdemo.jar *.py

Note: One special thing to consider when building applets is that the Java VM version used when compiling the sources must usually be the same as the VM version used by the browser. If a newer JVM is used when compiling the applets, the compiled code may have references to classes that do not exist in older JVMs.

To generate a skeleton class to allow a Python class to be used as a java.awt.Component in a Java gui program:

example$ jythonc Graph.py

To generate a Jython-based bean:

example$ jythonc --deep --bean f2c.jar conversion.FahrenheitToCelsius


jython(1), jython.conf(5).

If the Debian package jython-doc is installed, full documentation from the Jython authors will be available in /usr/share/doc/jython-doc/html/.


This manual page was prepared by Ben Burton <bab@debian.org> for the Debian GNU/Linux system (but may be used by others). It is based upon the official Jython documentation.