feat: consolidation de l'API build_command(context) pour tous les moteurs

Author: raidos23

Core/engine/base.py

@@ -90,41 +90,22 @@ def preflight(self, gui, file: str) -> bool:
         """Perform preflight checks and setup. Return True if OK, False to abort."""
         return True
 
-    def build_command(self, gui, file: str) -> list[str]:
-        """Return the full command list including the program at index 0."""
-        raise NotImplementedError
-
-    def build_command_from_context(self, context: "BuildContext") -> list[str]:
+    def build_command(self, context: "BuildContext") -> list[str]:
         """
         Return the full command list for a normalized build context.
 
-        Engines can override this method to support the new BuildContext-based
-        contract without depending on GUI state or source files such as
-        `ark.yml`/lock files. The default implementation is intentionally not
-        provided because legacy `build_command(gui, file)` implementations may
-        require UI state and would otherwise silently produce incomplete builds.
+        This is the primary entry point for command generation. Engines should
+        use the provided `context` for project settings and `self._config_overrides`
+        for engine-specific options.
         """
         raise NotImplementedError
 
-    def program_and_args(self, gui, file: str) -> Optional[tuple[str, list[str]]]:
-        """
-        Resolve the program (executable path) and its arguments for QProcess.
-        Default implementation splits build_command into program and args.
-        Return None to abort.
-        """
-        cmd = self.build_command(gui, file)
-        if not cmd:
-            return None
-        return cmd[0], cmd[1:]
-
-    def program_and_args_from_context(
-        self, context: "BuildContext"
-    ) -> Optional[tuple[str, list[str]]]:
+    def program_and_args(self, context: "BuildContext") -> Optional[tuple[str, list[str]]]:
         """
         Resolve the program and arguments for a normalized build context.
-        Default implementation splits `build_command_from_context`.
+        Default implementation splits `build_command`.
         """
-        cmd = self.build_command_from_context(context)
+        cmd = self.build_command(context)
         if not cmd:
             return None
         return cmd[0], cmd[1:]

Ui/Cli/discovery.py

@@ -255,7 +255,7 @@ def scaffold_engine(target_name: str, root_dir: str | None = None) -> dict[str,
                 '    required_core_version = "1.0.0"',
                 '    required_sdk_version = "1.0.0"',
                 "",
-                "    def build_command_from_context(self, context: BuildContext) -> list[str]:",
+                "    def build_command(self, context: BuildContext) -> list[str]:",
                 "        return [sys.executable, context.entry_point]",
             ]
         )

engines/cx_freeze/__init__.py

@@ -66,13 +66,22 @@ def preflight(self, gui, file: str) -> bool:
         """Preflight check - dependencies are handled automatically by required_tools."""
         return True
 
-    def build_command_from_context(self, context: BuildContext) -> list[str]:
+    def build_command(self, context: BuildContext) -> list[str]:
         """Build a cx_Freeze command line from a normalized build context."""
         cfg = getattr(self, "_config_overrides", {})
         if not isinstance(cfg, dict):
             cfg = {}
 
-        cmd = [sys.executable, "-m", "cx_Freeze"]
+        # Resolve executable (prefer venv if available)
+        python_exe = sys.executable
+        if hasattr(self, "_gui") and self._gui:
+            venv_manager = getattr(self._gui, "venv_manager", None)
+            if venv_manager:
+                venv_path = venv_manager.resolve_project_venv()
+                if venv_path:
+                    python_exe = venv_manager.python_path(venv_path)
+
+        cmd = [python_exe, "-m", "cx_Freeze"]
 
         windowed_enabled = bool(cfg.get("windowed", False))
         if hasattr(self, "_cx_windowed") and self._cx_windowed is not None:
@@ -112,107 +121,17 @@ def build_command_from_context(self, context: BuildContext) -> list[str]:
             if source and destination:
                 cmd.extend(["--include-files", f"{source}={destination}"])
 
