pybend 0.2.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,172 @@
+import sys
+from pathlib import Path
+from typing import List, Optional
+import click
+from rich.console import Console
+from rich.theme import Theme
+
+from pybend.config import resolve_config
+from pybend.compiler import compile_app
+
+# Set up custom theme for Rich logging
+custom_theme = Theme(
+    {
+        "info": "cyan",
+        "warning": "yellow",
+        "error": "bold red",
+        "success": "bold green",
+    }
+)
+console = Console(theme=custom_theme)
+
+
+def find_default_template() -> Path:
+    """Finds the default bootloader template location in the project workspace."""
+    pybend_root = Path(__file__).resolve().parent.parent
+
+    # Check release target first
+    release_path = (
+        pybend_root / "bootloader" / "target" / "release" / "bootloader"
+    )
+    if release_path.exists():
+        return release_path
+
+    # Fall back to debug target
+    debug_path = pybend_root / "bootloader" / "target" / "debug" / "bootloader"
+    if debug_path.exists():
+        return debug_path
+
+    # Fall back to packaged template folder (e.g. templates/linux/x86_64/bootloader)
+    import platform
+    templates_dir = Path(__file__).resolve().parent / "templates"
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    # Map Python names to Rust target triples
+    arch_map = {"x86_64": "x86_64", "aarch64": "aarch64", "amd64": "x86_64"}
+    os_map = {"linux": "linux", "darwin": "macos", "windows": "windows"}
+    guessed_arch = arch_map.get(machine, machine)
+    guessed_os = os_map.get(system, system)
+    package_path = templates_dir / guessed_os / guessed_arch / "bootloader"
+    if package_path.exists():
+        return package_path
+    # Ultimate fallback: direct path
+    return templates_dir / "bootloader"
+
+
+@click.group()
+def main() -> None:
+    """PyBend: A zero-configuration, high-performance compiler
+
+    for Python applications.
+    """
+    pass
+
+
+@main.command()
+@click.option("--entry", "-e", type=str, help="Python entry script path.")
+@click.option("--output", "-o", type=str, help="Output standalone executable path.")
+@click.option(
+    "--optimize",
+    "-O",
+    type=click.Choice(["0", "1", "2"]),
+    help="Bytecode optimization level.",
+)
+@click.option(
+    "--include", "-i", multiple=True, help="Force include module(s) in the VFS."
+)
+@click.option(
+    "--exclude",
+    "-x",
+    multiple=True,
+    help="Explicitly exclude module(s) from the VFS.",
+)
+@click.option(
+    "--template",
+    "-t",
+    type=str,
+    help="Custom native runner bootloader template path.",
+)
+@click.option("--config", "-c", type=str, help="Custom pybend.toml config path.")
+def build(
+    entry: Optional[str],
+    output: Optional[str],
+    optimize: Optional[str],
+    include: List[str],
+    exclude: List[str],
+    template: Optional[str],
+    config: Optional[str],
+) -> None:
+    """Compile a Python application into a standalone native binary."""
+    console.print("[info]Starting PyBend compilation toolchain...[/info]")
+
+    # 1. Resolve configuration options
+    cli_args = {}
+    if entry is not None:
+        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)
+
+    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)
+
+    # 2. Resolve template path
+    if template:
+        runner_template = Path(template).resolve()
+    else:
+        runner_template = find_default_template()
+
+    if not runner_template.exists():
+        console.print(
+            "[error]Template Error:[/error] Bootloader template not found "
+            f"at '{runner_template}'.\n"
+            "Please build the bootloader or specify it via --template."
+        )
+        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)
+
+    # Make parent output directory if missing
+    output_exe.parent.mkdir(parents=True, exist_ok=True)
+
+    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}")
+        sys.exit(3)
+
+    console.print(
+        f"[success]Successfully compiled '{entry_point.name}' to '{output_exe}'[/success]"
+    )

pybend/compiler.py

