48 votos

La distribución de mis secuencias de comandos de python como frascos con jython?

He sido programador python por casi 2 años y estoy acostumbrado a escribir pequeñas secuencias de comandos para automatizar tareas repetitivas que tenía que hacer en la oficina. Ahora, al parecer, mis colegas di cuenta de esto y quieren esos scripts.

Algunos de ellos han macs, algunas ventanas, hice estas en windows. He investigado la posibilidad de utilizar py2exe o incluso py2app para hacer que los nativos de mi script, pero nunca me ha satisfecho..

Me di cuenta de que todos ellos tienen JVM en sus sistemas, por lo que puedo darles un único archivo jar ejecutable de mi script usando algo como jython puede ser?

¿Qué tan factible es esto... quiero decir, yo no tenía idea de cómo escribir secuencias de comandos para jython, tampoco me importa cuando me escribió... ¿qué tipo de problemas va a dar?

55voto

Frank Wierzbicki Puntos 1096

La mejor de las técnicas actuales para la difusión de tus archivos de Python en un tarro que se detallan en este artículo en Jython de la wiki: http://wiki.python.org/jython/JythonFaq/DistributingJythonScripts

Para tu caso, creo que le quieren tomar el jython.jar archivo que usted consigue cuando usted instale Jython y postal de la Jython directorio Lib, zip .py archivos y, a continuación, agregar un __run__.py archivo con el inicio de la lógica (este archivo es tratada especialmente por Jython y será el archivo que se ejecuta cuando se llame el frasco con el "java-jar").

Este proceso es más complicado, a continuación, en la que debería ser, y por lo tanto, (el Jython desarrolladores) la necesidad de llegar con una buena herramienta que permitirá automatizar estas tareas, pero por ahora estos son los mejores métodos. A continuación voy a copiar la receta en la parte inferior del artículo anterior (ligeramente modificado para adaptarse a la descripción del problema) para dar una idea de la solución.

Crear la básica jar:

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

Agregar otros módulos para el vaso:

$ 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

Añadir el __run__.py módulo de:

# 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

En MS Windows, que la última línea, la configuración de la variable de entorno CLASSPATH, sería algo como esto:

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

O, de nuevo en MS Windows, utilice el Panel de Control y el Sistema de propiedades para establecer la variable de entorno CLASSPATH.

Ejecutar la aplicación:

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

O, si usted ha agregado a su script de inicio para el frasco, utilice uno de los siguientes:

$ 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

El doble-jar es algo molesto, así que si quieres evitar esto y conseguir el más agradable:

$ java -jar myapp.jar arg1

Tendrás que trabajar un poco más hasta conseguir algo parecido a esto en un futuro Jython [Actualización: JarRunner es parte de Jython 2.5.1]. Aquí está algo de código Java que busca la __run__.py automáticamente, y lo ejecuta. Tenga en cuenta que este es mi primer intento en esta clase. Déjeme saber si se necesita mejorar!

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

Puedo poner este código en la org.python.util paquete, ya que es donde iría si decidimos incluirlo en un futuro Jython. Para compilarlo, tendrás que poner jython.jar (o su myapp.jar) en la ruta de clases como:

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

A continuación, tendrás que agregar JarRunner.class a su jarra (el archivo de clase tendrá que ser en org/python/util/JarRunner.class), llamando a jar en la "org" directorio de obtener la ruta completa en el frasco.

$ frasco uf org

Agregue esto a un archivo que se va a utilizar para actualizar el manifiesto, es el buen nombre manifest.txt:

Main-Class: org.python.util.JarRunner

A continuación, actualizar el tarro de manifiesto:

$ jar ufm myapp.jar manifest.txt

Ahora usted debería ser capaz de ejecutar la aplicación como esta:

$ java -jar myapp.jar

1voto

Lucas Puntos 13318

Es una gran idea. Es bueno saber que ellos ya tienen la JVM (como la mayoría de la gente (gracias a facebook)). Usted incluso no tiene que cambiar su código. Acaba de volver a compilar y listo.

Pero tenga en cuenta que:

Hay un número de diferencias. En primer lugar, Jython programas no pueden utilizar CPython 
los módulos de extensión, escrito en C. Estos módulos suelen tener archivos con el
la extensión .así .pyd o .dll. Si desea utilizar un módulo, usted debe buscar 
por otro equivalente escrito en puro Python o Java. Aunque es técnicamente 
factible para apoyar tales extensiones de IronPython lo hace - no hay planes 
para hacerlo en Jython.

