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

{xwlazy/lazy → exonware/xwlazy/package/services}/manifest.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 """
-xwlazy.lazy.manifest
---------------------
+xwlazy.common.utils.manifest
+----------------------------
 
 Centralized loader for per-package dependency manifests. A manifest can be
 declared either as a JSON file located in the target project's root directory
@@ -18,7 +18,7 @@ It also keeps lightweight caches with file-modification tracking so repeated
 lookups do not hit the filesystem unnecessarily.
 """
 
-from dataclasses import dataclass, field
+from dataclasses import field
 import importlib.util
 import json
 import os
@@ -67,27 +67,8 @@ def _normalize_wrap_hints(values: Iterable[Any]) -> List[str]:
     return hints
 
 
-@dataclass(frozen=True)
-class PackageManifest:
-    """Resolved manifest data for a single package."""
-
-    package: str
-    dependencies: Dict[str, str] = field(default_factory=dict)
-    watched_prefixes: Tuple[str, ...] = ()
-    async_installs: bool = False
-    async_workers: int = 1
-    class_wrap_prefixes: Tuple[str, ...] = ()
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-    def get_dependency(self, import_name: str) -> Optional[str]:
-        """Return the declared package for the given import name."""
-        if not import_name:
-            return None
-        direct = self.dependencies.get(import_name)
-        if direct is not None:
-            return direct
-        # Case-insensitive fallback for convenience
-        return self.dependencies.get(import_name.lower())
+# PackageManifest moved to defs.py - import it from there
+from ...defs import PackageManifest
 
 
 class LazyManifestLoader:
@@ -133,6 +114,28 @@ class LazyManifestLoader:
             self._shared_dependency_maps.clear()
             self._generation += 1
 
+    def sync_manifest_configuration(self, package_name: str) -> None:
+        """
+        Sync configuration from manifest for a specific package.
+        
+        This method forces a reload of the manifest and clears caches
+        to ensure the latest configuration is used.
+        
+        Args:
+            package_name: The package name to sync configuration for
+        """
+        with self._lock:
+            # Clear cache for this package
+            package_key = _normalize_package_name(package_name)
+            if package_key in self._manifest_cache:
+                del self._manifest_cache[package_key]
+            if package_key in self._source_signatures:
+                del self._source_signatures[package_key]
+            # Increment generation to invalidate shared caches
+            self._generation += 1
+            # Force reload by getting manifest
+            self.get_manifest(package_key)
+
     # --------------------------------------------------------------------- #
     # Public API
     # --------------------------------------------------------------------- #
@@ -479,11 +482,25 @@ def refresh_manifest_cache() -> None:
     loader.clear_cache()
 
 
+def sync_manifest_configuration(package_name: str) -> None:
+    """
+    Sync configuration from manifest for a specific package.
+    
+    This is a convenience function that calls the manifest loader's
+    sync_manifest_configuration method.
+    
+    Args:
+        package_name: The package name to sync configuration for
+    """
+    loader = get_manifest_loader()
+    loader.sync_manifest_configuration(package_name)
+
+
 __all__ = [
     "PackageManifest",
     "LazyManifestLoader",
     "get_manifest_loader",
     "refresh_manifest_cache",
+    "sync_manifest_configuration",
 ]
 
-

exonware/xwlazy/package/services/strategy_registry.py

@@ -0,0 +1,188 @@
+"""
+Strategy Registry
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Registry to store custom strategies per package for both package and module operations.
+"""
+
+import threading
+from typing import Dict, Optional, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...contracts import (
+        IInstallExecutionStrategy,
+        IInstallTimingStrategy,
+        IDiscoveryStrategy,
+        IPolicyStrategy,
+        IMappingStrategy,
+        IModuleHelperStrategy,
+        IModuleManagerStrategy,
+        ICachingStrategy,
+    )
+
+
+class StrategyRegistry:
+    """Registry to store custom strategies per package."""
+    
+    # Package strategies
+    _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
+    _module_helper_strategies: Dict[str, 'IModuleHelperStrategy'] = {}
+    _module_manager_strategies: Dict[str, 'IModuleManagerStrategy'] = {}
+    _module_caching_strategies: Dict[str, 'ICachingStrategy'] = {}
+    
+    _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)
+
+
+__all__ = ['StrategyRegistry']
+

exonware/xwlazy/package/strategies/__init__.py

@@ -0,0 +1,57 @@
+"""
+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

@@ -0,0 +1,130 @@
+"""
+File-Based Discovery Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+File-based discovery - discovers dependencies from project files.
+"""
+
+from pathlib import Path
+from typing import Dict, 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

@@ -0,0 +1,85 @@
+"""
+Hybrid Discovery Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Hybrid discovery - combines file-based and manifest-based discovery.
+"""
+
+from pathlib import Path
+from typing import Dict, 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

@@ -0,0 +1,102 @@
+"""
+Manifest-Based Discovery Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Manifest-based discovery - discovers dependencies from manifest files.
+"""
+
+from pathlib import Path
+from typing import Dict, 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
+