compilation - from - integrar python con c#

Ironpython 2.6.py->.exe

Question

Ya intenté usar py2exe (no compatible con ipy) y PYC (desactualizado). ¿Alguien puede dirigirme hacia un buen compilador?

Answer 1

Echa un vistazo a la página de muestras de IronPython

Alrededor de la mitad de la página:

Pyc - Compilador de línea de comandos de Python Este ejemplo muestra a los desarrolladores cómo crear ejecutables .NET directamente a partir de scripts de IronPython. El archivo readme.htm en la descarga te ayudará a comenzar.

Las API de alojamiento de IronPython se pueden usar para compilar scripts de Python en DLL, ejecutables de consola o ejecutables de Windows. El script pyc.py incluido en este tutorial aprovecha estas API de alojamiento y puede usarse para compilar otros scripts de Python. Proporciona una variedad de indicadores, como la capacidad de especificar la plataforma de destino del ensamblado .NET (por ejemplo, x64).

Si bien los ensamblajes producidos por las API de hosting de IronPython son verdaderos ensamblajes .NET, la naturaleza dinámica del lenguaje Python hace que sea difícil usarlos desde otros lenguajes .NET. En resumen, esto significa que no se recomienda intentar importar tipos de Python en otros lenguajes .NET como C #.

Editar: Acabo de notar que usted mencionó que PYC estaba fuera de fecha. ¿Qué lo hace así? El equipo de IronPython parece que todavía lo está promocionando, así que me imagino que no está tan lejos.

Answer 2

Esta es una pregunta de larga data sobre la cual hay muy poca información en Internet. La única solución conocida que puedo encontrar es en http://community.sharpdevelop.net/blogs/mattward/archive/2010/03/16/CompilingPythonPackagesWithIronPython.aspx que usa SharpDevelop. Sin embargo, esta solución no es práctica porque cualquier proyecto Python semicomplejo realizará MUCHAS importaciones de módulos, y la solución SharpDevelop requiere que usted cree un proyecto por importación . Comencé y me rendí después de unos treinta proyectos nuevos, ¡mejor para escribir una solución automatizada!

Así que aquí está mi solución, y le advierto que en este momento no se lanzará como un proyecto adecuado por una buena razón:

#!/usr/bin/env python
# CompileToStandalone, a Python to .NET ILR compiler which produces standalone binaries
# (C) 2012 Niall Douglas http://www.nedproductions.biz/
# Created: March 2012

import modulefinder, sys, os, subprocess, _winreg

if len(sys.argv)<2:
    print("Usage: CompileEverythingToILR.py <source py> [-outdir=<dest dir>]")
    sys.exit(0)

if sys.platform=="cli":
    print("ERROR: IronPython''s ModuleFinder currently doesn''t work, so run me under CPython please")
    sys.exit(1)

sourcepath=sys.argv[1]
destpath=sys.argv[2][8:] if len(sys.argv)==3 else os.path.dirname(sys.argv[0])
ironpythonpath=None
try:
    try:
        keyh=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, "SOFTWARE//IronPython//2.7//InstallPath")
        ironpythonpath=_winreg.QueryValue(keyh, None)
    except Exception as e:
        try:
            keyh=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, "SOFTWARE//Wow6432Node//IronPython//2.7//InstallPath")
            ironpythonpath=_winreg.QueryValue(keyh, "")
        except Exception as e:
            pass
finally:
    if ironpythonpath is not None:
        _winreg.CloseKey(keyh)
        print("IronPython found at "+ironpythonpath)
    else:
        raise Exception("Cannot find IronPython in the registry")

# What we do now is to load the python source but against the customised IronPython runtime
# library which has been hacked to work with IronPython. This spits out the right set of
# modules mostly, but we include the main python''s site-packages in order to resolve any
# third party packages
print("Scanning ''"+sourcepath+"'' for dependencies and outputting into ''"+destpath+"'' ...")
searchpaths=[".", ironpythonpath+os.sep+"Lib"]
searchpaths+=[x for x in sys.path if ''site-packages'' in x]
finder=modulefinder.ModuleFinder(searchpaths)
finder.run_script(sourcepath)
print(finder.report())
modules=[]
badmodules=finder.badmodules.keys()
for name, mod in finder.modules.iteritems():
    path=mod.__file__
    # Ignore internal modules
    if path is None: continue
    # Ignore DLL internal modules
    #if ''//DLLs//' in path: continue
    # Watch out for C modules
    if os.path.splitext(path)[1]==''.pyd'':
        print("WARNING: I don''t support handling C modules at ''"+path+"''")
        badmodules.append(name)
        continue
    modules.append((name, os.path.abspath(path)))
modules.sort()
print("Modules not imported due to not found, error or being a C module:")
print("/n".join(badmodules))
raw_input("/nPress Return if you are happy with these missing modules ...")

with open(destpath+os.sep+"files.txt", "w") as oh:
    oh.writelines([x[1]+''/n'' for x in modules])
cmd=''ipy64 ''+destpath+os.sep+''pyc.py /main:"''+os.path.abspath(sourcepath)+''" /out:''+os.path.splitext(os.path.basename(sourcepath))[0]+'' /target:exe /standalone /platform:x86 /files:''+destpath+os.sep+''files.txt''
print(cmd)
cwd=os.getcwd()
try:
    os.chdir(destpath)
    retcode=subprocess.call(cmd, shell=True)
finally:
    os.chdir(cwd)
sys.exit(retcode)

