python-script-launcher 0.0.10__py3-none-any.whl

python_script_launcher/__init__.py

@@ -0,0 +1,49 @@
+"""Python App Launcher - Package Python scripts into standalone exe.
+
+This package is normally built by publish.py from the top-level source files
+(app.py, client.py, tasks.py, __init__.py, __main__.py). Importing this
+package makes the sibling `app` / `client` / `launcher` modules available under
+their bare names, so `from app import ...` works both from the repo root and
+from an installed wheel.
+"""
+import os
+import sys
+from pathlib import Path
+
+# Make sibling modules (app.py, client.py, tasks.py) importable by bare
+# name, matching how they are used from the repo root and inside a frozen exe.
+_here = os.path.dirname(os.path.abspath(__file__))
+if _here not in sys.path:
+    sys.path.insert(0, _here)
+
+# When installed from a wheel, the version comes from package metadata.
+# When running from the source repo, fall back to the VERSION file at the
+# project root (which publish.py maintains).
+try:
+    from importlib.metadata import version as _pkg_version, PackageNotFoundError
+    try:
+        __version__ = _pkg_version("python-script-launcher")
+    except PackageNotFoundError:
+        _version_file = Path(_here).parent / "VERSION"
+        __version__ = _version_file.read_text(encoding="utf-8").strip() if _version_file.exists() else "0.0.0"
+except Exception:
+    __version__ = "0.0.0"
+
+from app import create_app, scan_scripts, find_python, ScriptInfo, ParamInfo  # noqa: E402
+from client import start_desktop  # noqa: E402
+from tasks import task, run_cli, collect_tasks, TaskSpec, TaskParam  # noqa: E402
+
+__all__ = [
+    "create_app",
+    "scan_scripts",
+    "find_python",
+    "start_desktop",
+    "ScriptInfo",
+    "ParamInfo",
+    "task",
+    "run_cli",
+    "collect_tasks",
+    "TaskSpec",
+    "TaskParam",
+    "__version__",
+]

python_script_launcher/__main__.py