@@ -0,0 +1,79 @@
+import os
+import tempfile
+from pathlib import Path
+from typing import Any, Dict
+from pybend.dependency_resolver import DependencyResolver
+from pybend.vfs_builder import VfsBuilder
+from pybend.splicer import splice
+
+
+def compile_app(config: Dict[str, Any], runner_template: Path) -> None:
+    """Compiles a Python application into a standalone binary.
+
+    Accepts the fully resolved configuration dictionary and the bootloader template path.
+    """
+    entry_point = Path(config["entry_point"]).resolve()
+    output_exe = Path(config["output_exe"]).resolve()
+    runner_template = Path(runner_template).resolve()
+
+    optimization_level = config.get("optimization_level", 2)
+    include_modules = config.get("include_modules", [])
+    exclude_modules = config.get("exclude_modules", [])
+    include_data = [Path(p) for p in config.get("include_data", [])]
+
+    # 1. Resolve static dependencies
+    resolver = DependencyResolver(entry_point, include_modules, exclude_modules)
+    modules_map = resolver.resolve_static_imports()
+
+    # 2. Add the user's entry point under 'pybend_app_entry' name in VFS
+    modules_map["pybend_app_entry"] = str(entry_point)
+
+    # 3. Create the dynamic bend_app_main module
+    app_main_code = """import sys
+import types
+
+def exec_bootstrap():
+    finder = sys.meta_path[0]
+    code_obj = finder.get_code_object("pybend_app_entry")
+
+    # Configure __main__ module environment
+    main_mod = sys.modules.setdefault("__main__", types.ModuleType("__main__"))
+    main_mod.__file__ = "pybend_app_entry.py"
+
+    # Execute the entry bytecode in __main__ context
+    try:
+        exec(code_obj, main_mod.__dict__)
+    finally:
+        try:
+            sys.stdout.flush()
+        except Exception:
+            pass
+        try:
+            sys.stderr.flush()
+        except Exception:
+            pass
+"""
+
+    with tempfile.NamedTemporaryFile(suffix=".py", mode="w", delete=False) as tmp:
+        tmp.write(app_main_code)
+        tmp_path = Path(tmp.name)
+
+    try:
+        modules_map["bend_app_main"] = str(tmp_path)
+
+        # 4. Build VFS payload
+        builder = VfsBuilder(
+            modules_map,
+            optimization_level=optimization_level,
+            include_data=include_data,
+        )
+        vfs_blob = builder.build_vfs_blob()
+    finally:
+        if tmp_path.exists():
+            tmp_path.unlink()
+
+    # 5. Append VFS payload onto target native runner template
+    splice(runner_template, vfs_blob, output_exe)
+
+    # 6. Mark output binary as executable
+    os.chmod(output_exe, 0o755)

pybend/config.py

