Dystrybuowanie skryptów Pythona jako plików JAR za pomocą Jython?

Najlepsze techniki dystrybucji plików Pythona w jar są opisane w tym artykule na wiki Jython: http://wiki.python.org/jython/JythonFaq/DistributingJythonScripts

Ten proces jest zdecydowanie bardziej skomplikowany niż w ought to be, więc my (programiści Jython) musimy wymyślić ładne narzędzie, które zautomatyzuje te zadania, ale na razie są to najlepsze metody. Poniżej kopiuję przepis na dole powyższego artykułu (lekko zmodyfikowany, aby pasował do opisu problemu), aby dać poczucie rozwiązania.

Utwórz podstawowy jar:

$ cd $JYTHON_HOME
$ cp jython.jar jythonlib.jar
$ zip -r jythonlib.jar Lib

Dodaj inne moduły do słoika:

$ 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

Dodaj moduł __run__.py:

# 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

W MS Windows ostatnia linia, ustawiająca zmienną środowiskową CLASSPATH, wyglądałaby mniej więcej tak:

set CLASSPATH=C:\path\to\my\app\myapp.jar;%CLASSPATH%

Lub, ponownie w MS Windows, użyj panelu sterowania i właściwości systemu, aby ustawić zmienną środowiskową CLASSPATH.

Uruchom aplikację:

$ java -jar myapp.jar mymainscript.py arg1 arg2

Lub, jeśli dodałeś skrypt startowy do jar, użyj jednej z następujących opcji:

$ 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

The double-jar jest trochę irytujące, więc jeśli chcesz tego uniknąć i uzyskać bardziej przyjemne: {]}

$ java -jar myapp.jar arg1

Będziesz musiał wykonać trochę więcej pracy, dopóki nie wprowadzimy czegoś takiego do przyszłego Jythona [aktualizacja: JarRunner jest częścią Jython 2.5.1]. Oto kod Javy, który szuka __run__.py automatycznie i uruchamia go. Zauważ, że to moja pierwsza próba na tych zajęciach. Daj mi znać, jeśli wymaga poprawy!

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);
    }
}

Umieściłem ten kod w org.python.pakiet util, bo tam by poszedł, gdyby decydujemy się na włączenie go do przyszłego Jythonu. Aby go skompilować, musisz umieścić jython.jar (lub your myapp.jar) do klasy jak:

$ javac -classpath myapp.jar org/python/util/JarRunner.java

Następnie musisz dodać JarRunner.klasy do twojego jar (plik klasy musi znajdować się w org/python/util/JarRunner.class) wywołanie jar w katalogu " org " przeniesie całą ścieżkę do twojego jar.

$ jar uf org

Dodaj to do pliku, który będzie używany do aktualizacji manifestu, dobra nazwa to manifest.txt:

Main-Class: org.python.util.JarRunner

Następnie zaktualizuj manifest Jara:

$ jar ufm myapp.jar manifest.txt

Teraz powinieneś móc uruchomić swoją aplikację w następujący sposób:

$ java -jar myapp.jar