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

exonware/xwlazy/package/strategies/__init__.py

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

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

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

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

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

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

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