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

exonware/xwlazy/package/strategies/package_execution_async.py

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

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

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

@@ -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 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
-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
-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]
-