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

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

exonware/xwlazy/package/strategies/package_timing_full.py

@@ -1,66 +0,0 @@
-"""
-Full Timing Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Full timing - install all dependencies upfront.
-"""
-
-from typing import Any
-from ...package.base import AInstallTimingStrategy
-
-class FullTiming(AInstallTimingStrategy):
-    """
-    Full timing strategy - installs all packages upfront (LazyInstallMode.FULL).
-    
-    Batch installs all dependencies in parallel on initialization.
-    """
-    
-    def should_install_now(self, package_name: str, context: Any) -> bool:
-        """
-        Determine if package should be installed now.
-        
-        Full mode: Install all upfront.
-        
-        Args:
-            package_name: Package name to check
-            context: Context information (ignored in full mode)
-            
-        Returns:
-            True (always install upfront)
-        """
-        return True
-    
-    def should_uninstall_after(self, package_name: str, context: Any) -> bool:
-        """
-        Determine if package should be uninstalled after use.
-        
-        Full mode: Keep installed after use.
-        
-        Args:
-            package_name: Package name to check
-            context: Context information
-            
-        Returns:
-            False (keep installed)
-        """
-        return False
-    
-    def get_install_priority(self, packages: list[str]) -> list[str]:
-        """
-        Get priority order for installing packages.
-        
-        Full mode: Install all in parallel (no specific order).
-        
-        Args:
-            packages: List of package names
-            
-        Returns:
-            Priority-ordered list (original order)
-        """
-        return packages
-

exonware/xwlazy/package/strategies/package_timing_smart.py

