pytron-kit 0.3.12__py3-none-macosx_11_0_universal2.whl

pytron/commands/install.py

@@ -0,0 +1,294 @@
+import argparse
+import subprocess
+import venv
+import json
+import re
+from pathlib import Path
+from ..console import (
+    log,
+    get_progress,
+    run_command_with_output,
+)
+import shutil
+
+from .helpers import get_venv_python_path
+from .plugin import perform_plugin_install
+
+REQUIREMENTS_JSON = Path("requirements.json")
+
+
+def load_requirements() -> dict:
+    if REQUIREMENTS_JSON.exists():
+        try:
+            data = json.loads(REQUIREMENTS_JSON.read_text())
+            if "plugins" not in data:
+                data["plugins"] = []
+            return data
+        except json.JSONDecodeError:
+            log(
+                f"Warning: {REQUIREMENTS_JSON} is invalid JSON. Using empty defaults.",
+                style="warning",
+            )
+    return {"dependencies": [], "plugins": []}
+
+
+def save_requirements(data: dict):
+    REQUIREMENTS_JSON.write_text(json.dumps(data, indent=4))
+
+
+def get_installed_packages(venv_python) -> dict[str, str]:
+    """Returns a dict of {package_name: version} for all installed packages."""
+    try:
+        cmd = [str(venv_python), "-m", "pip", "list", "--format=json"]
+        output = subprocess.check_output(cmd, text=True).strip()
+        data = json.loads(output)
+        return {item["name"].lower(): item["version"] for item in data}
+    except (subprocess.CalledProcessError, json.JSONDecodeError):
+        return {}
+
+
+def get_package_name_from_source(path: Path) -> str | None:
+    """Attempts to read package name from pyproject.toml."""
+    try:
+        pyproject = path / "pyproject.toml"
+        if pyproject.exists():
+            content = pyproject.read_text(encoding="utf-8")
+            # Rudimentary TOML parsing for [project] name = "..."
+            match = re.search(r'(?m)^name\s*=\s*["\']([^"\']+)["\']', content)
+            if match:
+                return match.group(1).lower()
+    except Exception:
+        pass
+    return None
+
+
+def cmd_install(args: argparse.Namespace) -> int:
+    """
+    Creates a virtual environment (if not exists) and installs dependencies.
+    If packages are provided, installs them and adds to requirements.json.
+    If no packages provided, installs from requirements.json.
+    """
+    venv_dir = Path("env")
+
+    # 1. Create virtual environment if it doesn't exist
+    if not venv_dir.exists():
+        log(f"Creating virtual environment in {venv_dir}...", style="info")
+        venv.create(venv_dir, with_pip=True)
+    else:
+        # Only print if we are doing a full install or explicit install to reassure user
+        pass
+
+    venv_python = get_venv_python_path(venv_dir)
+    if not venv_python.exists():
+        log(f"Error: Python executable not found at {venv_python}", style="error")
+        return 1
+
+    packages_to_install = args.packages
+    req_data = load_requirements()
+    current_deps = req_data.get("dependencies", [])
+    current_plugins = req_data.get("plugins", [])
+
+    if packages_to_install:
+        if getattr(args, "plugin", False):
+            # Handle Plugin Installation
+            for plugin_id in packages_to_install:
+                ret = perform_plugin_install(plugin_id)
+                if ret == 0:
+                    if plugin_id not in current_plugins:
+                        current_plugins.append(plugin_id)
+                else:
+                    return 1
+
+            req_data["plugins"] = sorted(list(set(current_plugins)))
+            save_requirements(req_data)
+            log(f"Added plugins to {REQUIREMENTS_JSON}", style="success")
+            return 0
+
+        # Warn about versionless packages
+        for pkg in packages_to_install:
+            # Check if it's a local path
+            if Path(pkg).exists():
+                pass  # Local path
+            elif not any(op in pkg for op in ["==", ">=", "<=", "<", ">", "@"]):
+                log(
+                    f"Warning: No version specified for '{pkg}'. Installing latest version.",
+                    style="warning",
+                )
+
+        log(f"Installing: {', '.join(packages_to_install)}")
+
+        # Snapshot before
+        before_state = get_installed_packages(venv_python)
+
+        try:
+            # Install packages
+            progress = get_progress()
+            progress.start()
+            task = progress.add_task("Installing...", total=None)
+
+            # Use run_command_with_output to stream logs cleanly above the progress bar
+            ret = run_command_with_output(
+                [str(venv_python), "-m", "pip", "install", "--no-build-isolation"]
+                + packages_to_install
+            )
+
+            progress.stop()
+            if ret != 0:
+                log("pip install failed", style="error")
+                return 1
+
+            # Snapshot after
+            after_state = get_installed_packages(venv_python)
+
+            updated = False
+
+            for pkg_arg in packages_to_install:
+                # Resolve package name
+                resolved_name = None
+
+                # Case 1: Local Path (e.g., D:\lib or ./lib)
+                if Path(pkg_arg).exists():
+                    # Strategy A: Try to read name from source (pyproject.toml)
+                    resolved_name = get_package_name_from_source(Path(pkg_arg))
+
+                    if not resolved_name:
+                        # Strategy B: Heuristic from pip list diff
+                        candidates = []
+                        for name, ver in after_state.items():
+                            if name not in before_state:
+                                candidates.append(name)
+                            elif before_state.get(name) != ver:
+                                candidates.append(name)
+
+                        if len(candidates) == 1:
+                            resolved_name = candidates[0]
+                        elif len(candidates) > 1:
+                            # Fuzzy match guess
+                            guess = (
+                                Path(pkg_arg)
+                                .name.replace("-", "_")
+                                .split(".")[0]
+                                .lower()
+                            )
+                            for cand in candidates:
+                                if guess in cand or cand in guess:
+                                    resolved_name = cand
+                                    break
+
+                    # Strategy C: Check folder name against installed packages
+                    if not resolved_name:
+                        folder_name = Path(pkg_arg).name.lower()
+                        if folder_name in after_state:
+                            resolved_name = folder_name
+                        else:
+                            norm_folder = folder_name.replace("-", "_")
+                            if norm_folder in after_state:
+                                resolved_name = norm_folder
+
+                # Case 2: Package Name (e.g., "requests")
+                else:
+                    match = re.split(r"[=<>@]", pkg_arg)
+                    resolved_name = match[0].strip().lower()
+
+                # Get Version & Update Config
+                if resolved_name and resolved_name in after_state:
+                    resolved_version = after_state[resolved_name]
+                    entry = f"{resolved_name}=={resolved_version}"
+
+                    # Remove old entry if exists (replacement logic)
+                    new_deps = []
+                    replaced = False
+                    for dep in current_deps:
+                        dep_name = re.split(r"[=<>@]", dep)[0].strip().lower()
+                        if dep_name == resolved_name:
+                            new_deps.append(entry)
+                            replaced = True
+                        else:
+                            new_deps.append(dep)
+
+                    if not replaced:
+                        new_deps.append(entry)
+
+                    current_deps = new_deps
+                    updated = True
+                else:
+                    log(
+                        f"Warning: Could not resolve installed version for '{pkg_arg}'. Skipping requirement update.",
+                        style="warning",
+                    )
+
+            if updated:
+                req_data["dependencies"] = sorted(list(set(current_deps)))
+                save_requirements(req_data)
+                log(f"Added to {REQUIREMENTS_JSON}", style="success")
+
+        except subprocess.CalledProcessError as e:
+            log(f"Error installing packages: {e}", style="error")
+            return 1
+    else:
+        # Install from requirements.json
+        current_plugins = req_data.get("plugins", [])
+
+        if not current_deps and not current_plugins:
+            log(
+                f"No dependencies or plugins found in {REQUIREMENTS_JSON}.",
+                style="warning",
+            )
+            return 0
+
+        if current_deps:
+            log(f"Installing dependencies from {REQUIREMENTS_JSON}...")
+            try:
+                progress = get_progress()
+                progress.start()
+                task = progress.add_task("Syncing Dependencies...", total=None)
+
+                ret = run_command_with_output(
+                    [str(venv_python), "-m", "pip", "install", "--no-build-isolation"]
+                    + current_deps
+                )
+
+                progress.stop()
+                if ret == 0:
+                    log("Dependencies installed successfully.", style="success")
+                else:
+                    log("Failed to install dependencies.", style="error")
+                    return 1
+            except Exception as e:
+                if "progress" in locals():
+                    progress.stop()
+                log(f"Error installing dependencies: {e}", style="error")
+                return 1
+
+        if current_plugins:
+            log(f"Installing plugins from {REQUIREMENTS_JSON}...")
+            for plugin_id in current_plugins:
+                ret = perform_plugin_install(plugin_id)
+                if ret != 0:
+                    log(f"Failed to install plugin: {plugin_id}", style="error")
+                    return 1
+
+        # 3. Frontend Dependencies (NPM/Yarn/Bun)
+        frontend_dir = Path("frontend")
+        if frontend_dir.exists() and (frontend_dir / "package.json").exists():
+            log(f"Detected frontend in {frontend_dir}. Syncing NPM dependencies...")
+            provider = req_data.get("provider", "npm")
+            provider_bin = shutil.which(provider)
+
+            if provider_bin:
+                try:
+                    # Run install in the frontend directory
+                    subprocess.check_call([provider_bin, "install"], cwd=frontend_dir)
+                    log(
+                        "Frontend dependencies installed successfully.", style="success"
+                    )
+                except subprocess.CalledProcessError as e:
+                    log(f"Failed to install frontend dependencies: {e}", style="error")
+                    return 1
+            else:
+                log(
+                    f"Warning: '{provider}' not found. Please install '{provider}' to sync frontend dependencies.",
+                    style="warning",
+                )
+
+    return 0

