Séquence l'installation des dépendances et borne PySide6 pour Python 3.11

Réorganise ensure_tools_installed() pour exécuter systématiquement l'installation des dépendances système avant l'installation des dépendances Python, afin d'éviter les lancements concurrents qui provoquaient des conflits entre gestionnaire système et pip.

En cas d'échec, d'impossibilité de démarrage ou de dépassement de délai sur la phase système, conserve désormais une journalisation explicite de l'erreur mais enchaîne quand même sur la phase Python. La méthode retourne toujours l'état global de la phase système via system_install_ok, ce qui permet de préserver le signal d'échec sans bloquer l'installation Python.

Ajoute un test unitaire dédié qui vérifie deux comportements clés : l'ordre d'exécution système puis Python, et la poursuite de l'installation Python après un timeout système.

Nettoie requirements.txt en supprimant les doublons PySide6/shiboken6 et en bornant explicitement les versions par branche de Python. Pour Python 3.11, la dépendance est limitée à la ligne 6.4.x (< 6.5) ; pour Python 3.12, la ligne 6.6-6.7 est conservée ; pour Python 3.13 et plus, la ligne 6.8+ reste autorisée. Une note a aussi été ajoutée pour documenter que la compatibilité avec des CPU anciens sans certaines extensions SIMD ne peut pas être garantie uniquement via les wheels PyPI.

Author: raidos23

EngineLoader/base.py

@@ -178,31 +178,9 @@ def ensure_tools_installed(self, gui) -> bool:
             tools = self.required_tools
             python_tools = tools.get("python", [])
             system_tools = tools.get("system", [])
-            missing_python: list[str] = []
-            use_system_python = False
-            python_venv_path = None
-            can_install_python = bool(
-                hasattr(gui, "venv_manager") and gui.venv_manager and python_tools
-            )
-
-            # Collect missing Python tools first; actual installation is executed after system phase.
-            if can_install_python:
-                use_system_python = bool(getattr(gui, "use_system_python", False))
-                if use_system_python:
-                    for tool in python_tools:
-                        if not gui.venv_manager.is_tool_installed_system(tool):
-                            missing_python.append(tool)
-                else:
-                    python_venv_path = gui.venv_manager.resolve_project_venv()
-                    if python_venv_path:
-                        for tool in python_tools:
-                            if not gui.venv_manager.is_tool_installed(
-                                python_venv_path, tool
-                            ):
-                                missing_python.append(tool)
+            system_install_ok = True
 
-            # Check and install system tools first to avoid concurrent installs.
-            system_phase_ok = True
+            # Check and install system tools first to avoid overlapping system/Python installs.
             if system_tools:
                 try:
                     # Import and use SysDependencyManager directly for full GUI support
@@ -259,7 +237,7 @@ def ensure_tools_installed(self, gui) -> bool:
                                             f"Échec installation outils système: {missing_system} (code: {process.exitCode()})",
                                             f"System tools installation failed: {missing_system} (code: {process.exitCode()})",
                                         )
-                                        system_phase_ok = False
+                                        system_install_ok = False
                                 else:
                                     _log_tools(
                                         gui,
@@ -268,7 +246,7 @@ def ensure_tools_installed(self, gui) -> bool:
                                         "Timeout lors de l'installation des outils système",
                                         "Timeout during system tools installation",
                                     )
-                                    system_phase_ok = False
+                                    system_install_ok = False
                             else:
                                 _log_tools(
                                     gui,
@@ -277,7 +255,7 @@ def ensure_tools_installed(self, gui) -> bool:
                                     "Impossible de démarrer l'installation des outils système",
                                     "Unable to start system tools installation",
                                 )
-                                system_phase_ok = False
+                                system_install_ok = False
 
                         elif system == "windows":
                             # Convert package names to winget format for Windows
@@ -326,7 +304,7 @@ def ensure_tools_installed(self, gui) -> bool:
                                                 f"Échec installation Windows: {missing_system}",
                                                 f"Windows installation failed: {missing_system}",
                                             )
-                                            system_phase_ok = False
+                                            system_install_ok = False
                                     else:
                                         _log_tools(
                                             gui,
@@ -335,7 +313,7 @@ def ensure_tools_installed(self, gui) -> bool:
                                             "Timeout lors de l'installation Windows",
                                             "Timeout during Windows installation",
                                         )
