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,53 +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 _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 []
+    prefix = f"{namespace_package.rstrip('.') }."
+    return [
+        name
+        for _finder, name, ispkg in pkgutil.iter_modules([base_path], prefix=prefix)
+        if 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
+
+
+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
 
+    for _finder, subname, _ispkg in pkgutil.walk_packages(module_path, prefix=f"{module_name}."):
+        try:
+            imported.append(importlib.import_module(subname))
+        except Exception:
+            logger.exception("Failed to import engine submodule %s", subname)
+    return imported
 
-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.
-    """
+
+def _sync_engine_sdk_registry() -> None:
+    """Keep engine_sdk.registry aligned with the active EngineLoader registry module."""
+    try:
+        import engine_sdk
+
+        engine_sdk.registry = engine_registry
+    except Exception:
+        logger.exception("Failed to synchronize engine_sdk.registry with EngineLoader.registry")
+
+
+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
-        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
+
+        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:
-                # 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
+                imported_modules = _import_module_tree(module_name)
             except Exception:
-                # Ignore broken plugins; do not crash host discovery
-                pass
+                logger.exception("Failed to import engine package %s", module_name)
+                continue
+
+            registered_any = False
+            for module in imported_modules:
+                try:
+                    if _register_engine_classes(module):
+                        registered_any = True
+                except Exception:
+                    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:
-        # Never let discovery break the host application
-        pass
+        logger.exception("Engine discovery failed for base path %s", base_path)
+    finally:
+        _sync_engine_sdk_registry()
 
 
 def _auto_discover() -> None:
-    """Discover and register external engine plugins ONLY from the 'ENGINES' folder at project root."""
+    """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")
-        _discover_external_plugins(external_dir)
+        _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.

EngineLoader/registry.py

@@ -15,10 +15,13 @@
 
 from __future__ import annotations
 
+import logging
 import os
 from typing import Optional, Any
 
-from .base import CompilerEngine
+from .base import CompilerEngine, log_i18n_level
+
+logger = logging.getLogger(__name__)
 
 _REGISTRY: dict[str, type[CompilerEngine]] = {}
 _ORDER: list[str] = []
@@ -45,6 +48,9 @@
     "zh_cn": "zh-CN",
     "zh-cn": "zh-CN",
 }
+_GLOBAL_TR: dict[str, Any] = {}
+_GLOBAL_LANG: str = "en"
+_ENGINE_TR: dict[str, dict[str, Any]] = {}
 
 
 def normalize_language_code(code: Optional[str]) -> str:
@@ -113,6 +119,112 @@ def resolve_language_code(gui, tr: Optional[dict]) -> str:
     return normalize_language_code(code)
 
 
+def set_translations(gui, tr: Optional[dict]) -> None:
+    """Store host translations and the resolved active language for engine i18n."""
+    global _GLOBAL_TR, _GLOBAL_LANG
+    try:
+        _GLOBAL_TR = dict(tr) if isinstance(tr, dict) else {}
+    except Exception:
+        _GLOBAL_TR = {}
+    try:
+        _GLOBAL_LANG = resolve_language_code(gui, tr if isinstance(tr, dict) else None)
+    except Exception:
+        _GLOBAL_LANG = "en"
+
+
+def get_translations() -> dict[str, Any]:
+    return dict(_GLOBAL_TR) if isinstance(_GLOBAL_TR, dict) else {}
+
+
+def get_language_code() -> str:
+    return _GLOBAL_LANG or "en"
+
+
+def register_engine_translations(engine_id: str, tr: dict) -> None:
+    """Register or refresh translations for a specific engine id."""
+    if not engine_id:
+        return
+    try:
+        if isinstance(tr, dict):
+            payload = dict(tr)
+        else:
+            payload = {}
+        _ENGINE_TR[str(engine_id)] = payload
+        _ENGINE_TR[str(engine_id).lower()] = payload
+    except Exception:
+        pass
+
+
+def _engine_package_for_class(engine_cls: type[CompilerEngine]) -> str | None:
+    try:
+        module_name = str(getattr(engine_cls, "__module__", "") or "")
+        if not module_name:
+            return None
+        parts = module_name.split(".")
+        if len(parts) >= 2:
+            return ".".join(parts[:2])
+        return module_name
+    except Exception:
+        return None
+
+
+def _refresh_engine_translations_for_ids(engine_ids: list[str], code: str) -> None:
+    """Load and cache language files for selected engine ids."""
+    for eid in engine_ids:
+        try:
+            engine_cls = get_engine(eid)
+            if engine_cls is None:
+                continue
+            engine_package = _engine_package_for_class(engine_cls)
+            if not engine_package:
+                continue
+            data = load_engine_language_file(engine_package, code)
+            register_engine_translations(eid, data if isinstance(data, dict) else {})
+        except Exception:
+            continue
+
+
+def _refresh_all_engine_translations(code: str) -> None:
+    """Reload translations for all registered engines for the active language."""
+    try:
+        _ENGINE_TR.clear()
+    except Exception:
+        pass
+    _refresh_engine_translations_for_ids(list(_ORDER), code)
+
+
+def engine_translate(engine_or_id: Any, key: str, default: Optional[str] = None) -> str:
+    """Translate an engine-local key with fallback to host translations and defaults."""
+    engine_id = None
+    try:
+        if isinstance(engine_or_id, str):
+            engine_id = engine_or_id
+        else:
+            engine_id = getattr(engine_or_id, "id", None)
+    except Exception:
+        engine_id = None
+
+    try:
+        if engine_id:
+            for candidate in (str(engine_id), str(engine_id).lower()):
+                payload = _ENGINE_TR.get(candidate)
+                if isinstance(payload, dict):
+                    value = payload.get(key)
+                    if isinstance(value, str):
+                        return value
+    except Exception:
+        pass
+
+    try:
+        fallback = _GLOBAL_TR.get(key)
+        if isinstance(fallback, str):
+            return fallback
+    except Exception:
+        pass
+
+    return default if default is not None else str(key)
+
+
 def unregister(eid: str) -> None:
     """Unregister an engine id and its tab mapping if present."""
     try:
@@ -219,6 +331,19 @@ def bind_tabs(gui) -> None:
         # Track if any engine created a tab
         any_engine_tab_created = False
 
+        def _log_tab_load_issue(eid: str, fr: str, en: str, exc: Exception | None = None) -> None:
+            try:
+                log_i18n_level(gui, "warning", fr, en)
+            except Exception:
+                pass
+            try:
+                if exc is None:
+                    logger.warning("%s", en)
+                else:
+                    logger.warning("%s: %s", en, exc, exc_info=exc)
+            except Exception:
+                pass
+
         def _wrap_tab_scroll(widget):
             try:
                 from PySide6.QtCore import Qt
@@ -261,9 +386,25 @@ def _wrap_tab_scroll(widget):
                 res = getattr(engine, "create_tab", None)
                 if not callable(res):
                     continue
-                pair = res(gui)
+                try:
+                    pair = res(gui)
+                except Exception as exc:
+                    _log_tab_load_issue(
+                        eid,
+                        f"Echec du chargement de l'onglet moteur '{eid}'",
+                        f"Failed to load engine tab '{eid}'",
+                        exc,
+                    )
+                    continue
                 if not pair:
                     continue
+                if not isinstance(pair, tuple) or len(pair) != 2:
+                    _log_tab_load_issue(
+                        eid,
+                        f"Onglet invalide retourne par le moteur '{eid}'",
+                        f"Engine '{eid}' returned an invalid tab payload",
+                    )
+                    continue
                 any_engine_tab_created = True
                 widget, label = pair
                 widget = _wrap_tab_scroll(widget)
@@ -280,12 +421,20 @@ def _wrap_tab_scroll(widget):
                 try:
                     tr = getattr(gui, "_tr", None)
                     fn = getattr(engine, "apply_i18n", None)
+                    if isinstance(tr, dict):
+                        set_translations(gui, tr)
+                        _refresh_engine_translations_for_ids([eid], get_language_code())
                     if callable(fn) and isinstance(tr, dict):
                         fn(gui, tr)
                 except Exception:
                     pass
-            except Exception:
-                # keep UI responsive even if a plugin tab fails
+            except Exception as exc:
+                _log_tab_load_issue(
+                    eid,
+                    f"Echec inattendu lors du chargement de l'onglet moteur '{eid}'",
+                    f"Unexpected failure while loading engine tab '{eid}'",
+                    exc,
+                )
                 continue
 
         # Hide the Hello tab if any engine has created a tab
@@ -321,6 +470,8 @@ def show_hello_tab(gui) -> None:
 def apply_translations(gui, tr: dict) -> None:
     """Propagate i18n translations to all engines that expose 'apply_i18n(gui, tr)'."""
     try:
+        set_translations(gui, tr)
+        _refresh_all_engine_translations(get_language_code())
         for eid, inst in list(_INSTANCES.items()):
             try:
                 fn = getattr(inst, "apply_i18n", None)