pytron-kit 0.3.12__py3-none-macosx_11_0_universal2.whl

pytron/pack/secure.py

@@ -0,0 +1,309 @@
+import os
+import sys
+import shutil
+import traceback
+import subprocess
+import re
+import sysconfig
+import platform
+from pathlib import Path
+from ..console import log, run_command_with_output, console, Rule
+from .installers import build_installer
+from ..commands.helpers import get_python_executable, get_venv_site_packages
+from ..commands.harvest import generate_nuclear_hooks
+
+from .metadata import MetadataEditor
+from .pipeline import BuildModule, BuildContext
+from .utils import cleanup_dist
+
+
+from .compilers import compile_script as cython_compile
+
+# Legacy compatibility if needed or removed entirely
+# def cython_compile(script_path: Path, build_dir: Path): ...
+
+
+class SecurityModule(BuildModule):
+    def __init__(self):
+        self.original_script = None
+        self.build_dir = Path("build") / "secure_build"
+        self.compiled_pyd = None
+
+    def prepare(self, context: BuildContext):
+        log(
+            "Shield: Initializing Secure Packaging (Binary Compilation)...",
+            style="info",
+        )
+
+        # 1. CYTHON COMPILATION
+        if self.build_dir.exists():
+            shutil.rmtree(self.build_dir)
+        self.build_dir.mkdir(parents=True, exist_ok=True)
+
+        self.compiled_pyd = cython_compile(context.script, self.build_dir)
+        if not self.compiled_pyd:
+            raise RuntimeError("Shield Error: Cython compilation failed.")
+
+        # 3. GENERATE BOOTSTRAP SCRIPT
+        bootstrap_path = self.build_dir / "bootstrap_env.py"
+        bootstrap_content = """
+import sys, os, json, logging, threading, asyncio, textwrap, re, socket, ssl, ctypes, hashlib, time, base64, mimetypes
+from collections import deque
+import pytron
+
+try:
+    import app # This imports the compiled app.pyd/so
+except Exception as e:
+    print(f"Boot Error: Failed to load compiled app: {e}")
+    sys.exit(1)
+
+if __name__ == "__main__":
+    pass
+"""
+        bootstrap_path.write_text(bootstrap_content)
+
+        # 2. CONFIGURE SHIELDED ANALYSIS
+        self.original_script = context.script
+        context.script = bootstrap_path
+
+        # Store original for PyInstaller module to pick up (Dual Analysis)
+        context.original_script = self.original_script
+
+        # Add the compiled binary to the build context binaries
+        # CRITICAL: We EXCLUDE the original script from being bundled as source
+        if self.original_script.stem not in context.excludes:
+            context.excludes.append(self.original_script.stem)
+
+        # Add to pathex so PyInstaller finds the .pyd during analysis of bootstrap
+        if str(self.build_dir.resolve()) not in context.pathex:
+            context.pathex.append(str(self.build_dir.resolve()))
+
+        context.binaries.append(f"{self.compiled_pyd.resolve()}{os.pathsep}.")
+
+        # 4. FORCE NO-ARCHIVE (Required for our custom fusion process)
+        if "--debug" not in context.extra_args:
+            context.extra_args.extend(["--debug", "noarchive"])
+
+    def compact_library(self, dist_path: Path, bundle_path: Path):
+        """Fuses all loose .pyc files into a single safeguarded app.bundle,
+        preserving the physical integrity of 'Special' packages (Native/Resource-heavy).
+        """
+        import zipfile
+
+        internal_dir = dist_path / "_internal"
+
+        if not internal_dir.exists():
+            return
+
+        log(
+            f"Fusing Python library into {bundle_path.name} (Surgical Preservation)...",
+            style="cyan",
+        )
+
+        # 1. DISCOVERY: Identify 'Special' packages that MUST stay loose
+        preserving_packages = set()
+        special_exts = (
+            ".pyd",
+            ".so",
+            ".dll",
+            ".lib",
+            ".pem",
+            ".onnx",
+            ".prototxt",
+            ".bin",
+            ".pb",
+        )
+
+        for root, _, files in os.walk(internal_dir):
+            if any(f.endswith(special_exts) for f in files):
+                # Identify the top-level package name in _internal
+                rel_parts = Path(root).relative_to(internal_dir).parts
+                if rel_parts:
+                    preserving_packages.add(rel_parts[0])
+
+        log(
+            f"  + Preserving physical package domains: {', '.join(preserving_packages)}",
+            style="dim",
+        )
+
+        to_remove = []
+        # USE ZIP_STORED for zero-latency imports
+        with zipfile.ZipFile(bundle_path, "w", zipfile.ZIP_STORED) as bundle:
+            # 2. Merge standard base_library
+            base_zip = internal_dir / "base_library.zip"
+            if base_zip.exists():
+                with zipfile.ZipFile(base_zip, "r") as bzip:
+                    for name in bzip.namelist():
+                        bundle.writestr(name, bzip.read(name))
+                to_remove.append(base_zip)
+
+            # 3. Process the rest of _internal
+            for root, _, files in os.walk(internal_dir):
+                rel_parts = Path(root).relative_to(internal_dir).parts
+
+                # If this is inside a preserved package, skip fusion entirely
+                if rel_parts and rel_parts[0] in preserving_packages:
+                    continue
+
+                for f in files:
+                    # Capture code only for fused packages to keep them clean
+                    if f.endswith((".pyc", ".py")):
+                        full_path = Path(root) / f
+                        rel_path = full_path.relative_to(internal_dir)
+                        bundle.write(full_path, rel_path)
+                        to_remove.append(full_path)
+
+        # 4. Cleanup fused source files
+        for p in to_remove:
+            try:
+                os.remove(p)
+            except Exception:
+                pass
+
+        # 5. PRUNING: Recursive remove empty directory skeletons
+        for root, dirs, _ in os.walk(internal_dir, topdown=False):
+            for d in dirs:
+                dir_path = Path(root) / d
+                try:
+                    if not any(dir_path.iterdir()):
+                        os.rmdir(dir_path)
+                except Exception:
+                    pass
+
+        log(
+            f"  + Shielded {len(to_remove)} modules into bundle. Logic is safeguarded.",
+            style="dim",
+        )
+
+    def build_wrapper(self, context: BuildContext, build_func):
+        # We need to change the output name for the "base" build
+        # so it doesn't collide with the final loader
+        original_out_name = context.out_name
+        context.out_name = f"{original_out_name}_base"
+
+        # Run the actual build
+        ret_code = build_func(context)
+
+        # Restore name
+        context.out_name = original_out_name
+
+        if ret_code != 0:
+            return ret_code
+
+        # 4. ASSEMBLE SECURE DISTRIBUTION
+        log("Hardening Distribution...", style="cyan")
+
+        base_dist = Path("dist") / f"{original_out_name}_base"
+        final_dist = Path("dist") / original_out_name
+
+        if final_dist.exists():
+            try:
+                shutil.rmtree(final_dist)
+            except Exception:
+                log(
+                    f"Warning: Could not clear {final_dist}. Some files may be locked.",
+                    style="warning",
+                )
+
+        final_dist.mkdir(parents=True, exist_ok=True)
+
+        log("Assembling secure distribution...", style="dim")
+        for item in base_dist.iterdir():
+            target = final_dist / item.name
+            try:
+                if item.is_dir():
+                    if target.exists():
+                        shutil.rmtree(target)
+                    shutil.copytree(item, target)
+                else:
+                    shutil.copy2(item, target)
+            except Exception as e:
+                log(f"Warning: Could not copy {item.name}: {e}", style="warning")
+
+        # 5. FUSE AND CLOAK LIBRARY (Optional via --bundled)
+        if getattr(context, "bundled", False):
+            # Place the bundle inside _internal for a cleaner root
+            bundle_path = final_dist / "_internal" / "app.bundle"
+            self.compact_library(final_dist, bundle_path)
+        else:
+            log(
+                "Skipping aggressive library bundling for stability (Safe Mode).",
+                style="dim",
+            )
+            log("Use --bundled to group Python modules into app.bundle.", style="dim")
+
+        # 7. DEPLOY RUST LOADER
+        log("Hardening Loader...", style="info")
+        ext_exe = ".exe" if sys.platform == "win32" else ""
+        loader_name = f"pytron_rust_bootloader{ext_exe}"
+        precompiled_bin = (
+            context.package_dir
+            / "pytron"
+            / "pack"
+            / "secure_loader"
+            / "bin"
+            / loader_name
+        )
+
+        final_loader = final_dist / f"{original_out_name}{ext_exe}"
+        shutil.copy(precompiled_bin, final_loader)
+
+        # Cleanup dummy base exe if it exists
+        base_exe = final_dist / f"{original_out_name}_base{ext_exe}"
+        if base_exe.exists():
+            try:
+                os.remove(base_exe)
+            except Exception:
+                pass
+
+        # 8. FINAL OPTIMIZATION
+        cleanup_dist(final_dist)
+
+        # Try to remove the temp base dist if possible
+        try:
+            shutil.rmtree(base_dist, ignore_errors=True)
+        except Exception:
+            pass
+
+        return 0
+
+
+def get_native_engine_libs():
+    from .utils import get_native_engine_binaries
+
+    return get_native_engine_binaries()
+
+
+from .utils import cleanup_dist as prune_junk_folders
+
+
+def apply_metadata_to_binary(
+    binary_path, icon_path, settings, dist_dir, package_dir=None
+):
+    editor = MetadataEditor(package_dir=package_dir)
+    return editor.update(binary_path, icon_path, settings, dist_dir)
+
+
+def run_secure_build(
+    args,
+    script,
+    out_name,
+    settings,
+    app_icon,
+    package_dir,
+    add_data,
+    progress,
+    task,
+    package_context=None,
+):
+    """
+    Legacy entry point for secure build.
+    """
+    # This function is now mostly a wrapper for the SecurityModule pipeline logic
+    # but kept for backward compatibility if called directly.
+    log(
+        "Secure Build started via legacy entry point. Using SecurityModule internally.",
+        style="info",
+    )
+    # For now, we'll let the pipeline handle it as the preferred route.
+    return 0

