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

exonware/xwlazy/runtime/facade.py

@@ -1,94 +0,0 @@
-"""
-Runtime Services Facade
-
-Main facade: XWRuntimeHelper extends ARuntimeHelper
-Provides concrete implementation for all runtime services.
-"""
-
-from typing import Dict, List, Optional, Tuple, Any
-from .base import ARuntimeHelper
-from ..defs import LazyLoadMode, LazyInstallMode
-
-class XWRuntimeHelper(ARuntimeHelper):
-    """
-    Concrete implementation of ARuntimeHelper.
-    
-    Provides runtime services for state management, learning, monitoring, and caching.
-    """
-    
-    def __init__(self):
-        """Initialize XW runtime services."""
-        super().__init__()
-    
-    # Abstract methods from ARuntime that need implementation
-    def record_import(self, module_name: str, import_time: float) -> None:
-        """Record an import event."""
-        # TODO: Implement import recording
-        pass
-    
-    def predict_next_imports(self, current_module: str, count: int = 3) -> List[str]:
-        """Predict next likely imports based on patterns."""
-        # TODO: Implement prediction logic
-        return []
-    
-    def get_module_score(self, module_name: str) -> float:
-        """Get priority score for a module."""
-        # TODO: Implement scoring logic
-        return 0.0
-    
-    def detect_load_level(
-        self,
-        module_count: int = 0,
-        total_import_time: float = 0.0,
-        import_count: int = 0,
-        memory_usage_mb: float = 0.0
-    ):
-        """Detect current load level."""
-        # TODO: Implement load level detection
-        from .intelligent_selector import LoadLevel
-        return LoadLevel.LIGHT
-    
-    def get_optimal_mode(self, load_level) -> Tuple[LazyLoadMode, LazyInstallMode]:
-        """Get optimal mode for a load level."""
-        # TODO: Implement mode selection
-        return LazyLoadMode.AUTO, LazyInstallMode.SMART
-    
-    def update_mode_map(self, mode_map: Dict[Any, Tuple[LazyLoadMode, LazyInstallMode]]) -> None:
-        """Update mode mapping with benchmark results."""
-        # TODO: Implement mode map update
-        pass
-    
-    def get_metric_stats(self, name: str) -> Dict[str, Any]:
-        """Get statistics for a metric."""
-        with self._lock:
-            values = self._metrics.get(name, [])
-            if not values:
-                return {'count': 0, 'total': 0.0, 'average': 0.0, 'min': 0.0, 'max': 0.0}
-            return {
-                'count': len(values),
-                'total': sum(values),
-                'average': sum(values) / len(values),
-                'min': min(values),
-                'max': max(values)
-            }
-    
-    def get_all_stats(self) -> Dict[str, Dict[str, Any]]:
-        """Get statistics for all metrics."""
-        with self._lock:
-            return {name: self.get_metric_stats(name) for name in self._metrics.keys()}
-    
-    def get_performance_stats(self) -> Dict[str, Any]:
-        """Get performance statistics."""
-        with self._lock:
-            return {
-                'load_times': {k: {'count': len(v), 'total': sum(v), 'average': sum(v) / len(v) if v else 0.0} 
-                              for k, v in self._load_times.items()},
-                'access_counts': self._access_counts.copy(),
-                'memory_usage': 0.0  # TODO: Implement memory usage tracking
-            }
-    
-    def shutdown_multi_tier_cache(self) -> None:
-        """Shutdown cache (flush L2, cleanup threads)."""
-        # TODO: Implement cache shutdown
-        pass
-

exonware/xwlazy/runtime/intelligent_selector.py