Leer más sobre la Jython de preguntas frecuentes.

Buena Suerte!

1voto

Yancy Puntos 149

El 'jythonc' comando debe ser capaz de compilar su .py origen en la JVM de código de bytes, lo que debería hacer es portable a cualquier instalación de Java. O por lo que he leído en: http://hell.org.ua/Docs/oreilly/other2/python/0596001886_pythonian-chp-25-sect-3.html

1voto

Robert Casey Puntos 88

He experimentado un problema similar en que quiero ser capaz de crear una simple línea de comandos llamadas para mi jython apps, no requieren que el usuario vaya a través de la jython proceso de instalación, y ser capaz de tener la jython scripts anexar dependencias de la biblioteca en tiempo de ejecución a sys.ruta de acceso con el fin de incluir núcleo de código java.

# append Java library elements to path
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "lib", "poi-3.8-20120326.jar"))

Cuando se ejecuta el 'jython' launcher explícitamente en la línea de comandos, en los sistemas Unix, que sólo se ejecuta una gran secuencia de comandos de shell para bien formar una línea de comandos de java llamada. Este jython launcher parece tener una dependencia en que se remontan a una instalación básica de jython, y por alguna forma de magia que permite el manejo adecuado de .los archivos jar que se añade a la sys.ruta de acceso en tiempo de ejecución dentro de mi .py secuencias de comandos. Usted puede ver lo que la llamada es de bloque y la ejecución de los siguientes:

jython --print run_form.py
java -Xmx512m -Xss1024k -Dfile.encoding=UTF-8 -classpath /Applications/jython2.5.2/jython.jar: -Dpython.home=/Applications/jython2.5.2 -Dpython.executable=/Applications/jython2.5.2/bin/jython org.python.util.jython run_form.py

Pero aún sigue siendo fuego en una JVM y el funcionamiento de un archivo de clase. Así que mi objetivo era ser capaz de hacer esto en java llamada a un independiente jython.jar presente en mi distribución del directorio lib de forma que los usuarios no necesitan hacer ninguna instalación adicional pasos para empezar a usar mi .py secuencias de comandos de utilidades.

java -Xmx512m -Xss1024k -classpath ../../lib/jython.jar org.python.util.jython run_form.py

Problema es que el comportamiento es bastante diferente que iba a obtener respuestas como esta:

  File "run_form.py", line 14, in <module>
    import xls_mgr
  File "/Users/test/Eclipse/workspace/test_code/py/test/xls_mgr.py", line 17, in <module>
    import org.apache.poi.hssf.extractor as xls_extractor
ImportError: No module named apache

Ahora se podría decir que solo debo agregar los archivos jar al classpath, que de hecho he intentado, pero me gustaría conseguir el mismo resultado.

La propuesta de la agrupación de todas las de su .los archivos de clase en un jython.jar no me suena atractivo en absoluto. Sería un desastre y se unen a la de Java/Python aplicación híbrida con demasiada fuerza a la jython de distribución. Así que la idea no iba a volar. Finalmente, después de mucho buscar, me encontré con el error #1776 en jython.org, que ha sido catalogado como crítico de un año y medio, pero yo no veo que las últimas actualizaciones de jython incorporar una solución. Sin embargo, si usted está teniendo problemas con el hecho de tener jython incluir sus archivos jar, usted debe leer esto.

http://bugs.jython.org/issue1776

Allí, usted encontrará la solución temporal para este. En mi caso, tomé el Apache POI archivo jar y unjar ed en su propio directorio lib y luego de modificar el sys.ruta de la entrada para que apunte al directorio en lugar de la jarra:

sys.path.append('/Users/test/Eclipse/workspace/test_code/lib/poi_lib')

Ahora, cuando me encuentro con jython por medio de java, hacer referencia a mi local jython.jar la utilidad se ejecuta sólo peachy. Ahora puedo crear secuencias de comandos simples o archivos por lotes para hacer una perfecta línea de comandos experiencia para mi .py utilidades, que el usuario puede ejecutar sin ningún tipo de instalación adicional pasos.

Iteramos.com

Iteramos es una comunidad de desarrolladores que busca expandir el conocimiento de la programación mas allá del inglés.
Tenemos una gran cantidad de contenido, y también puedes hacer tus propias preguntas o resolver las de los demás.

Powered by:

X