@@ -1,68 +0,0 @@
-"""
-Smart Timing Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Smart timing - install on first usage (on-demand).
-"""
-
-from typing import Any
-from ...package.base import AInstallTimingStrategy
-from ...defs import LazyInstallMode
-
-class SmartTiming(AInstallTimingStrategy):
-    """
-    Smart timing strategy - installs packages on-demand (LazyInstallMode.SMART).
-    
-    Installs package when first needed, then caches the result.
-    """
-    
-    def should_install_now(self, package_name: str, context: Any) -> bool:
-        """
-        Determine if package should be installed now.
-        
-        Smart 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 smart mode, install when first needed (context indicates need)
-        return context is not None
-    
-    def should_uninstall_after(self, package_name: str, context: Any) -> bool:
-        """
-        Determine if package should be uninstalled after use.
-        
-        Smart mode: Keep installed after use.
-        
-        Args:
-            package_name: Package name to check
-            context: Context information
-            
-        Returns:
-            False (keep installed)
-        """
-        return False
-    
-    def get_install_priority(self, packages: list[str]) -> list[str]:
-        """
-        Get priority order for installing packages.
-        
-        Smart mode: Install in order requested.
-        
-        Args:
-            packages: List of package names
-            
-        Returns:
-            Priority-ordered list
-        """
-        return packages
-

exonware/xwlazy/package/strategies/package_timing_temporary.py

@@ -1,66 +0,0 @@
-"""
-Temporary Timing Strategy
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Temporary timing - always uninstall after use (more aggressive than CLEAN).
-"""
-
-from typing import Any
-from ...package.base import AInstallTimingStrategy
-
-class TemporaryTiming(AInstallTimingStrategy):
-    """
-    Temporary timing strategy - always uninstalls after use (LazyInstallMode.TEMPORARY).
-    
-    More aggressive than CLEAN - always uninstalls packages after use.
-    """
-    
-    def should_install_now(self, package_name: str, context: Any) -> bool:
-        """
-        Determine if package should be installed now.
-        
-        Temporary 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
-        """
-        return context is not None
-    
-    def should_uninstall_after(self, package_name: str, context: Any) -> bool:
-        """
-        Determine if package should be uninstalled after use.
-        
-        Temporary mode: Always uninstall after use.
-        
-        Args:
-            package_name: Package name to check
-            context: Context information (ignored)
-            
-        Returns:
-            True (always uninstall)
-        """
-        return True
-    
-    def get_install_priority(self, packages: list[str]) -> list[str]:
-        """
-        Get priority order for installing packages.
-        
-        Temporary mode: Install in order requested.
-        
-        Args:
-            packages: List of package names
-            
-        Returns:
-            Priority-ordered list
-        """
-        return packages
-

exonware/xwlazy/runtime/__init__.py

@@ -1,18 +0,0 @@
-"""
-Runtime Services Module
-
-This module provides concrete implementations for runtime services.
-Main facade: XWRuntimeHelper extends ARuntimeHelper
-"""
-
-# Lazy imports to avoid circular dependencies
-def __getattr__(name: str):
-    if name == 'XWRuntimeHelper':
-        from .facade import XWRuntimeHelper
-        return XWRuntimeHelper
-    if name == 'XWRuntime':  # Backward compatibility alias
-        from .facade import XWRuntimeHelper
-        return XWRuntimeHelper
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-
-__all__ = ['XWRuntimeHelper', 'XWRuntime']  # XWRuntime is backward compatibility alias

exonware/xwlazy/runtime/adaptive_learner.py

@@ -1,129 +0,0 @@
-"""
-#exonware/xwlazy/src/exonware/xwlazy/loading/adaptive_utils.py
-
-Adaptive learning utilities for pattern-based optimization.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 19-Nov-2025
-
-This module provides adaptive learning for ADAPTIVE mode.
-"""
-
-import time
-import threading
-from typing import Optional
-from collections import defaultdict, deque
-
-# Logger not used in this module, removed to avoid circular dependency
-
-class AdaptiveLearner:
-    """Learns import patterns and optimizes loading strategy."""
-    
-    def __init__(self, learning_window: int = 100, prediction_depth: int = 3):
-        """
-        Initialize adaptive learner.
-        
-        Args:
-            learning_window: Number of imports to track for learning
-            prediction_depth: Depth of sequence predictions
-        """
-        self._learning_window = learning_window
-        self._prediction_depth = prediction_depth
-        self._import_sequences: deque = deque(maxlen=learning_window)
-        self._access_times: dict[str, list[float]] = defaultdict(list)
-        self._import_chains: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
-        self._module_scores: dict[str, float] = {}
-        self._lock = threading.RLock()
-    
-    def record_import(self, module_name: str, import_time: float) -> None:
-        """Record an import event."""
-        current_time = time.time()
-        
-        # Lock-free append to deque (thread-safe for appends)
-        self._import_sequences.append((module_name, current_time, import_time))
-        
-        with self._lock:
-            self._access_times[module_name].append(current_time)
-            
-            # Update import chains (what imports after what)
-            if len(self._import_sequences) > 1:
-                prev_name, _, _ = self._import_sequences[-2]
-                self._import_chains[prev_name][module_name] += 1
-            
-            # Update module score (frequency * recency) - defer heavy computation
-            if len(self._access_times[module_name]) % 5 == 0:  # Update every 5th access
-                self._update_module_score(module_name)
-    
-    def _update_module_score(self, module_name: str) -> None:
-        """Update module priority score."""
-        with self._lock:
-            accesses = self._access_times[module_name]
-            if not accesses:
-                return
-            
-            # Frequency component
-            recent_accesses = [t for t in accesses if time.time() - t < 3600]  # Last hour
-            frequency = len(recent_accesses)
-            
-            # Recency component (more recent = higher score)
-            if accesses:
-                last_access = accesses[-1]
-                recency = 1.0 / (time.time() - last_access + 1.0)
-            else:
-                recency = 0.0
-            
-            # Chain component (if often imported after another module)
-            chain_weight = sum(self._import_chains.get(prev, {}).get(module_name, 0) 
-                             for prev in self._access_times.keys()) / max(len(self._import_sequences), 1)
-            
-            # Combined score
-            self._module_scores[module_name] = frequency * 0.4 + recency * 1000 * 0.4 + chain_weight * 0.2
-    
-    def predict_next_imports(self, current_module: Optional[str] = None, limit: int = 5) -> list[str]:
-        """Predict likely next imports based on patterns."""
-        # Lock-free check first
-        if not self._import_sequences:
-            return []
-        
-        with self._lock:
-            candidates: dict[str, float] = {}
-            
-            # Predict based on current module chain (lock-free read of dict)
-            if current_module:
-                chain_candidates = self._import_chains.get(current_module, {})
-                for module, count in chain_candidates.items():
-                    candidates[module] = candidates.get(module, 0.0) + count * 2.0
-            
-            # Add high-scoring modules (lock-free read of dict)
-            for module, score in self._module_scores.items():
-                candidates[module] = candidates.get(module, 0.0) + score * 0.5
-            
-            # Sort by score
-            sorted_candidates = sorted(candidates.items(), key=lambda x: x[1], reverse=True)
-            return [module for module, _ in sorted_candidates[:limit]]
-    
-    def get_priority_modules(self, limit: int = 10) -> list[str]:
-        """Get modules that should be preloaded based on scores."""
-        with self._lock:
-            sorted_modules = sorted(
-                self._module_scores.items(),
-                key=lambda x: x[1],
-                reverse=True
-            )
-            return [module for module, _ in sorted_modules[:limit]]
-    
-    def get_stats(self) -> Dict:
-        """Get learning statistics."""
-        with self._lock:
-            return {
-                'sequences_tracked': len(self._import_sequences),
-                'unique_modules': len(self._access_times),
-                'chains_tracked': sum(len(chains) for chains in self._import_chains.values()),
-                'top_modules': self.get_priority_modules(5),
-            }
-
-__all__ = ['AdaptiveLearner']
-