loader: passer a une decouverte 100% dynamique des engines

- supprime les chemins hardcodes d'enregistrement

- importe les modules engines de maniere namespacée et robuste

- enregistre dynamiquement les classes CompilerEngine par introspection

- aligne engine_sdk.registry sur le registre actif EngineLoader

- ajoute des logs explicites en cas d'echec de chargement de tab

Author: raidos23

EngineLoader/Loader/EngineLoader.py

@@ -14,52 +14,95 @@
 # limitations under the License.
 
 import importlib
+import inspect
 import os
 import pkgutil
 import sys
 
 
-def _discover_external_plugins(base_path: str) -> None:
-    """Import all top-level modules and packages under base_path (ENGINES/),
-    recursively importing subpackages to trigger engine registration side-effects.
-    """
-    try:
-        if not os.path.isdir(base_path):
-            return
-        if base_path not in sys.path:
-            sys.path.insert(0, base_path)
-        # Import only top-level PACKAGES (directories with __init__.py). Skip bare modules.
-        for _finder, name, ispkg in pkgutil.iter_modules([base_path]):
-            if not ispkg:
-                # Enforce package-only engines
-                continue
+def _import_engine_modules(base_path: str, project_root: str | None = None) -> list[object]:
+    """Import all engine packages and submodules found under ENGINES/ dynamically."""
+    imported: list[object] = []
+    if not os.path.isdir(base_path):
+        return imported
+
+    # Prefer project-root namespace imports (ENGINES.<name>) to avoid collisions.
+    if project_root and project_root not in sys.path:
+        sys.path.insert(0, project_root)
+    if base_path not in sys.path:
+        sys.path.insert(0, base_path)
+
+    for _finder, name, ispkg in pkgutil.iter_modules([base_path]):
+        if not ispkg:
+            continue
+
+        module_names: list[str] = []
+        if project_root:
+            module_names.append(f"ENGINES.{name}")
+        module_names.append(name)
+
+        package = None
+        for mod_name in module_names:
             try:
-                # Import the package so its __init__ can self-register the engine
-                importlib.import_module(name)
-                # Import submodules to trigger additional registrations if needed
-                pkg_path = os.path.join(base_path, name)
-                for __f, subname, __ispkg in pkgutil.walk_packages(
-                    [pkg_path], prefix=f"{name}."
-                ):
-                    try:
-                        importlib.import_module(subname)
-                    except Exception:
-                        # Ignore broken submodules to avoid crashing global discovery
-                        pass
+                package = importlib.import_module(mod_name)
+                imported.append(package)
+                break
             except Exception:
-                # Ignore broken plugins; do not crash host discovery
-                pass
+                continue
+        if package is None:
+            continue
+
+        pkg_name = getattr(package, "__name__", "")
+        pkg_path = os.path.join(base_path, name)
+        try:
+            for _f, sub_name, _is_pkg in pkgutil.walk_packages(
+                [pkg_path], prefix=f"{pkg_name}."
+            ):
+                try:
+                    sub = importlib.import_module(sub_name)
+                    imported.append(sub)
+                except Exception:
+                    continue
+        except Exception:
+            continue
+
+    return imported
+
+
+def _register_discovered_engines(modules: list[object]) -> None:
+    """Register all CompilerEngine subclasses discovered in imported modules."""
+    try:
+        from EngineLoader import registry as _registry  # local import to avoid cycles
+        from EngineLoader.base import CompilerEngine
     except Exception:
-        # Never let discovery break the host application
-        pass
+        return
+
+    for mod in modules:
+        try:
+            for _, cls in inspect.getmembers(mod, inspect.isclass):
+                try:
+                    if not issubclass(cls, CompilerEngine) or cls is CompilerEngine:
+                        continue
+                except Exception:
+                    continue
+                try:
+                    eid = getattr(cls, "id", None)
+                    if not isinstance(eid, str) or not eid.strip():
+                        continue
+                    _registry.register(cls)
+                except Exception:
+                    continue
+        except Exception:
+            continue
 
 
 def _auto_discover() -> None:
-    """Discover and register external engine plugins ONLY from the 'ENGINES' folder at project root."""
+    """Discover and register engine plugins dynamically from the ENGINES folder."""
     base_dir = os.path.dirname(__file__)
     try:
         project_root = os.path.abspath(os.path.join(base_dir, os.pardir, os.pardir))
         external_dir = os.path.join(project_root, "ENGINES")
-        _discover_external_plugins(external_dir)
+        modules = _import_engine_modules(external_dir, project_root=project_root)
+        _register_discovered_engines(modules)
     except Exception:
         pass

EngineLoader/registry.py

@@ -253,6 +253,26 @@ def _wrap_tab_scroll(widget):
             except Exception:
                 return widget
 
+        def _debug_log(level: str, fr: str, en: str) -> None:
+            try:
+                from .base import log_i18n_level as _log_i18n_level
+
+                _log_i18n_level(gui, level, fr, en)
+                return
+            except Exception:
+                pass
+            try:
+                msg = en
+                if hasattr(gui, "tr") and callable(getattr(gui, "tr")):
+                    msg = gui.tr(fr, en)
+                line = f"[{level.upper()}] {msg}"
+                if hasattr(gui, "log") and getattr(gui, "log", None) is not None:
+                    gui.log.append(line)
+                else:
+                    print(line)
+            except Exception:
+                pass
+
         for eid in list(_ORDER):
             try:
                 engine = create(eid)
@@ -276,6 +296,14 @@ def _wrap_tab_scroll(widget):
                 else:
                     idx = tabs.addTab(widget, label)
                     _TAB_INDEX[eid] = int(idx)
+                try:
+                    _debug_log(
+                        "state",
+                        f"Moteur charge dans les tabs: {eid}",
+                        f"Engine loaded into tabs: {eid}",
+                    )
+                except Exception:
+                    pass
                 # Apply engine i18n immediately if GUI already has active translations
                 try:
                     tr = getattr(gui, "_tr", None)
@@ -284,7 +312,12 @@ def _wrap_tab_scroll(widget):
                         fn(gui, tr)
                 except Exception:
                     pass
-            except Exception:
+            except Exception as e:
+                _debug_log(
+                    "warning",
+                    f"Echec chargement tab moteur '{eid}': {e}",
+                    f"Failed loading engine tab '{eid}': {e}",
+                )
                 # keep UI responsive even if a plugin tab fails
                 continue
 
@@ -294,6 +327,12 @@ def _wrap_tab_scroll(widget):
                 tabs.tabBar().hideTab(hello_tab_index)
             except Exception:
                 pass
+        elif not any_engine_tab_created:
+            _debug_log(
+                "warning",
+                "Aucun moteur n'a fourni de tab UI.",
+                "No engine provided a UI tab.",
+            )
     except Exception:
         # Swallow to avoid breaking app init
         pass

engine_sdk/__init__.py

@@ -49,11 +49,16 @@
 )
 from .sysdep import SysDependencyManager  # type: ignore
 
-# Re-export engines registry for self-registration from engine packages
+# Re-export engines registry for self-registration from engine packages.
+# Priority is the active host registry used by current GUI/runtime.
 try:
-    from utils.engines_loader import registry as registry  # type: ignore
+    from EngineLoader import registry as registry  # type: ignore
 except Exception:  # pragma: no cover
-    registry = None  # type: ignore
+    try:
+        # Backward-compat fallback for older layouts.
+        from utils.engines_loader import registry as registry  # type: ignore
+    except Exception:  # pragma: no cover
+        registry = None  # type: ignore
 
 
 __version__ = "3.2.3"