@@ -1,170 +0,0 @@
-"""
-#exonware/xwlazy/src/exonware/xwlazy/loading/intelligent_utils.py
-
-Intelligent mode utilities for automatic mode switching.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 19-Nov-2025
-
-This module provides intelligent mode switching based on load level.
-"""
-
-from typing import Dict, Tuple, Optional
-
-from ..defs import LazyLoadMode, LazyInstallMode, LoadLevel
-
-# Lazy import to avoid circular dependency
-logger = None
-
-def _get_logger():
-    """Get logger (lazy import to avoid circular dependency)."""
-    global logger
-    if logger is None:
-        from ..common.logger import get_logger
-        logger = get_logger("xwlazy.loading.intelligent")
-    return logger
-
-# Optimal mode mappings based on benchmark results (updated from consistency test)
-# Format: {LoadLevel: (LazyLoadMode, LazyInstallMode)}
-# Updated: 2025-11-19 - Based on 20-iteration consistency test averages
-# Light: ultra+full (0.568ms avg), Medium: hyperparallel+full (5.134ms avg)
-# Heavy: preload+size_aware (18.475ms avg), Enterprise: preload+full (44.742ms avg)
-INTELLIGENT_MODE_MAP: Dict[LoadLevel, Tuple[LazyLoadMode, LazyInstallMode]] = {
-    LoadLevel.LIGHT: (LazyLoadMode.ULTRA, LazyInstallMode.FULL),  # Winner: 0.568ms avg (±26.1% CV)
-    LoadLevel.MEDIUM: (LazyLoadMode.HYPERPARALLEL, LazyInstallMode.FULL),  # Winner: 5.134ms avg (±4.7% CV)
-    LoadLevel.HEAVY: (LazyLoadMode.PRELOAD, LazyInstallMode.SIZE_AWARE),  # Winner: 18.475ms avg (±10.2% CV)
-    LoadLevel.ENTERPRISE: (LazyLoadMode.PRELOAD, LazyInstallMode.FULL),  # Winner: 44.742ms avg (±1.5% CV)
-}
-
-class IntelligentModeSelector:
-    """Selects optimal mode based on current load characteristics."""
-    
-    def __init__(self, mode_map: Optional[Dict[LoadLevel, Tuple[LazyLoadMode, LazyInstallMode]]] = None):
-        """
-        Initialize intelligent mode selector.
-        
-        Args:
-            mode_map: Custom mode mapping (defaults to INTELLIGENT_MODE_MAP)
-        """
-        self._mode_map = mode_map or INTELLIGENT_MODE_MAP.copy()
-        self._current_load_level: Optional[LoadLevel] = None
-        self._module_count = 0
-        self._total_import_time = 0.0
-        self._import_count = 0
-    
-    def update_mode_map(self, mode_map: Dict[LoadLevel, Tuple[LazyLoadMode, LazyInstallMode]]) -> None:
-        """Update the mode mapping with benchmark results."""
-        self._mode_map = mode_map.copy()
-        _get_logger().info(f"Updated INTELLIGENT mode mapping: {mode_map}")
-    
-    def detect_load_level(
-        self,
-        module_count: int = 0,
-        total_import_time: float = 0.0,
-        import_count: int = 0,
-        memory_usage_mb: float = 0.0
-    ) -> LoadLevel:
-        """
-        Detect current load level based on system characteristics.
-        
-        Args:
-            module_count: Number of modules loaded
-            total_import_time: Total time spent on imports (seconds)
-            import_count: Number of imports performed
-            memory_usage_mb: Current memory usage in MB
-            
-        Returns:
-            Detected LoadLevel
-        """
-        # Update internal state
-        self._module_count = module_count
-        self._total_import_time = total_import_time
-        self._import_count = import_count
-        
-        # Simple heuristics based on module count and import patterns
-        # These thresholds can be tuned based on actual usage patterns
-        
-        if import_count == 0:
-            # Initial state - default to light
-            self._current_load_level = LoadLevel.LIGHT
-        elif module_count < 5 and import_count < 10:
-            # Light load: few modules, few imports
-            self._current_load_level = LoadLevel.LIGHT
-        elif module_count < 20 and import_count < 50:
-            # Medium load: moderate number of modules/imports
-            self._current_load_level = LoadLevel.MEDIUM
-        elif module_count < 100 and import_count < 200:
-            # Heavy load: many modules, many imports
-            self._current_load_level = LoadLevel.HEAVY
-        else:
-            # Enterprise load: very large scale
-            self._current_load_level = LoadLevel.ENTERPRISE
-        
-        # Override based on memory usage if significant
-        if memory_usage_mb > 300:
-            self._current_load_level = LoadLevel.ENTERPRISE
-        elif memory_usage_mb > 150:
-            self._current_load_level = LoadLevel.HEAVY
-        
-        return self._current_load_level
-    
-    def get_optimal_mode(self, load_level: Optional[LoadLevel] = None) -> Tuple[LazyLoadMode, LazyInstallMode]:
-        """
-        Get optimal mode combination for given load level.
-        
-        Args:
-            load_level: Load level (if None, uses detected level)
-            
-        Returns:
-            Tuple of (LazyLoadMode, LazyInstallMode)
-        """
-        if load_level is None:
-            load_level = self._current_load_level or LoadLevel.LIGHT
-        
-        optimal = self._mode_map.get(load_level)
-        if optimal is None:
-            # Fallback to default
-            _get_logger().warning(f"No optimal mode found for {load_level}, using default")
-            optimal = (LazyLoadMode.AUTO, LazyInstallMode.SMART)
-        
-        return optimal
-    
-    def should_switch_mode(
-        self,
-        current_mode: Tuple[LazyLoadMode, LazyInstallMode],
-        detected_level: LoadLevel
-    ) -> bool:
-        """
-        Determine if mode should be switched based on detected load level.
-        
-        Args:
-            current_mode: Current (load_mode, install_mode) tuple
-            detected_level: Detected load level
-            
-        Returns:
-            True if mode should be switched
-        """
-        optimal_mode = self.get_optimal_mode(detected_level)
-        return current_mode != optimal_mode
-    
-    def get_stats(self) -> Dict:
-        """Get intelligent mode statistics."""
-        return {
-            'current_load_level': self._current_load_level.value if self._current_load_level else None,
-            'module_count': self._module_count,
-            'import_count': self._import_count,
-            'total_import_time': self._total_import_time,
-            'mode_map': {
-                level.value: {
-                    'load_mode': mode[0].value,
-                    'install_mode': mode[1].value
-                }
-                for level, mode in self._mode_map.items()
-            }
-        }
-
-__all__ = ['LoadLevel', 'INTELLIGENT_MODE_MAP', 'IntelligentModeSelector']
-