@@ -0,0 +1,133 @@
+import tomllib
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+DEFAULT_CONFIG: Dict[str, Any] = {
+    "entry_point": None,
+    "output_exe": None,
+    "optimization_level": 2,
+    "include_modules": [],
+    "exclude_modules": [],
+    "include_data": [],
+}
+
+
+def load_config(config_path: Path) -> Dict[str, Any]:
+    """Loads configuration from a TOML file and validates it.
+
+    If the file doesn't exist, returns the default configuration.
+    """
+    config_path = Path(config_path).resolve()
+    if not config_path.exists():
+        return DEFAULT_CONFIG.copy()
+
+    try:
+        with open(config_path, "rb") as f:
+            data = tomllib.load(f)
+    except Exception as e:
+        raise ValueError(f"Failed to parse TOML config file: {e}")
+
+    build_data = data.get("build", {})
+    config = DEFAULT_CONFIG.copy()
+
+    # Merge values from [build] section
+    for key in config.keys():
+        if key in build_data:
+            config[key] = build_data[key]
+
+    # Validate type and values
+    if config["entry_point"] is not None and not isinstance(config["entry_point"], str):
+        raise ValueError("entry_point must be a string")
+    if config["output_exe"] is not None and not isinstance(config["output_exe"], str):
+        raise ValueError("output_exe must be a string")
+    if not isinstance(config["optimization_level"], int):
+        raise ValueError("optimization_level must be an integer")
+    if not isinstance(config["include_modules"], list) or not all(
+        isinstance(x, str) for x in config["include_modules"]
+    ):
+        raise ValueError("include_modules must be a list of strings")
+    if not isinstance(config["exclude_modules"], list) or not all(
+        isinstance(x, str) for x in config["exclude_modules"]
+    ):
+        raise ValueError("exclude_modules must be a list of strings")
+    if not isinstance(config["include_data"], list) or not all(
+        isinstance(x, str) for x in config["include_data"]
+    ):
+        raise ValueError("include_data must be a list of strings")
+
+    opt_level = config["optimization_level"]
+    if opt_level not in (0, 1, 2):
+        raise ValueError(
+            f"Invalid optimization_level: {opt_level}. Must be 0, 1, or 2."
+        )
+
+    # Resolve paths relative to pybend.toml location
+    config_dir = config_path.parent
+    if config["entry_point"] is not None:
+        config["entry_point"] = str((config_dir / config["entry_point"]).resolve())
+    if config["output_exe"] is not None:
+        config["output_exe"] = str((config_dir / config["output_exe"]).resolve())
+
+    resolved_data = []
+    for item in config["include_data"]:
+        resolved_data.append(str((config_dir / item).resolve()))
+    config["include_data"] = resolved_data
+
+    return config
+
+
+def resolve_config(
+    cli_args: Dict[str, Any],
+    config_path: Optional[Path] = None,
+    project_dir: Optional[Path] = None,
+) -> Dict[str, Any]:
+    """Resolves configuration options by merging command-line overrides,
+
+    TOML configuration values, and defaults. Performs auto-discovery
+    for missing entry points.
+    """
+    if project_dir is None:
+        project_dir = Path.cwd()
+    project_dir = Path(project_dir).resolve()
+
+    # Determine TOML configuration file path
+    if config_path is None:
+        config_path = project_dir / "pybend.toml"
+    else:
+        config_path = Path(config_path).resolve()
+
+    # 1. Load TOML configuration
+    config = load_config(config_path)
+
+    # 2. Merge CLI overrides
+    for key, val in cli_args.items():
+        if val is not None:
+            # If the value is a file path parameter, resolve it relative to CWD
+            if key in ("entry_point", "output_exe"):
+                config[key] = str(Path(val).resolve())
+            elif key == "include_data":
+                config[key] = [str(Path(x).resolve()) for x in val]
+            else:
+                config[key] = val
+
+    # 3. Auto-Discovery for entry_point
+    if config["entry_point"] is None:
+        main_py = project_dir / "main.py"
+        app_py = project_dir / "app.py"
+        if main_py.exists():
+            config["entry_point"] = str(main_py.resolve())
+        elif app_py.exists():
+            config["entry_point"] = str(app_py.resolve())
+        else:
+            raise ValueError(
+                "Could not auto-discover entry point. "
+                "Please specify entry_point in pybend.toml or via --entry flag."
+            )
+
+    # 4. Generate output_exe default if missing
+    if config["output_exe"] is None:
+        entry_path = Path(config["entry_point"])
+        dist_dir = entry_path.parent / "dist"
+        config["output_exe"] = str(dist_dir / f"{entry_path.stem}.bin")
+
+    return config

pybend/dependency_resolver.py

