Update utils/__init__.py

utils/__init__.py

@@ -1,79 +1,69 @@
 """
-Fixed utils/__init__.py - Prevents recursion in __getattr__
+Fixed utils/__init__.py - Properly imports existing functions from utils modules
+Replaces the recursive lazy-loading approach with direct imports
 """
 
 from __future__ import annotations
 
-import importlib
-import sys
-from types import ModuleType
-from typing import Any, Iterable
+import logging
+from typing import Any
 
-__all__ = ["__getattr__", "__dir__"]
+logger = logging.getLogger(__name__)
 
-_swapped: bool = False
-_real_utils: ModuleType | None = None
+# Import all required functions from their actual locations in the utils package
+try:
+    from .cv_processing import (
+        segment_person_hq,
+        refine_mask_hq, 
+        replace_background_hq,
+        PROFESSIONAL_BACKGROUNDS
+    )
+    logger.debug("Successfully imported cv_processing functions")
+except ImportError as e:
+    logger.error(f"Failed to import cv_processing functions: {e}")
+    # Provide fallback implementations
+    def segment_person_hq(*args, **kwargs):
+        raise NotImplementedError("segment_person_hq not available")
+    def refine_mask_hq(*args, **kwargs):
+        raise NotImplementedError("refine_mask_hq not available")
+    def replace_background_hq(*args, **kwargs):
+        raise NotImplementedError("replace_background_hq not available")
+    PROFESSIONAL_BACKGROUNDS = {}
 
-def _swap_with_utils() -> ModuleType:
-    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:
-        # 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
+try:
+    from .utils import (
+        validate_video_file,
+    )
+    logger.debug("Successfully imported utils functions")
+except ImportError as e:
+    logger.error(f"Failed to import utils functions: {e}")
+    def validate_video_file(*args, **kwargs):
+        raise NotImplementedError("validate_video_file not available")
 
-def __getattr__(name: str) -> Any:
-    # 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:
+    from .cv_processing import create_professional_background
+    logger.debug("Successfully imported create_professional_background")
+except ImportError:
     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')
+        from .utils import create_professional_background
+        logger.debug("Successfully imported create_professional_background from utils")
+    except ImportError as e:
+        logger.error(f"Failed to import create_professional_background: {e}")
+        def create_professional_background(*args, **kwargs):
+            raise NotImplementedError("create_professional_background not available")
 
-def __dir__() -> Iterable[str]:
-    try:
-        real = _swap_with_utils()
-        return dir(real)
-    except Exception:
-        return ["__getattr__", "__dir__"]
+# Export all functions for backward compatibility
+__all__ = [
+    "segment_person_hq",
+    "refine_mask_hq", 
+    "replace_background_hq",
+    "create_professional_background",
+    "PROFESSIONAL_BACKGROUNDS",
+    "validate_video_file"
+]
+
+# For backward compatibility with utilities import
+import sys
+sys.modules["utilities"] = sys.modules[__name__]
+
+logger.info("Utils module initialized successfully")