exonware/xwlazy/runtime/metrics.py

@@ -1,60 +0,0 @@
-"""
-Performance metrics tracking for lazy loading system.
-
-This module provides utilities for tracking and aggregating performance metrics.
-"""
-
-from typing import Dict, Any, List, Optional
-from datetime import datetime
-from collections import defaultdict
-
-class MetricsCollector:
-    """Collects and aggregates performance metrics."""
-    
-    def __init__(self):
-        """Initialize metrics collector."""
-        self._metrics: Dict[str, List[float]] = defaultdict(list)
-        self._counts: Dict[str, int] = defaultdict(int)
-        self._timestamps: Dict[str, List[datetime]] = defaultdict(list)
-    
-    def record_metric(self, name: str, value: float, timestamp: Optional[datetime] = None) -> None:
-        """Record a metric value."""
-        self._metrics[name].append(value)
-        self._counts[name] += 1
-        if timestamp is None:
-            timestamp = datetime.now()
-        self._timestamps[name].append(timestamp)
-    
-    def get_metric_stats(self, name: str) -> Dict[str, Any]:
-        """Get statistics for a specific metric."""
-        values = self._metrics.get(name, [])
-        if not values:
-            return {}
-        
-        return {
-            'count': len(values),
-            'total': sum(values),
-            'average': sum(values) / len(values),
-            'min': min(values),
-            'max': max(values),
-        }
-    
-    def get_all_stats(self) -> Dict[str, Dict[str, Any]]:
-        """Get statistics for all metrics."""
-        return {name: self.get_metric_stats(name) for name in self._metrics.keys()}
-    
-    def clear(self) -> None:
-        """Clear all collected metrics."""
-        self._metrics.clear()
-        self._counts.clear()
-        self._timestamps.clear()
-
-# Global metrics collector instance
-_global_metrics = MetricsCollector()
-
-def get_metrics_collector() -> MetricsCollector:
-    """Get the global metrics collector instance."""
-    return _global_metrics
-
-__all__ = ['MetricsCollector', 'get_metrics_collector']
-

exonware/xwlazy/runtime/performance.py