pytron/commands/login.py

@@ -0,0 +1,130 @@
+import argparse
+import keyring
+import time
+import webbrowser
+import requests
+from ..console import log
+
+SERVICE_NAME = "pytron-kit"
+ACCOUNT_NAME = "github-token"
+# NOTE: Replace this with the actual Client ID from your GitHub OAuth App
+CLIENT_ID = "Ov23linvJ7QhMWN2tOth"
+
+
+def cmd_login(args: argparse.Namespace) -> int:
+    log("GitHub Device Login", style="info")
+
+    # 1. Ask GitHub for a "Device Code"
+    try:
+        response = requests.post(
+            "https://github.com/login/device/code",
+            headers={"Accept": "application/json"},
+            data={"client_id": CLIENT_ID, "scope": "read:user"},
+            timeout=10,
+        )
+        data = response.json()
+
+        if "error" in data:
+            log(
+                f"GitHub Error: {data.get('error_description', data['error'])}",
+                style="error",
+            )
+            log(
+                "Make sure the Client ID is correct and Device Flow is enabled in GitHub settings.",
+                style="info",
+            )
+            return 1
+
+        device_code = data["device_code"]
+        user_code = data["user_code"]  # e.g., "WDJB-VJTW"
+        verification_uri = data["verification_uri"]  # github.com/login/device
+        interval = data["interval"]  # How often to check
+
+        # 2. Show the user what to do
+        log(f"1. Copy your one-time code: [bold green]{user_code}[/bold green]")
+        log(f"2. Visit: {verification_uri}")
+
+        print("")
+        input("Press Enter to open the browser and authorize...")
+        webbrowser.open(verification_uri)
+
+        log("Waiting for authorization...", style="info")
+
+        # 3. Poll GitHub until the user clicks "Approve"
+        while True:
+            time.sleep(interval)
+
+            check_resp = requests.post(
+                "https://github.com/login/oauth/access_token",
+                headers={"Accept": "application/json"},
+                data={
+                    "client_id": CLIENT_ID,
+                    "device_code": device_code,
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                },
+                timeout=10,
+            )
+            token_data = check_resp.json()
+
+            if "access_token" in token_data:
+                token = token_data["access_token"]
+
+                # Success! Let's get the username for the welcome message
+                user_res = requests.get(
+                    "https://api.github.com/user",
+                    headers={"Authorization": f"token {token}"},
+                    timeout=5,
+                )
+                username = (
+                    user_res.json().get("login", "User")
+                    if user_res.status_code == 200
+                    else "User"
+                )
+
+                keyring.set_password(SERVICE_NAME, ACCOUNT_NAME, token)
+                log(f"Successfully logged in as @{username}!", style="success")
+                return 0
+
+            if "error" in token_data:
+                error = token_data["error"]
+                if error == "authorization_pending":
+                    continue  # Keep polling
+                elif error == "slow_down":
+                    interval += 5  # GitHub is telling us to chill
+                elif error == "expired_token":
+                    log("Code expired. Please run 'pytron login' again.", style="error")
+                    return 1
+                else:
+                    log(f"Authorization failed: {error}", style="error")
+                    return 1
+    except Exception as e:
+        log(f"Login failed: {e}", style="error")
+        return 1
+
+
+def cmd_logout(args: argparse.Namespace) -> int:
+    try:
+        keyring.delete_password(SERVICE_NAME, ACCOUNT_NAME)
+        log("Logged out. GitHub token removed from keyring.", style="success")
+        return 0
+    except keyring.errors.PasswordDeleteError:
+        log("Already logged out.", style="warning")
+        return 0
+    except Exception as e:
+        log(f"Logout failed: {e}", style="error")
+        return 1
+
+
+def get_github_token() -> str | None:
+    import os
+
+    # Priority 1: Environment Variable (highest priority/override)
+    env_token = os.environ.get("PYTRON_GITHUB_TOKEN")
+    if env_token:
+        return env_token
+
+    # Priority 2: Keyring
+    try:
+        return keyring.get_password(SERVICE_NAME, ACCOUNT_NAME)
+    except Exception:
+        return None

