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

exonware/xwlazy/package/strategies/package_execution_async.py

@@ -0,0 +1,113 @@
+"""
+Async Execution Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+
+Generation Date: 15-Nov-2025
+
+Async execution strategy - async pip install using asyncio.
+Uses shared utilities from common/services/install_async_utils.
+"""
+
+import sys
+import asyncio
+import subprocess
+from typing import List, Any
+from ...package.base import AInstallExecutionStrategy
+from ...package.services.install_result import InstallResult, InstallStatus
+from ...common.services.install_async_utils import async_install_package
+
+class AsyncExecution(AInstallExecutionStrategy):
+    """
+    Async execution strategy - installs packages asynchronously using asyncio.
+    
+    Uses asyncio subprocess for non-blocking installation.
+    Uses shared utilities from common/services/install_async_utils.
+    """
+    
+    def execute_install(self, package_name: str, policy_args: List[str]) -> Any:
+        """
+        Execute installation asynchronously.
+        
+        Note: This is a synchronous wrapper that runs async code.
+        For true async, use the async methods directly.
+        
+        Args:
+            package_name: Package name to install
+            policy_args: Policy arguments
+            
+        Returns:
+            InstallResult with success status
+        """
+        try:
+            # Run async install in event loop
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # If loop is running, use run_coroutine_threadsafe
+                future = asyncio.run_coroutine_threadsafe(
+                    self._async_install(package_name, policy_args),
+                    loop
+                )
+                return future.result(timeout=600)  # 10 min timeout
+            else:
+                # If no loop running, use asyncio.run
+                return asyncio.run(self._async_install(package_name, policy_args))
+        except Exception as e:
+            return InstallResult(
+                package_name=package_name,
+                success=False,
+                status=InstallStatus.FAILED,
+                error=str(e)
+            )
+    
+    async def _async_install(self, package_name: str, policy_args: List[str]) -> InstallResult:
+        """
+        Async installation implementation.
+        
+        Args:
+            package_name: Package name to install
+            policy_args: Policy arguments
+            
+        Returns:
+            InstallResult with success status
+        """
+        success, error_msg = await async_install_package(package_name, policy_args)
+        
+        if success:
+            return InstallResult(
+                package_name=package_name,
+                success=True,
+                status=InstallStatus.SUCCESS,
+                source="pip-async"
+            )
+        else:
+            return InstallResult(
+                package_name=package_name,
+                success=False,
+                status=InstallStatus.FAILED,
+                error=error_msg or "Unknown error"
+            )
+    
+    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_execution_cached.py

@@ -0,0 +1,90 @@
+"""
+Cached Execution Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+
+Generation Date: 15-Nov-2025
+
+Cached execution strategy - install from cached tree.
+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_cache_dir,
+    install_from_cached_tree,
+)
+
+class CachedExecution(AInstallExecutionStrategy):
+    """
+    Cached execution strategy - installs packages from cached installation tree.
+    
+    Fastest installation method - copies from pre-extracted cache.
+    Uses shared utilities from common/services/install_cache_utils.
+    """
+    
+    def __init__(self, cache_dir: Optional[Path] = None):
+        """
+        Initialize cached execution strategy.
+        
+        Args:
+            cache_dir: Optional cache directory for installation trees
+        """
+        self._cache_dir = cache_dir
+    
+    def execute_install(self, package_name: str, policy_args: List[str]) -> Any:
+        """
+        Execute installation from cached tree.
+        
+        Args:
+            package_name: Package name to install
+            policy_args: Policy arguments (ignored for cached install)
+            
+        Returns:
+            InstallResult with success status
+        """
+        success = install_from_cached_tree(package_name, self._cache_dir)
+        
+        if success:
+            return InstallResult(
+                package_name=package_name,
+                success=True,
+                status=InstallStatus.SUCCESS,
+                source="cache-tree"
+            )
+        else:
+            return InstallResult(
+                package_name=package_name,
+                success=False,
+                status=InstallStatus.FAILED,
+                error="Cached installation tree not found"
+            )
+    
+    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_execution_pip.py

@@ -0,0 +1,99 @@
+"""
+Pip Execution Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+
+Generation Date: 15-Nov-2025
+
+Pip execution strategy - direct pip install.
+"""
+
+import sys
+import subprocess
+from typing import List, Any
+from ...package.base import AInstallExecutionStrategy
+from ...package.services.install_result import InstallResult, InstallStatus
+
+class PipExecution(AInstallExecutionStrategy):
+    """
+    Pip execution strategy - installs packages directly using pip.
+    
+    This is the default execution strategy that uses pip install.
+    """
+    
+    def execute_install(self, package_name: str, policy_args: List[str]) -> Any:
+        """
+        Execute installation using pip.
+        
+        Args:
+            package_name: Package name to install
+            policy_args: Policy arguments (index URLs, trusted hosts, etc.)
+            
+        Returns:
+            InstallResult with success status
+        """
+        try:
+            pip_args = [sys.executable, '-m', 'pip', 'install']
+            if policy_args:
+                pip_args.extend(policy_args)
+            pip_args.append(package_name)
+            
+            result = subprocess.run(
+                pip_args,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            
+            if result.returncode == 0:
+                return InstallResult(
+                    package_name=package_name,
+                    success=True,
+                    status=InstallStatus.SUCCESS,
+                    source="pip"
+                )
+            else:
+                return InstallResult(
+                    package_name=package_name,
+                    success=False,
+                    status=InstallStatus.FAILED,
+                    error=result.stderr or "Unknown error"
+                )
+        except subprocess.CalledProcessError as e:
+            return InstallResult(
+                package_name=package_name,
+                success=False,
+                status=InstallStatus.FAILED,
+                error=e.stderr or str(e)
+            )
+        except Exception as e:
+            return InstallResult(
+                package_name=package_name,
+                success=False,
+                status=InstallStatus.FAILED,
+                error=str(e)
+            )
+    
+    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_execution_wheel.py

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

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

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