@@ -1,37 +0,0 @@
-"""
-Performance monitoring for lazy loading system.
-
-This module contains LazyPerformanceMonitor extracted from lazy_core.py Section 4.
-"""
-
-from typing import Dict, Any
-
-class LazyPerformanceMonitor:
-    """Performance monitor for lazy loading operations."""
-    
-    __slots__ = ('_load_times', '_access_counts', '_memory_usage')
-    
-    def __init__(self):
-        """Initialize performance monitor."""
-        self._load_times: Dict[str, float] = {}
-        self._access_counts: Dict[str, int] = {}
-        self._memory_usage: Dict[str, Any] = {}
-    
-    def record_load_time(self, module: str, load_time: float) -> None:
-        """Record module load time."""
-        self._load_times[module] = load_time
-    
-    def record_access(self, module: str) -> None:
-        """Record module access."""
-        self._access_counts[module] = self._access_counts.get(module, 0) + 1
-    
-    def get_stats(self) -> Dict[str, Any]:
-        """Get performance statistics."""
-        return {
-            'load_times': self._load_times.copy(),
-            'access_counts': self._access_counts.copy(),
-            'memory_usage': self._memory_usage.copy()
-        }
-
-__all__ = ['LazyPerformanceMonitor']
-

exonware_xwlazy-0.1.0.22.dist-info/RECORD

