pytron-kit 0.3.12__py3-none-macosx_11_0_universal2.whl

pytron/commands/build.py

@@ -0,0 +1,26 @@
+import argparse
+import shutil
+import subprocess
+from pathlib import Path
+from .helpers import get_config
+
+
+def cmd_build_frontend(args: argparse.Namespace) -> int:
+    folder = Path(args.folder)
+    if not folder.exists():
+        print(f"Folder not found: {folder}")
+        return 1
+
+    config = get_config()
+    provider = config.get("frontend_provider", "npm")
+    provider_bin = shutil.which(provider)
+    if not provider_bin:
+        print(f"{provider} not found in PATH")
+        return 1
+
+    print(f"Running {provider} run build in {folder}")
+    return subprocess.call(
+        [provider_bin, "run", "build"],
+        cwd=str(folder),
+        shell=False,
+    )  # nosec B603

pytron/commands/doctor.py

@@ -0,0 +1,221 @@
+import os
+import sys
+import shutil
+import subprocess
+import platform
+import argparse
+from pathlib import Path
+from ..console import console, print_rule
+
+
+def check_command(cmd, version_args=["--version", "-v", "version"]):
+    """Check if a command exists and return its version."""
+    path = shutil.which(cmd)
+    if not path:
+        return None, None
+
+    # Try common version flags
+    for arg in version_args:
+        try:
+            # We use shell=False for better security
+            result = subprocess.run(
+                [cmd, arg], capture_output=True, text=True, timeout=3, shell=False
+            )  # nosec B603
+            output = (result.stdout + result.stderr).strip()
+            if output:
+                # Keep only the first line of version output
+                version = output.split("\n")[0].strip()
+                return path, version
+        except Exception:
+            continue
+
+    return path, "Found"
+
+
+def get_python_info():
+    return sys.version.split("\n")[0], platform.architecture()[0]
+
+
+def cmd_doctor(args: argparse.Namespace) -> int:
+    print_rule("Pytron Doctor - System Diagnostic")
+
+    # 1. Core Python Info
+    py_ver, py_arch = get_python_info()
+    console.print(f"[bold]Python Environment[/bold]")
+    console.print(f"  [success]✓[/success] Python: {py_ver} ({py_arch})")
+    console.print(
+        f"  [success]✓[/success] Platform: {platform.system()} {platform.release()}"
+    )
+
+    # Check if in VENV
+    is_venv = sys.prefix != sys.base_prefix
+    if is_venv:
+        console.print(
+            f"  [success]✓[/success] Status: Running inside a virtual environment"
+        )
+    else:
+        # Check for env/ in CWD
+        if Path("env").exists() or Path(".venv").exists():
+            console.print(
+                f"  [info]i[/info] Status: Global Python (local environment detected but not active)"
+            )
+        else:
+            console.print(
+                f"  [warning]![/warning] Status: Global Python (no local environment detected)"
+            )
+
+    console.print("")
+
+    # 2. Web Application Dependencies
+    console.print(f"[bold]Web & Frontend Tools[/bold]")
+    from .helpers import get_config
+
+    config = get_config()
+    configured_provider = config.get("frontend_provider", "npm")
+
+    node_path, node_ver = check_command("node")
+    if node_path:
+        console.print(f"  [success]✓[/success] Node.js: {node_ver}")
+    else:
+        console.print(
+            f"  [error]✗[/error] Node.js: Not found (Only required for 'npm/yarn/pnpm')"
+        )
+
+    providers = ["npm", "yarn", "pnpm", "bun"]
+    for p in providers:
+        p_path, p_ver = check_command(p)
+        status = "[success]✓[/success]" if p_path else "[dim]✗[/dim]"
+        configured_tag = (
+            " [cyan](Configured)[/cyan]" if p == configured_provider else ""
+        )
+        if p_path:
+            console.print(f"  {status} {p}: {p_ver}{configured_tag}")
+        elif p == configured_provider:
+            console.print(f"  [error]✗[/error] {p}: Not found{configured_tag}")
+        else:
+            console.print(f"  {status} {p}: Not found")
+
+    console.print("")
+
+    # 3. Packaging Tools
+    console.print(f"[bold]Packaging Tools[/bold]")
+    pi_path, pi_ver = check_command("pyinstaller")
+    if pi_path:
+        console.print(f"  [success]✓[/success] PyInstaller: {pi_ver}")
+    else:
+        # Check if installed but not in PATH
+        try:
+            from importlib.metadata import version as get_pkg_version
+
+            console.print(
+                f"  [success]✓[/success] PyInstaller: {get_pkg_version('pyinstaller')} (accessible via module)"
+            )
+        except Exception:
+            console.print(
+                f"  [error]✗[/error] PyInstaller: Not found (Required for 'pytron package')"
+            )
+
+    if platform.system() == "Windows":
+        # Check NSIS
+        from .package import find_makensis
+
+        makensis = find_makensis()
+        if makensis:
+            console.print(f"  [success]✓[/success] NSIS: Found ({makensis})")
+        else:
+            console.print(
+                f"  [warning]![/warning] NSIS: Not found (Required for creating installers)"
+            )
+
+        # Check SignTool
+        signtool = shutil.which("signtool")
+        if signtool:
+            console.print(f"  [success]✓[/success] SignTool: Found ({signtool})")
+        else:
+            console.print(
+                f"  [dim]i[/dim] SignTool: Not found (Optional: needed for code signing)"
+            )
+
+    console.print("")
+
+    # 4. Android Development
+    console.print(f"[bold]Android Development[/bold]")
+    java_path, java_ver = check_command("java")
+    adb_path, adb_ver = check_command("adb")
+    android_home = os.environ.get("ANDROID_HOME") or os.environ.get("ANDROID_SDK_ROOT")
+
+    if java_path:
+        console.print(f"  [success]✓[/success] Java/JDK: {java_ver}")
+    else:
+        console.print(
+            f"  [error]✗[/error] Java/JDK: Not found (Required for 'pytron android')"
+        )
+
+    if android_home and os.path.exists(android_home):
+        console.print(f"  [success]✓[/success] Android SDK: {android_home}")
+    else:
+        console.print(
+            f"  [error]✗[/error] Android SDK: ANDROID_HOME environment variable not set or invalid"
+        )
+
+    if adb_path:
+        # Clean up adb version (Android Debug Bridge version 1.0.41 -> 1.0.41)
+        v_clean = adb_ver.replace("Android Debug Bridge version ", "").strip()
+        console.print(f"  [success]✓[/success] ADB: {v_clean}")
+    else:
+        console.print(
+            f"  [warning]![/warning] ADB: Not found (Needed to run on physical devices)"
+        )
+
+    console.print("")
+
+    # 5. Project Integrity
+    if Path("settings.json").exists():
+        console.print(f"[bold]Project Context[/bold]")
+        req_json = Path("requirements.json")
+        if req_json.exists():
+            console.print(f"  [success]✓[/success] requirements.json: Found")
+        else:
+            console.print(
+                f"  [warning]![/warning] requirements.json: Missing (Run 'pytron init' or create it)"
+            )
+        console.print("")
+
+    # 6. Pytron Bridge Check
+    console.print(f"[bold]Pytron Core[/bold]")
+    try:
+        import pytron
+
+        pkg_root = Path(pytron.__file__).parent
+        console.print(f"  [success]✓[/success] Pytron Location: {pkg_root.parent}")
+
+        # Check for native dynamic libraries
+        # Check for native dynamic libraries
+        from ..pack.utils import get_native_engine_binaries
+
+        needed = get_native_engine_binaries()
+        missing = []
+
+        for name in needed:
+            dll_path = pkg_root / "dependencies" / name
+            if not dll_path.exists():
+                missing.append(name)
+
+        if not missing:
+            console.print(
+                f"  [success]✓[/success] Native Bridge: Found all required binaries ({', '.join(needed)})"
+            )
+        else:
+            console.print(
+                f"  [error]✗[/error] Native Bridge: MISSING ({', '.join(missing)}) from {pkg_root / 'dependencies'}"
+            )
+
+    except Exception as e:
+        console.print(f"  [error]✗[/error] Pytron Core: Failed to inspect ({e})")
+
+    print_rule("Diagnostic Complete", style="bold green")
+
+    console.print(
+        "\n[dim]If you have many [error]✗[/error], please refer to the documentation at https://pytron-kit.github.io/docs/[/dim]"
+    )
+    return 0

