exonware-xwlazy 0.1.0.23__py3-none-any.whl → 1.0.1.2__py3-none-any.whl

exonware/xwlazy/package/services/strategy_registry.py

@@ -1,324 +0,0 @@
-"""
-Strategy Registry
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Registry to store custom strategies per package for both package and module operations.
-"""
-
-import threading
-from typing import Optional, Any, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ...contracts import (
-        IInstallExecutionStrategy,
-        IInstallTimingStrategy,
-        IDiscoveryStrategy,
-        IPolicyStrategy,
-        IMappingStrategy,
-        IModuleHelperStrategy,
-        IModuleManagerStrategy,
-        ICachingStrategy,
-        IInstallStrategy,
-        ILoadStrategy,
-        ICacheStrategy,
-    )
-
-class StrategyRegistry:
-    """
-    Registry to store custom strategies per package and enable runtime strategy swapping.
-    
-    Supports both:
-    - Per-package strategies (different strategies for different packages)
-    - Global strategy swapping (change default strategies used by all packages)
-    """
-    
-    # Package strategies (per-package)
-    _package_execution_strategies: dict[str, 'IInstallExecutionStrategy'] = {}
-    _package_timing_strategies: dict[str, 'IInstallTimingStrategy'] = {}
-    _package_discovery_strategies: dict[str, 'IDiscoveryStrategy'] = {}
-    _package_policy_strategies: dict[str, 'IPolicyStrategy'] = {}
-    _package_mapping_strategies: dict[str, 'IMappingStrategy'] = {}
-    
-    # Module strategies (per-package)
-    _module_helper_strategies: dict[str, 'IModuleHelperStrategy'] = {}
-    _module_manager_strategies: dict[str, 'IModuleManagerStrategy'] = {}
-    _module_caching_strategies: dict[str, 'ICachingStrategy'] = {}
-    
-    # Global strategies (for runtime swapping)
-    _global_install_strategies: dict[str, 'IInstallStrategy'] = {}
-    _global_load_strategies: dict[str, 'ILoadStrategy'] = {}
-    _global_cache_strategies: dict[str, 'ICacheStrategy'] = {}
-    _default_install_strategy: Optional[str] = None
-    _default_load_strategy: Optional[str] = None
-    _default_cache_strategy: Optional[str] = None
-    
-    _lock = threading.RLock()
-    
-    @classmethod
-    def set_package_strategy(
-        cls,
-        package_name: str,
-        strategy_type: str,
-        strategy: Any,
-    ) -> None:
-        """
-        Set a package strategy for a package.
-        
-        Args:
-            package_name: Package name
-            strategy_type: One of 'execution', 'timing', 'discovery', 'policy', 'mapping'
-            strategy: Strategy instance
-        """
-        package_key = package_name.lower()
-        with cls._lock:
-            if strategy_type == 'execution':
-                cls._package_execution_strategies[package_key] = strategy
-            elif strategy_type == 'timing':
-                cls._package_timing_strategies[package_key] = strategy
-            elif strategy_type == 'discovery':
-                cls._package_discovery_strategies[package_key] = strategy
-            elif strategy_type == 'policy':
-                cls._package_policy_strategies[package_key] = strategy
-            elif strategy_type == 'mapping':
-                cls._package_mapping_strategies[package_key] = strategy
-            else:
-                raise ValueError(f"Unknown package strategy type: {strategy_type}")
-    
-    @classmethod
-    def get_package_strategy(
-        cls,
-        package_name: str,
-        strategy_type: str,
-    ) -> Optional[Any]:
-        """
-        Get a package strategy for a package.
-        
-        Args:
-            package_name: Package name
-            strategy_type: One of 'execution', 'timing', 'discovery', 'policy', 'mapping'
-            
-        Returns:
-            Strategy instance or None if not set
-        """
-        package_key = package_name.lower()
-        with cls._lock:
-            if strategy_type == 'execution':
-                return cls._package_execution_strategies.get(package_key)
-            elif strategy_type == 'timing':
-                return cls._package_timing_strategies.get(package_key)
-            elif strategy_type == 'discovery':
-                return cls._package_discovery_strategies.get(package_key)
-            elif strategy_type == 'policy':
-                return cls._package_policy_strategies.get(package_key)
-            elif strategy_type == 'mapping':
-                return cls._package_mapping_strategies.get(package_key)
-            else:
-                raise ValueError(f"Unknown package strategy type: {strategy_type}")
-    
-    @classmethod
-    def set_module_strategy(
-        cls,
-        package_name: str,
-        strategy_type: str,
-        strategy: Any,
-    ) -> None:
-        """
-        Set a module strategy for a package.
-        
-        Args:
-            package_name: Package name
-            strategy_type: One of 'helper', 'manager', 'caching'
-            strategy: Strategy instance
-        """
-        package_key = package_name.lower()
-        with cls._lock:
-            if strategy_type == 'helper':
-                cls._module_helper_strategies[package_key] = strategy
-            elif strategy_type == 'manager':
-                cls._module_manager_strategies[package_key] = strategy
-            elif strategy_type == 'caching':
-                cls._module_caching_strategies[package_key] = strategy
-            else:
-                raise ValueError(f"Unknown module strategy type: {strategy_type}")
-    
-    @classmethod
-    def get_module_strategy(
-        cls,
-        package_name: str,
-        strategy_type: str,
-    ) -> Optional[Any]:
-        """
-        Get a module strategy for a package.
-        
-        Args:
-            package_name: Package name
-            strategy_type: One of 'helper', 'manager', 'caching'
-            
-        Returns:
-            Strategy instance or None if not set
-        """
-        package_key = package_name.lower()
-        with cls._lock:
-            if strategy_type == 'helper':
-                return cls._module_helper_strategies.get(package_key)
-            elif strategy_type == 'manager':
-                return cls._module_manager_strategies.get(package_key)
-            elif strategy_type == 'caching':
-                return cls._module_caching_strategies.get(package_key)
-            else:
-                raise ValueError(f"Unknown module strategy type: {strategy_type}")
-    
-    @classmethod
-    def clear_package_strategies(cls, package_name: str) -> None:
-        """Clear all package strategies for a package."""
-        package_key = package_name.lower()
-        with cls._lock:
-            cls._package_execution_strategies.pop(package_key, None)
-            cls._package_timing_strategies.pop(package_key, None)
-            cls._package_discovery_strategies.pop(package_key, None)
-            cls._package_policy_strategies.pop(package_key, None)
-            cls._package_mapping_strategies.pop(package_key, None)
-    
-    @classmethod
-    def clear_module_strategies(cls, package_name: str) -> None:
-        """Clear all module strategies for a package."""
-        package_key = package_name.lower()
-        with cls._lock:
-            cls._module_helper_strategies.pop(package_key, None)
-            cls._module_manager_strategies.pop(package_key, None)
-            cls._module_caching_strategies.pop(package_key, None)
-    
-    @classmethod
-    def clear_all_strategies(cls, package_name: str) -> None:
-        """Clear all strategies (package and module) for a package."""
-        cls.clear_package_strategies(package_name)
-        cls.clear_module_strategies(package_name)
-    
-    # ========================================================================
-    # Global Strategy Management (for runtime swapping)
-    # ========================================================================
-    
-    @classmethod
-    def register_install_strategy(cls, name: str, strategy: 'IInstallStrategy') -> None:
-        """
-        Register a global installation strategy for runtime swapping.
-        
-        Args:
-            name: Strategy name (e.g., 'pip', 'wheel', 'async', 'cached')
-            strategy: Strategy instance implementing IInstallStrategy
-        """
-        with cls._lock:
-            cls._global_install_strategies[name] = strategy
-            if cls._default_install_strategy is None:
-                cls._default_install_strategy = name
-    
-    @classmethod
-    def get_install_strategy(cls, name: Optional[str] = None) -> Optional['IInstallStrategy']:
-        """
-        Get global installation strategy by name.
-        
-        Args:
-            name: Strategy name (uses default if None)
-            
-        Returns:
-            Strategy instance or None if not found
-        """
-        with cls._lock:
-            if name is None:
-                name = cls._default_install_strategy
-            return cls._global_install_strategies.get(name) if name else None
-    
-    @classmethod
-    def register_load_strategy(cls, name: str, strategy: 'ILoadStrategy') -> None:
-        """
-        Register a global loading strategy for runtime swapping.
-        
-        Args:
-            name: Strategy name (e.g., 'lazy', 'simple', 'advanced')
-            strategy: Strategy instance implementing ILoadStrategy
-        """
-        with cls._lock:
-            cls._global_load_strategies[name] = strategy
-            if cls._default_load_strategy is None:
-                cls._default_load_strategy = name
-    
-    @classmethod
-    def get_load_strategy(cls, name: Optional[str] = None) -> Optional['ILoadStrategy']:
-        """
-        Get global loading strategy by name.
-        
-        Args:
-            name: Strategy name (uses default if None)
-            
-        Returns:
-            Strategy instance or None if not found
-        """
-        with cls._lock:
-            if name is None:
-                name = cls._default_load_strategy
-            return cls._global_load_strategies.get(name) if name else None
-    
-    @classmethod
-    def register_cache_strategy(cls, name: str, strategy: 'ICacheStrategy') -> None:
-        """
-        Register a global caching strategy for runtime swapping.
-        
-        Args:
-            name: Strategy name (e.g., 'lru', 'lfu', 'ttl', 'multitier')
-            strategy: Strategy instance implementing ICacheStrategy
-        """
-        with cls._lock:
-            cls._global_cache_strategies[name] = strategy
-            if cls._default_cache_strategy is None:
-                cls._default_cache_strategy = name
-    
-    @classmethod
-    def get_cache_strategy(cls, name: Optional[str] = None) -> Optional['ICacheStrategy']:
-        """
-        Get global caching strategy by name.
-        
-        Args:
-            name: Strategy name (uses default if None)
-            
-        Returns:
-            Strategy instance or None if not found
-        """
-        with cls._lock:
-            if name is None:
-                name = cls._default_cache_strategy
-            return cls._global_cache_strategies.get(name) if name else None
-    
-    @classmethod
-    def swap_install_strategy(cls, name: str) -> bool:
-        """Swap to a different global installation strategy."""
-        with cls._lock:
-            if name in cls._global_install_strategies:
-                cls._default_install_strategy = name
-                return True
-            return False
-    
-    @classmethod
-    def swap_load_strategy(cls, name: str) -> bool:
-        """Swap to a different global loading strategy."""
-        with cls._lock:
-            if name in cls._global_load_strategies:
-                cls._default_load_strategy = name
-                return True
-            return False
-    
-    @classmethod
-    def swap_cache_strategy(cls, name: str) -> bool:
-        """Swap to a different global caching strategy."""
-        with cls._lock:
-            if name in cls._global_cache_strategies:
-                cls._default_cache_strategy = name
-                return True
-            return False
-
-__all__ = ['StrategyRegistry']
-