@@ -1,87 +0,0 @@
-exonware/__init__.py,sha256=xpCICV8C4s1oKqjpDVuHMmilz0pDpJn-j0wrWk5irDE,695
-exonware/xwlazy/__init__.py,sha256=7_eS3ekP3Z3A5FbXUFaovcrCexUqvNsf57tLHv8XnMQ,10235
-exonware/xwlazy/config.py,sha256=ca0ECwTt34zFbNYfuwCeC0w17zatLstNk5l52UwhhQg,6241
-exonware/xwlazy/contracts.py,sha256=Jyr1anMVZS_DCjhY7k27I2qNOJYYc1pBFStMJMmG--M,44365
-exonware/xwlazy/defs.py,sha256=hY-MOMLbFNNPfdZXUwRCdOj9pYEUuFuTZQlwPSYUz2M,12290
-exonware/xwlazy/errors.py,sha256=2a-FMiQa4h-m7SCqo19a7h09zGiAHClnuZCGKgvYO0I,9188
-exonware/xwlazy/facade.py,sha256=4Hd6JGAKbn2y7n9QsS4Mbf1AjaXdFMSUEiaOCQyrZ4U,38749
-exonware/xwlazy/version.py,sha256=k6zX-9WJv4yTRXqJWQYw5XrLf-yyZ9n_ECKpO77dqOo,2351
-exonware/xwlazy/common/__init__.py,sha256=VSW_iv6dyaC1YtoY66bAsrLFRJW-f0UVeB7Qgr-FOiU,860
-exonware/xwlazy/common/base.py,sha256=TsGduH5yspumKjMPKXeqJkz7-n7KyXcbm6PhzwapZOo,1404
-exonware/xwlazy/common/cache.py,sha256=ZDGtx1XfY_g_EP7eV20ASKkxyTANqvciOKk1UdQkIf4,17547
-exonware/xwlazy/common/logger.py,sha256=mHyFyBulHcvwb2EuTHhVYDsdKoaVXCdJ84vowiXBUrI,8350
-exonware/xwlazy/common/services/__init__.py,sha256=LgoL5PdLdaanKKkw1WghiNirLIFpkSkExlXWBezGZdc,1774
-exonware/xwlazy/common/services/dependency_mapper.py,sha256=D4Hdu-oDt_RHMFdRkHyYeiQlvhf5pgShopvzytt486A,8555
-exonware/xwlazy/common/services/install_async_utils.py,sha256=RIx5bemXjcQOPyPvKLuHUQOFGWdwdM9tOz-w-ZAF8lw,4966
-exonware/xwlazy/common/services/install_cache_utils.py,sha256=vIZxNASN8q_rigla8LoHWDAqGo8qgaHQ4xI1SOcj25k,7589
-exonware/xwlazy/common/services/keyword_detection.py,sha256=B-Wo_KArhsZSUb_XNSnJjcoZob6l4BrBYyXf5ixk444,9776
-exonware/xwlazy/common/services/spec_cache.py,sha256=rdQb43vUoMpNeHUeK3ANF42mn9k5V2D9ohEeLunqrkk,5318
-exonware/xwlazy/common/services/state_manager.py,sha256=hYU4w8GX0-Zq7NAcMGRuEKMWMJ1LBzPhJH0A5dmM7jg,3116
-exonware/xwlazy/common/strategies/__init__.py,sha256=4GERnc2Ktj_DiMHn0UUqdXcY5nGedbZer9vPhKQyf9I,633
-exonware/xwlazy/common/strategies/caching_dict.py,sha256=IFX6bjf5jStqG66qMKWYXpWiGKsvxIE1WCfsz_KKJhM,1126
-exonware/xwlazy/common/strategies/caching_installation.py,sha256=uamdlsXbbf_rkz3O5z9MlMlmTKYF2i_-G7ZiOP62Zyk,2523
-exonware/xwlazy/common/strategies/caching_lfu.py,sha256=5lBOaDolMHqX3_KjZLavaXeAEiVnhLpPHJlQD3oP2mU,1971
-exonware/xwlazy/common/strategies/caching_lru.py,sha256=5ibtwtmZSJsz9rlga3p8MIIdfAUTidhUCuSWHbFU4Jk,1832
-exonware/xwlazy/common/strategies/caching_multitier.py,sha256=HpFYjc-8-suosexfpwrw9NQyZSdKh0Nd3KT4E7MjC0Y,1910
-exonware/xwlazy/common/strategies/caching_ttl.py,sha256=OvJtelb_-q3yTN8DzKfquYm-_igfe9DddLBbD71J80U,1637
-exonware/xwlazy/module/__init__.py,sha256=sL_G0RvpMfif0e3Yzo0CSj2xAPPF6phlQB367agzqfE,627
-exonware/xwlazy/module/base.py,sha256=eqTj8xHtSXIiqMiycfAcQ76RUQVqxpKXGIiyyesbViI,20682
-exonware/xwlazy/module/data.py,sha256=Q3xNBQgHM_AlMvujkx_YmVT3H1Fr-6xUqryTlWClbp8,318
-exonware/xwlazy/module/facade.py,sha256=zrjN5BEMpEjT64etss2Rh627onjwIzV3c6UNvk2jD-k,8089
-exonware/xwlazy/module/importer_engine.py,sha256=dc1EF95nAHu9omnN0ui9XkSO6PM_ly3yx_unz694m4I,91818
-exonware/xwlazy/module/strategies/__init__.py,sha256=oV49bhWlErG197Y7yKcUzm4acDvfGnVm77lcNLgAu5I,467
-exonware/xwlazy/module/strategies/module_helper_lazy.py,sha256=fr71AOWXS2BE5RWccFar8Edi5SppsPwbuCtLvahppYY,2679
-exonware/xwlazy/module/strategies/module_helper_simple.py,sha256=Hu3z5X_Fg24jZuumUmV8mk1bFyrNu85gUgSR-YHHUZI,1683
-exonware/xwlazy/module/strategies/module_manager_advanced.py,sha256=lMkfFZlExpGUTDKpZAmxAXX5Cely4qy5l3yPl0rD0Hs,3293
-exonware/xwlazy/module/strategies/module_manager_simple.py,sha256=zKkWSZXpz0gZAftkaQZVfjdh3zpHvdLhHik5iOLZGXc,2442
-exonware/xwlazy/package/__init__.py,sha256=UI7xwTbFDURAt7kCr3yRhZzZtFrWRDwhJXakSyJwSCU,640
-exonware/xwlazy/package/base.py,sha256=SAj5kCxVt9gHvrT770aEiFb8mc3OELz5kE2ZxpR8Kdk,27930
-exonware/xwlazy/package/conf.py,sha256=OMoLj59sypWaVQZ-ELrxKv5fIqMyJcN7HhzYgWJW-Mg,14053
-exonware/xwlazy/package/data.py,sha256=3TFb_Qr6HJfQSCBG4Kg9-dIbyrt76zpMnAFoD0ZdTEA,323
-exonware/xwlazy/package/facade.py,sha256=r5hW0ve2FQ6oqspCPts3ZHFA-cvNQcsCBZVjfClpVkw,18743
-exonware/xwlazy/package/services/__init__.py,sha256=ydB2kRzx6I3Kpm-bYyecTwHdkE_544X0CAXHZh7AyZY,2240
-exonware/xwlazy/package/services/async_install_handle.py,sha256=TN7iYUOPiTGG-xXtPjdFTIZ7-_IEn0vYeWK-EuEhlNU,2803
-exonware/xwlazy/package/services/config_manager.py,sha256=JOWciuQi2D7BCLm90i0nbWvksVidPrK1vCUcXjhAnkE,10551
-exonware/xwlazy/package/services/discovery.py,sha256=DxFHz5OMg4kg5Dy_zkKQaU5wdSyIGFXFXz7-DVvLgfI,14637
-exonware/xwlazy/package/services/host_packages.py,sha256=NGpqadJpJtUBFTBxG4axNhEYXAuCUu_ktWYRTbobaVI,5429
-exonware/xwlazy/package/services/install_async.py,sha256=pcTzX_COx2E4vP6MAzwu7OC0XZImWKfsrFrPQvV46Z0,13279
-exonware/xwlazy/package/services/install_cache.py,sha256=KL0uzK7CmFiTFs8zjWOY8zYXKSC2cLcUD_cWDEktsTI,5974
-exonware/xwlazy/package/services/install_interactive.py,sha256=5tvVeogm9wIVG6u8jiSSpmXiPt1wXMtdTAETjsZ3QBE,2155
-exonware/xwlazy/package/services/install_policy.py,sha256=_et-C7m5iOxudpkSBT9G2lNqqt1EUZh-nygSjyQdMEM,5876
-exonware/xwlazy/package/services/install_registry.py,sha256=1_6T3xaMM0IaitpFsvLxBCSBBWbnE0nwdPZd86a9qFg,1504
-exonware/xwlazy/package/services/install_result.py,sha256=MeXi-B9QBO1uZlyUbCBDNu_LBoYYQiInWoIDLQ0BVCs,346
-exonware/xwlazy/package/services/install_sbom.py,sha256=aph691SEPu8lvPDR5Fbf2JyPemlKKVEbra-79JzhV60,5571
-exonware/xwlazy/package/services/install_utils.py,sha256=T1KeU3fbyNFYdYjeBWUIfWwTSQ6WHASVl-zSDDvxrvI,2371
-exonware/xwlazy/package/services/installer_engine.py,sha256=d5Vxq_wicVhn52Mm-iTd9pWCkqJZ9_361L-6rP3bhrI,15363
-exonware/xwlazy/package/services/lazy_installer.py,sha256=2oZxVZZX3hMsBwIYwzS97YVUPvRGbepTb04EnlIfHMI,32098
-exonware/xwlazy/package/services/manifest.py,sha256=txAotO00hJtfsMuNX6HycyCTBbjs_nSgOARXSSLNGPw,19163
-exonware/xwlazy/package/services/strategy_registry.py,sha256=4pKEKSy_TshHNGw2GctYJTMzk7z5YBncS2wfrBNBEsY,6796
-exonware/xwlazy/package/strategies/__init__.py,sha256=r_gpreZ6kcsWfHkGABYlZVx69JdvbMwlftitAKEwbrA,1626
-exonware/xwlazy/package/strategies/package_discovery_file.py,sha256=mArPdled9s3ql7NncFwPgRSINtC2FM7a7k7Xi5jPgVA,4394
-exonware/xwlazy/package/strategies/package_discovery_hybrid.py,sha256=7HdmbIILFcm2FNV7o3x3Pc1jUUuiUHaSAMItor6xJCk,2654
-exonware/xwlazy/package/strategies/package_discovery_manifest.py,sha256=EiBbwWcggJvue6iJbmSmsNXpBNhS74vb7sLysEEK_F4,3368
-exonware/xwlazy/package/strategies/package_execution_async.py,sha256=sZDtelXLdoumdVTywjyjdyvv10mKXroASc2FuAZ-p60,3644
-exonware/xwlazy/package/strategies/package_execution_cached.py,sha256=htl8YOusqwIgEPZjn__KNK77lHCkWfFJyjF90gb2CcY,2680
-exonware/xwlazy/package/strategies/package_execution_pip.py,sha256=gBz7tCpE6n5bkrU2EjQvt0gymn-cPUFxyAxmJfDIgtI,2963
-exonware/xwlazy/package/strategies/package_execution_wheel.py,sha256=pb4mJLqwDrLiH46koW0wcQtbrwTDY1-GgtTCR6ryGuM,3209
-exonware/xwlazy/package/strategies/package_mapping_discovery_first.py,sha256=La3VZPPDsvhBgQ-q23kFJWVqPBYhzt2fzpFINobnotA,3279
-exonware/xwlazy/package/strategies/package_mapping_hybrid.py,sha256=bchfFkzVRLh1AVCQ6OLYzkilW5pqAJug4C_fS_XRFn0,3399
-exonware/xwlazy/package/strategies/package_mapping_manifest_first.py,sha256=Q25r0L4193sKPWPe1YMMxvXnH0hkrKPc_TchPSgOljw,3304
-exonware/xwlazy/package/strategies/package_policy_allow_list.py,sha256=l_1w_LnWWvGtOsJxlbrwfYIDLn1DSgwWlJh-dDQIoWE,1556
-exonware/xwlazy/package/strategies/package_policy_deny_list.py,sha256=S1xdNe_ticMvSt_gigLkTR_b9wV0_H9iDTJ-io9yfWk,1516
-exonware/xwlazy/package/strategies/package_policy_permissive.py,sha256=k2MndZ7kBH-SEfgEycNJidwaVo9994a32YLCStR2pH0,1127
-exonware/xwlazy/package/strategies/package_timing_clean.py,sha256=KwZmo8KSa4_jJOwwgrAujdUUBJQEHml8rWY0tuvhoZk,1826
-exonware/xwlazy/package/strategies/package_timing_full.py,sha256=1vphf9RXTE1tLFfmqAwytleGqR2Pia9jGXNT5d-pvQg,1736
-exonware/xwlazy/package/strategies/package_timing_smart.py,sha256=GlmAR77qK0lfpu6DoLokJ1BOUo1cWVgZt0nBmf5xG2U,1835
-exonware/xwlazy/package/strategies/package_timing_temporary.py,sha256=ek6HE4S5RAiljDgbfw6m1D_U4iDYV-F6r5LZ_uzvxM4,1795
-exonware/xwlazy/runtime/__init__.py,sha256=jbIzemqwtWvKu2LxhYU7pIcihNakQHCON8xZW0orqZA,636
-exonware/xwlazy/runtime/adaptive_learner.py,sha256=fx1p9cMES_CB8l4ir0giuJHPzlCLPbl3iMpru6TNvPo,5256
-exonware/xwlazy/runtime/base.py,sha256=mEKlUe09wpCI8VHF3I-pdnH5VIDC1PqK8iQzANR_b90,10019
-exonware/xwlazy/runtime/facade.py,sha256=9R-1aXMTxZuaN1xD2JrU2RFjzPKXu7-oTM5dTV5kY1E,3415
-exonware/xwlazy/runtime/intelligent_selector.py,sha256=501Lrsa3_CaA1-mY6H-w46KEblpsYjO3_mzbNJJKgKM,6531
-exonware/xwlazy/runtime/metrics.py,sha256=QHYKZ55pjdEKeOBjMVQ2N2y0rgJWAOWeD_N0S7YYOHg,1987
-exonware/xwlazy/runtime/performance.py,sha256=57ygfRhqyZVn75B55b7-eKk1EIisdCD8qrbwv2wKAl4,1198
-exonware_xwlazy-0.1.0.22.dist-info/METADATA,sha256=02FdVbrd98Q538U5emQRRqscmaQWFulDQhNREaBydqw,16859
-exonware_xwlazy-0.1.0.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-exonware_xwlazy-0.1.0.22.dist-info/licenses/LICENSE,sha256=w42ohoEUfhyT0NgiivAL4fWg2AMRLGnfXPMAR4EO-MU,1094
-exonware_xwlazy-0.1.0.22.dist-info/RECORD,,