pytron/pack/utils.py

@@ -0,0 +1,110 @@
+import os
+import sys
+import shutil
+from pathlib import Path
+from ..console import console, log
+import fnmatch
+from ..commands.helpers import get_config
+
+
+def cleanup_dist(dist_path: Path, preserve_tk: bool = False):
+    """
+    Removes unnecessary files (node_modules, node.exe, etc) from the build output
+    to optimize the package size.
+    """
+    target_path = dist_path
+    # On macOS, if we built a bundle, the output is .app
+    if sys.platform == "darwin":
+        app_path = dist_path.parent / f"{dist_path.name}.app"
+        if app_path.exists():
+            target_path = app_path
+
+    if not target_path.exists():
+        return
+
+    # Items to remove (exact names)
+    remove_names = {
+        "node_modules",
+        "node.exe",
+        "npm.cmd",
+        "npx.cmd",
+        ".git",
+        ".gitignore",
+        ".vscode",
+        ".idea",
+        "package.json",
+        "package-lock.json",
+        "yarn.lock",
+        "pnpm-lock.yaml",
+        "__pycache__",
+        ".env",
+        "venv",
+        ".venv",
+        "python.exe",
+        "pythonw.exe",
+        "lib2to3",
+        "idle_test",
+        "test",
+        "tests",
+        "unit_test",
+        "include",
+        "msvcrt.dll",
+        "LICENSE",
+        "README.md",
+        "CHANGELOG.md",
+    }
+
+    if not preserve_tk:
+        remove_names.update({"tcl86t.dll", "tk86t.dll", "tcl", "tk", "tcl8.6", "tk8.6"})
+
+    log(f"Aggressively optimizing: {target_path}")
+
+    for root, dirs, files in os.walk(target_path, topdown=True):
+        # 1. PRUNE DIRECTORIES
+        dirs_to_remove = []
+        for d in dirs:
+            # Remove exact matches OR metadata patterns
+            if d in remove_names or d.endswith((".dist-info", ".egg-info")):
+                dirs_to_remove.append(d)
+
+        for d in dirs_to_remove:
+            full_path = Path(root) / d
+            try:
+                shutil.rmtree(full_path)
+                console.print(f"  - Pruned: {d}", style="dim")
+                dirs.remove(d)
+            except Exception:
+                pass
+
+        # 2. PRUNE FILES
+        for f in files:
+            # We remove common clutter names and development artifacts like .pdb and .pyi
+            # We DON'T remove all .txt files globally because they are often legitimate assets (e.g. certificates, data).
+            should_remove = f in remove_names or f.endswith((".pdb", ".pyi"))
+
+            if should_remove:
+                # SAFETY: Protect critical entry points in embedded engines
+                if (
+                    f == "package.json"
+                    and "pytron/engines/chrome/shell" in root.replace("\\", "/")
+                ):
+                    continue
+
+                full_path = Path(root) / f
+                try:
+                    os.remove(full_path)
+                except Exception:
+                    pass
+
+
+def get_native_engine_binaries() -> list[str]:
+    """Returns the names of the native engine binary artifacts."""
+    binaries = []
+    if sys.platform == "win32":
+        binaries.append("pytron_native.pyd")
+        binaries.append("WebView2Loader.dll")
+    elif sys.platform == "darwin":
+        binaries.append("pytron_native.so")
+    else:
+        binaries.append("pytron_native.so")
+    return binaries