pytron/commands/engine.py

@@ -0,0 +1,23 @@
+from ..console import log
+from ..engines.chrome.forge import setup_engine
+
+
+def cmd_engine(args):
+    """Entry point for 'pytron engine' commands."""
+    if not args.engine_command:
+        log("Usage: pytron engine <command> [args]", style="warning")
+        return 0
+
+    if args.engine_command == "install":
+        if args.name == "chrome":
+            log(f"Installing Chrome Mojo Engine...", style="info")
+            try:
+                target = setup_engine()
+                log(f"Engine Forge Successful: {target}", style="success")
+            except Exception as e:
+                log(f"Engine Forge Failed: {e}", style="error")
+                return 1
+        else:
+            log(f"Unsupported engine: {args.name}", style="error")
+            return 1
+    return 0

pytron/commands/frontend.py

@@ -0,0 +1,60 @@
+import argparse
+import shutil
+from pathlib import Path
+from .helpers import locate_frontend_dir, get_config
+from ..console import log, run_command_with_output, get_progress
+
+
+def cmd_frontend(args: argparse.Namespace) -> int:
+    """
+    Proxy command that runs '<provider> <args>' in the frontend directory.
+    """
+    # Try to find frontend dir
+    frontend_dir = locate_frontend_dir(Path("."))
+
+    if not frontend_dir:
+        log("Could not locate a frontend directory (package.json).", style="error")
+        return 1
+
+    # Order of precedence: CLI Arg > settings.json > default 'npm'
+    config = get_config()
+    default_provider = config.get("frontend_provider", "npm")
+    provider = getattr(args, "provider", None) or default_provider
+
+    # Check for provider binary
+    provider_bin = shutil.which(provider)
+    if not provider_bin:
+        log(f"'{provider}' is not installed or not in PATH.", style="error")
+        return 1
+
+    npm_args = args.npm_args
+    if not npm_args:
+        # Default to 'install' if no args provided
+        npm_args = ["install"]
+
+    # Special case: 'install' gets the progress bar for better UX
+    if "install" in npm_args:
+        prog = get_progress()
+        prog.start()
+        task_msg = (
+            f"[{provider}] Installing packages..."
+            if len(npm_args) > 1
+            else f"[{provider}] Installing JS dependencies..."
+        )
+        prog.add_task(task_msg, total=None)
+        cmd = [provider_bin] + npm_args
+        ret = run_command_with_output(cmd, cwd=str(frontend_dir), shell=False)
+        prog.stop()
+    else:
+        # For 'run dev', 'build', etc., just stream the output directly
+        cmd = [provider_bin] + npm_args
+        log(f"Running: {provider} {' '.join(npm_args)}", style="dim")
+        ret = run_command_with_output(cmd, cwd=str(frontend_dir), shell=False)
+
+    if ret == 0:
+        log(f"Frontend command ({provider}) completed successfully.", style="success")
+    else:
+        log(f"Command failed ({provider} {' '.join(npm_args)})", style="error")
+        return 1
+
+    return 0

