qyro-cli 1.0.0a1__py3-none-any.whl

qyro_cli/__main__.py

@@ -0,0 +1,29 @@
+"""
+Module entry point.
+
+Allows invoking the CLI directly via:
+
+    python -m qyro <command> [options]
+"""
+
+import sys
+
+from qyro_cli.cmdline import main
+
+
+def _configure_stdio() -> None:
+    """Use UTF-8 output when possible to avoid Windows codepage crashes."""
+    for stream_name in ("stdout", "stderr"):
+        stream = getattr(sys, stream_name, None)
+        reconfigure = getattr(stream, "reconfigure", None)
+        if callable(reconfigure):
+            try:
+                reconfigure(encoding="utf-8", errors="replace")
+            except Exception:
+                # Keep default stream settings if the runtime disallows reconfigure.
+                pass
+
+
+if __name__ == "__main__":
+    _configure_stdio()
+    sys.exit(main())

qyro_cli/adapters/cli/console_ui.py

@@ -0,0 +1,224 @@
+"""
+Concrete presentation adapter implementing UserInteractionPort
+using Rich and Questionary.
+"""
+
+import random
+from pathlib import Path
+from typing import Sequence
+
+import questionary
+from prompt_toolkit.styles import Style
+from rich.theme import Theme
+from rich.align import Align
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+from rich.text import Text
+
+QUESTIONARY_STYLE = Style([
+    ("qmark", "fg:#c08457 bold"),
+    ("question", "fg:#f1f5f9 bold"),
+    ("answer", "fg:#fdba74 bold"),
+    ("pointer", "fg:#fb923c bold"),
+    ("highlighted", "fg:#fb923c bg:default bold"), 
+    ("selected", "fg:#fdba74 bg:default"),
+    ("instruction", "fg:#9ca3af"),
+])
+
+
+custom_theme = Theme(
+    {
+        "prompt.choices": "bold white",
+        "prompt.default": "bold #ff8c00",
+    }
+)
+class RichConsoleUI:
+    def __init__(self, console: Console | None = None):
+        self._console = console or Console(
+            force_terminal=True,
+            color_system="truecolor",
+            theme=custom_theme,
+        )
+
+    def _ascii_fallback(self, message: str) -> str:
+        safe = (
+            message
+            .replace("⏳", "...")
+            .replace("💔", "Error")
+            .replace("🚀", "*")
+            .replace("✓", "OK")
+            .replace("⚠️", "WARN")
+            .replace("⚠", "WARN")
+        )
+        return safe.encode("ascii", errors="replace").decode("ascii")
+
+    def _print(self, renderable: object) -> None:
+        try:
+            self._console.print(renderable)
+        except UnicodeEncodeError:
+            if isinstance(renderable, str):
+                self._console.print(self._ascii_fallback(renderable))
+                return
+            raise
+
+    def welcome(self) -> None:
+        messages = [
+            "What are we building today?",
+            "What will you build today?",
+            "Let's build something great.",
+            "Your next project starts here.",
+        ]
+
+        message = random.choice(messages)
+        directory = Path.cwd().name
+
+        logo = Text(
+            "\n"
+            " ██████╗ ██╗   ██╗██████╗  ██████╗\n"
+            "██╔═══██╗╚██╗ ██╔╝██╔══██╗██╔═══██╗\n"
+            "██║   ██║ ╚████╔╝ ██████╔╝██║   ██║\n"
+            "██║▄▄ ██║  ╚██╔╝  ██╔══██╗██║   ██║\n"
+            "╚██████╔╝   ██║   ██║  ██║╚██████╔╝\n"
+            " ╚══▀▀═╝    ╚═╝   ╚═╝  ╚═╝ ╚═════╝\n",
+            style="bold #ff8c00",
+        )
+
+        title = Text(message, style="bold white")
+        subtitle = Text(
+            f"Creating your next application in {directory}/",
+            style="dim",
+        )
+
+        content = Group(
+            Align.center(logo),
+            Align.center(title),
+            Align.center(subtitle),
+        )
+
+        self._console.print(
+            Panel(
+                content,
+                border_style="#ff8c00",
+                padding=(1, 4),
+            )
+        )
+
+    def ask_text(
+        self,
+        prompt: str,
+        default: str = "",
+        show_default: bool = True,
+    ) -> str:
+        return Prompt.ask(
+            f"[bold]{prompt}[/bold]",
+            default=default,
+            show_default=show_default,
+            console=self._console
+        )
+
+    def ask_choice(
+        self,
+        prompt: str,
+        choices: Sequence[str],
+        default: str = "",
+    ) -> str:
+        options = list(choices)
+
+        if not options:
+            return default
+
+        answer = questionary.select(
+            prompt,
+            choices=options,
+            default=default or options[0],
+            style=QUESTIONARY_STYLE,
+        ).ask()
+
+        if answer is None:
+            raise KeyboardInterrupt
+
+        return answer
+
+    def ask_multi_choice(
+        self,
+        prompt: str,
+        choices: Sequence[str],
+    ) -> list[str]:
+        answer = questionary.checkbox(
+            prompt,
+            choices=[
+                questionary.Choice(
+                    choice,
+                    value=choice,
+                    checked=False,
+                )
+                for choice in choices
+            ],
+            style=QUESTIONARY_STYLE,
+        ).ask()
+
+        if answer is None:
+            raise KeyboardInterrupt
+
+        return answer
+
+    def confirm(
+        self,
+        prompt: str,
+        default: bool = True,
+    ) -> bool:
+        return Confirm.ask(
+            f"[bold #fff]{prompt}[/bold #fff]",
+            default=default,
+            console=self._console,
+        )
+
+    def show_summary(
+        self,
+        title: str,
+        fields: dict[str, str],
+    ) -> None:
+        table = Table(
+            title="Project Configuration",
+            show_header=False,
+            box=None,
+        )
+
+        for label, value in fields.items():
+            table.add_row(
+                f"{label}:",
+                f"[#fdba74]{value}[/#fdba74]",
+            )
+
+        self._console.print(
+            Panel(
+                table,
+                title=f"[bold]{title}[/bold]",
+                border_style="#ff8c00",
+            )
+        )
+
+    def info(self, message: str) -> None:
+        self._print(message)
+
+    def success(self, message: str) -> None:
+        self._print(
+            f"[bold #fff]{message}[/bold #fff]"
+        )
+
+    def warning(self, message: str) -> None:
+        self._print(
+            f"[#fdba74]{message}[/#fdba74]"
+        )
+
+    def progress(self, message: str) -> None:
+        self._print(
+            f"[#fdba74]⏳ {message}[/#fdba74]"
+        )
+
+    def error(self, message: str) -> None:
+        self._print(
+            f"\n💔 [bold red]Error:[/bold red] {message}"
+        )