@@ -0,0 +1,80 @@
+import sys
+import modulefinder
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+class DependencyResolver:
+    """traces static dependencies of a Python entry script using standard ModuleFinder."""
+
+    def __init__(
+        self,
+        entry_point: Path,
+        include_modules: Optional[List[str]] = None,
+        exclude_modules: Optional[List[str]] = None,
+    ) -> None:
+        self.entry_point = Path(entry_point).resolve()
+        self.include_modules = include_modules or []
+        self.exclude_modules = exclude_modules or []
+        # Add entry point's parent directory to search path for local imports
+        search_path = [str(self.entry_point.parent)] + sys.path
+        self.finder = modulefinder.ModuleFinder(path=search_path)
+
+    @staticmethod
+    def _get_site_packages_dirs() -> List[Path]:
+        """Return all site-packages directories from sys.path."""
+        return [
+            Path(p).resolve()
+            for p in sys.path
+            if "site-packages" in p or "dist-packages" in p
+        ]
+
+    def _should_include(self, path: Path) -> bool:
+        """Check if a module path should be included in the VFS."""
+        path = path.resolve()
+        if path.suffix not in (".py", ".so"):
+            return False
+
+        entry_parent = self.entry_point.parent.resolve()
+        # Always include modules relative to the project directory
+        if path.is_relative_to(entry_parent):
+            return True
+
+        # Include modules from site-packages (third-party packages)
+        for site_dir in self._get_site_packages_dirs():
+            if path.is_relative_to(site_dir):
+                return True
+
+        return False
+
+    def resolve_static_imports(self) -> Dict[str, str]:
+        """Runs the module finder script tracing and returns module name to absolute path map."""
+        self.finder.run_script(str(self.entry_point))
+        resolved: Dict[str, str] = {}
+        entry_parent = self.entry_point.parent.resolve()
+
+        for name, mod in self.finder.modules.items():
+            if mod.__file__ is not None:
+                path = Path(mod.__file__).resolve()
+                if self._should_include(path):
+                    resolved[name] = str(path)
+
+        # Force-include whitelisted modules
+        for mod_name in self.include_modules:
+            if mod_name not in resolved:
+                # Try to find the module on sys.path
+                try:
+                    import importlib
+                    spec = importlib.util.find_spec(mod_name)
+                    if spec is not None and spec.origin is not None:
+                        origin = Path(spec.origin).resolve()
+                        if origin.suffix in (".py", ".so"):
+                            resolved[mod_name] = str(origin)
+                except (ImportError, ModuleNotFoundError, AttributeError):
+                    pass
+
+        # Remove blacklisted modules
+        for mod_name in self.exclude_modules:
+            resolved.pop(mod_name, None)
+
+        return resolved

pybend/importer.py

@@ -0,0 +1,128 @@
+from types import ModuleType, CodeType
+import importlib.machinery
+from importlib.machinery import ModuleSpec
+import marshal
+import os
+from typing import Dict, Tuple, Optional, List
+import zlib
+
+
+VfsIndexValue = Tuple[int, int, int, int]  # (offset, compressed_size, uncompressed_size, is_c_ext)
+
+
+class BendMemoryLoader:
+    """PEP 451 module loader that executes compiled bytecodes from memory."""
+
+    def __init__(self, code_obj: CodeType) -> None:
+        self.code_obj = code_obj
+
+    def create_module(self, spec: ModuleSpec) -> Optional[ModuleType]:
+        return None
+
+    def exec_module(self, module: ModuleType) -> None:
+        exec(self.code_obj, module.__dict__)
+
+
+class BendMemoryExtensionLoader:
+    """PEP 451 module loader that loads compiled C-extensions
+    from memory using os.memfd_create.
+    """
+
+    def __init__(self, fullname: str, so_bytes: bytes) -> None:
+        self.fullname = fullname
+        self.so_bytes = so_bytes
+        self.fd: Optional[int] = None
+        self.delegate: Optional[importlib.machinery.ExtensionFileLoader] = None
+
+    def create_module(self, spec: ModuleSpec) -> Optional[ModuleType]:
+        self.fd = os.memfd_create(self.fullname, flags=os.MFD_CLOEXEC)
+        os.write(self.fd, self.so_bytes)
+        path = f"/proc/self/fd/{self.fd}"
+        spec.origin = path
+        self.delegate = importlib.machinery.ExtensionFileLoader(self.fullname, path)
+        return self.delegate.create_module(spec)
+
+    def exec_module(self, module: ModuleType) -> None:
+        if self.delegate is None:
+            raise ImportError(
+                f"Loader delegate for {self.fullname} was not initialized."
+            )
+        try:
+            self.delegate.exec_module(module)
+        finally:
+            if self.fd is not None:
+                try:
+                    os.close(self.fd)
+                except OSError:
+                    pass
+                self.fd = None
+
+
+class BendMemoryFinder:
+    """PEP 451 MetaPathFinder that resolves modules from the memory-mapped BendVFS index."""
+
+    def __init__(
+        self,
+        vfs_index: Dict[str, VfsIndexValue],
+        vfs_data: bytes,
+        asset_index: Optional[Dict[str, Tuple[int, int, int]]] = None,
+    ) -> None:
+        self.index = vfs_index
+        self.data = vfs_data
+        self.asset_index = asset_index or {}
+
+    def find_spec(
+        self,
+        fullname: str,
+        path: Optional[List[str]],
+        target: Optional[ModuleType] = None,
+    ) -> Optional[ModuleSpec]:
+        if fullname in self.index:
+            is_package = any(k.startswith(fullname + ".") for k in self.index.keys())
+            offset, comp_size, uncomp_size, is_c_ext = self.index[fullname]
+
+            if is_c_ext == 1:
+                compressed_bytes = self.data[offset : offset + comp_size]
+                so_bytes = zlib.decompress(compressed_bytes)
+                loader = BendMemoryExtensionLoader(fullname, so_bytes)
+            else:
+                code_obj = self.get_code_object(fullname)
+                loader = BendMemoryLoader(code_obj)
+
+            spec = importlib.machinery.ModuleSpec(
+                fullname, loader, is_package=is_package
+            )
+            if is_package:
+                spec.submodule_search_locations = []
+            return spec
+        return None
+
+    def get_code_object(self, fullname: str) -> CodeType:
+        offset, comp_size, uncomp_size, is_c_ext = self.index[fullname]
+        compressed_bytes = self.data[offset : offset + comp_size]
+        bytecode_bytes = zlib.decompress(compressed_bytes)
+        return marshal.loads(bytecode_bytes)
+
+
+def get_asset(relative_path: str) -> bytes:
+    """Retrieve a static asset from the VFS by its relative project path."""
+    finder = _get_bend_finder()
+    if finder is None:
+        raise FileNotFoundError(
+            f"PyBend VFS not initialized; cannot load asset '{relative_path}'"
+        )
+    if relative_path not in finder.asset_index:
+        raise FileNotFoundError(
+            f"Asset '{relative_path}' not found in PyBend VFS"
+        )
+    offset, comp_size, uncomp_size = finder.asset_index[relative_path]
+    compressed_bytes = finder.data[offset : offset + comp_size]
+    return zlib.decompress(compressed_bytes)
+
+
+def _get_bend_finder() -> Optional["BendMemoryFinder"]:
+    import sys
+    for finder in sys.meta_path:
+        if isinstance(finder, BendMemoryFinder):
+            return finder
+    return None