-                                        system_phase_ok = False
+                                        system_install_ok = False
                                 else:
                                     _log_tools(
                                         gui,
@@ -350,7 +328,7 @@ def ensure_tools_installed(self, gui) -> bool:
                                             "https://learn.microsoft.com/en-us/windows/package-manager/winget/"
                                         ]
                                     )
-                                    system_phase_ok = False
+                                    system_install_ok = False
                             else:
                                 _log_tools(
                                     gui,
@@ -367,7 +345,7 @@ def ensure_tools_installed(self, gui) -> bool:
                                 "Plateforme non supportée pour l'installation automatique",
                                 "Platform not supported for automatic installation",
                             )
-                            system_phase_ok = False
+                            system_install_ok = False
                     else:
                         _log_tools(
                             gui,
@@ -385,43 +363,43 @@ def ensure_tools_installed(self, gui) -> bool:
                         f"Erreur lors de la vérification/installation des outils système: {e}",
                         f"Error checking/installing system tools: {e}",
                     )
-                    system_phase_ok = False
-
-            if not system_phase_ok:
-                _log_tools(
-                    gui,
-                    "warning",
-                    "system",
-                    "Installation système incomplète/échouée; passage à l'installation Python.",
-                    "System installation failed/incomplete; continuing with Python installation.",
-                )
-
-            # Install Python tools only after system phase has ended.
-            if can_install_python and missing_python:
-                _log_tools(
-                    gui,
-                    "info",
-                    "python",
-                    f"Installation des outils Python manquants: {missing_python}",
-                    f"Installing missing Python tools: {missing_python}",
-                )
-                try:
-                    if use_system_python:
-                        gui.venv_manager.ensure_tools_installed_system(missing_python)
-                    elif python_venv_path:
-                        gui.venv_manager.ensure_tools_installed(
-                            python_venv_path, missing_python
+                    system_install_ok = False
+
+            # Check Python tools after the system phase, even if the system phase failed.
+            if hasattr(gui, "venv_manager") and gui.venv_manager and python_tools:
+                use_system = bool(getattr(gui, "use_system_python", False))
+                if use_system:
+                    missing_python = []
+                    for tool in python_tools:
+                        if not gui.venv_manager.is_tool_installed_system(tool):
+                            missing_python.append(tool)
+                    if missing_python:
+                        log_i18n_level(
+                            gui,
+                            "info",
+                            f"Installation des outils Python manquants: {missing_python}",
+                            f"Installing missing Python tools: {missing_python}",
                         )
-                except Exception as e:
-                    _log_tools(
-                        gui,
-                        "warning",
-                        "python",
-                        f"Erreur lors de l'installation des outils Python: {e}",
-                        f"Error during Python tools installation: {e}",
-                    )
+                        gui.venv_manager.ensure_tools_installed_system(missing_python)
+                else:
+                    venv_path = gui.venv_manager.resolve_project_venv()
+                    if venv_path:
+                        missing_python = []
+                        for tool in python_tools:
+                            if not gui.venv_manager.is_tool_installed(venv_path, tool):
+                                missing_python.append(tool)
+                        if missing_python:
+                            log_i18n_level(
+                                gui,
+                                "info",
+                                f"Installation des outils Python manquants: {missing_python}",
+                                f"Installing missing Python tools: {missing_python}",
+                            )
+                            gui.venv_manager.ensure_tools_installed(
+                                venv_path, missing_python
+                            )
 
-            return True
+            return system_install_ok
         except Exception as e:
             log_i18n_level(
                 gui,

requirements.txt

@@ -3,11 +3,21 @@
 # Use with constraints.txt for reproducible builds: pip install -r requirements.txt -c constraints.txt
 
 # Core GUI framework (Qt for Python)
-# PySide6/shiboken6 6.8+ adds Python 3.13 support. Keep 6.7.x for <=3.12.
-PySide6
-PySide6
-shiboken6
-shiboken6
+# Matrix:
+# - Python 3.11 => keep PySide6/shiboken6 < 6.5 as requested
+# - Python 3.12 => stay on the Qt 6.7 line for better stability
+# - Python >= 3.13 => PySide6/shiboken6 >= 6.8 (adds 3.13 support)
+# Note:
+# - I found official support for Python 3.11 on the 6.4 line.
+# - I did not find a reliable official source proving that a given PyPI wheel avoids SSE/SSE2/SSE4.x requirements.
+# - So the < 6.5 pin is a compatibility choice, not a hard guarantee for very old CPUs.
+# - On such machines, prefer distro packages or a source build of PySide6/shiboken6.
+PySide6>=6.8,<6.11; python_version >= "3.13"
+shiboken6>=6.8,<6.11; python_version >= "3.13"
+PySide6>=6.6,<6.8; python_version >= "3.12" and python_version < "3.13"
+shiboken6>=6.6,<6.8; python_version >= "3.12" and python_version < "3.13"
+PySide6>=6.4,<6.5; python_version >= "3.11" and python_version < "3.12"
+shiboken6>=6.4,<6.5; python_version >= "3.11" and python_version < "3.12"
 
 # System utilities
 psutil>=5.9.0,<6.0.0

tests/test_engine_tool_install_order.py

@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Ague Samuel Amen
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from EngineLoader.base import CompilerEngine
+
+
+class DummyProcess:
+    def __init__(self, wait_result: bool, exit_code: int) -> None:
+        self._wait_result = wait_result
+        self._exit_code = exit_code
+
+    def waitForFinished(self, _timeout: int) -> bool:
+        return self._wait_result
+
+    def exitCode(self) -> int:
+        return self._exit_code
+
+
+class DummySysDepsManager:
+    def __init__(self, events: list[str], process: DummyProcess) -> None:
+        self._events = events
+        self._process = process
+
+    def install_packages_linux(self, packages: list[str]):
+        self._events.append(f"system-install:{','.join(packages)}")
+        return self._process
+
+    def open_urls(self, _urls: list[str]) -> None:
+        self._events.append("open-urls")
+
+
+class DummyVenvManager:
+    def __init__(self, events: list[str]) -> None:
+        self._events = events
+
+    def resolve_project_venv(self) -> str:
+        return "/tmp/project/.venv"
+
+    def is_tool_installed(self, _venv_path: str, _tool: str) -> bool:
+        return False
+
+    def ensure_tools_installed(self, venv_path: str, tools: list[str]) -> None:
+        self._events.append(f"python-install:{venv_path}:{','.join(tools)}")
+
+
+class DummyGui:
+    def __init__(self, events: list[str]) -> None:
+        self.current_language = "fr"
+        self.log: list[str] = []
+        self.venv_manager = DummyVenvManager(events)
+        self.use_system_python = False
+
+
+class DummyEngine(CompilerEngine):
+    @property
+    def required_tools(self) -> dict[str, list[str]]:
+        return {"system": ["patchelf"], "python": ["nuitka"]}
+
+
+def test_ensure_tools_installed_runs_system_before_python(monkeypatch) -> None:
+    events: list[str] = []
+    process = DummyProcess(wait_result=True, exit_code=0)
+
+    import Core.sys_deps as sys_deps
+
+    monkeypatch.setattr(sys_deps, "check_system_packages", lambda _packages: False)
+    monkeypatch.setattr(
+        sys_deps,
+        "SysDependencyManager",
+        lambda gui: DummySysDepsManager(events, process),
+    )
+    monkeypatch.setattr("platform.system", lambda: "Linux")
+
+    gui = DummyGui(events)
+    engine = DummyEngine()
+
+    assert engine.ensure_tools_installed(gui) is True
+    assert events == [
+        "system-install:patchelf",
+        "python-install:/tmp/project/.venv:nuitka",
+    ]
+
+
+def test_ensure_tools_installed_continues_python_after_system_timeout(
+    monkeypatch,
+) -> None:
+    events: list[str] = []
+    process = DummyProcess(wait_result=False, exit_code=1)
+
+    import Core.sys_deps as sys_deps
+
+    monkeypatch.setattr(sys_deps, "check_system_packages", lambda _packages: False)
+    monkeypatch.setattr(
+        sys_deps,
+        "SysDependencyManager",
+        lambda gui: DummySysDepsManager(events, process),
+    )
+    monkeypatch.setattr("platform.system", lambda: "Linux")
+
+    gui = DummyGui(events)
+    engine = DummyEngine()
+
+    assert engine.ensure_tools_installed(gui) is False
+    assert events == [
+        "system-install:patchelf",
+        "python-install:/tmp/project/.venv:nuitka",
+    ]
+    assert any("Timeout" in msg or "timeout" in msg for msg in gui.log)