python-script-launcher 0.0.10__tar.gz

python_script_launcher-0.0.10/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: python-script-launcher
+Version: 0.0.10
+Summary: Package Python scripts into standalone exe (Web + desktop client).
+License-Expression: MIT
+Keywords: pyinstaller,packaging,exe,launcher,scripts
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: python-multipart>=0.0.32
+Requires-Dist: uvicorn[standard]>=0.20.0
+Requires-Dist: requests>=2.34.2
+Provides-Extra: desktop
+Requires-Dist: pywebview>=4.0; extra == "desktop"
+Provides-Extra: build
+Requires-Dist: pyinstaller>=6.0; extra == "build"
+Requires-Dist: build>=1.0; extra == "build"
+Provides-Extra: all
+Requires-Dist: pywebview>=4.0; extra == "all"
+Requires-Dist: pyinstaller>=6.0; extra == "all"
+Requires-Dist: build>=1.0; extra == "all"
+
+# Python App Launcher
+
+一键把任意 Python 脚本目录变成独立 Web/桌面 exe：自动扫描脚本、生成参数表单、实时流式输出，支持一份脚本注册多个可运行任务。
+
+## 特性
+
+- **自动扫描**：递归识别 `scripts/` 下的入口，支持 `@task` 装饰器与传统 `def main()`。
+- **多任务脚本**：一个 `.py` 文件可注册多个 `@task`，无需手写 `if __name__ == "__main__"`。
+- **参数表单**：根据函数签名自动生成 UI（`str/int/float/bool` + 默认值 + 文件上传）。
+- **实时输出**：进程内 `runpy` / `importlib` 执行 + SSE 行流，冷启动毫秒级。
+- **一键打包**：`launcher build` 调用 PyInstaller，产出无需 Python 环境的 `.exe`。
+- **双形态发布**：`publish.py` 同步产出 wheel + sdist + `onedir/onefile` exe + release zip。
+
+## 安装
+
+```bash
+# 通过 uv（推荐）
+uv sync
+
+# 或安装已发布的 wheel（含打包依赖）
+pip install "python-script-launcher[build]"
+```
+
+## 用户脚本写法
+
+推荐使用 `@task` 装饰器，一个文件可暴露多个可调用任务：
+
+```python
+# my_tools/demo.py
+from python_script_launcher import task  # 或 from tasks import task
+
+@task
+def hi(name: str = "world"):
+    """打个招呼。"""
+    print(f"hi, {name}!")
+
+@task(name="add", desc="加两个整数")
+def add_(a: int, b: int = 1):
+    print(a + b)
+```
+
+依然兼容旧式 `def main(...) + __main__` 脚本：
+
+```python
+def main(name: str = "world"):
+    print(f"hello, {name}!")
+
+if __name__ == "__main__":
+    import argparse
+    p = argparse.ArgumentParser()
+    p.add_argument("--name", default="world")
+    main(**vars(p.parse_args()))
+```
+
+**约定**
+
+| 特性 | 说明 |
+|------|------|
+| 入口 | `@task` 装饰函数，或顶层 `def main(...)` |
+| 参数类型 | 通过类型注解推导（`str/int/float/bool`），无注解按 `str` 处理 |
+| 必填/可选 | 有默认值 → 可选；无默认值 → 必填 |
+| 文件参数 | 参数名含 `file` / `path` / `upload` 时启用上传控件 |
+| 说明文字 | 函数 docstring 显示在 UI 上 |
+
+## CLI
+
+安装后可直接使用 `launcher` 入口（或 `python -m python_script_launcher`）：
+
+```bash
+# 扫描并列出脚本
+launcher scan --scripts D:\my_tools
+
+# 开发模式启动 Web UI（http://localhost:8765）
+launcher run --scripts D:\my_tools --port 8765
+
+# 打包成 exe（onedir 默认，冷启动快）
+launcher build --scripts D:\my_tools --name MyTools --mode both
+
+# 单文件 exe（体积大、启动稍慢）
+launcher build --scripts D:\my_tools --onefile --clean
+```
+
+`build` 参数：
+
+| 参数 | 说明 | 默认 |
+|------|------|------|
+| `--scripts, -s` | 脚本目录 | 必填 |
+| `--output, -o` | 产物目录 | `./dist` |
+| `--name, -n` | 应用名 | 脚本目录名 |
+| `--mode, -m` | `web` / `client` / `both` | `both` |
+| `--onefile` | 单文件 exe | `false` |
+| `--clean` | 丢弃 `build/` 缓存重打 | `false` |
+
+## 作为库调用
+
+```python
+from python_script_launcher import create_app, scan_scripts, start_desktop
+from pathlib import Path
+
+# 扫描
+scripts = scan_scripts(Path(r"D:\\my_tools"))
+
+# 启动 Web
+app = create_app(root=r"D:\\my_tools")  # ASGI app, 用 uvicorn.run 起
+
+# 启动桌面
+start_desktop(root=r"D:\\my_tools", title="我的工具", port=8765)
+```
+
+## 发布 / 版本管理
+
+`publish.py` 是唯一的发布入口，从根目录源码 stage 出一份 `python_script_launcher/` 布局并调用 `python -m build`：
+
+```bash
+# 只出 wheel + sdist
+python publish.py --wheel
+
+# 只出 exe（onedir，PythonAppLauncher / PythonAppDesktop）
+python publish.py --exe
+
+# 完整发布：wheel + exe + zip
+python publish.py --wheel --exe --zip
+
+# 升版本号（写入 VERSION 后再构建）
+python publish.py --version 1.2.0 --wheel --exe
+```
+
+## 打包原理速览
+
+- `make_exe.py` 用 `importlib.metadata.distributions()` 拿到当前解释器里所有第三方包，通过 `--collect-all` 全量塞进 exe，避开脆弱的 import 扫描。
+- `__main__.py::_stage_project()` 会把 `app.py / client.py / tasks.py / static/` + 用户脚本复制到临时目录，并合成 `python_script_launcher/` 包 shim（转发 `tasks`），让打包后的 exe 里用户脚本 `from python_script_launcher import task` 依然可用。
+- 打包后 `app.py` 在 frozen 模式下直接进程内跑用户脚本（`runpy.run_path` 或 `@task` importlib），不再拉起子 Python，冷启动 20-60 ms。
+
+## 目录结构
+
+```
+pyRunner/
+├─ app.py            # FastAPI 后端 + 脚本扫描 / SSE 执行
+├─ client.py         # pywebview 桌面壳
+├─ tasks.py          # @task 装饰器 + run_cli()
+├─ make_exe.py       # PyInstaller 封装（build_exe 可复用）
+├─ __init__.py       # wheel 包入口 + 版本号
+├─ __main__.py       # launcher CLI (scan/run/build)
+├─ publish.py        # wheel + exe + zip 发布器
+├─ static/           # Web UI（单页）
+├─ scripts/          # 示例脚本
+├─ pyproject.toml    # 本地 dev 依赖（wheel 由 publish.py 生成）
+└─ VERSION           # 版本号（publish.py 读写）
+```
+
+## License
+
+MIT

