pybend 0.1.0__py3-none-any.whl

pybend/__init__.py

@@ -0,0 +1,3 @@
+from pybend.importer import get_asset, BendMemoryFinder, BendMemoryLoader, BendMemoryExtensionLoader
+
+__all__ = ["get_asset", "BendMemoryFinder", "BendMemoryLoader", "BendMemoryExtensionLoader"]

pybend/cli.py

@@ -0,0 +1,642 @@
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+from io import StringIO
+import click
+from rich.console import Console
+from rich.theme import Theme
+from rich.table import Table
+from rich import box
+
+from pybend.config import resolve_config
+from pybend.compiler import compile_app
+from pybend.detector import detect_django, generate_entry_code
+
+custom_theme = Theme(
+    {
+        "info": "cyan",
+        "warning": "yellow",
+        "error": "bold red",
+        "success": "bold green",
+    }
+)
+
+
+def _get_console(quiet: bool = False) -> Console:
+    if quiet:
+        return Console(file=StringIO(), theme=custom_theme)
+    return Console(theme=custom_theme)
+
+
+def _py_version() -> str:
+    return f"python{sys.version_info.major}.{sys.version_info.minor}"
+
+
+def _bootloader_name() -> str:
+    return "bootloader.exe" if sys.platform == "win32" else "bootloader"
+
+
+def _platform_path(templates_dir: Path, target: Optional[str] = None) -> Path:
+    import platform
+    if target:
+        parts = target.split("/", 1)
+        if len(parts) != 2:
+            raise click.UsageError(f"Invalid target format '{target}'. Use os/arch (e.g. linux/x86_64)")
+        return templates_dir / parts[0] / parts[1]
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    arch_map = {"x86_64": "x86_64", "aarch64": "aarch64", "amd64": "x86_64"}
+    os_map = {"linux": "linux", "darwin": "macos", "windows": "windows"}
+    return templates_dir / os_map.get(system, system) / arch_map.get(machine, machine)
+
+
+def _has_static_libpython() -> Optional[Path]:
+    """Returns path to libpython.a if available and compiled with -fPIC."""
+    import sysconfig, subprocess
+    libdir = sysconfig.get_config_var("LIBDIR")
+    if not libdir:
+        return None
+    major = sys.version_info.major
+    minor = sys.version_info.minor
+    for name in [f"libpython{major}.{minor}.a", f"libpython{major}{minor}.a"]:
+        p = Path(libdir) / name
+        if p.exists():
+            return p
+    return None
+
+
+def _build_bootloader_from_source(target_dir: Path, quiet: bool = False, static: bool = False) -> Optional[Path]:
+    """Attempts to compile the bootloader from Rust source using cargo."""
+    console = _get_console(quiet)
+    bootloader_dir = Path(__file__).resolve().parent.parent / "bootloader"
+    if not (bootloader_dir / "Cargo.toml").exists():
+        return None
+
+    if not _check_cargo():
+        return None
+
+    py_ver = _py_version()
+    if not quiet:
+        console.print(f"[info]Building bootloader for {py_ver} from source...[/info]")
+
+    env = {**os.environ}
+    import sysconfig
+    stdlib = sysconfig.get_paths().get("stdlib", "")
+    platstdlib = sysconfig.get_paths().get("platstdlib", "")
+    if stdlib:
+        env["PYBEND_STDLIB_PATH"] = stdlib
+    if platstdlib:
+        env["PYBEND_PLATSTDLIB_PATH"] = platstdlib
+
+    libpython_a = _has_static_libpython()
+    is_static = static or bool(libpython_a)
+
+    lib_dir = bootloader_dir / "lib"
+    lib_dir.mkdir(parents=True, exist_ok=True)
+    ldlib = sysconfig.get_config_var("LDLIBRARY")
+    libdir = sysconfig.get_config_var("LIBDIR")
+    if libdir and ldlib:
+        src_lib = Path(libdir) / ldlib
+        dst_lib = lib_dir / ldlib
+        if src_lib.exists() and not dst_lib.exists():
+            dst_lib.symlink_to(src_lib)
+    env["RUSTFLAGS"] = f"-L {lib_dir}"
+
+    env["PYO3_PYTHON"] = sys.executable
+    env["PYTHON_SYS_EXECUTABLE"] = sys.executable
+    if is_static:
+        if libpython_a:
+            if not quiet:
+                console.print(f"[info]Static libpython found at {libpython_a}[/info]")
+            import tempfile
+            cfg = tempfile.NamedTemporaryFile(mode="w", suffix=".toml", delete=False, prefix="pyo3-")
+            cfg.write(f"""implementation = "CPython"
+version = "{sys.version_info.major}.{sys.version_info.minor}"
+shared = false
+lib_name = "python{sys.version_info.major}.{sys.version_info.minor}"
+lib_dir = "{libdir}"
+executable = "{sys.executable}"
+""")
+            cfg.close()
+            env["PYO3_CONFIG_FILE"] = cfg.name
+    if not quiet:
+        console.print(f"[info]Using Python: {sys.executable}[/info]")
+
+    result = subprocess.run(
+        ["cargo", "build", "--release"],
+        cwd=bootloader_dir,
+        env=env,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        if not quiet:
+            console.print(f"[warning]Cargo build stderr:[/warning] {result.stderr}")
+        return None
+
+    pybend_root = Path(__file__).resolve().parent.parent
+    for candidate in [
+        bootloader_dir / "target" / "release" / _bootloader_name(),
+        pybend_root / "target" / "release" / _bootloader_name(),
+    ]:
+        if candidate.exists():
+            built = candidate
+            break
+    else:
+        return None
+
+    # Set rpath on the built bootloader so libpython can be found at runtime
+    import sysconfig
+    libdir = sysconfig.get_config_var("LIBDIR")
+    ldlib = sysconfig.get_config_var("LDLIBRARY")
+    if libdir and Path(libdir).exists():
+        _set_rpath(str(built), libdir)
+
+    # Stage into versioned template directory
+    versioned = target_dir / _py_version()
+    versioned.mkdir(parents=True, exist_ok=True)
+    staged = versioned / _bootloader_name()
+    import shutil
+    shutil.copy2(built, staged)
+    os.chmod(staged, 0o755)
+    if not quiet:
+        console.print(f"[success]Bootloader built and staged at {staged}[/success]")
+    return staged
+
+
+def _set_rpath(binary: str, *libdirs: str) -> None:
+    """Set RUNPATH on an ELF binary so shared libraries are found at runtime."""
+    import subprocess
+    try:
+        rpath = ":".join(libdirs)
+        subprocess.run(
+            ["patchelf", "--set-rpath", rpath, binary],
+            capture_output=True,
+            timeout=10,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+
+
+def _check_cargo() -> bool:
+    try:
+        result = subprocess.run(
+            ["cargo", "--version"], capture_output=True, text=True, timeout=10
+        )
+        return result.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def _check_libpython(bootloader_path: Path) -> bool:
+    """Returns True if the bootloader's libpython dependency can be resolved."""
+    import platform as _platform
+    if _platform.system() != "Linux":
+        return True
+    try:
+        result = subprocess.run(
+            ["ldd", str(bootloader_path)],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        for line in result.stdout.splitlines():
+            if "libpython" in line and "not found" in line:
+                return False
+        return True
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return True
+
+
+def find_default_template(target: Optional[str] = None, python: Optional[str] = None, quiet: bool = False) -> Path:
+    """Finds a bootloader template compatible with the given Python version."""
+    console = _get_console(quiet)
+    pybend_root = Path(__file__).resolve().parent.parent
+    py_ver = python if python else _py_version()
+
+    templates_dir = Path(__file__).resolve().parent / "templates"
+    base = _platform_path(templates_dir, target=target)
+
+    # 1. Packaged templates: versioned path first (these are CI-built or local-build staged)
+    versioned = base / py_ver / _bootloader_name()
+    if versioned.exists():
+        return versioned
+
+    # 2. Development builds from cargo target dir (fallback for dev)
+    for variant in ["release", "debug"]:
+        for p in [
+            pybend_root / "bootloader" / "target" / variant / _bootloader_name(),
+            pybend_root / "target" / variant / _bootloader_name(),
+        ]:
+            if p.exists():
+                return p
+
+    unversioned = base / _bootloader_name()
+    if unversioned.exists():
+        if _check_libpython(unversioned):
+            return unversioned
+        console.print(
+            f"[warning]Packaged bootloader ({unversioned}) needs libpython for "
+            f"'{py_ver}' but it targets a different version.[/warning]"
+        )
+
+    # 3. Build from source if cargo is available
+    target_dir = _platform_path(templates_dir, target=target)
+    built = _build_bootloader_from_source(target_dir)
+    if built is not None:
+        return built
+
+    return templates_dir / "bootloader"
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def main(ctx: click.Context) -> None:
+    """PyBend — Compile Python applications into standalone native binaries.
+
+    Combines your application, its dependencies, and the Python runtime
+    into a single portable executable. Run without arguments to build
+    the project in the current directory.
+
+    Commands:
+        build       Compile a Python app into a standalone binary.
+        bootstrap   Build the native bootloader from Rust source.
+        inspect     Display the contents of a compiled binary's VFS.
+    """
+    if ctx.invoked_subcommand is None:
+        ctx.invoke(build)
+
+
+@main.command()
+@click.option(
+    "--entry", "-e",
+    type=str,
+    metavar="PATH",
+    help="Application entry point (e.g. app.py, manage.py, main.py). "
+         "Auto-detected in the current directory if not specified.",
+)
+@click.option(
+    "--output", "-o",
+    type=str,
+    metavar="PATH",
+    help="Output binary path. Defaults to <project_dir>/dist/<entry_name>.",
+)
+@click.option(
+    "--optimize", "-O",
+    type=click.Choice(["0", "1", "2"]),
+    metavar="LEVEL",
+    help="Bytecode optimization level: 0=none, 1=remove assert/__debug__, "
+         "2=also remove docstrings (default: 2).",
+)
+@click.option(
+    "--include", "-i",
+    multiple=True,
+    metavar="MODULE",
+    help="Forcefully include a module in the bundle even if not traced "
+         "as a dependency. Repeatable.",
+)
+@click.option(
+    "--exclude", "-x",
+    multiple=True,
+    metavar="MODULE",
+    help="Exclude a module from the bundle. Overrides --include if both "
+         "specify the same module. Repeatable.",
+)
+@click.option(
+    "--template", "-t",
+    type=str,
+    metavar="PATH",
+    help="Custom bootloader binary path. Overrides automatic template "
+         "resolution. Use 'pybend bootstrap' to build one from source.",
+)
+@click.option(
+    "--config", "-c",
+    type=str,
+    metavar="PATH",
+    help="Path to pybend.toml configuration file. Defaults to "
+         "./pybend.toml if it exists.",
+)
+@click.option(
+    "--target", "-p",
+    type=str,
+    default=None,
+    metavar="OS/ARCH",
+    help="Target platform as os/arch (e.g. linux/x86_64, macos/aarch64). "
+         "Defaults to the current build platform.",
+)
+@click.option(
+    "--python", "-V",
+    type=str,
+    default=None,
+    metavar="VERSION",
+    help="Python version to target (e.g. 3.12, 3.13). Must match a "
+         "bootloader template in the templates directory.",
+)
+@click.option(
+    "--verbose", "-v",
+    is_flag=True,
+    help="Print detailed build logs including compiler tracebacks.",
+)
+@click.option(
+    "--quiet", "-q",
+    is_flag=True,
+    help="Suppress all output except errors.",
+)
+@click.option(
+    "--no-strip",
+    is_flag=True,
+    help="Preserve debug symbols in the output binary (larger file size).",
+)
+def build(
+    entry: Optional[str],
+    output: Optional[str],
+    optimize: Optional[str],
+    include: List[str],
+    exclude: List[str],
+    template: Optional[str],
+    config: Optional[str],
+    target: Optional[str],
+    python: Optional[str],
+    verbose: bool,
+    quiet: bool,
+    no_strip: bool,
+) -> None:
+    """Compile a Python application into a standalone native binary."""
+    console = _get_console(quiet)
+    if not quiet:
+        console.print("[info]Starting PyBend compilation toolchain...[/info]")
+
+    entry_explicit = entry is not None
+    cli_args = {}
+    if entry_explicit:
+        cli_args["entry_point"] = entry
+    if output is not None:
+        cli_args["output_exe"] = output
+    if optimize is not None:
+        cli_args["optimization_level"] = int(optimize)
+    if include:
+        cli_args["include_modules"] = list(include)
+    if exclude:
+        cli_args["exclude_modules"] = list(exclude)
+    if no_strip:
+        cli_args["no_strip"] = True
+
+    config_path = Path(config) if config else None
+
+    try:
+        resolved_config = resolve_config(cli_args, config_path=config_path)
+    except ValueError as e:
+        console.print(f"[error]Configuration Error:[/error] {e}")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[error]Unexpected Error:[/error] {e}")
+        sys.exit(1)
+
+    entry_point = Path(resolved_config["entry_point"])
+    auto_entry_path: Optional[Path] = None
+
+    # Detect Django project: look for manage.py relative to entry point parent or CWD
+    django_settings = detect_django(entry_point.parent) or detect_django(Path.cwd())
+    if django_settings:
+        project_pkg = django_settings.split(".")[0]
+        include_mods = resolved_config.setdefault("include_modules", [])
+        if project_pkg not in include_mods:
+            include_mods.append(project_pkg)
+            if not quiet:
+                console.print(f"[info]Including project package: {project_pkg}[/info]")
+        for extra in ["django.templatetags", "django.contrib.staticfiles",
+                        "django.core.management.commands", "dj_rest_auth"]:
+            if extra not in include_mods:
+                include_mods.append(extra)
+                if not quiet:
+                    console.print(f"[info]Including Django extra: {extra}[/info]")
+
+    if not entry_explicit or django_settings:
+        wrapper_code = generate_entry_code(entry_point.parent if django_settings else Path.cwd(), entry_point)
+        if wrapper_code:
+            tmp = tempfile.NamedTemporaryFile(
+                mode="w", suffix=".py", delete=False, prefix="pybend_auto_"
+            )
+            tmp.write(wrapper_code)
+            auto_entry_path = Path(tmp.name)
+            tmp.close()
+            resolved_config["entry_point"] = str(auto_entry_path)
+            if wrapper_code:
+                resolved_config["_project_dir"] = str(entry_point.parent.resolve())
+            if not quiet:
+                console.print(f"[info]Generated framework entry wrapper[/info]")
+            entry_point = auto_entry_path
+
+    if template:
+        runner_template = Path(template).resolve()
+    else:
+        runner_template = find_default_template(target=target, python=python, quiet=quiet)
+
+    if not runner_template.exists():
+        console.print(
+            "[error]Template Error:[/error] Bootloader template not found. "
+            "Use --template to specify one, or run 'pybend bootstrap' to build from source."
+        )
+        sys.exit(3)
+
+    if not _check_libpython(runner_template):
+        console.print(
+            f"[warning]Bootloader at {runner_template} requires a different "
+            f"libpython version than your current Python ({_py_version()}).[/warning]"
+        )
+        if _check_cargo():
+            if not quiet:
+                console.print("[info]Building a matching bootloader from source...[/info]")
+            templates_dir = Path(__file__).resolve().parent / "templates"
+            built = _build_bootloader_from_source(_platform_path(templates_dir, target=target))
+            if built is not None:
+                runner_template = built
+            else:
+                console.print("[error]Auto-build failed. Try 'pybend bootstrap --force'.[/error]")
+                sys.exit(3)
+        else:
+            console.print(
+                "[error]Install Rust/Cargo (https://rustup.rs) then run "
+                "'pybend bootstrap' to build a bootloader for your Python.[/error]"
+            )
+            sys.exit(3)
+
+    entry_point = Path(resolved_config["entry_point"])
+    output_exe = Path(resolved_config["output_exe"])
+
+    if not entry_point.exists():
+        console.print(
+            f"[error]Resolution Error:[/error] Entry point script '{entry_point}' does not exist."
+        )
+        sys.exit(2)
+
+    output_exe.parent.mkdir(parents=True, exist_ok=True)
+
+    if not quiet:
+        console.print(f"[info]Entry Point:   [/info] {entry_point}")
+        console.print(f"[info]Output Target: [/info] {output_exe}")
+        console.print(
+            f"[info]Optimization:  [/info] Level {resolved_config['optimization_level']}"
+        )
+
+    try:
+        compile_app(resolved_config, runner_template)
+    except ImportError as e:
+        console.print(f"[error]Dependency Error:[/error] {e}")
+        sys.exit(2)
+    except FileNotFoundError as e:
+        console.print(f"[error]Compilation Error:[/error] {e}")
+        sys.exit(3)
+    except Exception as e:
+        console.print(f"[error]Build Failed:[/error] {e}")
+        if verbose:
+            import traceback
+            traceback.print_exc()
+        sys.exit(3)
+    finally:
+        if auto_entry_path and auto_entry_path.exists():
+            auto_entry_path.unlink()
+
+    if not quiet:
+        console.print(
+            f"[success]Successfully compiled '{entry_point.name}' to '{output_exe}'[/success]"
+        )
+
+
+@main.command()
+@click.option("--force", "-f", is_flag=True,
+              help="Force rebuild even if a bootloader template already exists for this version.")
+@click.option("--target", "-p", type=str, default=None,
+              metavar="OS/ARCH",
+              help="Target platform as os/arch (e.g. linux/x86_64, macos/aarch64). "
+                   "Defaults to the current build platform.")
+@click.option("--python", "-V", type=str, default=None,
+              metavar="VERSION",
+              help="Python version string for the bootloader (e.g. 3.12). "
+                   "Defaults to the version of the Python running this command.")
+@click.option("--static", is_flag=True,
+              help="Link libpython statically if libpython.a is detected. "
+                   "Produces a fully self-contained binary.")
+def bootstrap(force: bool, target: Optional[str], python: Optional[str], static: bool) -> None:
+    """Build the bootloader template from Rust source.
+
+    Requires Rust/Cargo (https://rustup.rs) to be installed. The compiled
+    bootloader is staged into the versioned templates directory for use
+    by 'pybend build'.
+
+    Use --force to rebuild an existing template, --target to cross-compile,
+    and --static to embed libpython for fully standalone binaries.
+    """
+    console = _get_console()
+    if not _check_cargo():
+        console.print("[error]Rust/Cargo not found.[/error] Install from https://rustup.rs")
+        sys.exit(1)
+
+    templates_dir = Path(__file__).resolve().parent / "templates"
+    target_dir = _platform_path(templates_dir, target=target)
+    py_ver = _py_version()
+    dest = target_dir / py_ver / _bootloader_name()
+
+    if dest.exists() and not force:
+        console.print(f"[info]Bootloader already exists at {dest}. Use --force to rebuild.[/info]")
+        return
+
+    built = _build_bootloader_from_source(target_dir, static=static)
+    if built is None:
+        console.print("[error]Failed to build bootloader from source.[/error]")
+        sys.exit(1)
+    console.print(f"[success]Bootloader ready at {built}[/success]")
+
+
+@main.command()
+@click.argument("binary", type=str, metavar="BINARY")
+@click.option("--json-output", is_flag=True,
+              help="Output the VFS table as JSON for programmatic consumption.")
+@click.option("--tree", is_flag=True,
+              help="Display the VFS entries as a tree layout instead of a table.")
+def inspect(binary: str, json_output: bool, tree: bool) -> None:
+    """Inspect the VFS (Virtual File System) inside a compiled PyBend binary.
+
+    Parses the embedded VFS blob and displays all code and asset entries
+    with their names, compressed/uncompressed sizes, and compression ratios.
+
+    Use --json for machine-readable output, or --tree for a hierarchical view.
+    """
+    console = _get_console()
+    from pybend.inspector import locate_vfs_blob, parse_vfs_blob
+
+    binary_path = Path(binary).resolve()
+    if not binary_path.exists():
+        console.print(f"[error]File not found: {binary_path}[/error]")
+        sys.exit(1)
+
+    try:
+        vfs_blob = locate_vfs_blob(binary_path)
+    except ValueError as e:
+        console.print(f"[error]{e}[/error]")
+        sys.exit(1)
+
+    info = parse_vfs_blob(vfs_blob)
+
+    console.print(f"[info]PyBend Binary:[/info] {binary_path}")
+    console.print(f"[info]VFS Total Size:[/info] {info['vfs_total_size']:,} bytes")
+    console.print(f"[info]Payload Size:[/info]   {info['payload_size']:,} bytes")
+    console.print()
+
+    if info["entries"]:
+        table = Table(
+            title=f"Code Entries ({info['entry_count']})",
+            box=box.ROUNDED,
+            title_style="bold cyan",
+        )
+        table.add_column("Module", style="cyan")
+        table.add_column("Compressed", justify="right")
+        table.add_column("Uncompressed", justify="right")
+        table.add_column("Ratio", justify="right")
+        table.add_column("Type")
+
+        for e in info["entries"]:
+            ratio = (
+                f"{e['compressed_size'] / e['uncompressed_size'] * 100:.0f}%"
+                if e["uncompressed_size"]
+                else "N/A"
+            )
+            typ = "C Ext" if e["is_c_ext"] else "Python"
+            table.add_row(
+                e["name"],
+                f"{e['compressed_size']:,}",
+                f"{e['uncompressed_size']:,}",
+                ratio,
+                typ,
+            )
+        console.print(table)
+    else:
+        console.print("[warning]No code entries found in VFS.[/warning]")
+
+    if info["asset_entries"]:
+        table = Table(
+            title=f"Asset Entries ({info['asset_count']})",
+            box=box.ROUNDED,
+            title_style="bold cyan",
+        )
+        table.add_column("Path", style="green")
+        table.add_column("Compressed", justify="right")
+        table.add_column("Uncompressed", justify="right")
+        table.add_column("Ratio", justify="right")
+
+        for e in info["asset_entries"]:
+            ratio = (
+                f"{e['compressed_size'] / e['uncompressed_size'] * 100:.0f}%"
+                if e["uncompressed_size"]
+                else "N/A"
+            )
+            table.add_row(
+                e["name"],
+                f"{e['compressed_size']:,}",
+                f"{e['uncompressed_size']:,}",
+                ratio,
+            )
+        console.print(table)