Update app.py

app.py

@@ -459,65 +459,91 @@ def _install_supervisely_logger_shim():
     """))
     return str(root)
 
-# ---- NEW: signature-agnostic sitecustomize shim (safe, non-invasive) ---------
+# ---- NEW: robust sitecustomize shim with lazy import hook --------------------
 def _install_workspace_shim_v3(dest_dir: str, module_default: str = "rtdetrv2_pytorch.src"):
     """
-    sitecustomize shim that patches rtdetrv2_pytorch.src.core.workspace.create
-    to be robust for BOTH call styles:
-        - create(name, cfg, **extras)           (positional cfg)
-        - create(name, cfg=<dict>, **extras)    (keyword cfg)
-    It guarantees cfg is a dict and cfg['_pymodule'] is a *module object*.
+    sitecustomize shim that:
+      - patches workspace.create for positional/keyword cfg,
+      - ensures cfg is a dict,
+      - injects cfg['_pymodule'] as a *module object*,
+    even if the target module is imported after sitecustomize runs.
     """
     os.makedirs(dest_dir, exist_ok=True)
     sc_path = os.path.join(dest_dir, "sitecustomize.py")
 
-    # Use Template so braces in code remain literal; only $module_default is substituted.
     tmpl = Template(r"""
-import os, importlib, types
-try:
-    MOD_DEFAULT = os.environ.get("RTDETR_PYMODULE", "$module_default") or "$module_default"
-    ws_mod = importlib.import_module("rtdetrv2_pytorch.src.core.workspace")
-    _orig_create = ws_mod.create
-
-    def _ensure_pymodule_object(cfg: dict):
-        pm = cfg.get("_pymodule", None)
-        if isinstance(pm, types.ModuleType):
-            return pm
-        name = (pm or "").strip() if isinstance(pm, str) else MOD_DEFAULT
-        if not name:
-            name = MOD_DEFAULT
-        try:
-            mod = importlib.import_module(name)
-        except Exception:
-            mod = importlib.import_module(MOD_DEFAULT)
-        cfg["_pymodule"] = mod
-        return mod
+import os, sys, importlib, importlib.abc, importlib.util, importlib.machinery, types
+MOD_DEFAULT = os.environ.get("RTDETR_PYMODULE", "$module_default") or "$module_default"
+TARGET = "rtdetrv2_pytorch.src.core.workspace"
+
+def _ensure_pymodule_object(cfg: dict):
+    pm = cfg.get("_pymodule", None)
+    if isinstance(pm, types.ModuleType):
+        return pm
+    name = (pm or "").strip() if isinstance(pm, str) else MOD_DEFAULT
+    if not name:
+        name = MOD_DEFAULT
+    try:
+        mod = importlib.import_module(name)
+    except Exception:
+        mod = importlib.import_module(MOD_DEFAULT)
+    cfg["_pymodule"] = mod
+    return mod
 
+def _patch_ws(ws_mod):
+    if getattr(ws_mod, "__rolo_patched__", False):
+        return
+    _orig_create = ws_mod.create
     def create(name, *args, **kwargs):
-        # Accept both positional and keyword cfg
         if args:
             args = list(args)
             cfg = args[0]
         else:
             cfg = kwargs.get("cfg", None)
-
         if not isinstance(cfg, dict):
             cfg = {} if cfg is None else dict(cfg)
-
         _ensure_pymodule_object(cfg)
-
         if args:
             args[0] = cfg
             args = tuple(args)
         else:
             kwargs["cfg"] = cfg
-
         return _orig_create(name, *args, **kwargs)
-
     ws_mod.create = create
-except Exception:
-    # Never block training on shim failure
-    pass
+    ws_mod.__rolo_patched__ = True
+
+def _try_patch_now():
+    try:
+        ws_mod = importlib.import_module(TARGET)
+        _patch_ws(ws_mod)
+        return True
+    except Exception:
+        return False
+
+if not _try_patch_now():
+    class _RoloFinder(importlib.abc.MetaPathFinder):
+        def find_spec(self, fullname, path, target=None):
+            if fullname != TARGET:
+                return None
+            origin_spec = importlib.util.find_spec(fullname)
+            if origin_spec is None or origin_spec.loader is None:
+                return None
+            loader = origin_spec.loader
+            class _RoloLoader(importlib.abc.Loader):
+                def create_module(self, spec):
+                    if hasattr(loader, "create_module"):
+                        return loader.create_module(spec)
+                    return None
+                def exec_module(self, module):
+                    loader.exec_module(module)
+                    try:
+                        _patch_ws(module)
+                    except Exception:
+                        pass
+            spec = importlib.machinery.ModuleSpec(fullname, _RoloLoader(), origin=origin_spec.origin)
+            spec.submodule_search_locations = origin_spec.submodule_search_locations
+            return spec
+    sys.meta_path.insert(0, _RoloFinder())
 """)
     code = tmpl.substitute(module_default=module_default)
     with open(sc_path, "w", encoding="utf-8") as f:
@@ -657,12 +683,16 @@ def patch_base_config(base_cfg_path, merged_dir, class_count, run_name,
     cfg.setdefault("device", "")
     cfg["find_unused_parameters"] = False
 
-    # Remove COCO dataset include so it can't override our dataset paths later
+    # STRONG include pruning: keep ONLY runtime.yml to avoid overrides
     if "__include__" in cfg and isinstance(cfg["__include__"], list):
-        cfg["__include__"] = [
-            p for p in cfg["__include__"]
-            if not (isinstance(p, str) and "configs/dataset/coco" in p.replace("\\", "/"))
-        ]
+        kept = []
+        for p in cfg["__include__"]:
+            if not isinstance(p, str):
+                continue
+            pp = p.replace("\\", "/")
+            if pp.endswith("/configs/runtime.yml"):
+                kept.append(p)
+        cfg["__include__"] = kept
 
     ann_dir = os.path.join(merged_dir, "annotations")
     paths = {