qyro_cli/adapters/cli/progress.py

@@ -0,0 +1,46 @@
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+
+
+class RichProgress:
+    def __init__(self, console: Console | None = None):
+        self._progress = Progress(
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TimeRemainingColumn(),
+            console=console,
+        )
+        self._task_id = None
+
+    def start(
+        self,
+        message: str,
+        total: int | None = None,
+    ) -> None:
+        self._task_id = self._progress.add_task(
+            message,
+            total=total,
+        )
+        self._progress.start()
+
+    def update(self, completed: int) -> None:
+        if self._task_id is not None:
+            self._progress.update(
+                self._task_id,
+                completed=completed,
+            )
+
+    def stop(self) -> None:
+        if self._task_id is not None:
+            self._progress.stop()
+            self._progress.remove_task(self._task_id)
+            self._task_id = None

qyro_cli/adapters/freeze/__init__.py

@@ -0,0 +1,6 @@
+"""qyro.adapters.freeze package."""
+from qyro_cli.adapters.freeze.framework_hooks import FrameworkHookResolver
+from qyro_cli.adapters.freeze.optimizer import BinaryOptimizer
+from qyro_cli.adapters.freeze.pyinstaller_adapter import PyInstallerFreezer
+
+__all__ = ["FrameworkHookResolver", "BinaryOptimizer", "PyInstallerFreezer"]

qyro_cli/adapters/freeze/framework_hooks.py

