pytron-kit 0.3.12__py3-none-macosx_11_0_universal2.whl

pytron/pack/nuitka.py

@@ -0,0 +1,108 @@
+import os
+import sys
+import shutil
+import subprocess  # nosec B404
+import platform
+from pathlib import Path
+from ..console import log, run_command_with_output, console, Rule
+from ..commands.helpers import get_python_executable, get_venv_site_packages
+from .installers import build_installer
+
+
+from .pipeline import BuildContext
+
+
+def run_nuitka_build(context: BuildContext):
+    """
+    Core Nuitka compiler stage.
+    """
+    log("Packaging using Nuitka (Native Compilation)...", style="info")
+
+    # 1. Check for Nuitka
+    import shutil
+    from .pipeline import BuildContext
+    from ..commands.helpers import get_python_executable, get_venv_site_packages
+
+    python_exe = get_python_executable()
+    if (
+        not shutil.which("nuitka")
+        and not get_venv_site_packages(python_exe).joinpath("nuitka").exists()
+    ):
+        log("Nuitka not found. Installing...", style="warning")
+        subprocess.check_call(
+            [python_exe, "-m", "pip", "install", "nuitka", "zstandard"]
+        )
+
+    # 2. Build Nuitka Command
+    cmd = [
+        python_exe,
+        "-m",
+        "nuitka",
+        "--standalone",
+        "--assume-yes-for-downloads",
+        "--output-dir=dist",
+    ]
+
+    if context.is_onefile:
+        cmd.append("--onefile")
+        ext = ".exe" if sys.platform == "win32" else ".bin"
+        cmd.append(f"--output-filename={context.out_name}{ext}")
+
+    # Metadata
+    title = context.settings.get("title") or context.out_name
+    version = context.settings.get("version", "1.0.0")
+    author = context.settings.get("author") or "Pytron User"
+
+    cmd.extend(
+        [
+            f"--company-name={author}",
+            f"--product-name={title}",
+            f"--file-version={version}",
+            f"--product-version={version}",
+        ]
+    )
+
+    if context.app_icon:
+        if sys.platform == "win32":
+            cmd.append(f"--windows-icon-from-ico={context.app_icon}")
+        elif sys.platform == "linux":
+            cmd.append(f"--linux-icon={context.app_icon}")
+
+    if context.settings.get("console"):
+        if sys.platform == "win32":
+            cmd.append("--windows-console-mode=force")
+    else:
+        if sys.platform == "win32":
+            cmd.append("--windows-console-mode=disable")
+
+    # Assets
+    # Native Engine Binaries
+    from .utils import get_native_engine_binaries
+
+    binaries = get_native_engine_binaries()
+
+    for bin_name in binaries:
+        bin_src = context.package_dir / "pytron" / "dependencies" / bin_name
+        if bin_src.exists():
+            cmd.append(f"--include-data-file={bin_src}=pytron/dependencies/{bin_name}")
+
+    for item in context.add_data:
+        if os.pathsep in item:
+            src, dst = item.split(os.pathsep, 1)
+            if os.path.isdir(src):
+                cmd.append(f"--include-data-dir={src}={dst}")
+            else:
+                if dst == ".":
+                    dst = os.path.basename(src)
+                cmd.append(f"--include-data-file={src}={dst}")
+
+    # Hidden Imports
+    for imp in context.hidden_imports:
+        cmd.append(f"--include-module={imp}")
+
+    cmd.append(str(context.script))
+
+    log(f"Running Nuitka: {' '.join(cmd)}", style="dim")
+    ret_code = run_command_with_output(cmd, style="dim")
+
+    return ret_code

pytron/pack/pipeline.py

