i18n renforcer pour les plugin

Author: PyCompiler ARK++

Plugins_SDK/GeneralContext/i18n.py

@@ -19,6 +19,8 @@
 """
 
 from typing import Any
+from pathlib import Path
+import json
 
 # Keep live Plugins instances to support dynamic interactions (e.g., i18n refresh)
 # We avoid importing BCASL types here to keep this utility decoupled.
@@ -64,4 +66,104 @@ def apply_translations(gui: Any, tr: dict) -> None:
             except Exception:
                 continue
     except Exception:
-        pass
+        pass
+
+# --- Synchronization helpers ---
+
+def _project_root() -> Path:
+    try:
+        # Plugins_SDK/GeneralContext/i18n.py -> project root is three parents up
+        return Path(__file__).resolve().parents[2]
+    except Exception:
+        return Path.cwd()
+
+
+def _global_language_sync() -> str:
+    """Return the current global language preference synchronously.
+    Falls back to 'en' on failure.
+    """
+    try:
+        from Core.i18n import get_current_language_sync  # late import to avoid cycles
+        code = get_current_language_sync() or "en"
+        return str(code)
+    except Exception:
+        return "en"
+
+
+def _load_local_lang_sync(pkg_dir: Path, code: str) -> dict:
+    """Load a plugin-local language json from <pkg_dir>/languages/<code>.json with robust fallbacks."""
+    try:
+        base = pkg_dir / "languages"
+        raw = (code or "en").strip()
+        low = raw.lower().replace("_", "-")
+        candidates = []
+        if raw:
+            candidates.append(raw)
+        if low and low not in candidates:
+            candidates.append(low)
+        base_code = None
+        try:
+            if "-" in low:
+                base_code = low.split("-", 1)[0]
+        except Exception:
+            base_code = None
+        if base_code and base_code not in candidates:
+            candidates.append(base_code)
+        if "en" not in candidates:
+            candidates.append("en")
+        for c in candidates:
+            f = base / f"{c}.json"
+            if f.is_file():
+                with open(f, encoding="utf-8") as fp:
+                    data = json.load(fp)
+                if isinstance(data, dict):
+                    return data
+    except Exception:
+        pass
+    return {"_meta": {"code": code or "en", "name": code or "en"}}
+
+
+def sync_with_global_language(gui: Any) -> dict:
+    """Synchronize all registered plugin instances with the current global language.
+    - Resolves global language (Core.i18n.get_current_language_sync)
+    - For each registered plugin instance, attempts to locate its package directory and
+      load a local languages/<code>.json and call apply_i18n(gui, tr).
+    - Returns the last loaded translation dict for convenience (can be ignored).
+    Notes:
+      - A plugin class may expose an attribute '__package_dir__' or a method 'get_package_dir()'
+        returning a Path to its package root (containing languages/). If absent, this function
+        attempts to infer the directory from the module of the class.
+    """
+    code = _global_language_sync()
+    last_tr: dict = {"_meta": {"code": code, "name": code}}
+    try:
+        for pid, inst in list(INSTANCES.items()):
+            try:
+                # Resolve package directory
+                pkg_dir: Path | None = None
+                try:
+                    if hasattr(inst, "get_package_dir") and callable(getattr(inst, "get_package_dir")):
+                        pkg_dir = Path(inst.get_package_dir())
+                    elif hasattr(inst, "__package_dir__"):
+                        pkg_dir = Path(getattr(inst, "__package_dir__"))
+                    else:
+                        mod = getattr(inst.__class__, "__module__", None)
+                        if mod:
+                            import importlib, inspect
+                            m = importlib.import_module(mod)
+                            f = Path(inspect.getfile(m))
+                            pkg_dir = f.parent
+                except Exception:
+                    pkg_dir = None
+                if not pkg_dir:
+                    continue
+                tr = _load_local_lang_sync(pkg_dir, code)
+                last_tr = tr
+                fn = getattr(inst, "apply_i18n", None)
+                if callable(fn):
+                    fn(gui, tr)
+            except Exception:
+                continue
+    except Exception:
+        pass
+    return last_tr