pytron/commands/package.py

@@ -0,0 +1,228 @@
+import argparse
+import json
+import os
+from pathlib import Path
+from ..console import (
+    console,
+    log,
+    get_progress,
+    run_command_with_output,
+    Rule,
+)
+from .harvest import generate_nuclear_hooks
+from .helpers import (
+    get_python_executable,
+    get_venv_site_packages,
+)
+from .utils import resolve_package_metadata
+from ..pack.assets import get_smart_assets
+from ..pack.installers import build_installer
+from ..pack.utils import cleanup_dist
+from ..pack.nuitka import run_nuitka_build
+from ..pack.pyinstaller import run_pyinstaller_build
+from ..pack.secure import run_secure_build
+
+
+def cmd_package(args: argparse.Namespace) -> int:
+    script_path = args.script
+    if not script_path:
+        script_path = "app.py"
+
+    script = Path(script_path)
+    # Resolve script path early for reliable relative lookups
+    script = script.resolve()
+    if not script.exists():
+        log(f"Script not found: {script}", style="error")
+        return 1
+
+    console.print(Rule("[bold cyan]Pytron Builder"))
+
+    progress = get_progress()
+    task = progress.add_task("Starting...", total=100)
+    progress.start()
+
+    # If the user provided a .spec file, use it directly
+    if script.suffix == ".spec":
+        log(f"Packaging using spec file: {script}")
+        progress.update(task, description="Building from Spec...", completed=10)
+        # When using a spec file, most other arguments are ignored by PyInstaller
+        # as the spec file contains the configuration.
+        # Prepare and optionally generate hooks from the current venv so PyInstaller
+        # includes missing dynamic imports/binaries. Only generate hooks if user
+        # requested via CLI flags (`--collect-all` or `--force-hooks`).
+        temp_hooks_dir = None
+        env = None
+        try:
+            if getattr(args, "collect_all", False) or getattr(
+                args, "force_hooks", False
+            ):
+                temp_hooks_dir = script.parent / "build" / "nuclear_hooks"
+                collect_mode = getattr(args, "collect_all", False)
+
+                # Get venv site-packages to ensure we harvest the correct environment
+                python_exe = get_python_executable()
+                site_packages = get_venv_site_packages(python_exe)
+
+                generate_nuclear_hooks(
+                    temp_hooks_dir,
+                    collect_all_mode=collect_mode,
+                    search_path=site_packages,
+                )
+        except Exception as e:
+            log(f"Warning: failed to generate nuclear hooks: {e}", style="warning")
+
+        cmd = [get_python_executable(), "-m", "PyInstaller"]
+        cmd.append(str(script))
+        cmd.append("--noconfirm")
+
+        log(f"Running: {' '.join(cmd)}", style="dim")
+
+        if env is not None:
+            ret_code = run_command_with_output(cmd, env=env, style="dim")
+        else:
+            ret_code = run_command_with_output(cmd, style="dim")
+
+        # Cleanup
+        if ret_code == 0:
+            out_name = args.name or script.stem
+            cleanup_dist(Path("dist") / out_name)
+
+        # If installer was requested, we still try to build it
+        if ret_code == 0 and args.installer:
+            progress.update(task, description="Building Installer...", completed=80)
+            out_name = args.name or script.stem
+            ret_code = build_installer(out_name, script.parent, args.icon)
+
+        progress.update(task, description="Done!", completed=100)
+        progress.stop()
+        if ret_code == 0:
+            console.print(Rule("[bold green]Success"))
+            log(f"App packaged successfully: dist/{out_name}", style="bold green")
+        return ret_code
+
+    # Resolve output name and load settings
+    out_name, settings = resolve_package_metadata(script, args.name)
+
+    # --- Modular Build Pipeline ---
+    from ..pack.pipeline import BuildContext, Pipeline
+    from ..pack.modules import (
+        AssetModule,
+        EngineModule,
+        MetadataModule,
+        InstallerModule,
+        PluginModule,
+        HookModule,
+        IconModule,
+    )
+
+    # Initialize Context
+    ctx = BuildContext(
+        script=script,
+        out_name=out_name,
+        app_icon=args.icon,
+        settings=settings,
+        engine=args.engine or ("chrome" if args.chrome else None),
+        is_secure=args.secure,
+        is_nuitka=args.nuitka,
+        is_onefile=args.one_file,
+        progress=progress,
+        task_id=task,
+    )
+
+    # Pass through some CLI flags to context for module use
+    ctx.smart_assets = args.smart_assets
+    ctx.build_installer = args.installer
+    ctx.bundled = args.bundled
+    ctx.collect_all = getattr(args, "collect_all", False)
+    ctx.force_hooks = getattr(args, "force_hooks", False)
+    ctx.add_data = args.add_data or []
+
+    # --- Crystal Integrity Check ---
+    if getattr(args, "crystal", False):
+        from ..pack.crystal import AppAuditor
+
+        auditor = AppAuditor(script)
+        log(f"Running Crystal Integrity Check on {script}...", style="cyan")
+
+        # Run the audit (this generates requirements.lock.json)
+        manifest = auditor.run_audit()
+
+        if manifest:
+            # Inject discovered modules as hidden imports for the builder
+            discovered_modules = manifest.get("modules", [])
+            log(
+                f"Crystal detected {len(discovered_modules)} hidden dependencies.",
+                style="green",
+            )
+
+            current_hidden = settings.get("hidden_imports", [])
+            # Merge unique items
+            settings["hidden_imports"] = list(set(current_hidden + discovered_modules))
+
+            # Also ensure data files are tracked if needed (future expansion)
+            # data_files = manifest.get("files", [])
+
+    # Initialize Pipeline
+    pipeline = Pipeline(ctx)
+
+    # Add Modules
+    pipeline.add_module(IconModule())
+    pipeline.add_module(AssetModule())
+    pipeline.add_module(HookModule())
+    pipeline.add_module(EngineModule())
+    pipeline.add_module(
+        PluginModule()
+    )  # Important: Plugin module handles custom add_data
+
+    if args.secure and ctx.engine != "rust":
+        from ..pack.secure import SecurityModule
+
+        pipeline.add_module(SecurityModule())
+
+    if args.fortress:
+        try:
+            from fortress import FortressModule
+
+            pipeline.add_module(
+                FortressModule(
+                    use_cython=not args.no_cython,
+                    use_optimization=not args.no_shake,
+                    patch_from=args.patch_from,
+                )
+            )
+            log("Fortress Architecture enabled.", style="cyan")
+        except ImportError:
+            log(
+                "Error: 'pytron-fortress' package not found. Run 'pip install -e pytron-suite/fortress' to use this feature.",
+                style="error",
+            )
+            return 1
+
+    pipeline.add_module(MetadataModule())
+    pipeline.add_module(InstallerModule())
+
+    # Run Pipeline with Core Compiler
+    if ctx.engine == "rust":
+        from ..pack.rust_engine import RustEngine
+
+        rust_engine = RustEngine()
+        # Rust Engine handles the entire build process natively
+        ret_code = pipeline.run(rust_engine.build)
+
+    elif args.nuitka:
+        from ..pack.nuitka import run_nuitka_build
+
+        # TODO: Refactor Nuitka to use BuildContext too for full parity
+        # For now, we'll call it with a compatible shim if possible or just original args
+        # But let's prioritize PyInstaller for this refactor
+        ret_code = pipeline.run(run_nuitka_build)
+    else:
+        from ..pack.pyinstaller import run_pyinstaller_build
+
+        ret_code = pipeline.run(run_pyinstaller_build)
+
+    progress.stop()
+    if ret_code == 0:
+        console.print(Rule("[bold green]Success"))
+        log(f"App packaged successfully: dist/{ctx.out_name}", style="bold green")
+    return ret_code