pytron-kit 0.3.12__py3-none-win_amd64.whl

pytron/apputils/windows.py

@@ -0,0 +1,286 @@
+import os
+import sys
+import shutil
+import inspect
+import asyncio
+from ..webview import Webview
+
+
+class WindowMixin:
+    def create_window(self, **kwargs):
+        if "url" in kwargs and not getattr(sys, "frozen", False):
+            if not kwargs["url"].startswith(("http:", "https:", "file:")):
+                if not os.path.isabs(kwargs["url"]):
+                    kwargs["url"] = os.path.join(self.app_root, kwargs["url"])
+        window_config = self.config.copy()
+        window_config.update(kwargs)
+        window_config["__app__"] = self
+        # Only navigate if a URL was explicitly provided, or if this is the first (main) window
+        target_url = kwargs.get("url")
+        if target_url is None and not self.windows:
+            target_url = self.config.get("url")
+
+        window_config["navigate_on_init"] = False
+
+        # Engine Selection
+        if getattr(self, "engine", "native") == "chrome":
+            from ..engines.chrome.engine import ChromeWebView
+
+            window = ChromeWebView(config=window_config)
+        else:
+            window = Webview(config=window_config)
+
+        self.windows.append(window)
+        for name, data in self._exposed_functions.items():
+            func = data["func"]
+            secure = data["secure"]
+            run_in_thread = data.get("run_in_thread", True)
+            if isinstance(func, type):
+                try:
+                    window.expose(func)
+                except Exception as e:
+                    self.logger.debug(f"Failed to expose class {name}: {e}")
+                    window.bind(name, func, secure=secure, run_in_thread=run_in_thread)
+            else:
+                window.bind(name, func, secure=secure, run_in_thread=run_in_thread)
+
+        if target_url:
+            window.navigate(target_url)
+        if window_config.get("center", True):
+            window.center()
+
+        icon = window_config.get("icon")
+        if icon:
+            # Resolve icon path relative to app root or via resource_path
+            from ..core import get_resource_path
+
+            resolved_icon = get_resource_path(icon)
+
+            # If not found in resource path, check script dir fallback
+            if not os.path.exists(resolved_icon):
+                resolved_icon = os.path.join(self.app_root, icon)
+
+            # If it's a PNG, check if a converted .ico exists (from packaging)
+            if resolved_icon.lower().endswith(".png"):
+                ico_path = resolved_icon.rsplit(".", 1)[0] + ".ico"
+                if os.path.exists(ico_path):
+                    resolved_icon = ico_path
+
+            if os.path.exists(resolved_icon):
+                self.logger.debug(f"Runtime: Applying window icon from {resolved_icon}")
+                window.set_icon(resolved_icon)
+            else:
+                self.logger.warning(f"Runtime: Icon file not found: {icon}")
+
+        # --- Native Drag & Drop Hook ---
+        if hasattr(self, "_on_file_drop_callback") and self._on_file_drop_callback:
+            try:
+                if sys.platform == "win32":
+
+                    # We wrap the callback to pass the window object as first arg
+                    def _drop_wrapper(files):
+                        self.thread_pool.submit(
+                            self._on_file_drop_callback, window, files
+                        )
+
+                    # Native Drag & Drop Hook
+                    # Switched to JS-based approach for simplicity and stability
+                    # if self._on_file_drop_callback:
+                    #     enable_drag_drop_safe(window.w, _drop_wrapper)
+                elif sys.platform == "linux":
+
+                    def _drop_wrapper(files):
+                        self.thread_pool.submit(
+                            self._on_file_drop_callback, window, files
+                        )
+
+                    # Native Drag & Drop Hook
+                    # Switched to JS-based approach for simplicity and stability
+                    # if self._on_file_drop_callback:
+                    #     enable_drag_drop(window.w, _drop_wrapper)
+                elif sys.platform == "darwin":
+                    # TODO: Implement Cocoa/NSDraggingInfo handling
+                    self.logger.warning(
+                        "Native Drag & Drop not yet implemented for macOS."
+                    )
+            except Exception as e:
+                self.logger.warning(f"Failed to enable Native Drag & Drop: {e}")
+
+        return window
+
+    def run(self, **kwargs):
+        self.is_running = True
+        if "storage_path" not in kwargs:
+            kwargs["storage_path"] = self.storage_path
+
+        if sys.platform == "win32" and "storage_path" in kwargs:
+            os.environ["WEBVIEW2_USER_DATA_FOLDER"] = kwargs["storage_path"]
+
+        if not self.windows:
+            self.create_window()
+
+        if len(self.windows) > 0:
+            # Only attempt to close PyInstaller splash if we are in a PyInstaller-managed environment
+            if sys.platform == "win32":
+                try:
+                    import pyi_splash
+
+                    if pyi_splash.is_alive():
+                        pyi_splash.close()
+                        self.logger.info("Closed PyInstaller splash screen.")
+                except (ImportError, Exception):
+                    # Not in a PyInstaller frozen environment with splash
+                    pass
+
+            for combo, func in self.shortcuts.items():
+                self.shortcut_manager.register(combo, func)
+
+            if self.tray:
+                self.tray.start(self)
+
+            # Dispatch pending deep link (Cold Start)
+            if hasattr(self, "state") and self.state.launch_url:
+                url = self.state.launch_url
+                if hasattr(self, "router"):
+                    self.router.dispatch(url)
+                # Also notify the main window
+                if self.windows:
+                    self.windows[0].emit("pytron:deep-link", {"url": url})
+
+            self.windows[0].start()
+
+        self.is_running = False
+
+        for callback in self._on_exit_callbacks:
+            try:
+                if inspect.iscoroutinefunction(callback):
+                    # For async callbacks, run them in the background loop
+                    # and wait for them to finish before proceeding
+                    future = asyncio.run_coroutine_threadsafe(callback(), self.loop)
+                    try:
+                        future.result(timeout=5)  # 5-second timeout for cleanup
+                    except Exception as e:
+                        self.logger.error(
+                            f"Async on_exit callback timed out or failed: {e}"
+                        )
+                else:
+                    callback()
+            except Exception as e:
+                self.logger.error(f"Error in on_exit callback: {e}")
+
+        if self.tray:
+            self.tray.stop()
+        self.shortcut_manager.stop()
+
+        if self.config.get("debug", False) and "storage_path" in kwargs:
+            path = kwargs["storage_path"]
+            if os.path.isdir(path):
+                try:
+                    shutil.rmtree(path, ignore_errors=True)
+                except Exception as e:
+                    self.logger.debug(f"Failed to cleanup temp dir {path}: {e}")
+
+    def register_protocol(self, scheme="pytron"):
+        if not getattr(sys, "frozen", False):
+            self.logger.info(
+                f"Skipping protocol registration '{scheme}://' in Development Mode."
+            )
+            return False
+
+        try:
+            # Use the platform implementation from the webview instance if it exists
+            # otherwise fall back to detection (Webview creates the correct impl on init)
+            impl = self._platform if hasattr(self, "_platform") else None
+
+            if not impl:
+                # Fallback detection for App level calls before windows are created
+                import platform
+
+                sys_plat = platform.system()
+                if sys_plat == "Windows":
+                    from ..platforms.windows import WindowsImplementation
+
+                    impl = WindowsImplementation()
+                elif sys_plat == "Linux":
+                    from ..platforms.linux import LinuxImplementation
+
+                    impl = LinuxImplementation()
+                elif sys_plat == "Darwin":
+                    from ..platforms.darwin import DarwinImplementation
+
+                    impl = DarwinImplementation()
+
+            if impl and impl.register_protocol(scheme):
+                self.logger.info(f"Successfully registered protocol: {scheme}://")
+            else:
+                self.logger.warning(
+                    f"Failed to register protocol: {scheme}:// (Not supported or failed on this OS)"
+                )
+        except Exception as e:
+            self.logger.error(f"Error registering protocol: {e}")
+
+    def broadcast(self, event_name, data):
+        if self.windows:
+            for window in self.windows:
+                try:
+                    window.emit(event_name, data)
+                except Exception as e:
+                    self.logger.warning(f"Failed to broadcast to window: {e}")
+
+    def emit_to(self, window_id, event_name, data):
+        """Send an event to a specific window by its ID."""
+        for window in self.windows:
+            if window.id == window_id:
+                window.emit(event_name, data)
+                return True
+        return False
+
+    def get_window(self, window_id):
+        """Find a window by its ID."""
+        for window in self.windows:
+            if window.id == window_id:
+                return window
+        return None
+
+    def emit(self, event_name, data):
+        self.broadcast(event_name, data)
+
+    def hide(self):
+        if self.windows:
+            for window in self.windows:
+                try:
+                    window.hide()
+                except Exception as e:
+                    self.logger.debug(f"Failed to hide window {window}: {e}")
+
+    def show(self):
+        if self.windows:
+            for window in self.windows:
+                try:
+                    window.show()
+                except Exception as e:
+                    self.logger.debug(f"Failed to show window {window}: {e}")
+
+    @property
+    def is_visible(self):
+        """Returns True if the primary window is visible."""
+        if self.windows:
+            return self.windows[0].is_visible()
+        return False
+
+    def notify(self, title, message, type="info", duration=5000):
+        if self.windows:
+            for window in self.windows:
+                try:
+                    window.notify(title, message, type, duration)
+                except Exception as e:
+                    self.logger.debug(f"Failed to notify window {window}: {e}")
+
+    def quit(self):
+        for window in self.windows:
+            window.close(force=True)
+
+    def set_menubar(self, menu_bar):
+        """Attaches a MenuBar to the primary window."""
+        if self.windows:
+            self.windows[0].set_menu(menu_bar)