Esto se escribió en contra de IronPython v2.7.2 RC1 usando su nueva característica binaria independiente, y de hecho funciona. Obtiene un archivo .exe independiente que es totalmente independiente, no necesita nada más instalado. La secuencia de comandos funciona analizando las importaciones de la secuencia de comandos suministrada y enviando todo el lote a pyc.py. Esa es la buena noticia.

La mala noticia es la siguiente:

1. IronPython v2.7.2 ModuleFinder RC1 no parece funcionar, por lo que el script anterior debe ejecutarse utilizando CPython. A continuación, utiliza ModuleFinder de CPython pero en contra de la biblioteca de tiempo de ejecución personalizada de IronPython. Sí, me sorprende que funcione también ...
2. La salida de los binarios comienza en aproximadamente 8Mb. Una prueba unitaria simple pesó 16Mb. Hay muchas cosas que no necesitan estar ahí, por ejemplo, le da soporte para Wpf y un poco más, pero aún no son pequeñas.
3. Los tiempos de carga son mucho más lentos que los no autónomos. Piense en unos cuarenta segundos para una prueba unitaria autónoma en un Intel Core 2 rápido en lugar de unos tres segundos para no autónomos. Si se compila solo para x86, se reduce a diez segundos.
4. El rendimiento en tiempo de ejecución es más lento que el no autónomo en aproximadamente un 40%. Si se compila solo para x86, el rendimiento se duplica aproximadamente. Es por eso que dejé en la plataforma /: x86 arriba.
5. Existe un error conocido en el soporte de codificaciones y codecs de CPython donde ModuleFinder no incluye ningún soporte de codec a menos que lo especifique manualmente. Entonces, por ejemplo, si está utilizando UTF-8 con codecs.open () entonces NECESITA que "desde las codificaciones, importe utf_8 como some_unique_identifier" para forzar la dependencia.
6. Lo anterior supone un pyc.py modificado que puede tomar un parámetro / files a medida que se excede fácilmente el límite de longitud de la línea de comando. Puede modificar su propio pyc.py de forma trivial, si no, he enviado la mejora para incluirla en el próximo IronPython.

Ahí vas. Funciona, pero la solución todavía necesita mucha más maduración. ¡La mejor de las suertes!

Answer 3

Sí, me ha resultado muy difícil compilar un exe, así que volví a usar Python estándar. Deben dar un buen tutorial sobre él en el sitio de IronPython.

Answer 4

Tuve un poco de problemas al intentar implementar esta solución. Esto es lo que hice:

1. Descarga pyc desde here . Esto me llevó a buscar más de lo que debería porque parece que Pyc es difícil de encontrar (y creo que, un poco fuera de fecha)
2. Extraje la carpeta pyc del archivo zip y la agregué a mi carpeta IronPython en C:/Program Files
3. Ahora intenté ejecutar este comando en la consola de Windows, como lo indica el archivo léame en la descarga de ipy.exe pyc.py other_hw.py /main:console_hw.py : ipy.exe pyc.py other_hw.py /main:console_hw.py

Me dio este error:

Traceback (most recent call last):
  File "pyc/pyc.py", line 35, in pyc/pyc.py
AttributeError: attribute ''CompilerSink'' of ''namespace#'' object is read-only

Hice el siguiente cambio a la línea 35:

Antes: class PycSink(Hosting.CompilerSink):

Después: class PycSink():

Guardar el archivo resultó ser un problema debido a los permisos, por lo que copié el contenido de pyc.py en una nueva ventana IDLE (para crear una copia), pyc.py copia existente de pyc.py y pyc.py la copia como pyc.py en el mismo lugar Esto se encarga de los problemas de permisos y permite cambios.

Después de hacer este cambio, intenté ejecutar este comando nuevamente:

ipy.exe pyc.py other_hw.py /main:console_hw.py

Sin embargo, esta vez, obtuve el siguiente error:

Traceback (most recent call last):
  File "pyc/pyc.py", line 170, in pyc/pyc.py
  File "pyc/pyc.py", line 56, in Main
AttributeError: attribute ''ResourceFile'' of ''namespace#'' object is read-only

En este punto, hice un balance del hecho de que ahora son las 1 AM y tengo un mediano plazo mañana, así que deshice los cambios y los apagué.

Por favor, avíseme si tiene una solución o algún avance en la mía.

Answer 5

Puede usar pyc.py , el Compilador de línea de comandos de Python , que se incluye en IronPython desde la versión 2.6 para compilar un script de Python en un ejecutable. Lo encuentra en %IRONPYTONINSTALLDIR%/Tools/Scripts/pyc.py en su disco duro.

Ejemplo

Supongamos que tiene un simple script test.py que simplemente imprime algo para la consola. Puede convertir esto en un ejecutable con la siguiente línea de comandos (asumiendo que el directorio IronPython es el directorio actual y que test.py está allí):

ipy.exe Tools/Scripts/pyc.py /main:test.py /target:exe

_{Nota: si está utilizando formularios y no desea que se abra una ventana de consola, desea usar /target:winexe lugar de /target:exe .}

El resultado serán dos archivos, test.dll y test.exe . test.dll contendrá su código de script real, mientras que test.exe es solo un lanzador para test.dll . Puede distribuir este EXE y DLL a otras computadoras que no tengan instalado IronPython si incluye los archivos

• IronPython.dll ,
• Microsoft.Dynamic.dll ,
• Microsoft.Scripting.Core.dll ,
• Microsoft.Scripting.Debugging.dll ,
• Microsoft.Scripting.dll ,
• Microsoft.Scripting.ExtensionAttribute.dll y
• IronPython.Modules.dll (a veces es necesario).

También vea la entrada del blog IronPython - cómo compilar exe .