@@ -0,0 +1,107 @@
+import os
+import sys
+import json
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+from ..console import log, console, get_progress
+
+
+@dataclass
+class BuildContext:
+    # CLI Arguments
+    script: Path
+    out_name: str
+    app_icon: Optional[str] = None
+    settings: Dict[str, Any] = field(default_factory=dict)
+
+    # Bundle Data
+    add_data: List[str] = field(default_factory=list)
+    binaries: List[str] = field(default_factory=list)
+    hidden_imports: List[str] = field(default_factory=list)
+    excludes: List[str] = field(default_factory=list)
+    pathex: List[str] = field(default_factory=list)
+    extra_args: List[str] = field(default_factory=list)
+    runtime_hooks: List[str] = field(default_factory=list)
+
+    # Path Helpers
+    package_dir: Path = field(init=False)
+    script_dir: Path = field(init=False)
+    build_dir: Path = field(init=False)
+    dist_dir: Path = field(init=False)
+
+    # Engine & Security Flags
+    engine: Optional[str] = None
+    is_secure: bool = False
+    is_nuitka: bool = False
+    is_onefile: bool = False
+
+    # Internal State
+    progress: Any = None
+    task_id: Any = None
+
+    def __post_init__(self):
+        import pytron
+
+        self.package_dir = Path(pytron.__file__).resolve().parent.parent
+        self.script_dir = self.script.parent
+        self.build_dir = Path("build")
+        self.dist_dir = Path("dist") / self.out_name
+
+
+class BuildModule:
+    """Base class for build modules."""
+
+    def prepare(self, context: BuildContext):
+        """Phase 1: Gather assets and requirements."""
+        pass
+
+    def build_wrapper(self, context: BuildContext, build_func):
+        """Phase 2: Wrap or modify the actual build execution.
+        Must return a function or call build_func.
+        """
+        return build_func(context)
+
+    def post_build(self, context: BuildContext):
+        """Phase 3: Cleanup, patching, signing."""
+        pass
+
+
+class Pipeline:
+    def __init__(self, context: BuildContext):
+        self.context = context
+        self.modules: List[BuildModule] = []
+
+    def add_module(self, module: BuildModule):
+        self.modules.append(module)
+
+    def run(self, core_build_func):
+        """
+        Execution flow:
+        1. Prepare (All modules)
+        2. Build Wrapper (Nested call)
+        3. Post Build (All modules, reverse order)
+        """
+        # 1. Prepare
+        for module in self.modules:
+            module.prepare(self.context)
+
+        # 2. Build Wrapper (Chain them)
+        current_build_func = core_build_func
+
+        # We wrap it in reverse order so the first module added is the outermost wrapper
+        for module in reversed(self.modules):
+            # Create a closure to capture the current state of build_func
+            def make_wrapper(m, func):
+                return lambda ctx: m.build_wrapper(ctx, func)
+
+            current_build_func = make_wrapper(module, current_build_func)
+
+        ret_code = current_build_func(self.context)
+
+        # 3. Post Build
+        if ret_code == 0:
+            for module in self.modules:
+                module.post_build(self.context)
+
+        return ret_code

pytron/pack/pyinstaller.py

