Amélioration des logs pip et correction de la boucle d'événements Qt en mode CLI

Author: raidos23

Core/Compiler/engine_runner.py

@@ -160,6 +160,7 @@ def run_engine_compile(
     context: BuildContext,
     engine_config: dict[str, Any] | None = None,
     gui: Any = None,
+    verbose: bool = False,
 ) -> dict[str, Any]:
     """
     Execute a compilation synchronously.
@@ -175,6 +176,7 @@ def run_engine_compile(
         engine_config: Optional per-engine config overrides (forwarded to
                        ``engine._config_overrides``).
         gui:           Optional GUI object.
+        verbose:       Whether to enable verbose logging.
 
     Returns:
         A result dict with success status, return code, command, stdout, stderr, and error message.
@@ -196,6 +198,7 @@ def _on_stderr(line: str):
         on_stdout=_on_stdout,
         on_stderr=_on_stderr,
         gui=gui,
+        verbose=verbose,
     )
 
     result["stdout"] = "\n".join(captured_stdout)
@@ -217,6 +220,7 @@ def run_engine_compile_streaming(
     on_stderr: Optional[Callable[[str], None]] = None,
     stop_signal: Optional[Callable[[], bool]] = None,
     gui: Any = None,
+    verbose: bool = False,
 ) -> dict[str, Any]:
     """
     Execute a compilation with real-time output streaming.
@@ -230,6 +234,7 @@ def run_engine_compile_streaming(
         on_stderr:     Callback for each line of stderr.
         stop_signal:   Optional callback that returns True if cancellation is requested.
         gui:           Optional GUI object to use instead of creating a bridge.
+        verbose:       Whether to enable verbose logging.
 
     Returns:
         A result dict.
@@ -258,11 +263,15 @@ def _log(fr, en):
         if gui:
             bridge = gui
         else:
+            from PySide6.QtCore import QObject
+            
             # We pass a dummy 'gui' object that supports log_i18n_level-like logging
-            class LogBridge:
-                def __init__(self, log_cb, workspace_path: Path):
+            class LogBridge(QObject):
+                def __init__(self, log_cb, workspace_path: Path, verbose: bool = False):
+                    super().__init__()
                     self.log_cb = log_cb
                     self.workspace_dir = str(workspace_path)
+                    self.verbose = verbose
                     self.log = self  # So gui.log.append works
                     self.use_system_python = False  # Default for CLI
                     self.venv_path_manuel = None
@@ -273,6 +282,11 @@ def append(self, message: str):
                     # message is already formatted by log_i18n_level
                     self.log_cb("", message)
 
+                def _safe_log(self, text, text_en=None, level=None):
+                    # Fallback for VenvManager
+                    msg = text_en if text_en else text
+                    self.log_cb("", msg)
+
                 def tr(self, fr, en):
                     return en  # Simple fallback
 
@@ -298,7 +312,7 @@ def sys_deps_manager(self):
                         self._sys_deps_manager = SysDependencyManager(self)
                     return self._sys_deps_manager
 
-            bridge = LogBridge(_log, workspace)
+            bridge = LogBridge(_log, workspace, verbose=verbose)
 
         # Link bridge to engine for venv/tool resolution in build_command
         try:

Core/Venv_Manager/Manager.py

@@ -484,7 +484,24 @@ def ensure_tools_installed(self, venv_root: str, tools: list[str]) -> None:
                 f"Verification de {tools[0]}...",
             )
             self._call_ui("update_progress_progress", "tools_check", 0, len(tools))
+            
+            # In CLI mode without a global event loop, we might need a local one
+            is_cli = getattr(self.parent, "verbose", False) or os.environ.get("PYCOMPILER_CLI") == "1"
+            loop = None
+            if is_cli:
+                from PySide6.QtCore import QCoreApplication, QEventLoop
+                if not QCoreApplication.instance():
+                    self._app_ref = QCoreApplication([]) # Keep alive
+                
+                loop = QEventLoop()
+                # We need a way to stop the loop when all tools are checked
+                self._venv_check_loop = loop
+            
             self._check_next_venv_pkg()
+            
+            if loop:
+                loop.exec()
+                self._venv_check_loop = None
         except Exception as e:
             self._safe_log(
                 f"[ERROR] {self._tools_stage_prefix()}Erreur ensure_tools_installed: {e}"
@@ -530,7 +547,23 @@ def ensure_tools_installed_system(self, tools: list[str]) -> None:
                 f"Verification de {tools[0]}...",
             )
             self._call_ui("update_progress_progress", "tools_check", 0, len(tools))
