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

exonware/xwlazy/package/strategies/package_execution_wheel.py

@@ -0,0 +1,107 @@
+"""
+Wheel Execution Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Wheel execution strategy - install from wheel files.
+Uses shared utilities from common/services/install_cache_utils.
+"""
+
+import sys
+import subprocess
+from pathlib import Path
+from typing import List, Any, Optional
+from ...package.base import AInstallExecutionStrategy
+from ...package.services.install_result import InstallResult, InstallStatus
+from ...common.services.install_cache_utils import (
+    get_wheel_path,
+    ensure_cached_wheel,
+    pip_install_from_path,
+)
+
+
+class WheelExecution(AInstallExecutionStrategy):
+    """
+    Wheel execution strategy - installs packages from wheel files.
+    
+    Downloads wheel first, then installs from local wheel file.
+    Uses shared utilities from common/services/install_cache_utils.
+    """
+    
+    def __init__(self, cache_dir: Optional[Path] = None):
+        """
+        Initialize wheel execution strategy.
+        
+        Args:
+            cache_dir: Optional cache directory for wheels
+        """
+        self._cache_dir = cache_dir
+    
+    def execute_install(self, package_name: str, policy_args: List[str]) -> Any:
+        """
+        Execute installation from wheel file.
+        
+        Args:
+            package_name: Package name to install
+            policy_args: Policy arguments
+            
+        Returns:
+            InstallResult with success status
+        """
+        # Check if wheel already exists
+        wheel_path = get_wheel_path(package_name, self._cache_dir)
+        
+        if not wheel_path.exists():
+            # Download wheel first
+            wheel_path = ensure_cached_wheel(package_name, policy_args, self._cache_dir)
+            if wheel_path is None:
+                return InstallResult(
+                    package_name=package_name,
+                    success=False,
+                    status=InstallStatus.FAILED,
+                    error="Failed to download wheel"
+                )
+        
+        # Install from wheel
+        success = pip_install_from_path(wheel_path, policy_args)
+        
+        if success:
+            return InstallResult(
+                package_name=package_name,
+                success=True,
+                status=InstallStatus.SUCCESS,
+                source="wheel"
+            )
+        else:
+            return InstallResult(
+                package_name=package_name,
+                success=False,
+                status=InstallStatus.FAILED,
+                error="Failed to install from wheel"
+            )
+    
+    def execute_uninstall(self, package_name: str) -> bool:
+        """
+        Execute uninstallation using pip.
+        
+        Args:
+            package_name: Package name to uninstall
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            result = subprocess.run(
+                [sys.executable, '-m', 'pip', 'uninstall', '-y', package_name],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+

exonware/xwlazy/package/strategies/package_mapping_discovery_first.py

@@ -0,0 +1,101 @@
+"""
+Discovery-First Mapping Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Discovery-first mapping strategy - discovery takes precedence over manifest.
+"""
+
+from typing import Optional, List
+from ...package.base import AMappingStrategy
+from ...package.services.manifest import get_manifest_loader
+
+
+class DiscoveryFirstMapping(AMappingStrategy):
+    """
+    Discovery-first mapping strategy.
+    
+    Priority order:
+    1. Discovery mappings (automatic discovery - highest priority)
+    2. Manifest dependencies (explicit user configuration)
+    3. Common mappings (fallback)
+    """
+    
+    def __init__(self, package_name: str = 'default'):
+        """
+        Initialize discovery-first mapping strategy.
+        
+        Args:
+            package_name: Package name for isolation
+        """
+        self._package_name = package_name
+        self._discovery = None  # Lazy init
+    
+    def _get_discovery(self):
+        """Get discovery instance (lazy init)."""
+        if self._discovery is None:
+            from ...package.services.discovery import LazyDiscovery
+            self._discovery = LazyDiscovery(self._package_name)
+        return self._discovery
+    
+    def map_import_to_package(self, import_name: str) -> Optional[str]:
+        """
+        Map import name to package name.
+        
+        Priority: Discovery > Manifest > Common mappings
+        
+        Args:
+            import_name: Import name (e.g., 'cv2')
+            
+        Returns:
+            Package name (e.g., 'opencv-python') or None
+        """
+        # Check discovery mappings FIRST
+        discovery = self._get_discovery()
+        discovery_mapping = discovery.get_import_package_mapping()
+        package = discovery_mapping.get(import_name)
+        if package:
+            return package
+        
+        # Check manifest (fallback)
+        loader = get_manifest_loader()
+        manifest = loader.get_manifest(self._package_name)
+        if manifest:
+            package = manifest.get_dependency(import_name)
+            if package:
+                return package
+        
+        # Fallback to common mappings
+        common_mappings = discovery.COMMON_MAPPINGS
+        return common_mappings.get(import_name)
+    
+    def map_package_to_imports(self, package_name: str) -> List[str]:
+        """
+        Map package name to possible import names.
+        
+        Args:
+            package_name: Package name (e.g., 'opencv-python')
+            
+        Returns:
+            List of possible import names (e.g., ['cv2'])
+        """
+        # Check discovery mappings FIRST
+        discovery = self._get_discovery()
+        package_mapping = discovery.get_package_import_mapping()
+        imports = package_mapping.get(package_name, [])
+        
+        # Also check manifest (reverse lookup)
+        loader = get_manifest_loader()
+        manifest = loader.get_manifest(self._package_name)
+        if manifest:
+            for import_name, pkg in manifest.dependencies.items():
+                if pkg.lower() == package_name.lower():
+                    if import_name not in imports:
+                        imports.append(import_name)
+        
+        return imports if imports else [package_name]
+

exonware/xwlazy/package/strategies/package_mapping_hybrid.py

@@ -0,0 +1,106 @@
+"""
+Hybrid Mapping Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Hybrid mapping strategy - tries both manifest and discovery, uses best match.
+"""
+
+from typing import Optional, List
+from ...package.base import AMappingStrategy
+from ...package.services.manifest import get_manifest_loader
+
+
+class HybridMapping(AMappingStrategy):
+    """
+    Hybrid mapping strategy.
+    
+    Tries both manifest and discovery, uses the best match.
+    If both exist, prefers the one that's more specific.
+    """
+    
+    def __init__(self, package_name: str = 'default'):
+        """
+        Initialize hybrid mapping strategy.
+        
+        Args:
+            package_name: Package name for isolation
+        """
+        self._package_name = package_name
+        self._discovery = None  # Lazy init
+    
+    def _get_discovery(self):
+        """Get discovery instance (lazy init)."""
+        if self._discovery is None:
+            from ...package.services.discovery import LazyDiscovery
+            self._discovery = LazyDiscovery(self._package_name)
+        return self._discovery
+    
+    def map_import_to_package(self, import_name: str) -> Optional[str]:
+        """
+        Map import name to package name.
+        
+        Tries both manifest and discovery, prefers more specific match.
+        
+        Args:
+            import_name: Import name (e.g., 'cv2')
+            
+        Returns:
+            Package name (e.g., 'opencv-python') or None
+        """
+        # Try manifest first
+        loader = get_manifest_loader()
+        manifest = loader.get_manifest(self._package_name)
+        manifest_package = None
+        if manifest:
+            manifest_package = manifest.get_dependency(import_name)
+        
+        # Try discovery
+        discovery = self._get_discovery()
+        discovery_mapping = discovery.get_import_package_mapping()
+        discovery_package = discovery_mapping.get(import_name)
+        
+        # Prefer manifest if both exist (more explicit)
+        if manifest_package:
+            return manifest_package
+        
+        if discovery_package:
+            return discovery_package
+        
+        # Fallback to common mappings
+        common_mappings = discovery.COMMON_MAPPINGS
+        return common_mappings.get(import_name)
+    
+    def map_package_to_imports(self, package_name: str) -> List[str]:
+        """
+        Map package name to possible import names.
+        
+        Args:
+            package_name: Package name (e.g., 'opencv-python')
+            
+        Returns:
+            List of possible import names (e.g., ['cv2'])
+        """
+        imports = []
+        
+        # Check discovery mappings
+        discovery = self._get_discovery()
+        package_mapping = discovery.get_package_import_mapping()
+        discovery_imports = package_mapping.get(package_name, [])
+        imports.extend(discovery_imports)
+        
+        # Check manifest (reverse lookup)
+        loader = get_manifest_loader()
+        manifest = loader.get_manifest(self._package_name)
+        if manifest:
+            for import_name, pkg in manifest.dependencies.items():
+                if pkg.lower() == package_name.lower():
+                    if import_name not in imports:
+                        imports.append(import_name)
+        
+        return imports if imports else [package_name]
+

exonware/xwlazy/package/strategies/package_mapping_manifest_first.py

@@ -0,0 +1,101 @@
+"""
+Manifest-First Mapping Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Manifest-first mapping strategy - manifest takes precedence over discovery.
+"""
+
+from typing import Optional, List
+from ...package.base import AMappingStrategy
+from ...package.services.manifest import get_manifest_loader
+
+
+class ManifestFirstMapping(AMappingStrategy):
+    """
+    Manifest-first mapping strategy.
+    
+    Priority order:
+    1. Manifest dependencies (explicit user configuration - highest priority)
+    2. Discovery mappings (automatic discovery)
+    3. Common mappings (fallback)
+    """
+    
+    def __init__(self, package_name: str = 'default'):
+        """
+        Initialize manifest-first mapping strategy.
+        
+        Args:
+            package_name: Package name for isolation
+        """
+        self._package_name = package_name
+        self._discovery = None  # Lazy init
+    
+    def _get_discovery(self):
+        """Get discovery instance (lazy init)."""
+        if self._discovery is None:
+            from ...package.services.discovery import LazyDiscovery
+            self._discovery = LazyDiscovery(self._package_name)
+        return self._discovery
+    
+    def map_import_to_package(self, import_name: str) -> Optional[str]:
+        """
+        Map import name to package name.
+        
+        Priority: Manifest > Discovery > Common mappings
+        
+        Args:
+            import_name: Import name (e.g., 'cv2')
+            
+        Returns:
+            Package name (e.g., 'opencv-python') or None
+        """
+        # Check manifest FIRST - explicit user configuration takes precedence
+        loader = get_manifest_loader()
+        manifest = loader.get_manifest(self._package_name)
+        if manifest:
+            package = manifest.get_dependency(import_name)
+            if package:
+                return package
+        
+        # Check discovery mappings
+        discovery = self._get_discovery()
+        discovery_mapping = discovery.get_import_package_mapping()
+        package = discovery_mapping.get(import_name)
+        if package:
+            return package
+        
+        # Fallback to common mappings
+        common_mappings = discovery.COMMON_MAPPINGS
+        return common_mappings.get(import_name)
+    
+    def map_package_to_imports(self, package_name: str) -> List[str]:
+        """
+        Map package name to possible import names.
+        
+        Args:
+            package_name: Package name (e.g., 'opencv-python')
+            
+        Returns:
+            List of possible import names (e.g., ['cv2'])
+        """
+        # Check discovery mappings
+        discovery = self._get_discovery()
+        package_mapping = discovery.get_package_import_mapping()
+        imports = package_mapping.get(package_name, [])
+        
+        # Also check manifest (reverse lookup)
+        loader = get_manifest_loader()
+        manifest = loader.get_manifest(self._package_name)
+        if manifest:
+            for import_name, pkg in manifest.dependencies.items():
+                if pkg.lower() == package_name.lower():
+                    if import_name not in imports:
+                        imports.append(import_name)
+        
+        return imports if imports else [package_name]
+

exonware/xwlazy/package/strategies/package_policy_allow_list.py

@@ -0,0 +1,58 @@
+"""
+Allow List Policy Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Allow list policy - only allows packages in the allow list.
+"""
+
+from typing import Tuple, List, Set
+from ...package.base import APolicyStrategy
+
+
+class AllowListPolicy(APolicyStrategy):
+    """
+    Allow list policy strategy - only allows packages in the allow list.
+    
+    Only packages explicitly in the allow list can be installed.
+    """
+    
+    def __init__(self, allowed_packages: Set[str]):
+        """
+        Initialize allow list policy.
+        
+        Args:
+            allowed_packages: Set of allowed package names
+        """
+        self._allowed = {pkg.lower() for pkg in allowed_packages}
+    
+    def is_allowed(self, package_name: str) -> Tuple[bool, str]:
+        """
+        Check if package is allowed to be installed.
+        
+        Args:
+            package_name: Package name to check
+            
+        Returns:
+            Tuple of (allowed: bool, reason: str)
+        """
+        if package_name.lower() in self._allowed:
+            return (True, f"Package '{package_name}' is in allow list")
+        return (False, f"Package '{package_name}' is not in allow list")
+    
+    def get_pip_args(self, package_name: str) -> List[str]:
+        """
+        Get pip arguments based on policy.
+        
+        Args:
+            package_name: Package name
+            
+        Returns:
+            List of pip arguments (empty for allow list policy)
+        """
+        return []
+

exonware/xwlazy/package/strategies/package_policy_deny_list.py

@@ -0,0 +1,58 @@
+"""
+Deny List Policy Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Deny list policy - blocks packages in the deny list.
+"""
+
+from typing import Tuple, List, Set
+from ...package.base import APolicyStrategy
+
+
+class DenyListPolicy(APolicyStrategy):
+    """
+    Deny list policy strategy - blocks packages in the deny list.
+    
+    Packages in the deny list cannot be installed.
+    """
+    
+    def __init__(self, denied_packages: Set[str]):
+        """
+        Initialize deny list policy.
+        
+        Args:
+            denied_packages: Set of denied package names
+        """
+        self._denied = {pkg.lower() for pkg in denied_packages}
+    
+    def is_allowed(self, package_name: str) -> Tuple[bool, str]:
+        """
+        Check if package is allowed to be installed.
+        
+        Args:
+            package_name: Package name to check
+            
+        Returns:
+            Tuple of (allowed: bool, reason: str)
+        """
+        if package_name.lower() in self._denied:
+            return (False, f"Package '{package_name}' is in deny list")
+        return (True, f"Package '{package_name}' is not in deny list")
+    
+    def get_pip_args(self, package_name: str) -> List[str]:
+        """
+        Get pip arguments based on policy.
+        
+        Args:
+            package_name: Package name
+            
+        Returns:
+            List of pip arguments (empty for deny list policy)
+        """
+        return []
+

exonware/xwlazy/package/strategies/package_policy_permissive.py

@@ -0,0 +1,47 @@
+"""
+Permissive Policy Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Permissive policy - allows all packages (default).
+"""
+
+from typing import Tuple, List
+from ...package.base import APolicyStrategy
+
+
+class PermissivePolicy(APolicyStrategy):
+    """
+    Permissive policy strategy - allows all packages.
+    
+    This is the default policy that doesn't restrict any packages.
+    """
+    
+    def is_allowed(self, package_name: str) -> Tuple[bool, str]:
+        """
+        Check if package is allowed to be installed.
+        
+        Args:
+            package_name: Package name to check
+            
+        Returns:
+            Tuple of (allowed: bool, reason: str)
+        """
+        return (True, "Permissive policy allows all packages")
+    
+    def get_pip_args(self, package_name: str) -> List[str]:
+        """
+        Get pip arguments based on policy.
+        
+        Args:
+            package_name: Package name
+            
+        Returns:
+            List of pip arguments (empty for permissive policy)
+        """
+        return []
+

exonware/xwlazy/package/strategies/package_timing_clean.py

@@ -0,0 +1,68 @@
+"""
+Clean Timing Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Clean timing - install on usage + uninstall after completion.
+"""
+
+from typing import List, Any
+from ...package.base import AInstallTimingStrategy
+
+
+class CleanTiming(AInstallTimingStrategy):
+    """
+    Clean timing strategy - installs on usage + uninstalls after completion (LazyInstallMode.CLEAN).
+    
+    Installs package when needed, then uninstalls after use to keep environment clean.
+    """
+    
+    def should_install_now(self, package_name: str, context: Any) -> bool:
+        """
+        Determine if package should be installed now.
+        
+        Clean mode: Install when first needed.
+        
+        Args:
+            package_name: Package name to check
+            context: Context information (e.g., import error)
+            
+        Returns:
+            True if should install now
+        """
+        # In clean mode, install when first needed
+        return context is not None
+    
+    def should_uninstall_after(self, package_name: str, context: Any) -> bool:
+        """
+        Determine if package should be uninstalled after use.
+        
+        Clean mode: Uninstall after use.
+        
+        Args:
+            package_name: Package name to check
+            context: Context information
+            
+        Returns:
+            True (uninstall after use)
+        """
+        return True
+    
+    def get_install_priority(self, packages: List[str]) -> List[str]:
+        """
+        Get priority order for installing packages.
+        
+        Clean mode: Install in order requested.
+        
+        Args:
+            packages: List of package names
+            
+        Returns:
+            Priority-ordered list
+        """
+        return packages
+