Rend la decouverte des engines dynamique et durcit le registre

Supprime la dependance a un chargement implicite base sur des effets de bord en remplacant l'ancien parcours par une decouverte dynamique des packages engines sous le namespace ENGINES.

Importe les modules de maniere namespacée et robuste, introspecte les sous-classes de CompilerEngine declarees dans chaque module puis les enregistre dynamiquement dans le registre actif.

Aligne egalement engine_sdk.registry sur EngineLoader.registry, ajoute une resolution lazy plus sure pour eviter certains chargements Qt trop precoces, et conserve une API SDK stable cote engines.

Renforce enfin bind_tabs avec des logs explicites lorsque la creation d'onglet echoue ou retourne une charge invalide, afin de faciliter le diagnostic sans casser l'initialisation du GUI.

Ajoute un test cible de non-regression pour couvrir la decouverte dynamique namespacée, la synchronisation du registre SDK et la journalisation des echecs de chargement d'onglets.

Author: raidos23

EngineLoader/Loader/EngineLoader.py

@@ -13,96 +13,127 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import importlib
 import inspect
+import logging
 import os
 import pkgutil
 import sys
+from types import ModuleType
+
+from EngineLoader.base import CompilerEngine
+from EngineLoader import registry as engine_registry
 
+logger = logging.getLogger(__name__)
 
-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] = []
+
+def _iter_engine_module_names(base_path: str, namespace_package: str) -> list[str]:
+    """Return top-level engine package names under the configured namespace."""
     if not os.path.isdir(base_path):
-        return imported
+        return []
+    prefix = f"{namespace_package.rstrip('.') }."
+    return [
+        name
+        for _finder, name, ispkg in pkgutil.iter_modules([base_path], prefix=prefix)
+        if ispkg
+    ]
 
-    # 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:
+def _register_engine_classes(module: ModuleType) -> list[str]:
+    """Register CompilerEngine subclasses declared by an imported module."""
+    registered: list[str] = []
+    for _name, obj in inspect.getmembers(module, inspect.isclass):
+        if not issubclass(obj, CompilerEngine) or obj is CompilerEngine:
             continue
+        try:
+            if not str(getattr(obj, "__module__", "")).startswith(module.__name__):
+                continue
+            engine_registry.engine_register(obj)
+            registered.append(getattr(obj, "id", obj.__name__))
+        except Exception:
+            logger.exception(
+                "Failed to register engine class %s from module %s",
+                getattr(obj, "__name__", repr(obj)),
+                module.__name__,
+            )
+    return registered
 
-        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:
-                package = importlib.import_module(mod_name)
-                imported.append(package)
-                break
-            except Exception:
-                continue
-        if package is None:
-            continue
+def _import_module_tree(module_name: str) -> list[ModuleType]:
+    """Import a package and its submodules, returning successfully loaded modules."""
+    imported: list[ModuleType] = []
+    root_module = importlib.import_module(module_name)
+    imported.append(root_module)
+
+    module_path = getattr(root_module, "__path__", None)
+    if not module_path:
+        return imported
 
-        pkg_name = getattr(package, "__name__", "")
-        pkg_path = os.path.join(base_path, name)
+    for _finder, subname, _ispkg in pkgutil.walk_packages(module_path, prefix=f"{module_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
+            imported.append(importlib.import_module(subname))
         except Exception:
-            continue
-
+            logger.exception("Failed to import engine submodule %s", subname)
     return imported
 
 
-def _register_discovered_engines(modules: list[object]) -> None:
-    """Register all CompilerEngine subclasses discovered in imported modules."""
+def _sync_engine_sdk_registry() -> None:
+    """Keep engine_sdk.registry aligned with the active EngineLoader registry module."""
     try:
-        from EngineLoader import registry as _registry  # local import to avoid cycles
-        from EngineLoader.base import CompilerEngine
+        import engine_sdk
+
+        engine_sdk.registry = engine_registry
     except Exception:
-        return
+        logger.exception("Failed to synchronize engine_sdk.registry with EngineLoader.registry")
 
-    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
+
+def _discover_external_plugins(base_path: str, namespace_package: str = "ENGINES") -> None:
+    """Import namespaced engine packages and register CompilerEngine classes dynamically."""
+    try:
+        if not os.path.isdir(base_path):
+            return
+
+        parent_dir = os.path.abspath(os.path.dirname(base_path))
+        if parent_dir not in sys.path:
+            sys.path.insert(0, parent_dir)
+
+        for module_name in _iter_engine_module_names(base_path, namespace_package):
+            try:
+                imported_modules = _import_module_tree(module_name)
+            except Exception:
+                logger.exception("Failed to import engine package %s", module_name)
+                continue
+
+            registered_any = False
+            for module in imported_modules:
                 try:
-                    eid = getattr(cls, "id", None)
-                    if not isinstance(eid, str) or not eid.strip():
-                        continue
-                    _registry.register(cls)
+                    if _register_engine_classes(module):
+                        registered_any = True
                 except Exception:
-                    continue
-        except Exception:
-            continue
+                    logger.exception(
+                        "Failed while introspecting engine module %s",
+                        getattr(module, "__name__", module_name),
+                    )
+            if not registered_any:
+                logger.warning(
+                    "No CompilerEngine subclasses were discovered in engine package %s",
+                    module_name,
+                )
+    except Exception:
+        logger.exception("Engine discovery failed for base path %s", base_path)
+    finally:
+        _sync_engine_sdk_registry()
 
 
 def _auto_discover() -> None:
-    """Discover and register engine plugins dynamically from the ENGINES folder."""
+    """Discover and register external engine plugins from the project 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")
-        modules = _import_engine_modules(external_dir, project_root=project_root)
-        _register_discovered_engines(modules)
+        _discover_external_plugins(external_dir, namespace_package="ENGINES")
     except Exception:
-        pass
+        logger.exception("Automatic engine discovery failed")
+        _sync_engine_sdk_registry()

EngineLoader/base.py

@@ -104,6 +104,15 @@ def on_success(self, gui, file: str) -> None:
         """Hook called when a build is successful."""
         pass
 
+    def engine_translate(self, key: str, default: Optional[str] = None) -> str:
+        """Translate an engine-local key using the shared engine i18n registry."""
+        try:
+            from .registry import engine_translate as _engine_translate
+
+            return _engine_translate(self, key, default)
+        except Exception:
+            return default if default is not None else str(key)
+
     def create_tab(self, gui):
         """
         Optionally create and return a QWidget tab and its label for the GUI.