exonware/xwlazy/package/strategies/__init__.py

@@ -1,57 +0,0 @@
-"""
-Package Strategies
-
-All package strategy implementations.
-"""
-
-# Mapping strategies
-from .package_mapping_manifest_first import ManifestFirstMapping
-from .package_mapping_discovery_first import DiscoveryFirstMapping
-from .package_mapping_hybrid import HybridMapping
-
-# Policy strategies
-from .package_policy_permissive import PermissivePolicy
-from .package_policy_allow_list import AllowListPolicy
-from .package_policy_deny_list import DenyListPolicy
-
-# Timing strategies
-from .package_timing_smart import SmartTiming
-from .package_timing_full import FullTiming
-from .package_timing_clean import CleanTiming
-from .package_timing_temporary import TemporaryTiming
-
-# Execution strategies
-from .package_execution_pip import PipExecution
-from .package_execution_wheel import WheelExecution
-from .package_execution_cached import CachedExecution
-from .package_execution_async import AsyncExecution
-
-# Discovery strategies
-from .package_discovery_file import FileBasedDiscovery
-from .package_discovery_manifest import ManifestBasedDiscovery
-from .package_discovery_hybrid import HybridDiscovery
-
-__all__ = [
-    # Mapping strategies
-    'ManifestFirstMapping',
-    'DiscoveryFirstMapping',
-    'HybridMapping',
-    # Policy strategies
-    'PermissivePolicy',
-    'AllowListPolicy',
-    'DenyListPolicy',
-    # Timing strategies
-    'SmartTiming',
-    'FullTiming',
-    'CleanTiming',
-    'TemporaryTiming',
-    # Execution strategies
-    'PipExecution',
-    'WheelExecution',
-    'CachedExecution',
-    'AsyncExecution',
-    # Discovery strategies
-    'FileBasedDiscovery',
-    'ManifestBasedDiscovery',
-    'HybridDiscovery',
-]

