exonware-xwlazy 0.1.0.11__py3-none-any.whl → 0.1.0.20__py3-none-any.whl

exonware/xwlazy/module/strategies/__init__.py

@@ -0,0 +1,22 @@
+"""
+Module Strategies - Helper and Manager implementations.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+
+Generation Date: 15-Nov-2025
+"""
+
+from .module_helper_simple import SimpleHelper
+from .module_helper_lazy import LazyHelper
+from .module_manager_simple import SimpleManager
+from .module_manager_advanced import AdvancedManager
+
+__all__ = [
+    'SimpleHelper',
+    'LazyHelper',
+    'SimpleManager',
+    'AdvancedManager',
+]
+

exonware/xwlazy/module/strategies/module_helper_lazy.py

@@ -0,0 +1,93 @@
+"""
+Lazy Module Helper Strategy - Deferred loading.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+
+Generation Date: 15-Nov-2025
+
+Lazy loading - loads module on first access with caching.
+"""
+
+import importlib
+import importlib.util
+import threading
+from types import ModuleType
+from typing import Any, Optional, Dict
+from ...module.base import AModuleHelperStrategy
+from ..data import ModuleData
+
+class LazyHelper(AModuleHelperStrategy):
+    """
+    Lazy helper - deferred loading with caching.
+    
+    Loads module on first access and caches it.
+    Thread-safe with circular import detection.
+    """
+    
+    def __init__(self):
+        """Initialize lazy helper."""
+        self._cache: Dict[str, ModuleType] = {}
+        self._loading: Dict[str, bool] = {}
+        self._lock = threading.RLock()
+    
+    def load(self, module_path: str, package_helper: Any) -> ModuleType:
+        """
+        Load the module lazily (with caching).
+        
+        Args:
+            module_path: Module path to load
+            package_helper: Package helper (unused)
+            
+        Returns:
+            Loaded module
+        """
+        # Check cache first
+        if module_path in self._cache:
+            return self._cache[module_path]
+        
+        with self._lock:
+            # Double-check after acquiring lock
+            if module_path in self._cache:
+                return self._cache[module_path]
+            
+            # Check for circular import
+            if self._loading.get(module_path, False):
+                raise ImportError(f"Circular import detected for {module_path}")
+            
+            try:
+                self._loading[module_path] = True
+                module = importlib.import_module(module_path)
+                self._cache[module_path] = module
+                return module
+            finally:
+                self._loading[module_path] = False
+    
+    def unload(self, module_path: str) -> None:
+        """
+        Unload the module from cache.
+        
+        Args:
+            module_path: Module path to unload
+        """
+        with self._lock:
+            self._cache.pop(module_path, None)
+            self._loading.pop(module_path, None)
+    
+    def check_importability(self, path: str) -> bool:
+        """
+        Check if module is importable.
+        
+        Args:
+            path: Module path to check
+            
+        Returns:
+            True if importable, False otherwise
+        """
+        try:
+            spec = importlib.util.find_spec(path)
+            return spec is not None
+        except (ValueError, AttributeError, ImportError):
+            return False
+

exonware/xwlazy/module/strategies/module_helper_simple.py

@@ -0,0 +1,65 @@
+"""
+Simple Module Helper Strategy - Basic synchronous loading.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+
+Generation Date: 15-Nov-2025
+
+Simple synchronous module loading - no lazy loading.
+"""
+
+import importlib
+from types import ModuleType
+from typing import Any
+from ...module.base import AModuleHelperStrategy
+
+class SimpleHelper(AModuleHelperStrategy):
+    """
+    Simple helper - standard synchronous import.
+    
+    No lazy loading, no caching, just direct importlib.import_module.
+    """
+    
+    def load(self, module_path: str, package_helper: Any) -> ModuleType:
+        """
+        Load the module synchronously.
+        
+        Args:
+            module_path: Module path to load
+            package_helper: Package helper (unused in simple mode)
+            
+        Returns:
+            Loaded module
+        """
+        return importlib.import_module(module_path)
+    
+    def unload(self, module_path: str) -> None:
+        """
+        Unload the module.
+        
+        Args:
+            module_path: Module path to unload
+        """
+        # Simple mode doesn't track loaded modules
+        # Could remove from sys.modules if needed
+        pass
+    
+    def check_importability(self, path: str) -> bool:
+        """
+        Check if module is importable.
+        
+        Args:
+            path: Module path to check
+            
+        Returns:
+            True if importable, False otherwise
+        """
+        import importlib.util
+        try:
+            spec = importlib.util.find_spec(path)
+            return spec is not None
+        except (ValueError, AttributeError, ImportError):
+            return False
+

exonware/xwlazy/module/strategies/module_manager_advanced.py