@@ -0,0 +1,352 @@
+
+"""
+qyro.adapters.freeze.framework_hooks
+Framework-specific resolution hooks for Qyro's Freeze system.
+Handles PyQt5, PyQt6, PySide2, PySide6, Kivy, Tkinter hidden imports and resource data,
+integrating with Qyro's domain Binding and Project entities.
+"""
+
+from pathlib import Path
+from typing import Callable, List
+
+from qyro_cli.application.ports import FrameworkHookResolverPort
+from qyro_cli.domain.build import FreezeManifest
+from qyro_cli.domain.project import Binding, AddonModule
+
+
+class FrameworkHookResolver(FrameworkHookResolverPort):
+    """
+    Intelligently inspects project files and domain Binding to resolve:
+    - PyInstaller hidden imports
+    - Collect data / resource paths
+    - Binary dependencies (SDL2, GLEW, etc. for Kivy)
+    - Plugin directories for Qt family
+    - Common project settings and assets
+    """
+
+    def resolve_args(
+        self,
+        project_root: Path,
+        manifest: FreezeManifest,
+    ) -> List[str]:
+        args: List[str] = []
+
+        binding = Binding.parse(manifest.binding)
+
+        resolvers: dict[Binding, Callable[[Path, FreezeManifest], List[str]]] = {
+            Binding.PYSIDE6: self._resolve_pyside6,
+            Binding.PYQT6: self._resolve_pyqt6,
+            Binding.PYQT5: self._resolve_pyqt5,
+            Binding.PYSIDE2: self._resolve_pyside2,
+            Binding.KIVY: self._resolve_kivy,
+            Binding.TKINTER: self._resolve_tkinter,
+        }
+
+        resolver = resolvers.get(binding)
+
+        if resolver:
+            args.extend(resolver(project_root, manifest))
+
+        args.extend(self._resolve_competing_framework_exclusions(binding, manifest))
+
+        args.extend(self._resolve_addons(manifest))
+        args.extend(self._resolve_project_assets(project_root, manifest))
+
+        return args
+
+    def _resolve_qt(
+        self,
+        package: str,
+        *,
+        sip: bool = False,
+    ) -> List[str]:
+        args = [
+            "--hidden-import", package,
+            "--hidden-import", f"{package}.QtCore",
+            "--hidden-import", f"{package}.QtGui",
+            "--hidden-import", f"{package}.QtWidgets",
+        ]
+
+        if package == "PySide6":
+            args.extend(["--exclude-module", "PySide6.scripts"])
+
+        if package == "PySide2":
+            args.extend(["--exclude-module", "PySide2.scripts"])
+
+        if package == "PyQt6":
+            args.extend(["--exclude-module", "PyQt6.scripts"])
+
+        if package == "PyQt5":
+            args.extend(["--exclude-module", "PyQt5.scripts"])
+
+        if sip:
+            args.extend(["--hidden-import", f"{package}.sip"])
+
+        return args
+
+    def _resolve_pyside6(
+        self,
+        project_root: Path,
+        manifest: FreezeManifest,
+    ) -> List[str]:
+        args = self._resolve_qt("PySide6")
+
+        # Check for QML / Quick in project only if not explicitly excluded
+        user_excludes = {m.lower() for m in manifest.optimization.exclude_modules}
+        if self._has_qml(project_root):
+            if "pyside6.qtquick" not in user_excludes:
+                args.extend(["--hidden-import", "PySide6.QtQuick"])
+            if "pyside6.qtqml" not in user_excludes:
+                args.extend(["--hidden-import", "PySide6.QtQml"])
+
+        return args
+
+    def _resolve_pyqt6(
+        self,
+        project_root: Path,
+        manifest: FreezeManifest,
+    ) -> List[str]:
+        return self._resolve_qt("PyQt6", sip=True)
+
+    def _resolve_pyqt5(
+        self,
+        project_root: Path,
+        manifest: FreezeManifest,
+    ) -> List[str]:
+        return self._resolve_qt("PyQt5", sip=True)
+
+    def _resolve_pyside2(
+        self,
+        project_root: Path,
+        manifest: FreezeManifest,
+    ) -> List[str]:
+        args = self._resolve_qt("PySide2")
+        args.extend(["--collect-all", "PySide2", "--collect-all", "shiboken2"])
+        return args
+
+    def _resolve_kivy(
+        self,
+        project_root: Path,
+        manifest: FreezeManifest,
+    ) -> List[str]:
+        args = [
+            "--hidden-import", "kivy",
+            "--hidden-import", "kivy.app",
+            "--hidden-import", "kivy.uix",
+            "--hidden-import", "kivy.factory",
+            "--hidden-import", "kivy.lang",
+            "--hidden-import", "kivy.lang.builder",
+            "--hidden-import", "kivy.core.window",
+            "--hidden-import", "kivy.core.window.window_sdl2",
+            "--hidden-import", "kivy.core.text",
+            "--hidden-import", "kivy.core.text.text_sdl2",
+            "--hidden-import", "kivy.core.image",
+            "--hidden-import", "kivy.core.image.img_sdl2",
+            "--hidden-import", "kivy.core.clipboard.clipboard_sdl2",
+            "--hidden-import", "kivy.graphics",
+            "--hidden-import", "kivy.graphics.cgl",
+            "--hidden-import", "kivy.graphics.cgl_backend.cgl_glew",
+            "--collect-data", "kivy",
+        ]
+
+        # Scan and bundle .kv files (Kivy declarative layout files)
+        kv_patterns = [
+            "*.kv",
+            "views/**/*.kv",
+            "components/**/*.kv",
+        ]
+
+        collected_kv: set[str] = set()
+
+        for pattern in kv_patterns:
+            for path in project_root.glob(pattern):
+                if not path.is_file():
+                    continue
+
+                relative = path.relative_to(project_root)
+                source = path.resolve().as_posix()
+                destination = relative.parent.as_posix()
+
+                if destination == ".":
+                    destination = "."
+
+                collected_kv.add(
+                    f"{source}{self._data_separator(manifest)}{destination}"
+                )
+
+        for item in sorted(collected_kv):
+            args.extend(["--add-data", item])
+
+        # Attach Qyro's bundled Kivy runtime hook to set custom window icon
+        kivy_rthook = Path(__file__).parent / "hooks" / "rthook_kivy_icon.py"
+        if kivy_rthook.exists():
+            args.extend(["--runtime-hook", kivy_rthook.as_posix()])
+
+        return args
+
+    def _resolve_tkinter(
+        self,
+        project_root: Path,
+        manifest: FreezeManifest,
+    ) -> List[str]:
+        args = [
+            "--hidden-import", "_tkinter",
+            "--hidden-import", "tkinter",
+            "--hidden-import", "tkinter.ttk",
+            "--hidden-import", "tkinter.messagebox",
+            "--hidden-import", "tkinter.filedialog",
+            "--collect-data", "tkinter",
+        ]
+
+        import sys
+        sep = self._data_separator(manifest)
+        py_prefix = Path(sys.prefix)
+
+        tcl_tk_candidates = [
+            (py_prefix / "lib" / "tcl8.6", "tcl8.6"),
+            (py_prefix / "lib" / "tk8.6", "tk8.6"),
+            (py_prefix / "lib" / "tcl8.5", "tcl8.5"),
+            (py_prefix / "lib" / "tk8.5", "tk8.5"),
+            (py_prefix / "tcl", "tcl"),
+            (py_prefix / "tk", "tk"),
+        ]
+
+        for src_path, target_name in tcl_tk_candidates:
+            if src_path.is_dir():
+                args.extend(["--add-data", f"{src_path.as_posix()}{sep}{target_name}"])
+
+        return args
+
+    def _resolve_addons(
+        self,
+        manifest: FreezeManifest,
+    ) -> List[str]:
+        """Resolves PyInstaller args for registered addons."""
+        args: List[str] = []
+        addons = {str(addon).lower() for addon in (manifest.addons or [])}
+
+        if AddonModule.REQUESTS.value.lower() in addons:
+            args.extend([
+                "--hidden-import", "requests",
+                "--hidden-import", "urllib3",
+                "--hidden-import", "certifi",
+                "--collect-data", "certifi",
+            ])
+
+        if "kivymd" in addons:
+            args.extend([
+                "--hidden-import", "kivymd",
+                "--hidden-import", "kivymd.app",
+                "--hidden-import", "kivymd.uix",
+                "--collect-data", "kivymd",
+            ])
+
+        if "plyer" in addons:
+            args.extend([
+                "--hidden-import", "plyer",
+                "--hidden-import", "plyer.platforms",
+            ])
+
+        return args
+
+    def _resolve_project_assets(
+        self,
+        project_root: Path,
+        manifest: FreezeManifest,
+    ) -> List[str]:
+        args: List[str] = []
+        sep = self._data_separator(manifest)
+
+        resources_dir_name = manifest.resources_dir or "resources"
+        resources_path = (project_root / resources_dir_name).resolve()
+
+        if resources_path.is_dir():
+            # If resources/base exists, include platform profiles
+            base_dir = resources_path / "base"
+            if base_dir.is_dir():
+                # Add base resources
+                args.extend(["--add-data", f"{base_dir.as_posix()}{sep}{resources_dir_name}"])
+
+                # Add platform-specific resources if present
+                plat = manifest.target_platform.lower()
+                plat_dir = None
+                if plat in ("mac", "macos", "darwin"):
+                    plat_dir = resources_path / "mac"
+                elif plat == "windows":
+                    plat_dir = resources_path / "windows"
+                elif plat == "linux":
+                    plat_dir = resources_path / "linux"
+
+                if plat_dir and plat_dir.is_dir():
+                    args.extend(["--add-data", f"{plat_dir.as_posix()}{sep}{resources_dir_name}"])
+            else:
+                # Flat resources directory
+                args.extend([
+                    "--add-data",
+                    f"{resources_path.as_posix()}{sep}{resources_dir_name}",
+                ])
+
+        settings_path = (project_root / "settings").resolve()
+        if settings_path.is_dir():
+            args.extend([
+                "--add-data",
+                f"{settings_path.as_posix()}{sep}settings",
+            ])
+
+        return args
+
+    def _data_separator(self, manifest: FreezeManifest) -> str:
+        return ";" if manifest.target_platform == "windows" else ":"
+
+    def _has_qml(self, project_root: Path) -> bool:
+        # Avoid detecting .qml in build directories or virtual environments
+        for path in project_root.rglob("*.qml"):
+            rel_parts = path.relative_to(project_root).parts
+            if any(part in ("build", "dist", ".git", ".venv", "venv", "temp") for part in rel_parts):
+                continue
+            return True
+        return False
+
+    def _resolve_competing_framework_exclusions(
+        self,
+        binding: Binding,
+        manifest: FreezeManifest,
+    ) -> List[str]:
+        """
+        Automatically excludes competing UI framework packages from PyInstaller scanning
+        so users never need to manually list 'kivy', 'kivy_install', etc. in exclude_modules.
+        """
+        exclusions: List[str] = []
+        user_excludes = {m.lower() for m in manifest.optimization.exclude_modules}
+
+        # If active binding is Qt-based (PySide6, PyQt6, PyQt5, PySide2)
+        if binding.is_pyside or binding in (Binding.PYQT6, Binding.PYQT5):
+            competing = ["kivy", "kivy_install", "tkinter"]
+            if binding != Binding.PYSIDE6:
+                competing.append("PySide6")
+            if binding != Binding.PYQT6:
+                competing.append("PyQt6")
+            if binding != Binding.PYQT5:
+                competing.append("PyQt5")
+            if binding != Binding.PYSIDE2:
+                competing.append("PySide2")
+
+            for mod in competing:
+                if mod.lower() not in user_excludes:
+                    exclusions.extend(["--exclude-module", mod])
+
+        # If active binding is Kivy
+        elif binding == Binding.KIVY:
+            competing = ["PySide6", "PyQt6", "PyQt5", "PySide2", "tkinter"]
+            for mod in competing:
+                if mod.lower() not in user_excludes:
+                    exclusions.extend(["--exclude-module", mod])
+
+        # If active binding is Tkinter
+        elif binding == Binding.TKINTER:
+            competing = ["kivy", "kivy_install", "PySide6", "PyQt6", "PyQt5", "PySide2"]
+            for mod in competing:
+                if mod.lower() not in user_excludes:
+                    exclusions.extend(["--exclude-module", mod])
+
+        return exclusions