pytron/commands/harvest.py

@@ -0,0 +1,112 @@
+from importlib import metadata as importlib_metadata
+from pathlib import Path
+from typing import Iterable
+
+
+def generate_nuclear_hooks(
+    output_dir: Path,
+    collect_all_mode: bool = True,
+    blacklist: Iterable[str] | None = None,
+    search_path: list[str] | None = None,
+    whitelist: Iterable[str] | None = None,
+) -> None:
+    """
+    Scans the current Python environment and writes PyInstaller hook files that
+    call `collect_all` (or `collect_submodules` if `collect_all_mode` is False)
+    for each installed distribution. Hooks are written as `hook-<package>.py`.
+
+    Parameters:
+    - output_dir: directory to place generated hook files
+    - collect_all_mode: if True use `collect_all`, else use `collect_submodules`
+    - blacklist: optional iterable of package names to skip (case-insensitive)
+    - search_path: optional list of paths to search for distributions (defaults to sys.path)
+    - whitelist: optional iterable of package names to ONLY include (overrides scan)
+    """
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    print(f"[Pytron]  Initiating Complete Hook Generation in {output_dir}...")
+
+    if blacklist is None:
+        blacklist = [
+            "pyinstaller",
+            "pytron-kit",
+            "setuptools",
+            "pip",
+            "wheel",
+            "altgraph",
+            "pefile",
+            "pyinstaller-hooks-contrib",
+        ]
+
+    bl = {n.lower() for n in blacklist}
+    wl = {n.lower() for n in whitelist} if whitelist else None
+
+    count = 0
+    # Use the provided search_path if available
+    dists = (
+        importlib_metadata.distributions(path=search_path)
+        if search_path
+        else importlib_metadata.distributions()
+    )
+
+    for dist in dists:
+        # Try to obtain a project/distribution name comparable to pkg_resources' project_name
+        name = None
+        try:
+            # metadata is an email.message.Message mapping; 'Name' is the canonical key
+            name = dist.metadata.get("Name") or getattr(dist, "name", None)
+        except Exception:
+            try:
+                name = getattr(dist, "name", None)
+            except Exception:
+                name = None
+
+        if not name:
+            # fallback: try the package root name derived from the distribution path
+            try:
+                name = Path(dist.locate_file("")).name
+            except Exception:
+                continue
+
+        if wl is not None:
+            # If whitelist is provided, skip if not in it
+            if name.lower() not in wl:
+                continue
+
+        if name.lower() in bl:
+            continue
+
+        safe_name = name.replace("-", "_")
+
+        func = "collect_all" if collect_all_mode else "collect_submodules"
+
+        if collect_all_mode:
+            body = f"binaries, hiddenimports, datas = collect_all('{name}')"
+        else:
+            body = f"hiddenimports = collect_submodules('{name}')\n    binaries, datas = [], []"
+
+        hook_content = f"""
+# Auto-generated nuclear hook for {name}
+from PyInstaller.utils.hooks import {func}
+
+try:
+    {body}
+except Exception:
+    # Fallback on any error to keep build moving
+    binaries, hiddenimports, datas = [], [], []
+"""
+
+        hook_file = output_dir / f"hook-{safe_name}.py"
+        try:
+            hook_file.write_text(hook_content, encoding="utf-8")
+            count += 1
+        except Exception as e:
+            print(f"[Pytron] Warning: failed to write hook for {name}: {e}")
+
+    print(
+        f"[Pytron] Generated {count} complete hooks. PyInstaller can't miss anything now."
+    )
+
+
+if __name__ == "__main__":
+    generate_nuclear_hooks(Path("temp_hooks"))