python_script_launcher-0.0.10/README.md

@@ -0,0 +1,153 @@
+# Python App Launcher
+
+一键把任意 Python 脚本目录变成独立 Web/桌面 exe：自动扫描脚本、生成参数表单、实时流式输出，支持一份脚本注册多个可运行任务。
+
+## 特性
+
+- **自动扫描**：递归识别 `scripts/` 下的入口，支持 `@task` 装饰器与传统 `def main()`。
+- **多任务脚本**：一个 `.py` 文件可注册多个 `@task`，无需手写 `if __name__ == "__main__"`。
+- **参数表单**：根据函数签名自动生成 UI（`str/int/float/bool` + 默认值 + 文件上传）。
+- **实时输出**：进程内 `runpy` / `importlib` 执行 + SSE 行流，冷启动毫秒级。
+- **一键打包**：`launcher build` 调用 PyInstaller，产出无需 Python 环境的 `.exe`。
+- **双形态发布**：`publish.py` 同步产出 wheel + sdist + `onedir/onefile` exe + release zip。
+
+## 安装
+
+```bash
+# 通过 uv（推荐）
+uv sync
+
+# 或安装已发布的 wheel（含打包依赖）
+pip install "python-script-launcher[build]"
+```
+
+## 用户脚本写法
+
+推荐使用 `@task` 装饰器，一个文件可暴露多个可调用任务：
+
+```python
+# my_tools/demo.py
+from python_script_launcher import task  # 或 from tasks import task
+
+@task
+def hi(name: str = "world"):
+    """打个招呼。"""
+    print(f"hi, {name}!")
+
+@task(name="add", desc="加两个整数")
+def add_(a: int, b: int = 1):
+    print(a + b)
+```
+
+依然兼容旧式 `def main(...) + __main__` 脚本：
+
+```python
+def main(name: str = "world"):
+    print(f"hello, {name}!")
+
+if __name__ == "__main__":
+    import argparse
+    p = argparse.ArgumentParser()
+    p.add_argument("--name", default="world")
+    main(**vars(p.parse_args()))
+```
+
+**约定**
+
+| 特性 | 说明 |
+|------|------|
+| 入口 | `@task` 装饰函数，或顶层 `def main(...)` |
+| 参数类型 | 通过类型注解推导（`str/int/float/bool`），无注解按 `str` 处理 |
+| 必填/可选 | 有默认值 → 可选；无默认值 → 必填 |
+| 文件参数 | 参数名含 `file` / `path` / `upload` 时启用上传控件 |
+| 说明文字 | 函数 docstring 显示在 UI 上 |
+
+## CLI
+
+安装后可直接使用 `launcher` 入口（或 `python -m python_script_launcher`）：
+
+```bash
+# 扫描并列出脚本
+launcher scan --scripts D:\my_tools
+
+# 开发模式启动 Web UI（http://localhost:8765）
+launcher run --scripts D:\my_tools --port 8765
+
+# 打包成 exe（onedir 默认，冷启动快）
+launcher build --scripts D:\my_tools --name MyTools --mode both
+
+# 单文件 exe（体积大、启动稍慢）
+launcher build --scripts D:\my_tools --onefile --clean
+```
+
+`build` 参数：
+
+| 参数 | 说明 | 默认 |
+|------|------|------|
+| `--scripts, -s` | 脚本目录 | 必填 |
+| `--output, -o` | 产物目录 | `./dist` |
+| `--name, -n` | 应用名 | 脚本目录名 |
+| `--mode, -m` | `web` / `client` / `both` | `both` |
+| `--onefile` | 单文件 exe | `false` |
+| `--clean` | 丢弃 `build/` 缓存重打 | `false` |
+
+## 作为库调用
+
+```python
+from python_script_launcher import create_app, scan_scripts, start_desktop
+from pathlib import Path
+
+# 扫描
+scripts = scan_scripts(Path(r"D:\\my_tools"))
+
+# 启动 Web
+app = create_app(root=r"D:\\my_tools")  # ASGI app, 用 uvicorn.run 起
+
+# 启动桌面
+start_desktop(root=r"D:\\my_tools", title="我的工具", port=8765)
+```
+
+## 发布 / 版本管理
+
+`publish.py` 是唯一的发布入口，从根目录源码 stage 出一份 `python_script_launcher/` 布局并调用 `python -m build`：
+
+```bash
+# 只出 wheel + sdist
+python publish.py --wheel
+
+# 只出 exe（onedir，PythonAppLauncher / PythonAppDesktop）
+python publish.py --exe
+
+# 完整发布：wheel + exe + zip
+python publish.py --wheel --exe --zip
+
+# 升版本号（写入 VERSION 后再构建）
+python publish.py --version 1.2.0 --wheel --exe
+```
+
+## 打包原理速览
+
+- `make_exe.py` 用 `importlib.metadata.distributions()` 拿到当前解释器里所有第三方包，通过 `--collect-all` 全量塞进 exe，避开脆弱的 import 扫描。
+- `__main__.py::_stage_project()` 会把 `app.py / client.py / tasks.py / static/` + 用户脚本复制到临时目录，并合成 `python_script_launcher/` 包 shim（转发 `tasks`），让打包后的 exe 里用户脚本 `from python_script_launcher import task` 依然可用。
+- 打包后 `app.py` 在 frozen 模式下直接进程内跑用户脚本（`runpy.run_path` 或 `@task` importlib），不再拉起子 Python，冷启动 20-60 ms。
+
+## 目录结构
+
+```
+pyRunner/
+├─ app.py            # FastAPI 后端 + 脚本扫描 / SSE 执行
+├─ client.py         # pywebview 桌面壳
+├─ tasks.py          # @task 装饰器 + run_cli()
+├─ make_exe.py       # PyInstaller 封装（build_exe 可复用）
+├─ __init__.py       # wheel 包入口 + 版本号
+├─ __main__.py       # launcher CLI (scan/run/build)
+├─ publish.py        # wheel + exe + zip 发布器
+├─ static/           # Web UI（单页）
+├─ scripts/          # 示例脚本
+├─ pyproject.toml    # 本地 dev 依赖（wheel 由 publish.py 生成）
+└─ VERSION           # 版本号（publish.py 读写）
+```
+
+## License
+
+MIT

python_script_launcher-0.0.10/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "python-script-launcher"
+version = "0.0.10"
+description = "Package Python scripts into standalone exe (Web + desktop client)."
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.11"
+keywords = ["pyinstaller", "packaging", "exe", "launcher", "scripts"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Build Tools",
+]
+dependencies = [
+    "fastapi>=0.100.0",
+    "python-multipart>=0.0.32",
+    "uvicorn[standard]>=0.20.0",
+    "requests>=2.34.2",
+]
+
+[project.optional-dependencies]
+desktop = ["pywebview>=4.0"]
+build = ["pyinstaller>=6.0", "build>=1.0"]
+all = ["pywebview>=4.0", "pyinstaller>=6.0", "build>=1.0"]
+
+[project.scripts]
+launcher = "python_script_launcher.__main__:main"
+
+[tool.setuptools.packages.find]
+include = ["python_script_launcher", "python_script_launcher.*"]
+
+[tool.setuptools.package-data]
+"python_script_launcher" = [
+    "app.py", "client.py", "make_exe.py", "tasks.py",
+    "static/**/*",
+    "scripts/**/*.py",
+]

python_script_launcher-0.0.10/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-0.0.10/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()