@@ -0,0 +1,176 @@
+import os
+import sys
+import subprocess  # nosec B404
+import platform
+from pathlib import Path
+from ..console import log, run_command_with_output, console, Rule
+from ..commands.helpers import get_python_executable, get_venv_site_packages
+from ..commands.harvest import generate_nuclear_hooks
+from .installers import build_installer
+from .utils import cleanup_dist
+
+from .metadata import MetadataEditor
+from .pipeline import BuildContext
+
+
+def run_pyinstaller_build(context: BuildContext):
+    """
+    Core PyInstaller compiler stage.
+    """
+    try:
+        log("Generating spec file...", style="info")
+        context.progress.update(
+            context.task_id, description="Generating Spec...", completed=30
+        )
+
+        # 1. Resolve Platform-Specific Libs
+        # 1. Resolve Platform-Specific Libs
+        from .utils import get_native_engine_binaries
+
+        binaries = get_native_engine_binaries()
+        dll_dest = os.path.join("pytron", "dependencies")
+
+        # 2. Build Makespec Command
+        makespec_cmd = [
+            get_python_executable(),
+            "-m",
+            "PyInstaller.utils.cliutils.makespec",
+            "--name",
+            context.out_name,
+        ]
+
+        if context.is_onefile:
+            makespec_cmd.append("--onefile")
+        else:
+            makespec_cmd.append("--onedir")
+
+        # Console handling
+        # Note: We'd ideally have this in the context, but for now we read from context.settings/args if available
+        # In this refactor, we'll assume context has what it needs.
+        # For simplicity, if --console was passed to CLI, we should have it in extra_args or similar.
+        # But let's check settings for now.
+        if context.settings.get("console"):
+            makespec_cmd.append("--console")
+        else:
+            makespec_cmd.append("--noconsole")
+
+        # Add Core Native Engine Binaries
+        for bin_name in binaries:
+            bin_src = context.package_dir / "pytron" / "dependencies" / bin_name
+            if bin_src.exists():
+                makespec_cmd.append(f"--add-binary={bin_src}{os.pathsep}{dll_dest}")
+
+        # Add Scripts
+        # For secure builds, we add BOTH the bootstrap and the original script
+        # PyInstaller will analyze both for dependencies, but bootstrap (first)
+        # stays as the primary entry point script.
+        makespec_cmd.append(str(context.script))
+
+        if context.is_secure and hasattr(context, "original_script"):
+            makespec_cmd.append(str(context.original_script))
+
+        # Add Runtime Hooks
+        if sys.platform == "win32":
+            utf8_hook = context.package_dir / "pytron" / "utf8_hook.py"
+            if utf8_hook.exists():
+                makespec_cmd.append(f"--runtime-hook={utf8_hook}")
+
+        for hook in context.runtime_hooks:
+            makespec_cmd.append(f"--runtime-hook={hook}")
+
+        # Add Assets (from Modules)
+        for item in context.add_data:
+            makespec_cmd.extend(["--add-data", item])
+
+        for item in context.binaries:
+            makespec_cmd.extend(["--add-binary", item])
+
+        for imp in context.hidden_imports:
+            makespec_cmd.append(f"--hidden-import={imp}")
+
+        for ex in context.excludes:
+            makespec_cmd.append(f"--exclude-module={ex}")
+
+        for p in context.pathex:
+            makespec_cmd.append(f"--paths={p}")
+
+        # Force Package (Collect All from Settings)
+        forced_pkgs = context.settings.get("force-package", [])
+        if forced_pkgs:
+            for pkg in forced_pkgs:
+                # Use collect-all to ensure data files (like .pyi stubs for lazy_loader) are included
+                makespec_cmd.append(f"--collect-all={pkg}")
+            log(f"Forcing collect-all for packages: {forced_pkgs}", style="dim")
+
+        makespec_cmd.extend(context.extra_args)
+
+        if context.app_icon:
+            makespec_cmd.extend(["--icon", context.app_icon])
+
+        # Splash Screen
+        splash_image = context.settings.get("splash_image")
+        if splash_image:
+            splash_path = context.script_dir / splash_image
+            if splash_path.exists():
+                makespec_cmd.extend(["--splash", str(splash_path)])
+                log(f"Splash screen enabled: {splash_image}", style="dim")
+            else:
+                log(
+                    f"Warning: Splash image not found at {splash_path}", style="warning"
+                )
+
+        # Run Makespec
+        log(f"Running makespec: {' '.join(makespec_cmd)}", style="dim")
+        makespec_ret = run_command_with_output(makespec_cmd, style="dim")
+        if makespec_ret != 0:
+            return 1
+
+        spec_file = Path(f"{context.out_name}.spec")
+        if not spec_file.exists():
+            log(f"Error: spec file {spec_file} not found", style="error")
+            return 1
+
+        # Fortress / Spec Optimization Hook
+        if (
+            context.settings.get("optimize_spec")
+            or context.is_secure
+            or hasattr(context, "fortress_active")
+        ):
+            try:
+                from fortress import SpecOptimizer
+
+                optimizer = SpecOptimizer(spec_file)
+                optimizer.optimize()
+                log("Fortress: Spec optimization applied.", style="dim")
+            except ImportError:
+                pass
+            except Exception as e:
+                log(f"Warning: Spec optimization failed: {e}", style="warning")
+
+        # 3. Execution Phase
+        build_cmd = [
+            get_python_executable(),
+            "-m",
+            "PyInstaller",
+            "--noconfirm",
+            "--clean",
+            str(spec_file),
+        ]
+
+        context.progress.update(
+            context.task_id, description="Compiling...", completed=50
+        )
+        log(f"Building from Spec: {' '.join(build_cmd)}", style="dim")
+
+        ret_code = run_command_with_output(build_cmd, style="dim")
+
+        if ret_code == 0:
+            # Cleanup
+            has_splash = bool(context.settings.get("splash_image"))
+            cleanup_dist(Path("dist") / context.out_name, preserve_tk=has_splash)
+
+        return ret_code
+
+    except Exception as e:
+        log(f"PyInstaller build failed: {e}", style="error")
+        return 1

pytron/pack/rust_engine.py