@@ -0,0 +1,111 @@
+"""
+Advanced Module Manager Strategy - Full features.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+
+Generation Date: 15-Nov-2025
+
+Advanced manager - with hooks, error handling, and full features.
+"""
+
+import sys
+from types import ModuleType
+from typing import Optional
+from ...module.base import AModuleManagerStrategy
+from ...contracts import ICachingStrategy, IModuleHelperStrategy
+from ...package.base import APackageHelper
+from ...module import importer_engine
+
+class AdvancedManager(AModuleManagerStrategy):
+    """
+    Advanced manager - full features with hooks and error handling.
+    
+    Supports import hooks, error recovery, and all advanced features.
+    """
+    
+    def __init__(
+        self,
+        package_name: str,
+        package_helper: APackageHelper,
+        caching: ICachingStrategy,
+        helper: IModuleHelperStrategy
+    ):
+        """
+        Initialize advanced manager.
+        
+        Args:
+            package_name: Package name for isolation
+            package_helper: Package helper instance
+            caching: Caching strategy
+            helper: Helper strategy
+        """
+        self._package_name = package_name
+        self._package_helper = package_helper
+        self._caching = caching
+        self._helper = helper
+        self._import_hook: Optional[importer_engine.LazyImportHook] = None
+    
+    def load_module(self, module_path: str) -> ModuleType:
+        """
+        Load a module.
+        
+        Args:
+            module_path: Module path to load
+            
+        Returns:
+            Loaded module
+        """
+        # Check cache first
+        cached = self._caching.get(module_path)
+        if cached is not None:
+            return cached
+        
+        # Load using helper
+        module = self._helper.load(module_path, self._package_helper)
+        
+        # Cache it
+        self._caching.set(module_path, module)
+        
+        return module
+    
+    def unload_module(self, module_path: str) -> None:
+        """
+        Unload a module.
+        
+        Args:
+            module_path: Module path to unload
+        """
+        self._helper.unload(module_path)
+        self._caching.invalidate(module_path)
+        
+        # Also remove from sys.modules if present
+        if module_path in sys.modules:
+            del sys.modules[module_path]
+    
+    def install_hook(self) -> None:
+        """Install import hook into sys.meta_path."""
+        importer_engine.install_import_hook(self._package_name)
+    
+    def uninstall_hook(self) -> None:
+        """Uninstall import hook from sys.meta_path."""
+        importer_engine.uninstall_import_hook(self._package_name)
+    
+    def handle_import_error(self, module_name: str) -> Optional[ModuleType]:
+        """
+        Handle ImportError by attempting to install and re-import.
+        
+        Args:
+            module_name: Name of module that failed to import
+            
+        Returns:
+            Imported module if successful, None otherwise
+        """
+        if self._import_hook is None:
+            self._import_hook = importer_engine.LazyImportHook(
+                self._package_name,
+                self._package_helper
+            )
+        return self._import_hook.handle_import_error(module_name)
+

exonware/xwlazy/module/strategies/module_manager_simple.py

@@ -0,0 +1,95 @@
+"""
+Simple Module Manager Strategy - Basic operations.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+
+Generation Date: 15-Nov-2025
+
+Simple manager - basic module loading/unloading only.
+"""
+
+from types import ModuleType
+from typing import Optional
+from ...module.base import AModuleManagerStrategy
+from ...contracts import ICachingStrategy, IModuleHelperStrategy
+
+class SimpleManager(AModuleManagerStrategy):
+    """
+    Simple manager - basic module operations only.
+    
+    No hooks, no error handling, just load/unload.
+    """
+    
+    def __init__(
+        self,
+        package_name: str,
+        caching: ICachingStrategy,
+        helper: IModuleHelperStrategy
+    ):
+        """
+        Initialize simple manager.
+        
+        Args:
+            package_name: Package name for isolation
+            caching: Caching strategy
+            helper: Helper strategy
+        """
+        self._package_name = package_name
+        self._caching = caching
+        self._helper = helper
+    
+    def load_module(self, module_path: str) -> ModuleType:
+        """
+        Load a module.
+        
+        Args:
+            module_path: Module path to load
+            
+        Returns:
+            Loaded module
+        """
+        # Check cache first
+        cached = self._caching.get(module_path)
+        if cached is not None:
+            return cached
+        
+        # Load using helper
+        module = self._helper.load(module_path, None)
+        
+        # Cache it
+        self._caching.set(module_path, module)
+        
+        return module
+    
+    def unload_module(self, module_path: str) -> None:
+        """
+        Unload a module.
+        
+        Args:
+            module_path: Module path to unload
+        """
+        self._helper.unload(module_path)
+        self._caching.invalidate(module_path)
+    
+    def install_hook(self) -> None:
+        """Install import hook (not supported in simple mode)."""
+        pass
+    
+    def uninstall_hook(self) -> None:
+        """Uninstall import hook (not supported in simple mode)."""
+        pass
+    
+    def handle_import_error(self, module_name: str) -> Optional[ModuleType]:
+        """
+        Handle import error (not supported in simple mode).
+        
+        Args:
+            module_name: Module name that failed
+            
+        Returns:
+            None (simple mode doesn't handle errors)
+        """
+        return None
+

exonware/xwlazy/package/__init__.py

@@ -0,0 +1,18 @@
+"""
+Package Operations Module
+
+This module provides concrete implementations for package operations.
+Main facade: XWPackageHelper extends APackageHelper
+"""
+
+# Lazy imports to avoid circular dependencies
+def __getattr__(name: str):
+    if name == 'XWPackageHelper':
+        from .facade import XWPackageHelper
+        return XWPackageHelper
+    if name == 'XWPackage':  # Backward compatibility alias
+        from .facade import XWPackageHelper
+        return XWPackageHelper
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+__all__ = ['XWPackageHelper', 'XWPackage']  # XWPackage is backward compatibility alias