pytron/pack/virtual_root.py

@@ -0,0 +1,124 @@
+import ast
+import os
+import re
+from pathlib import Path
+from typing import List, Set
+from ..console import log
+
+
+class VirtualRootGenerator:
+    """
+    Scans the codebase for 'app.expose' and generates a
+    Virtual Entry Point (VEP) that acts as the minimal root for the dependency graph.
+    """
+
+    def __init__(self, source_dir: Path):
+        self.source_dir = source_dir
+        self.exposed_functions = []  # List of (module_name, function_name)
+
+    def scan(self):
+        """
+        Recursively scans .py files for app.expose usages.
+        """
+        log("Scanning for exposed API endpoints...", style="cyan")
+
+        # We need to map file paths to module names relative to source_dir
+        for root, _, files in os.walk(self.source_dir):
+            for file in files:
+                if file.endswith(".py"):
+                    full_path = Path(root) / file
+                    self._scan_file(full_path)
+
+        log(f"Found {len(self.exposed_functions)} exposed endpoints.", style="info")
+
+    def _scan_file(self, file_path: Path):
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="ignore")
+
+            # Simple Text/Regex Heuristic (Robust against AST failures)
+            # Pattern 1: @app.expose or @expose
+            # Pattern 2: app.expose(func_name)
+
+            # 1. Decorator Scan
+            # This is hard because we need the function name AFTER the decorator.
+            # So we use AST because it's safer for structure.
+            tree = ast.parse(content)
+
+            # Calculate module name
+            rel_path = file_path.relative_to(self.source_dir)
+            module_parts = list(rel_path.parts)
+            module_parts[-1] = module_parts[-1].replace(".py", "")
+            if module_parts[-1] == "__init__":
+                module_parts.pop()
+            module_name = ".".join(module_parts)
+
+            for node in ast.walk(tree):
+                # Check for Decorators
+                if isinstance(node, ast.FunctionDef):
+                    is_exposed = False
+                    for dec in node.decorator_list:
+                        # Check @app.expose
+                        if isinstance(dec, ast.Attribute) and dec.attr == "expose":
+                            is_exposed = True
+                        # Check @expose direct import
+                        elif isinstance(dec, ast.Name) and dec.id == "expose":
+                            is_exposed = True
+
+                    if is_exposed:
+                        self.exposed_functions.append((module_name, node.name))
+
+                # Check for manual calls: app.expose(my_func)
+                elif isinstance(node, ast.Call):
+                    if (
+                        isinstance(node.func, ast.Attribute)
+                        and node.func.attr == "expose"
+                    ):
+                        # Look at arguments
+                        if node.args:
+                            arg = node.args[0]
+                            if isinstance(arg, ast.Name):
+                                # app.expose(my_func)
+                                self.exposed_functions.append((module_name, arg.id))
+
+        except Exception as e:
+            # log(f"Warning: Failed to parse {file_path.name}: {e}", style="dim")
+            pass
+
+    def generate(self, output_path: Path) -> Path:
+        """
+        Generates the _virtual_root.py file.
+        """
+        lines = [
+            "# VIRTUAL ENTRY POINT generated by Pytron Crystal",
+            "# This file imports all exposed functions to force-load their dependencies.",
+            "",
+            "import sys",
+            "import pytron",
+            "",
+            "# --- EXPOSED ENDPOINTS ---",
+        ]
+
+        # Sort for determinism
+        self.exposed_functions.sort()
+
+        used_modules = set()
+
+        for mod, func in self.exposed_functions:
+            lines.append(f"from {mod} import {func}")
+            used_modules.add(mod)
+
+        lines.append("")
+        lines.append(f"# Total Exposed Functions: {len(self.exposed_functions)}")
+        lines.append("")
+
+        # Add a main block that mimics the app startup
+        lines.append("if __name__ == '__main__':")
+        lines.append("    print('[VEP] Virtual Entry Point Loaded.')")
+        lines.append("    # This script does nothing but import variables.")
+        lines.append(
+            "    # The act of importing is what triggers the dependency loading."
+        )
+
+        output_path.write_text("\n".join(lines), encoding="utf-8")
+        log(f"Generated Virtual Entry Point: {output_path.name}", style="success")
+        return output_path