-        cmd.extend(["--script", context.entry_point])
-        return cmd
-
-    def build_command(self, gui, file: str) -> list[str]:
-        """Build the CX_Freeze command line."""
-        try:
-            cfg = getattr(self, "_config_overrides", {})
-            if not isinstance(cfg, dict):
-                cfg = {}
-            venv_manager = getattr(gui, "venv_manager", None)
-
-            # Resolve venv python
-            if venv_manager:
-                venv_path = venv_manager.resolve_project_venv()
-                if venv_path:
-                    python_path = venv_manager.python_path(venv_path)
-                else:
-                    python_path = sys.executable
-            else:
-                python_path = sys.executable
-
-            # Start with python -m cx_Freeze
-            cmd = [python_path, "-m", "cx_Freeze"]
-
-            # Add options from UI
-            # Windowed mode (Windows only)
-            windowed = self._get_opt("windowed")
-            windowed_enabled = bool(cfg.get("windowed", False))
-            if windowed is not None:
-                windowed_enabled = bool(windowed.isChecked())
-            if windowed_enabled and platform.system() == "Windows":
-                cmd.extend(["--base", "Win32GUI"])
-
-            # Output directory
-            output_dir = self._get_input("output_dir")
-            output_dir_value = str(cfg.get("output_dir") or "").strip()
-            if output_dir and output_dir.text().strip():
-                output_dir_value = output_dir.text().strip()
-            if output_dir_value:
-                cmd.extend(["--target-dir", output_dir_value])
-
-            # Icon
-            selected_icon = ""
-            if hasattr(self, "_selected_icon") and self._selected_icon:
-                selected_icon = str(self._selected_icon).strip()
-            if not selected_icon:
-                selected_icon = str(cfg.get("selected_icon") or "").strip()
-            if selected_icon:
-                cmd.extend(["--icon", selected_icon])
-
-            # Target name
-            target_name = self._get_input("target_name")
-            target_name_value = str(cfg.get("target_name") or "").strip()
-            if target_name and target_name.text().strip():
-                target_name_value = target_name.text().strip()
-            if target_name_value:
-                cmd.extend(["--target-name", target_name_value])
-
-            # Debug / verbose
-            debug = self._get_opt("debug")
-            debug_enabled = bool(cfg.get("debug", False))
-            if debug is not None:
-                debug_enabled = bool(debug.isChecked())
-            if debug_enabled:
-                cmd.append("--debug")
-            verbose = self._get_opt("verbose")
-            verbose_enabled = bool(cfg.get("verbose", False))
-            if verbose is not None:
-                verbose_enabled = bool(verbose.isChecked())
-            if verbose_enabled:
-                cmd.append("--verbose")
-
-            # Auto-mapping args (mapping.json / auto builder)
+        # Auto-mapping args (mapping.json / auto builder)
+        if hasattr(self, "_gui") and self._gui:
             try:
-                auto_args = compute_auto_for_engine(gui, self.id)
+                auto_args = compute_auto_for_engine(self._gui, self.id)
                 if auto_args:
                     cmd.extend(auto_args)
             except Exception:
                 pass
 
-            # Add the target script
-            cmd.extend(["--script", file])
-
-            return cmd
-
-        except Exception as e:
-            try:
-                if hasattr(gui, "log"):
-                    log_with_level(
-                        gui, "error", f"Erreur construction commande CX_Freeze: {e}"
-                    )
-            except Exception:
-                pass
-            return []
-
-    def program_and_args(self, gui, file: str) -> Optional[tuple[str, list[str]]]:
-        """Return the program and args for QProcess."""
-        cmd = self.build_command(gui, file)
-        if not cmd:
-            return None
-        return cmd[0], cmd[1:]
+        cmd.extend(["--script", context.entry_point])
+        return cmd
 
     def environment(self) -> Optional[dict[str, str]]:
         """Return environment variables for the compilation process."""

engines/nuitka/__init__.py

@@ -72,28 +72,37 @@ def preflight(self, gui, file: str) -> bool:
         """Preflight check - dependencies are handled automatically by required_tools."""
         return True
 
-    def build_command_from_context(self, context: BuildContext) -> list[str]:
+    def build_command(self, context: BuildContext) -> list[str]:
         """Build a Nuitka command line from a normalized build context."""
         cfg = getattr(self, "_config_overrides", {})
         if not isinstance(cfg, dict):
             cfg = {}
 
-        cmd = [sys.executable, "-m", "nuitka"]
+        # Resolve executable (prefer venv if available)
+        python_exe = sys.executable
+        if hasattr(self, "_gui") and self._gui:
+            venv_manager = getattr(self._gui, "venv_manager", None)
+            if venv_manager:
+                venv_path = venv_manager.resolve_project_venv()
+                if venv_path:
+                    python_exe = venv_manager.python_path(venv_path)
+
+        cmd = [python_exe, "-m", "nuitka"]
 
         standalone_enabled = bool(cfg.get("standalone", False))
-        if hasattr(self, "_nuitka_standalone"):
+        if hasattr(self, "_nuitka_standalone") and self._nuitka_standalone is not None:
             standalone_enabled = bool(self._nuitka_standalone.isChecked())
         if standalone_enabled:
             cmd.append("--standalone")
 
         onefile_enabled = bool(cfg.get("onefile", False))
-        if hasattr(self, "_nuitka_onefile"):
+        if hasattr(self, "_nuitka_onefile") and self._nuitka_onefile is not None:
             onefile_enabled = bool(self._nuitka_onefile.isChecked())
         if onefile_enabled:
             cmd.append("--onefile")
 
         disable_console = bool(cfg.get("disable_console", False))