pybend/splicer.py

@@ -0,0 +1,20 @@
+import struct
+from pathlib import Path
+
+
+def splice(runner_path: Path, vfs_blob: bytes, output_path: Path) -> None:
+    """Appends the VFS data array directly to the tail of the target native runner template."""
+    runner_data = Path(runner_path).read_bytes()
+
+    # 8-byte big-endian representation of the VFS payload length
+    vfs_length = struct.pack(">Q", len(vfs_blob))
+
+    # 4-byte magic signature footer
+    magic_footer = b"BEND"
+
+    # Write final output executable
+    with open(output_path, "wb") as f:
+        f.write(runner_data)
+        f.write(vfs_blob)
+        f.write(vfs_length)
+        f.write(magic_footer)

pybend/vfs_builder.py

@@ -0,0 +1,104 @@
+import py_compile
+import struct
+import tempfile
+import zlib
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+class VfsBuilder:
+    """compiles Python source modules to optimized bytecode and serializes them into a single BendVFS blob."""
+
+    def __init__(
+        self,
+        modules_map: Dict[str, str],
+        optimization_level: int = 2,
+        include_data: Optional[List[Path]] = None,
+    ):
+        self.modules_map = modules_map
+        self.optimization_level = optimization_level
+        self.include_data = include_data or []
+
+    def build_vfs_blob(self) -> bytes:
+        """Compiles modules, compresses them with zlib, and constructs the VFS payload."""
+        entries = []
+        asset_entries = []
+        payload_data = b""
+
+        # Process modules in sorted order for determinism
+        for name in sorted(self.modules_map.keys()):
+            py_file = Path(self.modules_map[name]).resolve()
+
+            if py_file.suffix == ".so":
+                bytecode_bytes = py_file.read_bytes()
+                is_c_ext = 0x01
+            else:
+                # Create a temporary file for .pyc compilation
+                with tempfile.NamedTemporaryFile(suffix=".pyc", delete=False) as tmp:
+                    tmp_path = Path(tmp.name)
+
+                try:
+                    py_compile.compile(
+                        str(py_file),
+                        cfile=str(tmp_path),
+                        optimize=self.optimization_level,
+                        doraise=True,
+                    )
+                    pyc_bytes = tmp_path.read_bytes()
+
+                    # Strip the 16-byte .pyc header to get raw marshalled code object
+                    bytecode_bytes = pyc_bytes[16:]
+                finally:
+                    if tmp_path.exists():
+                        tmp_path.unlink()
+                is_c_ext = 0x00
+
+            compressed_bytes = zlib.compress(bytecode_bytes)
+
+            compressed_size = len(compressed_bytes)
+            uncompressed_size = len(bytecode_bytes)
+            payload_offset = len(payload_data)
+
+            payload_data += compressed_bytes
+
+            # Serialize entry metadata: (payload_offset, compressed_size, uncompressed_size, is_c_ext)
+            name_bytes = name.encode("utf-8")
+            entry_header = struct.pack(">H", len(name_bytes)) + name_bytes
+            entry_meta = (
+                struct.pack(">QQQ", payload_offset, compressed_size, uncompressed_size)
+                + struct.pack("B", is_c_ext)
+            )
+
+            entries.append(entry_header + entry_meta)
+
+        # Process static asset files
+        for asset_path in self.include_data:
+            asset_path = Path(asset_path).resolve()
+            if not asset_path.exists():
+                continue
+            raw_bytes = asset_path.read_bytes()
+            compressed_bytes = zlib.compress(raw_bytes)
+
+            compressed_size = len(compressed_bytes)
+            uncompressed_size = len(raw_bytes)
+            payload_offset = len(payload_data)
+
+            payload_data += compressed_bytes
+
+            # Use relative path as the asset key
+            rel_path = str(asset_path.relative_to(Path.cwd()))
+            name_bytes = rel_path.encode("utf-8")
+            entry_header = struct.pack(">H", len(name_bytes)) + name_bytes
+            entry_meta = struct.pack(">QQQ", payload_offset, compressed_size, uncompressed_size)
+
+            asset_entries.append(entry_header + entry_meta)
+
+        # Assemble the final blob
+        magic = b"BEND"
+        entry_count = struct.pack(">I", len(entries))
+        metadata_table = b"".join(entries)
+
+        asset_count = struct.pack(">I", len(asset_entries))
+        asset_table = b"".join(asset_entries)
+
+        return magic + entry_count + metadata_table + asset_count + asset_table + payload_data

