Les meilleures techniques actuelles pour distribuer vos fichiers Python dans un jar sont détaillées dans cet article sur le wiki de Jython : http://wiki.python.org/jython/JythonFaq/DistributingJythonScripts
Dans votre cas, je pense que vous devriez prendre le fichier jython.jar que vous obtenez lors de l'installation de Jython et y placer le répertoire Jython Lib, puis y placer vos fichiers .py, et enfin ajouter une balise __run__.py avec votre logique de démarrage (ce fichier est traité spécialement par Jython et sera le fichier exécuté lorsque vous appellerez le jar avec "java -jar").
Ce processus est définitivement plus compliqué qu'il ne devrait l'être, et donc nous (les développeurs de Jython) devons trouver un bon outil qui automatisera ces tâches, mais pour l'instant ce sont les meilleures méthodes. Je copie ci-dessous la recette en bas de l'article ci-dessus (légèrement modifiée pour s'adapter à la description de votre problème) pour vous donner une idée de la solution.
Créez le pot de base :
$ cd $JYTHON_HOME
$ cp jython.jar jythonlib.jar
$ zip -r jythonlib.jar Lib
Ajoutez d'autres modules au bocal :
$ cd $MY_APP_DIRECTORY
$ cp $JYTHON_HOME/jythonlib.jar myapp.jar
$ zip myapp.jar Lib/showobjs.py
# Add path to additional jar file.
$ jar ufm myapp.jar othermanifest.mf
Ajouter le __run__.py module :
# Copy or rename your start-up script, removing the "__name__ == '__main__'" check.
$ cp mymainscript.py __run__.py
# Add your start-up script (__run__.py) to the jar.
$ zip myapp.jar __run__.py
# Add path to main jar to the CLASSPATH environment variable.
$ export CLASSPATH=/path/to/my/app/myapp.jar:$CLASSPATH
Sous MS Windows, cette dernière ligne, qui définit la variable d'environnement CLASSPATH, ressemblerait à quelque chose comme ceci :
set CLASSPATH=C:\path\to\my\app\myapp.jar;%CLASSPATH%
Ou, toujours sous MS Windows, utilisez le Panneau de configuration et les propriétés du système pour définir la variable d'environnement CLASSPATH.
Exécutez l'application :
$ java -jar myapp.jar mymainscript.py arg1 arg2
Ou, si vous avez ajouté votre script de démarrage au jar, utilisez l'un des éléments suivants :
$ java org.python.util.jython -jar myapp.jar arg1 arg2
$ java -cp myapp.jar org.python.util.jython -jar myapp.jar arg1 arg2
$ java -jar myapp.jar -jar myapp.jar arg1 arg2
Le double -jar est un peu ennuyeux, donc si vous voulez éviter cela et obtenir le plus agréable :
$ java -jar myapp.jar arg1
Il vous faudra encore travailler un peu avant que quelque chose de ce genre ne soit intégré à un futur Jython [Mise à jour : JarRunner fait partie de Jython 2.5.1]. Voici un peu de code Java qui recherche le __run__.py automatiquement, et l'exécute. Notez que c'est mon premier essai pour cette classe. Faites-moi savoir s'il faut l'améliorer !
package org.python.util;
import org.python.core.imp;
import org.python.core.PySystemState;
public class JarRunner {
public static void run(String[] args) {
final String runner = "__run__";
String[] argv = new String[args.length + 1];
argv[0] = runner;
System.arraycopy(args, 0, argv, 1, args.length);
PySystemState.initialize(PySystemState.getBaseProperties(), null, argv);
imp.load(runner);
}
public static void main(String[] args) {
run(args);
}
}
J'ai placé ce code dans le paquet org.python.util, puisque c'est là qu'il ira si nous décidons de l'inclure dans un futur Jython. Pour le compiler, vous devrez mettre jython.jar (ou votre myapp.jar) dans le classpath comme suit :
$ javac -classpath myapp.jar org/python/util/JarRunner.java
Ensuite, vous devrez ajouter JarRunner.class à votre jar (le fichier de classe devra se trouver dans org/python/util/JarRunner.class). Appeler jar sur le répertoire "org" mettra le chemin complet dans votre jar.
$ jar uf org
Ajoutez-le à un fichier que vous utiliserez pour mettre à jour le manifeste, un bon nom est manifest.txt :
Main-Class: org.python.util.JarRunner
Puis mettez à jour le manifeste du bocal :
$ jar ufm myapp.jar manifest.txt
Maintenant, vous devriez être en mesure d'exécuter votre application comme ceci :
$ java -jar myapp.jar