@@ -0,0 +1,273 @@
+import os
+import sys
+import shutil
+import subprocess
+import platform
+import re
+from pathlib import Path
+from .pipeline import BuildModule, BuildContext
+from ..console import log
+from ..commands.helpers import get_python_executable
+
+
+class RustEngine(BuildModule):
+    """
+    The 'God Mode' Build Engine.
+    Replaces PyInstaller with a native Rust Bootloader + Cython Compiled Entry Point.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.compiled_pyd = None
+
+    def build(self, context: BuildContext):
+        """
+        Main entry point for the Rust Engine build process.
+        """
+        log("Initialize Rust Engine (God Mode)...", style="cyan")
+
+        # 1. Compile the Entry Point (VEP) to Native Code
+        self._compile_entry_point(context)
+
+        # 2. Deploy Rust Bootloader
+        self._deploy_bootloader(context)
+
+        # 3. Assemble Dependencies (The Pure Python Libs)
+        self._assemble_libs(context)
+
+        # 4. Process Assets (Copy Context Data)
+        self._process_assets(context)
+
+        return 0  # Success
+
+    def _process_assets(self, context: BuildContext):
+        """
+        Copies assets defined in context.add_data (src;dest_dir structure).
+        """
+        log("Processing assets...", style="dim")
+        for item in context.add_data:
+            # Format is usually "src_path;dest_dir" (Windows) or "src_path:dest_dir" (Unix)
+            # PyInstaller uses os.pathsep
+            parts = item.split(os.pathsep)
+            if len(parts) != 2:
+                continue
+
+            src, dest_rel = parts
+            src_path = Path(src)
+            dest_path = context.dist_dir / dest_rel
+
+            if not src_path.exists():
+                continue
+
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+
+            if src_path.is_dir():
+                # Copy tree
+                if dest_path.exists():
+                    shutil.rmtree(dest_path)
+                shutil.copytree(src_path, dest_path)
+            else:
+                # Copy file
+                shutil.copy2(src_path, dest_path)
+
+    def _compile_entry_point(self, context: BuildContext):
+        """
+        Compiles the context.script to app.pyd using the shared compiler.
+        """
+        from .compilers import compile_script
+
+        build_dir = context.build_dir / "rust_build"
+        build_dir.mkdir(parents=True, exist_ok=True)
+
+        log(f"Compiling entry point: {context.script.name} -> app.pyd", style="dim")
+
+        output_pyd = compile_script(context.script, build_dir)
+
+        if output_pyd and output_pyd.exists():
+            log(f"Native compilation successful: {output_pyd.name}", style="success")
+            self.compiled_pyd = output_pyd
+        else:
+            raise RuntimeError("Native compilation failed.")
+
+    def _deploy_bootloader(self, context: BuildContext):
+        """
+        Copies the pre-compiled Rust Bootloader to dist.
+        """
+        log("Deploying Rust Bootloader...", style="info")
+
+        # Bootloader binary name
+        ext = ".exe" if sys.platform == "win32" else ""
+        loader_name = f"pytron_rust_bootloader{ext}"
+
+        # Source path
+        loader_src = (
+            context.package_dir
+            / "pytron"
+            / "pack"
+            / "secure_loader"
+            / "bin"
+            / loader_name
+        )
+
+        if not loader_src.exists():
+            raise RuntimeError(f"Rust Bootloader not found at {loader_src}")
+
+        # Dest path (Renamed to output name)
+        dest_exe = context.dist_dir / f"{context.out_name}{ext}"
+
+        shutil.copy2(loader_src, dest_exe)
+        log(f"Bootloader deployed: {dest_exe}", style="success")
+
+        # Also deploy the app.pyd next to it
+        if self.compiled_pyd:
+            shutil.copy2(self.compiled_pyd, context.dist_dir / self.compiled_pyd.name)
+
+    def _assemble_libs(self, context: BuildContext):
+        """
+        Copies required python libraries modules to dist folder using Crystal Manifest.
+        """
+        log("Assembling dependencies from Crystal Manifest...", style="cyan")
+
+        manifest_path = context.script.parent / "requirements.lock.json"
+
+        # Fallback if VEP was used, the manifest might be named after VEP or original?
+        # Crystal creates manifest at script.parent / "requirements.lock.json"
+
+        if not manifest_path.exists():
+            log(
+                "Warning: Requirements Lock not found. Skipping dependency assembly.",
+                style="warning",
+            )
+            return
+
+        import json
+
+        try:
+            data = json.loads(manifest_path.read_text())
+        except Exception:
+            data = {}
+
+        # Support both new "modules" style and old list style if any
+        # But Crystal now emits {modules:[], files:[]}
+        files = data.get("files", [])
+
+        # Resolve paths for classification
+        files = [Path(f).resolve() for f in files]
+
+        # 1. Identify Environment Locations
+        from ..commands.helpers import get_python_executable, get_venv_site_packages
+
+        python_exe = get_python_executable()
+        site_packages = get_venv_site_packages(python_exe).resolve()
+
+        # Project Root
+        project_root = context.script_dir.resolve()
+
+        # Destination for libraries
+        lib_dir = context.dist_dir / "libs"
+        lib_dir.mkdir(parents=True, exist_ok=True)
+
+        count = 0
+        copied_roots = set()
+
+        for f in files:
+            if not f.exists() or f.is_dir():
+                continue
+
+            # A. Site Packages (Third Party)
+            if site_packages in f.parents:
+                rel = f.relative_to(site_packages)
+                dest = lib_dir / rel
+
+                # Handling __pycache__: Skip
+                if "__pycache__" in dest.parts:
+                    continue
+
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(f, dest)
+                count += 1
+                copied_roots.add(rel.parts[0])
+                continue
+
+            # B. Project Code (User Scripts)
+            if project_root in f.parents:
+                # Don't copy the VEP script (it's compiled to app.pyd)
+                if f == context.script.resolve():
+                    continue
+                # Don't copy Crystal runner artifacts
+                if f.name in [
+                    "crystal_runner.py",
+                    "crystal_manifest.json",
+                    "_virtual_root.py",
+                ]:
+                    continue
+
+                rel = f.relative_to(project_root)
+                dest = lib_dir / rel  # We treat user code as library to keep root clean
+
+                if "__pycache__" in dest.parts:
+                    continue
+
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(f, dest)
+                count += 1
+                continue
+
+            # C. Standard Library
+            # We ignore files in base_prefix (e.g. C:\Python39\Lib\...) because we will rely on pythonXX.zip
+
+        log(f"Assembled {count} dependency files into dist/libs", style="success")
+        log(f"Roots captured: {', '.join(list(copied_roots)[:10])}", style="dim")
+
+        # 4. Deploy Runtime
+        self._deploy_python_runtime(context, python_exe)
+
+    def _deploy_python_runtime(self, context: BuildContext, python_exe: str):
+        """
+        Deploys python DLLs and Standard Library (minimal).
+        """
+        log("Deploying Python Runtime...", style="dim")
+
+        # Find Python DLLs
+        # usually next to python executable or in system
+        py_root = Path(python_exe).parent
+
+        # Copy DLLs (python3.dll, python311.dll, etc)
+        for f in py_root.glob("python*.dll"):
+            shutil.copy2(f, context.dist_dir / f.name)
+
+        # Copy Standard Lib Zip if exists
+        # Many embedded distributions have python3x.zip
+        found_zip = False
+        for f in py_root.glob("python*.zip"):
+            shutil.copy2(f, context.dist_dir / f.name)
+            found_zip = True
+
+        if not found_zip:
+            log(
+                "Warning: pythonXX.zip not found. Bundling 'Lib' folder may be required for StdLib.",
+                style="warning",
+            )
+            # In a full venv, we might need to copy Lib excluding site-packages
+            # For this "Pure" implementation, strictly we'd unzip or copy.
+            # To keep it safe, let's copy the Lib folder to dist/Lib if zip is missing
+            try:
+                sys_lib = py_root / "Lib"
+                if sys_lib.exists():
+                    dest_lib = context.dist_dir / "Lib"
+                    log(f"Copying Standard Library from {sys_lib}...", style="dim")
+                    # Copy everything EXCEPT site-packages and test
+                    shutil.copytree(
+                        sys_lib,
+                        dest_lib,
+                        ignore=shutil.ignore_patterns(
+                            "site-packages", "test", "__pycache__"
+                        ),
+                    )
+            except Exception as e:
+                log(f"Failed to copy StdLib: {e}", style="error")
+
+    # --- Helpers (Migrated from secure.py) ---
+
+    # --- Helpers ---
+    # Compilation logic moved to pytron.pack.compilers