exonware/xwlazy/package/strategies/package_discovery_file.py

@@ -1,129 +0,0 @@
-"""
-File-Based Discovery Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-File-based discovery - discovers dependencies from project files.
-"""
-
-from pathlib import Path
-from typing import Optional, Any
-from ...package.base import ADiscoveryStrategy
-
-class FileBasedDiscovery(ADiscoveryStrategy):
-    """
-    File-based discovery strategy - discovers dependencies from project files.
-    
-    Reads from pyproject.toml, requirements.txt, setup.py, etc.
-    """
-    
-    def __init__(self, project_root: Optional[Path] = None):
-        """
-        Initialize file-based discovery strategy.
-        
-        Args:
-            project_root: Project root directory (auto-detected if None)
-        """
-        self._project_root = project_root or self._detect_project_root()
-    
-    def _detect_project_root(self) -> Path:
-        """Detect project root directory."""
-        import os
-        cwd = Path.cwd()
-        
-        # Look for common project markers
-        markers = ['pyproject.toml', 'requirements.txt', 'setup.py', '.git']
-        for marker in markers:
-            current = cwd
-            for _ in range(5):  # Search up to 5 levels
-                if (current / marker).exists():
-                    return current
-                parent = current.parent
-                if parent == current:  # Reached filesystem root
-                    break
-                current = parent
-        
-        return cwd
-    
-    def discover(self, project_root: Any = None) -> dict[str, str]:
-        """
-        Discover dependencies from project files.
-        
-        Args:
-            project_root: Optional project root (uses instance root if None)
-            
-        Returns:
-            Dict mapping import_name -> package_name
-        """
-        root = Path(project_root) if project_root else self._project_root
-        dependencies = {}
-        
-        # Check pyproject.toml
-        pyproject = root / "pyproject.toml"
-        if pyproject.exists():
-            try:
-                import tomllib
-            except ImportError:
-                try:
-                    import tomli as tomllib
-                except ImportError:
-                    tomllib = None
-            
-            if tomllib:
-                with open(pyproject, 'rb') as f:
-                    data = tomllib.load(f)
-                    project = data.get('project', {})
-                    deps = project.get('dependencies', [])
-                    for dep in deps:
-                        # Parse dependency spec (e.g., "pandas>=1.0" -> "pandas")
-                        package_name = dep.split('>=')[0].split('==')[0].split('!=')[0].strip()
-                        # Use package name as import name (heuristic)
-                        import_name = package_name.replace('-', '_')
-                        dependencies[import_name] = package_name
-        
-        # Check requirements.txt
-        requirements = root / "requirements.txt"
-        if requirements.exists():
-            with open(requirements, 'r', encoding='utf-8') as f:
-                for line in f:
-                    line = line.strip()
-                    if line and not line.startswith('#'):
-                        # Parse requirement (e.g., "pandas>=1.0" -> "pandas")
-                        package_name = line.split('>=')[0].split('==')[0].split('!=')[0].strip()
-                        import_name = package_name.replace('-', '_')
-                        dependencies[import_name] = package_name
-        
-        return dependencies
-    
-    def get_source(self, import_name: str) -> Optional[str]:
-        """
-        Get the source of a discovered dependency.
-        
-        Args:
-            import_name: Import name to check
-            
-        Returns:
-            Source file name or None
-        """
-        root = self._project_root
-        
-        # Check pyproject.toml
-        pyproject = root / "pyproject.toml"
-        if pyproject.exists():
-            deps = self.discover()
-            if import_name in deps:
-                return "pyproject.toml"
-        
-        # Check requirements.txt
-        requirements = root / "requirements.txt"
-        if requirements.exists():
-            deps = self.discover()
-            if import_name in deps:
-                return "requirements.txt"
-        
-        return None
-

