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

exonware/xwlazy/package/strategies/package_execution_wheel.py

@@ -1,106 +0,0 @@
-"""
-Wheel Execution Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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

@@ -1,100 +0,0 @@
-"""
-Discovery-First Mapping Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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

@@ -1,105 +0,0 @@
-"""
-Hybrid Mapping Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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

@@ -1,100 +0,0 @@
-"""
-Manifest-First Mapping Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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

@@ -1,57 +0,0 @@
-"""
-Allow List Policy Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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

@@ -1,57 +0,0 @@
-"""
-Deny List Policy Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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

@@ -1,46 +0,0 @@
-"""
-Permissive Policy Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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

@@ -1,67 +0,0 @@
-"""
-Clean Timing Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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
-