Support running in file or command mode

Author: synap5e

README.md

@@ -16,7 +16,6 @@ Custom (python) import hooks are installed to support loading modules (both nati
 
 Currently the exe just drops to an interactive loop. Modification to run a script or embed a file/module should be trivial. 
 
-- [ ] Support `onefile_python.exe script.py`
 - [ ] Build option for embedding a python file/module and running that on launch
 - [ ] Support other versions of python than `3.10.1` (autodetect?)
 
@@ -32,7 +31,7 @@ py2exe supports a diskless/"bundle" mode.
 
 Both these projects are *much* more complex than this one and support lots of extra features, but sometimes you don't need that...
 
-This project is (maybe) better if you want a single exe that can run any python script [or will be once that is supported], or just want an exe that gives a python REPL.
+This project is (maybe) better if you want a single exe that can run any python script, or just want an exe that gives a python REPL.
 Being simpler, this project should be easier to hack on or learn from.
 
 
@@ -42,7 +41,7 @@ There's not much to it...
 
 0. Use nim's [staticRead](https://nim-lang.org/docs/system.html#staticRead%2Cstring) to include `python-*-embedded.zip` and `bootstrap.py` inside compiled exe itself.
 1. Use [zippy](https://github.com/guzba/zippy) to access the contents of the archive at runtime.
-2. Use [memlib](https://github.com/khchen/memlib) to perform reflective dll loading of the embedded `python*.dll`. Reflective dll loading allows for loading the dll from memory rather than from disk. Hook `LdrLoadDll` and `K32EnumProcessModules` so other code using the dll can find it. 
+2. Use [memlib](https://github.com/khchen/memlib) to perform reflective dll loading of the embedded `python*.dll`. Reflective dll loading allows for loading the dll from memory rather than from disk. Hook `LdrLoadDll` and `K32EnumProcessModules` so other code using the dll can find it. n.b. currently using a fork until https://github.com/khchen/memlib/pull/3 is merged.
 3. Call various functions in the (reflectively) loaded dll to partially initialize python. Configure python to not try to load anything from disk (not absolutely required, but prevents conflicts and means the exe doesn't run any code in the current directory)
 4. Use [nimpy](https://github.com/yglukhov/nimpy) to initialize a python extension exporting some nim functions that can read data out of the `python*.zip` standard library (contained within the `...-embedded.zip`).
 5. Run the embedded `bootsrap.py` code to install an import hook. This import hook uses the functions from (4) to support importing python modules. If a `.pyc` can be found that matches an import, a loader that returns the unmarshalled `.pyc` is provided. If a `.pyd` can be found, the returned loader reflectively loads the `.pyd` and calls the module's initialization routine.

bootstrap.py

@@ -4,7 +4,7 @@
 import _frozen_importlib_external as _bootstrap_external
 import _frozen_importlib as _bootstrap
 
-from nimporter import *
+from onefile_python import *
 
 _bootstrap._install_external_importers()
 _bootstrap_external._set_bootstrap_module(_bootstrap)

onefile_python.nim

@@ -7,10 +7,10 @@ import std/strutils
 import zippy/ziparchives
 import minhook
 import winim/lean
-
 import memlib
 import nimpy
 import nimpy/py_types
+import argparse
 
 import cpython_types
 
@@ -19,6 +19,14 @@ const DEBUG = false  # Print debug messages (in nim code, and in python loaders)
 const EMBED_DLL = true  # Use the .dll embedded in the zip archive. If false, will require python310.dll to be in the PATH. If true, debugging may be harder as the dll is reflectively loaded
 
 
+let p = newParser("onefile_python"):
+  help("{prog}")
+  flag("-V", "--version")
+  option("-c", "--command", help="program passed in as string")
+  arg("file", default=some(""), help="program read from script file")
+  arg("arg", nargs=(-1), help="arguments passed to program in sys.argv[1:]")
+
+
 template `//`(a, b: untyped) : untyped = a div b
 
 converter falsey(i: int): bool = i != 0
@@ -73,13 +81,21 @@ proc Py_SetProgramName(name: pointer): void {. memlib: python, importc: "Py_SetP
 proc Py_SetPath(path: pointer): void {. memlib: python, importc: "Py_SetPath", cdecl .}
 # proc PyConfig_InitPythonConfig(config: ptr PyConfig): void {. memlib: python, importc: "PyConfig_InitPythonConfig", cdecl .}
 proc PyConfig_InitIsolatedConfig(config: ptr PyConfig): void {. memlib: python, importc: "PyConfig_InitIsolatedConfig", cdecl .}
+proc PyConfig_SetArgv(r: PyStatus, config: ptr PyConfig, argc: int, argv: pointer): ptr PyStatus {. memlib: python, importc: "PyConfig_SetArgv", cdecl .}
 proc Py_InitializeFromConfig(r: PyStatus, config: ptr PyConfig): ptr PyStatus {. memlib: python, importc: "Py_InitializeFromConfig", cdecl .}
 proc PyUnicode_AsUTF8AndSize(obj: pointer, size: pointer): cstring {. memlib: python, importc: "PyUnicode_AsUTF8AndSize", cdecl .}
-proc PyRun_SimpleString(code: cstring): int {. memlib: python, importc: "PyRun_SimpleString", cdecl .}
 proc PyUnicode_FromString(str: cstring): pointer {. memlib: python, importc: "PyUnicode_FromString", cdecl .}
 proc PyImport_GetModuleDict(): pointer {. memlib: python, importc: "PyImport_GetModuleDict", cdecl .}
 proc PyImport_FixupExtensionObject(module: pointer, name: pointer, filename: pointer, modules: pointer): void {. memlib: python, importc: "_PyImport_FixupExtensionObject", cdecl .}
 proc PyModule_FromDefAndSpec2(def: PPyObject, spec: PPyObject, module: int): PPyObject {. memlib: python, importc: "PyModule_FromDefAndSpec2", cdecl .}
+
+proc Py_BuildValue(v1: cstring, v2: cstring): pointer {. memlib: python, importc: "Py_BuildValue", cdecl .}
+proc Py_fopen_obj(path: pointer, mode: cstring): pointer {. memlib: python, importc: "_Py_fopen_obj", cdecl .}
+proc PyRun_SimpleFile(fp: pointer, filename: cstring): cint {. memlib: python, importc: "PyRun_SimpleFile", cdecl .}
+
+proc Py_GetVersion(): cstring {. memlib: python, importc: "Py_GetVersion", cdecl .}
+
+proc PyRun_SimpleString(code: cstring): int {. memlib: python, importc: "PyRun_SimpleString", cdecl .}
 proc PyRun_InteractiveLoop(file: pointer, filename: cstring): int {. memlib: python, importc: "PyRun_InteractiveLoop", cdecl .}
 proc PyObject_Repr(obj: pointer): cstring {. memlib: python, importc: "PyObject_Repr", cdecl .}
 proc Py_InitializeMain(r: ptr PyStatus): ptr PyStatus {. memlib: python, importc: "_Py_InitializeMain", cdecl .}
@@ -138,11 +154,26 @@ proc PyInit_onefile_python(): pointer {. stdcall, importc: "PyInit_onefile_pytho
 const bootstrap_py = staticRead("bootstrap.py")
 
 
+proc parse_args: auto = 
+    try:
+        return p.parse(commandLineParams())
+    except ShortCircuit as e:
+        if e.flag == "argparse_help":
+            echo p.help
+            quit(1)
+    except UsageError:
+        stderr.writeLine getCurrentExceptionMsg()
+        quit(1)
+
+
 proc main = 
     var r: PyStatus
     var status: ptr PyStatus
     var res: int
 
+    var opts = parse_args()
+
+
     # Initial configuration - ignore argv, env vars (PYTHONHOME), any files, etc.
     var preconfig: PyPreConfig
     PyPreConfig_InitIsolatedConfig(preconfig)
@@ -164,17 +195,34 @@ proc main =
     config.init_main = 0
     when DEBUG:
         echo fmt"Py_InitializeFromConfig({config})"
+
+    var argv: array[256, pointer]
+    var argc = 0
+    if opts.file != "":
+        argv[argc] = Py_DecodeLocale(opts.file.cstring, NULL)
+        argc += 1
+    for arg in opts.arg:
+        argv[argc] = Py_DecodeLocale(arg.cstring, NULL)
+        argc += 1
+        if argc >= 256:
+            break
+    discard PyConfig_SetArgv(r, config, argc, argv.addr)
+
     status = Py_InitializeFromConfig(r, config)
     if PyStatus_Exception(status):
         Py_ExitStatusException(status)
         return
 
+    if opts.version:
+        echo $Py_GetVersion()
+        quit()
+
     # Set up "nimporter" to expose pyd_has, pyd_load, stdlib_has, stdlib_read
     when DEBUG:
-        echo "Loading nimporter module"
+        echo "Loading onefile_python python module"
     let modules = PyImport_GetModuleDict()
     let own_module = PyInit_onefile_python()
-    PyImport_FixupExtensionObject(own_module, PyUnicode_FromString("nimporter"), PyUnicode_FromString("<memory>"), modules)
+    PyImport_FixupExtensionObject(own_module, PyUnicode_FromString("onefile_python"), PyUnicode_FromString("<memory>"), modules)
 
     # Run `bootstrap.py` to install import hooks
     when DEBUG:
@@ -194,16 +242,24 @@ proc main =
 
     # Load dlls in the embedded archive. This seems to trigger AV if we call the nim function directly, but calling it via python is enough to bypass...
     res = PyRun_SimpleString("""
-import nimporter
-nimporter.load_dlls()
+import onefile_python
+onefile_python.load_dlls()
 """)
     if res > 0:
         echo "Error running nimporter.load_dlls()"
         return
 
-    # TODO parse cmdline and run .py, OR do loop, (or maybe run __autorun__.py)
-    # MAYBE: clean up scope from vars in bootstrap.py
-    discard PyRun_InteractiveLoop(stdin, "stdin")
-
+    # run modes: command, TODO: module, file, interactive
+    if opts.command != "":
+        discard PyRun_SimpleString(opts.command.cstring)
+    elif opts.file == "-" or opts.file == "":
+        discard PyRun_InteractiveLoop(stdin, "stdin")
+    elif opts.file != "-":
+        let filename_str = Py_BuildValue("s", opts.file.cstring)
+        let file = Py_fopen_obj(filename_str, "rb")
+        if file != NULL:
+            discard PyRun_SimpleFile(file, opts.file.cstring)
+        else:
+            echo fmt"can't open file '{opts.file}'"
 
 main()

onefile_python.nimble

@@ -1,6 +1,6 @@
 # Package
 
-version       = "0.1.0"
+version       = "0.2.0"
 author        = "Simon Pinfold"
 description   = "Run python from a single exe"
 license       = "ISC"
@@ -12,6 +12,8 @@ requires "nim >= 1.6.2"
 requires "https://github.com/synap5e/memlib.git"  # Use fork while https://github.com/khchen/memlib/pull/3 is not merged
 requires "zippy >= 0.7.3"
 requires "nimpy >= 0.2.0"
+requires "nimpy >= 0.2.0"
+requires "https://github.com/iffy/nim-argparse"
 
 task build, "Build":
     exec "nim -d:release c onefile_python.nim"