exonware/xwlazy/package/strategies/package_discovery_hybrid.py

@@ -1,84 +0,0 @@
-"""
-Hybrid Discovery Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Hybrid discovery - combines file-based and manifest-based discovery.
-"""
-
-from pathlib import Path
-from typing import Optional, Any
-from ...package.base import ADiscoveryStrategy
-from .package_discovery_file import FileBasedDiscovery
-from .package_discovery_manifest import ManifestBasedDiscovery
-
-class HybridDiscovery(ADiscoveryStrategy):
-    """
-    Hybrid discovery strategy - combines file-based and manifest-based discovery.
-    
-    Priority: Manifest > File-based
-    """
-    
-    def __init__(self, package_name: str = 'default', project_root: Optional[Path] = None):
-        """
-        Initialize hybrid discovery strategy.
-        
-        Args:
-            package_name: Package name for isolation
-            project_root: Project root directory (auto-detected if None)
-        """
-        self._package_name = package_name
-        self._project_root = project_root
-        self._file_discovery = FileBasedDiscovery(project_root)
-        self._manifest_discovery = ManifestBasedDiscovery(package_name, project_root)
-    
-    def discover(self, project_root: Any = None) -> dict[str, str]:
-        """
-        Discover dependencies from all sources.
-        
-        Priority: Manifest > File-based
-        
-        Args:
-            project_root: Optional project root (uses instance root if None)
-            
-        Returns:
-            Dict mapping import_name -> package_name
-        """
-        dependencies = {}
-        
-        # First, get file-based dependencies
-        file_deps = self._file_discovery.discover(project_root)
-        dependencies.update(file_deps)
-        
-        # Then, overlay manifest dependencies (takes precedence)
-        manifest_deps = self._manifest_discovery.discover(project_root)
-        dependencies.update(manifest_deps)  # Manifest overrides file-based
-        
-        return dependencies
-    
-    def get_source(self, import_name: str) -> Optional[str]:
-        """
-        Get the source of a discovered dependency.
-        
-        Args:
-            import_name: Import name to check
-            
-        Returns:
-            Source file name or "hybrid"
-        """
-        # Check manifest first (higher priority)
-        manifest_source = self._manifest_discovery.get_source(import_name)
-        if manifest_source:
-            return manifest_source
-        
-        # Check file-based
-        file_source = self._file_discovery.get_source(import_name)
-        if file_source:
-            return file_source
-        
-        return None
-