pybend-0.2.0.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: pybend
+Version: 0.2.0
+Summary: Compile Python applications into standalone native binaries
+Author: Jude Nii Klemesu Commey
+License: MIT License
+        
+        Copyright (c) 2026 Jude Nii Klemesu Commey
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: binary,compiler,deployment,freezer,standalone
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Description-Content-Type: text/markdown
+
+# PyBend 🪶
+
+> Compile Python applications into standalone native binaries that run entirely in volatile memory.
+
+PyBend is a zero-configuration, high-performance Python-to-Native-Binary compiler toolchain. It compiles your Python applications, third-party packages, and native C-extensions into a single, standalone executable — with **zero physical disk I/O at runtime**.
+
+Unlike traditional freezers (PyInstaller, cx_Freeze, Nuitka) that extract dependencies to `/tmp` or `%TEMP%`, PyBend keeps everything in RAM via a custom PEP 451 meta-path importer backed by an embedded Virtual File System.
+
+---
+
+## 🚀 Performance Snapshot
+
+| Metric | PyBend | PyInstaller |
+|--------|--------|-------------|
+| **Cold-Start Latency** | ~23 ms | ~300–500 ms |
+| **Disk I/O at Runtime** | 0 physical writes | Writes to `/tmp` |
+| **Binary Size (base)** | ~340 KB (engine) + VFS | ~30 MB+ |
+| **Code on Disk** | Never | Extracted to temp |
+
+## 🛠️ How It Works
+
+### 1. AST Tracing & Tree-Shaking
+Scans your import graph using Python's `modulefinder`. Only the modules your app actually imports are included — no bloat.
+
+### 2. Optimization Pass (-OO)
+All source is compiled to bytecode with assertions and docstrings stripped, yielding 8–15% smaller payloads.
+
+### 3. Dual-Table VFS v2 Layout
+Bytecode, native `.so` extensions, and static assets are packed into a structured binary blob:
+
+```
+┌──────────────────────────────────────────────────┐
+│  BENDVFS BLOB                                     │
+├──────────────────────────────────────────────────┤
+│  [4B: "BEND" Magic] [4B: Code Entry Count]       │
+│  ┌────────────────────────────────────────────┐  │
+│  │ Code Module Table                          │  │
+│  │  name → (offset, compressed_size,          │  │
+│  │          uncompressed_size, is_c_ext)      │  │
+│  └────────────────────────────────────────────┘  │
+│  [4B: Asset Entry Count]                         │
+│  ┌────────────────────────────────────────────┐  │
+│  │ Asset Table                                │  │
+│  │  path → (offset, compressed_size,          │  │
+│  │          uncompressed_size)                │  │
+│  └────────────────────────────────────────────┘  │
+│  ┌────────────────────────────────────────────┐  │
+│  │ Compressed Payload Pool (zlib DEFLATE)     │  │
+│  └────────────────────────────────────────────┘  │
+└──────────────────────────────────────────────────┘
+```
+
+### 4. RAM-Mapped Execution
+- The Rust bootloader memory-maps itself via `memmap2`, locates the VFS by its `BEND` footer signature, and passes it to the embedded Python runtime.
+- A `BendMemoryFinder` is injected into `sys.meta_path[0]` per PEP 451 — all imports resolve from RAM.
+- C-extensions are written to anonymous `memfd_create` file descriptors and loaded with `dlopen` — the kernel pages them directly from RAM.
+
+---
+
+## 📦 Quick Start
+
+### 1. Install
+
+```bash
+pip install pybend
+```
+
+### 2. Zero-Config Build
+
+If your project directory contains `main.py` or `app.py`:
+
+```bash
+pybend build
+```
+
+That's it. The output lands at `./dist/<name>.bin`.
+
+### 3. Explicit Build
+
+```bash
+pybend build --entry src/server.py --output deploy/server.bin -O 2
+```
+
+### 4. Config-Driven Build (`pybend.toml`)
+
+```toml
+[build]
+entry_point = "src/main.py"
+output_exe = "dist/app.bin"
+optimization_level = 2
+include_modules = ["hidden_dep"]
+exclude_modules = ["test", "unittest"]
+include_data = ["config.json", "assets/"]
+```
+
+```bash
+pybend build
+```
+
+### 5. Fetching Embedded Assets at Runtime
+
+Any file listed in `include_data` can be streamed from memory:
+
+```python
+import pybend
+
+config = pybend.get_asset("config.json")
+template = pybend.get_asset("templates/email.html")
+```
+
+No disk access. No extraction. Directly from the VFS.
+
+---
+
+## 🏗️ Project Structure
+
+```
+pybend/
+├── pyproject.toml              # Hatchling build config
+├── bootloader/                 # Rust runtime engine
+│   ├── Cargo.toml
+│   └── src/
+│       ├── main.rs
+│       ├── extractor.rs
+│       └── bootstrapper.rs
+├── pybend/                     # Python build orchestration
+│   ├── __init__.py
+│   ├── cli.py                  # Click CLI
+│   ├── compiler.py             # Pipeline orchestrator
+│   ├── config.py               # TOML + CLI config resolution
+│   ├── dependency_resolver.py  # Import tracing + filtering
+│   ├── importer.py             # Runtime VFS finder & loaders
+│   ├── splicer.py              # Binary tail-splicing
+│   ├── vfs_builder.py          # VFS blob construction
+│   └── templates/              # Pre-built bootloader binaries
+├── docs/                       # MkDocs documentation
+├── tests/                      # Test suite
+└── .github/workflows/          # CI/CD pipelines
+```
+
+---
+
+## ⚙️ Configuration Reference
+
+### CLI Flags
+
+| Flag | Shorthand | Description |
+|------|-----------|-------------|
+| `--entry` | `-e` | Entry point script path |
+| `--output` | `-o` | Output executable path |
+| `--optimize` | `-O` | Optimization level (0, 1, 2) |
+| `--include` | `-i` | Force-include a module |
+| `--exclude` | `-x` | Exclude a module |
+| `--template` | `-t` | Custom bootloader binary |
+| `--config` | `-c` | Custom pybend.toml path |
+
+### pybend.toml Fields
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `entry_point` | string | auto-discover | Entry script path |
+| `output_exe` | string | `dist/<name>.bin` | Output binary path |
+| `optimization_level` | int | `2` | Bytecode optimization (0/1/2) |
+| `include_modules` | string[] | `[]` | Force-include modules |
+| `exclude_modules` | string[] | `[]` | Exclude modules |
+| `include_data` | string[] | `[]` | Static file paths to embed |
+
+---
+
+## 🧪 Testing
+
+```bash
+# Python test suite (22 tests)
+python -m unittest discover -s tests -v
+
+# Rust tests
+cd bootloader && RUSTFLAGS="-L lib" cargo test
+```
+
+Current test coverage: **22 Python tests + 2 Rust tests — all passing**.
+
+Includes end-to-end compilation + execution tests, C-extension loading via `memfd_create`, VFS structural validation, latency benchmarks, and disk-isolation verification.
+
+---
+
+## 🎯 Target Platform
+
+- **Linux x86_64** (primary, production-tested)
+
+Future targets: `aarch64-unknown-linux-musl`, `x86_64-pc-windows-gnu`, `aarch64-apple-darwin`.
+
+---
+
+## 📜 License
+
+MIT — see [LICENSE](LICENSE).
+
+Copyright (c) 2026 Jude Nii Klemesu Commey