@@ -0,0 +1,191 @@
+"""
+Python App Launcher CLI.
+
+Usage:
+    python -m python_script_launcher scan --scripts <dir>
+    python -m python_script_launcher run --scripts <dir> [--port <port>]
+    python -m python_script_launcher build --scripts <dir>
+                                          [--output <dir>] [--name <exe>]
+                                          [--mode web|client|both]
+                                          [--onefile] [--clean]
+
+`build` reuses make_exe.build_exe: it stages the launcher runtime + your
+scripts into a temporary project directory and invokes PyInstaller with
+`--collect-all` for every package installed in the current environment.
+"""
+import argparse
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+
+PACKAGE_DIR = Path(__file__).parent.resolve()
+
+
+def _die(msg: str, code: int = 1):
+    print(f"[ERROR] {msg}")
+    sys.exit(code)
+
+
+def cmd_scan(args):
+    from app import scan_scripts
+    root = Path(args.scripts).resolve()
+    if not root.exists():
+        _die(f"Directory not found: {root}")
+    scripts = scan_scripts(root)
+    if not scripts:
+        _die(f"No scripts with main() found in: {root}")
+    print(f"\n  Scripts in: {root}")
+    print(f"  Found: {len(scripts)}\n")
+    for name, info in scripts.items():
+        params = ", ".join(p.name for p in info.params)
+        print(f"  - {name}({params})")
+        first_line = info.docstring.split("\n")[0]
+        if first_line:
+            print(f"    {first_line}")
+    return scripts
+
+
+def cmd_run(args):
+    from app import create_app, scan_scripts, is_port_used
+    import uvicorn
+    root = Path(args.scripts).resolve()
+    if not root.exists():
+        _die(f"Directory not found: {root}")
+    scripts = scan_scripts(root)
+    print(f"\n  Found {len(scripts)} scripts in {root}")
+    port = args.port
+    if is_port_used(port):
+        _die(f"Port {port} already in use")
+    app = create_app(root=root)
+    print(f"  http://localhost:{port}\n")
+    uvicorn.run(app, host="0.0.0.0", port=port)
+
+
+LAUNCHER_FILES = ["app.py", "client.py", "tasks.py"]
+STATIC_DIR = "static"
+SHIM_PKG = "python_script_launcher"
+SHIM_INIT = (
+    '"'*3 + "Compatibility shim generated by launcher build.\n\n"
+    "Allows user scripts to write ``from python_script_launcher import task``\n"
+    "even after being packaged into a standalone exe. All names are forwarded\n"
+    "from the top-level ``tasks`` module that ships alongside the launcher.\n"
+    + '"'*3 + "\n"
+    "from tasks import *  # noqa: F401,F403\n"
+    "from tasks import task, run_cli, collect_tasks, TaskSpec, TaskParam  # noqa: F401\n"
+)
+
+
+def _stage_project(scripts_src: Path) -> Path:
+    """Create a temp directory that mimics the launcher repo layout, so
+    make_exe.build_exe() can operate on it unchanged.
+    """
+    tmp = Path(tempfile.mkdtemp(prefix="launcher-build-"))
+    for name in LAUNCHER_FILES:
+        src = PACKAGE_DIR / name
+        if src.exists():
+            shutil.copy2(src, tmp / name)
+    static_src = PACKAGE_DIR / STATIC_DIR
+    if static_src.exists():
+        shutil.copytree(static_src, tmp / STATIC_DIR)
+    # Generate a lightweight `python_script_launcher` package shim so user
+    # scripts using `from python_script_launcher import task` keep working
+    # inside the frozen exe. The exe ships `tasks.py` at its root, and the
+    # shim just re-exports its public names.
+    shim_dir = tmp / SHIM_PKG
+    shim_dir.mkdir(parents=True, exist_ok=True)
+    (shim_dir / "__init__.py").write_text(SHIM_INIT, encoding="utf-8", newline="\n")
+    # Copy user scripts into <tmp>/scripts so both scan_scripts and
+    # PyInstaller's --add-data pick them up.
+    shutil.copytree(scripts_src, tmp / "scripts", dirs_exist_ok=True)
+    return tmp
+
+
+def cmd_build(args):
+    from app import scan_scripts
+    from make_exe import build_exe
+
+    scripts_dir = Path(args.scripts).resolve()
+    if not scripts_dir.exists():
+        _die(f"Directory not found: {scripts_dir}")
+
+    scripts = scan_scripts(scripts_dir)
+    if not scripts:
+        _die(f"No scripts with main() found in: {scripts_dir}")
+
+    output_dir = Path(args.output).resolve() if args.output else Path.cwd() / "dist"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    app_name = args.name or scripts_dir.name
+    mode = args.mode
+
+    print("=" * 60)
+    print(f"  Building : {app_name}")
+    print(f"  Mode     : {mode}")
+    print(f"  Scripts  : {len(scripts)}  ({', '.join(scripts)})")
+    print(f"  Output   : {output_dir}")
+    print("=" * 60)
+
+    stage = _stage_project(scripts_dir)
+    try:
+        targets = []
+        if mode in ("web", "both"):
+            targets.append(("app.py", app_name, False))
+        if mode in ("client", "both"):
+            client_name = f"{app_name}Desktop" if mode == "both" else app_name
+            targets.append(("client.py", client_name, True))
+
+        for entry, name, noconsole in targets:
+            build_exe(
+                entry=entry,
+                name=name,
+                project=stage,
+                dist=output_dir,
+                static=stage / STATIC_DIR,
+                noconsole=noconsole,
+                onefile=args.onefile,
+                clean=args.clean,
+            )
+    finally:
+        shutil.rmtree(stage, ignore_errors=True)
+
+    print("=" * 60)
+    print(f"  Done. Artifacts in {output_dir}")
+    print("=" * 60)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="python -m python_script_launcher",
+        description="Package Python scripts into standalone exe",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    p_scan = sub.add_parser("scan", help="Scan scripts directory")
+    p_scan.add_argument("--scripts", "-s", required=True)
+
+    p_run = sub.add_parser("run", help="Run launcher (dev mode)")
+    p_run.add_argument("--scripts", "-s", required=True)
+    p_run.add_argument("--port", "-p", type=int, default=8765)
+
+    p_build = sub.add_parser("build", help="Build exe")
+    p_build.add_argument("--scripts", "-s", required=True, help="Scripts directory")
+    p_build.add_argument("--output", "-o", default=None, help="Output directory")
+    p_build.add_argument("--name", "-n", default=None, help="App name")
+    p_build.add_argument("--mode", "-m", default="both",
+                         choices=["web", "client", "both"],
+                         help="Build mode: web / client / both (default: both)")
+    p_build.add_argument("--onefile", action="store_true",
+                         help="Single-file exe (slower cold start)")
+    p_build.add_argument("--clean", action="store_true", help="Drop build cache")
+
+    args = parser.parse_args()
+    handler = {"scan": cmd_scan, "run": cmd_run, "build": cmd_build}.get(args.command)
+    if handler is None:
+        parser.print_help()
+        return
+    handler(args)
+
+
+if __name__ == "__main__":
+    main()