exonware/xwlazy/package/strategies/package_discovery_manifest.py

@@ -1,101 +0,0 @@
-"""
-Manifest-Based Discovery Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Manifest-based discovery - discovers dependencies from manifest files.
-"""
-
-from pathlib import Path
-from typing import Optional, Any
-from ...package.base import ADiscoveryStrategy
-
-class ManifestBasedDiscovery(ADiscoveryStrategy):
-    """
-    Manifest-based discovery strategy - discovers dependencies from manifest files.
-    
-    Reads from xwlazy.manifest.json or pyproject.toml [tool.xwlazy] section.
-    """
-    
-    def __init__(self, package_name: str = 'default', project_root: Optional[Path] = None):
-        """
-        Initialize manifest-based discovery strategy.
-        
-        Args:
-            package_name: Package name for isolation
-            project_root: Project root directory (auto-detected if None)
-        """
-        self._package_name = package_name
-        self._project_root = project_root or self._detect_project_root()
-    
-    def _detect_project_root(self) -> Path:
-        """Detect project root directory."""
-        import os
-        cwd = Path.cwd()
-        
-        # Look for manifest files
-        markers = ['xwlazy.manifest.json', 'lazy.manifest.json', '.xwlazy.manifest.json', 'pyproject.toml']
-        for marker in markers:
-            current = cwd
-            for _ in range(5):  # Search up to 5 levels
-                if (current / marker).exists():
-                    return current
-                parent = current.parent
-                if parent == current:  # Reached filesystem root
-                    break
-                current = parent
-        
-        return cwd
-    
-    def discover(self, project_root: Any = None) -> dict[str, str]:
-        """
-        Discover dependencies from manifest files.
-        
-        Args:
-            project_root: Optional project root (uses instance root if None)
-            
-        Returns:
-            Dict mapping import_name -> package_name
-        """
-        # Lazy import to avoid circular dependency
-        from ...package.manifest import get_manifest_loader
-        
-        loader = get_manifest_loader()
-        manifest = loader.get_manifest(self._package_name)
-        
-        if manifest and manifest.dependencies:
-            return manifest.dependencies.copy()
-        
-        return {}
-    
-    def get_source(self, import_name: str) -> Optional[str]:
-        """
-        Get the source of a discovered dependency.
-        
-        Args:
-            import_name: Import name to check
-            
-        Returns:
-            Source file name (e.g., "xwlazy.manifest.json")
-        """
-        from ...package.manifest import get_manifest_loader
-        
-        loader = get_manifest_loader()
-        manifest = loader.get_manifest(self._package_name)
-        
-        if manifest and manifest.dependencies and import_name in manifest.dependencies:
-            # Try to find which file was used
-            root = self._project_root
-            for filename in ['xwlazy.manifest.json', 'lazy.manifest.json', '.xwlazy.manifest.json']:
-                if (root / filename).exists():
-                    return filename
-            # Check pyproject.toml
-            if (root / "pyproject.toml").exists():
-                return "pyproject.toml [tool.xwlazy]"
-        
-        return None
-