Update app.py

app.py

@@ -57,36 +57,60 @@ def _patch_relative_imports(project_root: str):
 # --- END ABSOLUTE-IMPORT & ENV HOTFIX ---
 
 
-# --- BEGIN runtime compatibility: lazy proxy for "utilities" -> "utils" -------
-# Some modules still do `import utilities`. Create a lazy proxy that will import
-# the real `utils` only when attributes are accessed, avoiding recursive
-# import-time interactions with any lazy `utils` implementation.
+# --- BEGIN robust compatibility: ensure 'utilities' references the real utils package ----------
+# Some legacy modules import `utilities`. We will ensure sys.modules['utilities'] points
+# to the same module object as 'utils' by:
+# 1) Attempting a normal import of utils; if that works, alias it.
+# 2) If normal import fails or would recurse, fall back to loading utils/__init__.py
+#    directly via importlib.util.spec_from_file_location, placing the module object
+#    into sys.modules BEFORE executing the module to avoid circular lazy-swaps.
 import importlib
+import importlib.util
 from types import ModuleType
 
-if "utilities" not in sys.modules:
-    class _LazyUtilities(ModuleType):
-        def __getattr__(self, name):
-            # Import the real utils once on first attribute access and replace
-            # the 'utilities' entry in sys.modules with it so subsequent
-            # imports refer to the real module.
-            real = importlib.import_module("utils")
-            sys.modules["utilities"] = real
-            # Alias already-imported utils submodules as utilities.<submodule>
-            for modname, module in list(sys.modules.items()):
-                if modname.startswith("utils.") and isinstance(module, ModuleType):
-                    suffix = modname.partition(".")[2]
-                    sys.modules[f"utilities.{suffix}"] = module
-            return getattr(real, name)
-        def __dir__(self):
-            try:
-                real = importlib.import_module("utils")
-                return dir(real)
-            except Exception:
-                return list(super().__dir__())
-
-    sys.modules["utilities"] = _LazyUtilities("utilities")
-# --- END runtime compatibility ---------------------------------------------
+def _ensure_utilities_alias(project_root: str):
+    # If utilities already exists and isn't obviously broken, leave it alone.
+    if "utilities" in sys.modules and getattr(sys.modules["utilities"], "__name__", "").startswith("utils"):
+        return
+
+    # Try normal import first (fast path)
+    try:
+        _utils = importlib.import_module("utils")
+        sys.modules["utilities"] = _utils
+        return
+    except Exception:
+        # proceed to robust file-loader fallback below
+        pass
+
+    # Fallback: load utils package explicitly from filesystem using its __init__.py
+    utils_init = os.path.join(project_root, "utils", "__init__.py")
+    if not os.path.exists(utils_init):
+        # nothing we can do here — leave to normal import to raise error later
+        return
+
+    spec = importlib.util.spec_from_file_location("utils", utils_init)
+    if spec is None or spec.loader is None:
+        return
+
+    # Create the module object and put it in sys.modules BEFORE execution.
+    # This ensures imports within utils that examine sys.modules won't re-enter a cycle.
+    utils_mod = importlib.util.module_from_spec(spec)
+    sys.modules["utils"] = utils_mod
+    # Also alias utilities -> utils_mod so imports of utilities see the same module object.
+    sys.modules["utilities"] = utils_mod
+
+    # Execute the module (this will run utils/__init__.py)
+    try:
+        spec.loader.exec_module(utils_mod)  # type: ignore[attr-defined]
+    except Exception:
+        # If execution fails, remove the partially-initialized entries so Python's import machinery can surface a clean error.
+        sys.modules.pop("utils", None)
+        sys.modules.pop("utilities", None)
+        raise
+
+# Ensure alias early, before importing core
+_ensure_utilities_alias(PROJECT_ROOT)
+# --- END robust compatibility ------------------------------------------------
 
 
 # Import the main application from core