pytron/platforms/android/__init__.py

@@ -0,0 +1,3 @@
+from .android import AndroidImplementation
+
+__all__ = ["AndroidImplementation"]

pytron/platforms/android/android.py

@@ -0,0 +1,103 @@
+import json
+import logging
+from ..interface import PlatformInterface
+
+# _pytron_android is expected to be a built-in module provided by the C++ JNI layer.
+try:
+    import _pytron_android
+except ImportError:
+    _pytron_android = None
+
+
+class AndroidImplementation(PlatformInterface):
+    def __init__(self):
+        self.logger = logging.getLogger("Pytron.Android")
+        if not _pytron_android:
+            self.logger.warning(
+                "_pytron_android module not found. This platform implementation requires running inside the Android shell."
+            )
+
+    def _send(self, method, **kwargs):
+        """
+        Send a message to the Java/Kotlin layer via the JNI bridge.
+        """
+        if _pytron_android:
+            payload = json.dumps({"method": method, "args": kwargs})
+            # This function is defined in the C++ JNI Bridge
+            return _pytron_android.send_to_android(payload)
+        else:
+            self.logger.debug(f"[Android Mock] Call: {method} Args: {kwargs}")
+            return None
+
+    def minimize(self, w):
+        self._send("minimize")
+
+    def set_bounds(self, w, x, y, width, height):
+        # On Android, windows are usually full screen activities, but we can support resizing if in multi-window mode or PiP
+        self._send("set_bounds", x=x, y=y, width=width, height=height)
+
+    def close(self, w):
+        self._send("close")
+
+    def toggle_maximize(self, w):
+        self._send("toggle_maximize")
+        return True
+
+    def make_frameless(self, w):
+        self._send("make_frameless")
+
+    def start_drag(self, w):
+        self._send("start_drag")
+
+    def message_box(self, w, title, message, style=0):
+        # Assuming the JNI call 'send_to_android' can return values if we implement it to wait.
+        # We will assume it returns a serialized JSON string or primitive for blocking calls.
+        ret = self._send("message_box", title=title, message=message, style=style)
+        return int(ret) if ret is not None else 6
+
+    def notification(self, w, title, message, icon=None):
+        self._send("notification", title=title, message=message, icon=icon)
+
+    def hide(self, w):
+        self._send("hide")
+
+    def show(self, w):
+        self._send("show")
+
+    def set_window_icon(self, w, icon_path):
+        self._send("set_window_icon", path=icon_path)
+
+    def set_app_id(self, app_id):
+        self._send("set_app_id", app_id=app_id)
+
+    # Dialogs
+    def open_file_dialog(self, w, title, default_path=None, file_types=None):
+        res = self._send(
+            "open_file_dialog",
+            title=title,
+            default_path=default_path,
+            file_types=file_types,
+        )
+        if res:
+            return json.loads(res)
+        return None
+
+    def save_file_dialog(
+        self, w, title, default_path=None, default_name=None, file_types=None
+    ):
+        res = self._send(
+            "save_file_dialog",
+            title=title,
+            default_path=default_path,
+            default_name=default_name,
+            file_types=file_types,
+        )
+        if res:
+            return json.loads(res)
+        return None
+
+    def open_folder_dialog(self, w, title, default_path=None):
+        res = self._send("open_folder_dialog", title=title, default_path=default_path)
+        if res:
+            return json.loads(res)
+        return None