pybend-0.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pybend/__init__.py,sha256=7lFhG2AL6EU35XFXp5DF7SbE_JcjCIZXUO7xZWY3JTM,195
+pybend/cli.py,sha256=tEJd46PQg8Sxx7b1CjcL00OcHTPyqLMlPSbEnhnR-Eg,5340
+pybend/compiler.py,sha256=O37w_6Y19AAvcvGVNl9xN0Y65CCgJqlo8Dz5qmv2y-E,2539
+pybend/config.py,sha256=qnrjn6ACW1T4Guhhex2JS9PTnTIE2IujWql-yMjlj0Q,4704
+pybend/dependency_resolver.py,sha256=AqFNcMZ-Loy_IkLxurZ-_Dp_AwhmHASebHbkuqNMwM8,3035
+pybend/importer.py,sha256=_uhc_ggr-eHMqaefyBbuEdQ7t3jVQ0nYQd0zqVWS27U,4449
+pybend/splicer.py,sha256=vPhCexiIrl12DxZb0U4yMU5rDQ-6y2d85-frdkgzzyo,630
+pybend/vfs_builder.py,sha256=vNmno3j96MzajCN5Ly4Cm7Z-akjc_kGBENjAPppl11M,3842
+pybend/templates/linux/x86_64/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pybend/templates/linux/x86_64/bootloader,sha256=j1RKz2XyPC0hHb9B9oJFk2XPK3hT4wMNW1yO-8jv3q4,336856
+pybend-0.2.0.dist-info/METADATA,sha256=yhp1eB1EDcxK6RvuqDeIQvwOM6HN-e7u3c5kbCa49_w,9551
+pybend-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pybend-0.2.0.dist-info/entry_points.txt,sha256=5MjBC2Sy6cuViomgHxZP6AL8NR5YRagE4PPWtZuw1RE,43
+pybend-0.2.0.dist-info/licenses/LICENSE,sha256=ytu4Q06aRxed_gQxDf4BOQCkZ_IWNSTNr04qkHLjTkc,1080
+pybend-0.2.0.dist-info/RECORD,,

pybend-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

pybend-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pybend = pybend.cli:main

pybend-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jude Nii Klemesu Commey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.