-        if hasattr(self, "_nuitka_disable_console"):
+        if hasattr(self, "_nuitka_disable_console") and self._nuitka_disable_console is not None:
             disable_console = bool(self._nuitka_disable_console.isChecked())
         if disable_console:
             cmd.append("--windows-disable-console")
@@ -107,8 +116,8 @@ def build_command_from_context(self, context: BuildContext) -> list[str]:
             cmd.append(f"--output-filename={output_name}")
 
         icon_path = str(context.icon or cfg.get("selected_icon") or "").strip()
-        if not icon_path:
-            icon_path = str(getattr(self, "_nuitka_selected_icon", "") or "").strip()
+        if not icon_path and hasattr(self, "_nuitka_selected_icon") and self._nuitka_selected_icon:
+            icon_path = str(self._nuitka_selected_icon).strip()
         if icon_path:
             cmd.append(f"--windows-icon-from-ico={icon_path}")
 
@@ -129,98 +138,17 @@ def build_command_from_context(self, context: BuildContext) -> list[str]:
             if source and destination:
                 cmd.append(f"--include-data-dir={source}={destination}")
 
-        cmd.append(context.entry_point)
-        return cmd
-
-    def build_command(self, gui, file: str) -> list[str]:
-        """Build the Nuitka command line."""
-        try:
-            cfg = getattr(self, "_config_overrides", {})
-            if not isinstance(cfg, dict):
-                cfg = {}
-
-            venv_manager = getattr(gui, "venv_manager", None)
-
-            # Resolve venv python
-            if venv_manager:
-                venv_path = venv_manager.resolve_project_venv()
-                if venv_path:
-                    python_path = venv_manager.python_path(venv_path)
-                else:
-                    python_path = sys.executable
-            else:
-                python_path = sys.executable
-
-            # Start with python -m nuitka
-            cmd = [python_path, "-m", "nuitka"]
-
-            # Standalone mode
-            standalone_enabled = bool(cfg.get("standalone", False))
-            if hasattr(self, "_nuitka_standalone"):
-                standalone_enabled = bool(self._nuitka_standalone.isChecked())
-            if standalone_enabled:
-                cmd.append("--standalone")
-
-            # Onefile mode
-            onefile_enabled = bool(cfg.get("onefile", False))
-            if hasattr(self, "_nuitka_onefile"):
-                onefile_enabled = bool(self._nuitka_onefile.isChecked())
-            if onefile_enabled:
-                cmd.append("--onefile")
-
-            # Windowed (no console)
-            disable_console = bool(cfg.get("disable_console", False))
-            if hasattr(self, "_nuitka_disable_console"):
-                disable_console = bool(self._nuitka_disable_console.isChecked())
-            if disable_console:
-                cmd.append("--windows-disable-console")
-
-            # Output directory
-            output_dir_value = str(cfg.get("output_dir") or "").strip()
-            if (
-                hasattr(self, "_nuitka_output_dir")
-                and self._nuitka_output_dir.text().strip()
-            ):
-                output_dir_value = self._nuitka_output_dir.text().strip()
-            if output_dir_value:
-                cmd.append(f"--output-dir={output_dir_value}")
-
-            # Icon
-            selected_icon = getattr(self, "_nuitka_selected_icon", None)
-            if not selected_icon:
-                selected_icon = cfg.get("selected_icon")
-            if selected_icon:
-                cmd.extend(["--windows-icon", selected_icon])
-
-            # Auto-mapping args (mapping.json / auto builder)
+        # Auto-mapping args (mapping.json / auto builder)
+        if hasattr(self, "_gui") and self._gui:
             try:
-                auto_args = compute_auto_for_engine(gui, self.id)
+                auto_args = compute_auto_for_engine(self._gui, self.id)
                 if auto_args:
                     cmd.extend(auto_args)
             except Exception:
                 pass
 
-            # Add the target file
-            cmd.append(file)
-
-            return cmd
-
-        except Exception as e:
-            try:
-                if hasattr(gui, "log"):
-                    log_with_level(
-                        gui, "error", f"Erreur construction commande Nuitka: {e}"
-                    )
-            except Exception:
-                pass
-            return []
-
-    def program_and_args(self, gui, file: str) -> Optional[tuple[str, list[str]]]:
-        """Return the program and args for QProcess."""
-        cmd = self.build_command(gui, file)
-        if not cmd:
-            return None
-        return cmd[0], cmd[1:]
+        cmd.append(context.entry_point)
+        return cmd
 
     def environment(self) -> Optional[dict[str, str]]:
         """Return environment variables for the compilation process."""