pytron/cli.py

@@ -0,0 +1,384 @@
+"""Simple CLI for Pytron: run, init, package, and frontend build helpers.
+
+This implementation uses only the standard library so there are no extra
+dependencies. It provides convenience commands to scaffold a minimal app,
+run a Python entrypoint, run `pyinstaller` to package, and run frontend builds
+for frontend folders.
+"""
+
+from __future__ import annotations
+
+import argparse
+from .commands.init import cmd_init
+from .commands.run import cmd_run
+from .commands.package import cmd_package
+from .commands.build import cmd_build_frontend
+from .commands.info import cmd_info
+from .commands.install import cmd_install
+from .commands.uninstall import cmd_uninstall
+from .commands.show import cmd_show
+from .commands.plugin import cmd_plugin
+from .commands.frontend import cmd_frontend
+from .commands.login import cmd_login, cmd_logout
+from .commands.android import cmd_android
+from .commands.engine import cmd_engine
+from .commands.doctor import cmd_doctor
+from .commands.workflow import cmd_workflow
+from .commands.scan import cmd_scan
+from .console import log
+
+
+def build_parser() -> argparse.ArgumentParser:
+    # Base parser for shared arguments like --logger
+    base_parser = argparse.ArgumentParser(add_help=False)
+    base_parser.add_argument(
+        "--logger",
+        help="Enable file logging (provide path or defaults to pytron.log)",
+        nargs="?",
+        const="pytron.log",
+    )
+
+    parser = argparse.ArgumentParser(
+        prog="pytron", description="Pytron CLI", parents=[base_parser]
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    p_init = sub.add_parser(
+        "init", help="Scaffold a minimal Pytron app", parents=[base_parser]
+    )
+    p_init.add_argument("target", help="Target directory for scaffold")
+    p_init.add_argument(
+        "--template",
+        default="react",
+        help="Frontend template (react, vue, svelte, vanilla, etc.)",
+    )
+    p_init.add_argument(
+        "--provider",
+        choices=["npm", "yarn", "pnpm", "bun"],
+        default="npm",
+        help="JS Package Manager to use for scaffolding (default: npm)",
+    )
+    p_init.set_defaults(func=cmd_init)
+
+    p_install = sub.add_parser(
+        "install",
+        help="Install dependencies into project environment",
+        parents=[base_parser],
+    )
+    p_install.add_argument(
+        "packages",
+        nargs="*",
+        help="Packages to install (if empty, installs from requirements.json)",
+    )
+    p_install.add_argument(
+        "--plugin",
+        action="store_true",
+        help="Install as a plugin instead of a Python dependency",
+    )
+    p_install.set_defaults(func=cmd_install)
+
+    p_uninstall = sub.add_parser(
+        "uninstall",
+        help="Uninstall dependencies and remove from requirements.json",
+        parents=[base_parser],
+    )
+    p_uninstall.add_argument("packages", nargs="+", help="Packages to uninstall")
+    p_uninstall.set_defaults(func=cmd_uninstall)
+
+    p_show = sub.add_parser(
+        "show", help="Show installed packages", parents=[base_parser]
+    )
+    p_show.set_defaults(func=cmd_show)
+
+    p_login = sub.add_parser(
+        "login",
+        help="Securely store GitHub credentials for plugin installation",
+        parents=[base_parser],
+    )
+    p_login.set_defaults(func=cmd_login)
+
+    p_logout = sub.add_parser(
+        "logout",
+        help="Log out from GitHub and remove stored credentials",
+        parents=[base_parser],
+    )
+    p_logout.set_defaults(func=cmd_logout)
+
+    p_doctor = sub.add_parser(
+        "doctor", help="Check system dependencies", parents=[base_parser]
+    )
+    p_doctor.set_defaults(func=cmd_doctor)
+
+    p_scan = sub.add_parser(
+        "scan", help="Analyze dependency graph with ML Oracle", parents=[base_parser]
+    )
+    p_scan.add_argument("target", nargs="?", help="Target directory (default: current)")
+    p_scan.add_argument("--json", action="store_true", help="Dump graph to JSON")
+    p_scan.add_argument(
+        "--html", action="store_true", help="Generate interactive HTML graph"
+    )
+    p_scan.add_argument(
+        "--verbose", action="store_true", help="Show raw uncertainty zones"
+    )
+    p_scan.set_defaults(func=cmd_scan)
+
+    p_frontend = sub.add_parser(
+        "frontend",
+        help="Frontend commands proxy (runs '<provider> <args>' in the frontend folder)",
+        parents=[base_parser],
+    )
+    p_frontend.add_argument(
+        "--provider",
+        choices=["npm", "yarn", "pnpm", "bun"],
+        default="npm",
+        help="JS Package Manager to use (default: npm)",
+    )
+    p_frontend.add_argument(
+        "npm_args",
+        nargs=argparse.REMAINDER,
+        help="Arguments to pass to the provider (e.g., install, run dev, test)",
+    )
+    p_frontend.set_defaults(func=cmd_frontend)
+
+    p_run = sub.add_parser(
+        "run", help="Run a Python entrypoint script", parents=[base_parser]
+    )
+    p_run.add_argument(
+        "script", nargs="?", help="Path to Python script to run (default: app.py)"
+    )
+    p_run.add_argument(
+        "--dev",
+        action="store_true",
+        help="Enable dev mode (hot reload + frontend watch)",
+    )
+    p_run.add_argument(
+        "--no-build",
+        action="store_true",
+        help="Skip automatic frontend build before running",
+    )
+    p_run.add_argument("--engine", help="Browser engine to use (native)")
+    p_run.add_argument(
+        "--chrome", action="store_true", help="Shortcut for --engine chrome"
+    )
+    p_run.add_argument(
+        "extra_args",
+        nargs=argparse.REMAINDER,
+        help="Extra args to forward to script",
+        default=[],
+    )
+    p_run.set_defaults(func=cmd_run)
+
+    p_pkg = sub.add_parser(
+        "package", help="Package app using PyInstaller", parents=[base_parser]
+    )
+    p_pkg.add_argument(
+        "script", nargs="?", help="Python entrypoint to package (default: app.py)"
+    )
+
+    # General Options
+    grp_general = p_pkg.add_argument_group("General Options")
+    grp_general.add_argument("--name", help="Output executable name")
+    grp_general.add_argument("--icon", help="Path to app icon (.ico)")
+    grp_general.add_argument(
+        "--console", action="store_true", help="Show console window (debug mode)"
+    )
+    grp_general.add_argument(
+        "--add-data", nargs="*", help="Additional data to include (format: src;dest)"
+    )
+    grp_general.add_argument(
+        "--installer", action="store_true", help="Build NSIS installer after packaging"
+    )
+    grp_general.add_argument(
+        "--smart-assets",
+        action="store_true",
+        help="Enable auto-inclusion of smart assets (non-code files).",
+    )
+
+    # Engine Options
+    grp_engine = p_pkg.add_argument_group("Engine Options")
+    grp_engine.add_argument("--engine", help="Browser engine to use (native)")
+    grp_engine.add_argument(
+        "--chrome", action="store_true", help="Shortcut for --engine chrome"
+    )
+
+    # Build Strategy
+    grp_build = p_pkg.add_argument_group("Build Strategy")
+    grp_build.add_argument(
+        "--one-file",
+        action="store_true",
+        help="Package into a single executable file (default for Nuitka)",
+    )
+    grp_build.add_argument(
+        "--one-dir",
+        action="store_true",
+        help="Package into a directory (default for PyInstaller, faster build)",
+    )
+    grp_build.add_argument(
+        "--nuitka",
+        action="store_true",
+        help="Use Nuitka compiler instead of PyInstaller (Advanced, secure)",
+    )
+    grp_build.add_argument(
+        "--bundled",
+        action="store_true",
+        help="Enable grouping of library modules into app.bundle (Cleaner dist)",
+    )
+    grp_build.add_argument(
+        "--no-shake",
+        action="store_true",
+        help="Disable post-build optimization (Tree Shaking).",
+    )
+
+    # Hook Generation
+    grp_hooks = p_pkg.add_argument_group("Hook Generation")
+    grp_hooks.add_argument(
+        "--collect-all",
+        action="store_true",
+        help='Generate full "collect_all" hooks (larger builds).',
+    )
+    grp_hooks.add_argument(
+        "--force-hooks",
+        action="store_true",
+        help="Force generation of hooks using collect_submodules.",
+    )
+
+    # Security (Fortress/Rust)
+    grp_sec = p_pkg.add_argument_group("Security & Hardening")
+    grp_sec.add_argument(
+        "--secure",
+        action="store_true",
+        help="Enable Rust Bootloader (Protects source logic)",
+    )
+    grp_sec.add_argument(
+        "--fortress",
+        action="store_true",
+        help="Enable Fortress Architecture (Hardened Core + Static Shield)",
+    )
+    grp_sec.add_argument(
+        "--no-cython",
+        action="store_true",
+        help="Disable Cythonization during Fortress build.",
+    )
+    grp_sec.add_argument(
+        "--patch-from",
+        help="Generate a binary patch against a previous app.pytron payload",
+    )
+
+    p_pkg.set_defaults(func=cmd_package)
+
+    p_build = sub.add_parser(
+        "build-frontend",
+        help="Run frontend build in a frontend folder",
+        parents=[base_parser],
+    )
+    p_build.add_argument("folder", help="Frontend folder (contains package.json)")
+    p_build.set_defaults(func=cmd_build_frontend)
+
+    p_info = sub.add_parser("info", help="Show environment info", parents=[base_parser])
+    p_info.set_defaults(func=cmd_info)
+
+    # Plugin Management
+    p_plugin = sub.add_parser(
+        "plugin", help="Manage application plugins", parents=[base_parser]
+    )
+    plugin_sub = p_plugin.add_subparsers(dest="plugin_command")
+
+    # Plugin Install
+    p_plugin_inst = plugin_sub.add_parser(
+        "install", help="Install a plugin from GitHub"
+    )
+    p_plugin_inst.add_argument(
+        "identifier", help="username.repo.version (e.g. ghua8088.pytron-weather-plugin)"
+    )
+
+    # Plugin List
+    plugin_sub.add_parser("list", help="List installed plugins")
+
+    # Plugin Create
+    p_plugin_create = plugin_sub.add_parser("create", help="Scaffold a new plugin")
+    p_plugin_create.add_argument("name", help="Name of the plugin directory")
+
+    # Plugin Uninstall
+    p_plugin_uninst = plugin_sub.add_parser("uninstall", help="Remove a plugin")
+    p_plugin_uninst.add_argument("name", help="Directory name of the plugin to remove")
+
+    p_plugin.set_defaults(func=cmd_plugin)
+
+    p_android = sub.add_parser(
+        "android", help="Android build tools", parents=[base_parser]
+    )
+    p_android.add_argument(
+        "action",
+        choices=["init", "sync", "build", "run", "logcat", "reset"],
+        help="Action to perform",
+    )
+    p_android.add_argument(
+        "--force", action="store_true", help="Force overwrite during init"
+    )
+    p_android.add_argument(
+        "--native",
+        action="store_true",
+        help="Enable native extension cross-compilation (defaults to False)",
+    )
+    p_android.add_argument(
+        "--aab",
+        action="store_true",
+        help="Build Android App Bundle (.aab) for Google Play Store",
+    )
+    p_android.set_defaults(func=cmd_android)
+
+    p_workflow = sub.add_parser(
+        "workflow", help="CI/CD Workflow management", parents=[base_parser]
+    )
+    p_workflow.set_defaults(func=cmd_workflow)
+
+    # Engine Management
+    p_eng = sub.add_parser(
+        "engine",
+        help="Manage browser engines (Mojo Chrome, etc.)",
+        parents=[base_parser],
+    )
+    eng_sub = p_eng.add_subparsers(dest="engine_command")
+
+    pe_inst = eng_sub.add_parser("install", help="Install/Forge a browser engine")
+    pe_inst.add_argument("name", choices=["chrome"], help="Name of the engine")
+
+    p_eng.set_defaults(func=cmd_engine)
+
+    return parser
+
+
+from .exceptions import PytronError
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    # Initialize logger if requested
+    if getattr(args, "logger", None):
+        from .console import set_log_file
+
+        set_log_file(args.logger)
+
+    if not hasattr(args, "func"):
+        parser.print_help()
+        return 0
+    try:
+        return args.func(args)
+    except KeyboardInterrupt:
+        print("\nCancelled")
+        return 1
+    except PytronError as e:
+        log(str(e), style="error")
+        return 1
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc()
+        log(f"Unexpected error: {e}", style="error")
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pytron/commands/android.py

@@ -0,0 +1,28 @@
+import os
+import argparse
+from ..platforms.android.ops.init import init_android_project, reset_android_project
+from ..platforms.android.ops.sync import sync_android_project
+from ..platforms.android.ops.build import build_android_project
+from ..platforms.android.ops.run import run_android_project, run_logcat
+
+
+def cmd_android(args: argparse.Namespace) -> None:
+    action = args.action
+    project_root = os.getcwd()
+
+    if action == "init":
+        # args.force might not be present if not defined in parser, but usually it is for init
+        force = getattr(args, "force", False)
+        init_android_project(project_root, force=force)
+    elif action == "reset":
+        reset_android_project(project_root)
+    elif action == "sync":
+        native = getattr(args, "native", False)
+        sync_android_project(project_root, native=native)
+    elif action == "build":
+        is_aab = getattr(args, "aab", False)
+        build_android_project(project_root, is_aab=is_aab)
+    elif action == "run":
+        run_android_project(project_root)
+    elif action == "logcat":
+        run_logcat()