pytron/commands/helpers.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+import shutil
+import subprocess
+import json
+import sys
+from pathlib import Path
+
+
+def get_venv_python_path(venv_dir: Path = Path("env")) -> Path:
+    if sys.platform == "win32":
+        return venv_dir / "Scripts" / "python.exe"
+    return venv_dir / "bin" / "python"
+
+
+def get_python_executable() -> str:
+    venv_python = get_venv_python_path()
+    if venv_python.exists():
+        return str(venv_python)
+    return sys.executable
+
+
+def get_config() -> dict:
+    """Load settings.json from the current directory."""
+    path = Path("settings.json")
+    if path.exists():
+        try:
+            return json.loads(path.read_text(encoding="utf-8"))
+        except Exception as e:
+            # Config file might be corrupted or unreadable
+            print(f"[Pytron] Debug: Failed to load settings.json: {e}")
+    return {}
+
+
+def get_venv_site_packages(python_exe: str) -> list[str]:
+    """
+    Get the site-packages directories for the given python executable.
+    """
+    try:
+        # We use a subprocess to ask the venv python where its site-packages are.
+        # We use json to safely parse the list.
+        cmd = [
+            python_exe,
+            "-c",
+            "import site; import json; print(json.dumps(site.getsitepackages()))",
+        ]
+        output = subprocess.check_output(cmd, text=True).strip()
+        return json.loads(output)
+    except Exception as e:
+        print(
+            f"[Pytron] Warning: Could not determine site-packages for {python_exe}: {e}"
+        )
+        return []
+
+
+def locate_frontend_dir(start_dir: Path | None = None) -> Path | None:
+    base = (start_dir or Path(".")).resolve()
+    if not base.exists():
+        return None
+    candidates = [base]
+    # Ignores common large folders to avoid slow searches and false positives
+    ignored_dirs = {"node_modules", "env", "venv", ".git", "build", "dist"}
+    candidates.extend(
+        [
+            p
+            for p in base.iterdir()
+            if p.is_dir() and p.name not in ignored_dirs and not p.name.startswith(".")
+        ]
+    )
+    for candidate in candidates:
+        pkg = candidate / "package.json"
+        if not pkg.exists():
+            continue
+        try:
+            data = json.loads(pkg.read_text())
+        except json.JSONDecodeError:
+            # Skip invalid package.json
+            continue
+        if isinstance(data.get("scripts"), dict) and "build" in data["scripts"]:
+            return candidate.resolve()
+    return None
+
+
+def run_frontend_build(frontend_dir: Path) -> bool | None:
+    config = get_config()
+    provider = config.get("frontend_provider", "npm")
+    provider_bin = shutil.which(provider)
+
+    if not provider_bin:
+        print(f"[Pytron] {provider} not found, skipping frontend build.")
+        return None
+
+    print(f"[Pytron] Building frontend at: {frontend_dir} using {provider}")
+    # Ensure Next.js static export-friendly config when applicable
+    # Determine if this is a Next.js project and ensure config if so
+    is_next = False
+    try:
+        pkg = json.loads((frontend_dir / "package.json").read_text())
+        if "next" in pkg.get("dependencies", {}) or "next" in pkg.get(
+            "devDependencies", {}
+        ):
+            ensure_next_config(frontend_dir)
+            patch_nextjs_defaults(frontend_dir)  # Patch default template paths
+            is_next = True
+    except Exception as e:
+        print(f"[Pytron] Debug: Failed to patch Next.js config: {e}")
+
+    try:
+        # If this is a Next.js project, prefer npx/bunx/pnpx next build (and export)
+        if is_next:
+            runner = "npx"
+            if provider == "bun":
+                runner = "bunx"
+            elif provider == "pnpm":
+                runner = "pnpx"
+
+            print(f"[Pytron] Detected Next.js project — running `{runner} next build`.")
+            # Run build to create a static `out/` directory (Next.js 13.4+ with output: "export")
+            subprocess.run(
+                [runner, "next", "build"],
+                cwd=str(frontend_dir),
+                shell=False,
+                check=True,
+            )
+            return True
+
+        # Fallback to the project's build script via provider
+        subprocess.run(
+            [provider_bin, "run", "build"],
+            cwd=str(frontend_dir),
+            shell=False,
+            check=True,
+        )
+        return True
+    except subprocess.CalledProcessError as exc:
+        print(f"[Pytron] Frontend build failed: {exc}")
+        return False
+
+
+def patch_nextjs_defaults(frontend_dir: Path):
+    """
+    Patches default Next.js template files to use relative paths for static assets.
+    This fixes issues where /next.svg resolves to file:///next.svg instead of relative to the HTML file.
+    """
+    # 1. Patch page.tsx / page.js (Fixes Image src)
+    for ext in ["tsx", "jsx", "js", "ts"]:
+        page_file = frontend_dir / "src" / "app" / f"page.{ext}"
+        if not page_file.exists():
+            page_file = frontend_dir / "app" / f"page.{ext}"  # Older structure
+
+        if page_file.exists():
+            try:
+                content = page_file.read_text(encoding="utf-8")
+                new_content = content
+                # Replace absolute paths with relative ones
+                replacements = {
+                    'src="/next.svg"': 'src="./next.svg"',
+                    'src="/vercel.svg"': 'src="./vercel.svg"',
+                    "src='/next.svg'": "src='./next.svg'",
+                    "src='/vercel.svg'": "src='./vercel.svg'",
+                }
+                for old, new in replacements.items():
+                    new_content = new_content.replace(old, new)
+
+                if new_content != content:
+                    page_file.write_text(new_content, encoding="utf-8")
+                    print(
+                        f"[Pytron] Patched {page_file.name} to use relative image paths."
+                    )
+            except Exception as e:
+                print(f"[Pytron] Warning: Failed to patch {page_file.name}: {e}")
+
+    # 2. Patch layout.tsx / layout.js (Fixes favicon)
+    # Note: Next.js App Router handles favicon via convention (favicon.ico in app/ or public/),
+    # but sometimes it's manually referenced in layout or head.
+    # However, the default create-next-app usually relies on the file presence.
+    # If the user sees 404 for favicon, it might be due to <link rel="icon" href="/favicon.ico"> generated by Next.
+    # We can't easily patch the internal generation of that link without a custom Head component or metadata.
+    # But if it's in the code:
+    for ext in ["tsx", "jsx", "js", "ts"]:
+        layout_file = frontend_dir / "src" / "app" / f"layout.{ext}"
+        if not layout_file.exists():
+            layout_file = frontend_dir / "app" / f"layout.{ext}"
+
+        if layout_file.exists():
+            try:
+                content = layout_file.read_text(encoding="utf-8")
+                # Check for manual link tags if any (unlikely in new app router but possible)
+                if 'href="/favicon.ico"' in content:
+                    new_content = content.replace(
+                        'href="/favicon.ico"', 'href="./favicon.ico"'
+                    )
+                    layout_file.write_text(new_content, encoding="utf-8")
+                    print(
+                        f"[Pytron] Patched {layout_file.name} to use relative favicon path."
+                    )
+            except Exception as e:
+                print(f"[Pytron] Debug: Failed to patch layout file: {e}")
+
+
+def ensure_next_config(frontend_dir: Path) -> bool:
+    """Ensure a `next.config.js` exists with static-export friendly settings.
+
+    If no `next.config.js` exists, create one with the recommended config.
+    If one exists but doesn't already set `output: 'export'`, back it up and overwrite
+    with the recommended config. Returns True if a file was created/overwritten,
+    False if no change was necessary.
+    """
+    next_config = frontend_dir / "next.config.js"
+    desired = """/** @type {import('next').NextConfig} */
+const nextConfig = {
+  output: 'export',          // required to generate static files (out/)
+  images: { unoptimized: true }, // so Next won’t rewrite image loaders
+  assetPrefix: './',         // makes asset paths relative
+};
+
+module.exports = nextConfig;
+"""
+    try:
+        if not next_config.exists():
+            next_config.write_text(desired, encoding="utf-8")
+            print(f"[Pytron] Created {next_config} to enable static export.")
+            return True
+        content = next_config.read_text(encoding="utf-8")
+        if ("output: 'export'" in content or 'output: "export"' in content) and (
+            "assetPrefix: './'" in content or 'assetPrefix: "./"' in content
+        ):
+            print(f"[Pytron] {next_config} already configures static export.")
+            return False
+        # Backup and overwrite to ensure static-friendly config
+        backup = frontend_dir / "next.config.js.bak"
+        backup.write_text(content, encoding="utf-8")
+        next_config.write_text(desired, encoding="utf-8")
+        print(
+            f"[Pytron] Backed up existing next.config.js to {backup} and injected export config."
+        )
+        return True
+    except Exception as exc:
+        print(f"[Pytron] Warning: could not ensure next.config.js: {exc}")
+        return False