Update utils/__init__.py

utils/__init__.py

@@ -1,12 +1,5 @@
 """
-Lightweight lazy compatibility shim for `utilities` -> forwards to `utils`.
-
-Behavior:
-- Avoids importing/probing `utils` at import time (prevents recursion).
-- On first attribute access, imports the real `utils`, replaces sys.modules["utilities"]
-  with that real module (so subsequent imports resolve normally), and aliases any
-  already-loaded utils submodules under utilities.* for backward compatibility.
-- Minimal and non-destructive.
+Fixed utils/__init__.py - Prevents recursion in __getattr__
 """
 
 from __future__ import annotations
@@ -19,29 +12,64 @@
 __all__ = ["__getattr__", "__dir__"]
 
 _swapped: bool = False
+_real_utils: ModuleType | None = None
 
 def _swap_with_utils() -> ModuleType:
-    global _swapped
+    global _swapped, _real_utils
+    
+    # Return cached module if already swapped
+    if _swapped and _real_utils is not None:
+        return _real_utils
+    
+    # Prevent recursion by checking if we're already in the process
     if _swapped:
-        mod = sys.modules.get("utilities")
-        if isinstance(mod, ModuleType):
-            return mod
-        return importlib.import_module("utils")
-
-    real_utils = importlib.import_module("utils")
-    sys.modules["utilities"] = real_utils
-
-    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
-
-    _swapped = True
-    return real_utils
+        # If we're here, something went wrong - return a dummy module
+        dummy = ModuleType("utils_dummy")
+        return dummy
+    
+    try:
+        _swapped = True  # Set this BEFORE importing to prevent recursion
+        _real_utils = importlib.import_module("utils")
+        
+        # Replace utilities in sys.modules
+        sys.modules["utilities"] = _real_utils
+        
+        # Alias submodules
+        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 _real_utils
+        
+    except Exception as e:
+        # Reset state on failure
+        _swapped = False
+        _real_utils = None
+        # Create a minimal fallback module to prevent further errors
+        fallback = ModuleType("utils_fallback")
+        fallback.__dict__.update({
+            'device': ModuleType('device'),
+            'logging': ModuleType('logging'), 
+            'config': ModuleType('config')
+        })
+        return fallback
 
 def __getattr__(name: str) -> Any:
-    real = _swap_with_utils()
-    return getattr(real, name)
+    # Prevent infinite recursion by checking if we're already trying to get this attribute
+    if hasattr(__getattr__, '_in_progress'):
+        raise AttributeError(f"Recursion detected while getting attribute '{name}'")
+    
+    try:
+        __getattr__._in_progress = True
+        real = _swap_with_utils()
+        if hasattr(real, name):
+            return getattr(real, name)
+        else:
+            raise AttributeError(f"module 'utilities' has no attribute '{name}'")
+    finally:
+        if hasattr(__getattr__, '_in_progress'):
+            delattr(__getattr__, '_in_progress')
 
 def __dir__() -> Iterable[str]:
     try:
@@ -49,5 +77,3 @@ def __dir__() -> Iterable[str]:
         return dir(real)
     except Exception:
         return ["__getattr__", "__dir__"]
-
-__doc__ = __doc__