+            
+            # In CLI mode without a global event loop, we might need a local one
+            is_cli = getattr(self.parent, "verbose", False) or os.environ.get("PYCOMPILER_CLI") == "1"
+            loop = None
+            if is_cli:
+                from PySide6.QtCore import QCoreApplication, QEventLoop
+                if not QCoreApplication.instance():
+                    self._app_ref = QCoreApplication([]) # Keep alive
+                
+                loop = QEventLoop()
+                self._venv_check_loop = loop
+            
             self._check_next_venv_pkg()
+            
+            if loop:
+                loop.exec()
+                self._venv_check_loop = None
         except Exception as e:
             self._safe_log(
                 f"[ERROR] {self._tools_stage_prefix()}Erreur ensure_tools_installed_system: {e}"
@@ -918,6 +951,10 @@ def _check_next_venv_pkg(self):
         """Execute _check_next_venv_pkg logic for this component."""
         if self._is_cancel_requested():
             self._call_ui("close_progress", "tools_check")
+            # Exit local loop if any
+            loop = getattr(self, "_venv_check_loop", None)
+            if loop:
+                loop.quit()
             return
         if self._venv_check_index >= len(self._venv_check_pkgs):
             self._call_ui(
@@ -931,6 +968,11 @@ def _check_next_venv_pkg(self):
             self._call_ui("update_progress_progress", "tools_check", total, total)
             self._call_ui("close_progress", "tools_check")
 
+            # Exit local loop if any
+            loop = getattr(self, "_venv_check_loop", None)
+            if loop:
+                loop.quit()
+
             # Installer les dependances du projet si un requirements.txt est present
             try:
                 if getattr(self.parent, "workspace_dir", None):
@@ -996,6 +1038,11 @@ def _on_venv_pkg_checked(self, process, code, status, pkg):
                     level="error",
                 )
                 self._call_ui("close_progress", "tools_check")
+                
+                # Exit local loop if any
+                loop = getattr(self, "_venv_check_loop", None)
+                if loop:
+                    loop.quit()
                 return
 
             self._safe_log(
@@ -1048,7 +1095,14 @@ def _on_venv_check_output(self, process, error=False):
         lines = data.strip().splitlines()
         if lines:
             self._call_ui("update_progress_message", "tools_check", lines[-1][:200])
-        self._safe_log(data)
+            
+            # Detailed logging for verbose mode or errors
+            is_verbose = getattr(self.parent, "verbose", False)
+            if is_verbose or error:
+                for line in lines:
+                    lvl = "warning" if error else "info"
+                    # We use a slight indentation to make it clear it's sub-output
+                    self._safe_log(f"  [pip] {line}", level=lvl)
 
     def verify_venv_binding(self, venv_root: str) -> bool:
         """Keep synchronous verification path for internal compatibility."""
@@ -1479,7 +1533,13 @@ def _on_venv_output(self, process, error=False):
                 self._venv_progress_lines,
                 0,
             )
-        self._safe_log(data)
+            
+            # Detailed logging for verbose mode or errors
+            is_verbose = getattr(self.parent, "verbose", False)
+            if is_verbose or error:
+                for line in lines:
+                    lvl = "warning" if error else "info"
+                    self._safe_log(f"  [venv] {line}", level=lvl)
 
     def _on_venv_created(self, process, code, status, venv_path):
         """Handle the related event callback."""
@@ -1735,7 +1795,13 @@ def _on_pip_output(self, process, error=False):
             self._call_ui(
                 "update_progress_progress", "reqs_install", self._pip_progress_lines, 0
             )
-        self._safe_log(data)
+            
+            # Detailed logging for verbose mode or errors
+            is_verbose = getattr(self.parent, "verbose", False)
+            if is_verbose or error:
+                for line in lines:
+                    lvl = "warning" if error else "info"
+                    self._safe_log(f"  [pip] {line}", level=lvl)
 
     def _on_pip_finished(self, process, code, status):
         """Handle the related event callback."""

Ui/Cli/helpers.py

@@ -115,6 +115,7 @@ def _on_stderr(line: str):
                 on_stdout=_on_stdout,
                 on_stderr=_on_stderr,
                 stop_signal=lambda: _CLI_CANCEL_EVENT.is_set(),
+                verbose=verbose,
             )
     except Exception as exc:
         result = {