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

exonware/xwlazy/package/strategies/package_mapping_manifest_first.py

@@ -0,0 +1,101 @@
+"""
+Manifest-First Mapping Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Manifest-first mapping strategy - manifest takes precedence over discovery.
+"""
+
+from typing import Optional, List
+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

@@ -0,0 +1,58 @@
+"""
+Allow List Policy Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Allow list policy - only allows packages in the allow list.
+"""
+
+from typing import Tuple, List, Set
+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

@@ -0,0 +1,58 @@
+"""
+Deny List Policy Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Deny list policy - blocks packages in the deny list.
+"""
+
+from typing import Tuple, List, Set
+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

@@ -0,0 +1,47 @@
+"""
+Permissive Policy Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Permissive policy - allows all packages (default).
+"""
+
+from typing import Tuple, List
+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

@@ -0,0 +1,68 @@
+"""
+Clean Timing Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Clean timing - install on usage + uninstall after completion.
+"""
+
+from typing import List, 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

@@ -0,0 +1,67 @@
+"""
+Full Timing Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Full timing - install all dependencies upfront.
+"""
+
+from typing import List, 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

@@ -0,0 +1,69 @@
+"""
+Smart Timing Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Smart timing - install on first usage (on-demand).
+"""
+
+from typing import List, 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

@@ -0,0 +1,67 @@
+"""
+Temporary Timing Strategy
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Temporary timing - always uninstall after use (more aggressive than CLEAN).
+"""
+
+from typing import List, 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

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

@@ -0,0 +1,131 @@
+"""
+#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
+Version: 0.1.0.19
+Generation Date: 19-Nov-2025
+
+This module provides adaptive learning for ADAPTIVE mode.
+"""
+
+import time
+import threading
+from typing import Dict, List, Tuple, 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']
+