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

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
+

exonware/xwlazy/package/strategies/package_execution_async.py

@@ -0,0 +1,114 @@
+"""
+Async Execution Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+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,91 @@
+"""
+Cached Execution Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+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,100 @@
+"""
+Pip Execution Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+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
+