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

exonware/xwlazy/package/strategies/package_execution_async.py

@@ -14,7 +14,7 @@ Uses shared utilities from common/services/install_async_utils.
 import sys
 import asyncio
 import subprocess
-from typing import List, Any
+from typing import Any
 from ...package.base import AInstallExecutionStrategy
 from ...package.services.install_result import InstallResult, InstallStatus
 from ...common.services.install_async_utils import async_install_package
@@ -27,7 +27,7 @@ class AsyncExecution(AInstallExecutionStrategy):
     Uses shared utilities from common/services/install_async_utils.
     """
     
-    def execute_install(self, package_name: str, policy_args: List[str]) -> Any:
+    def execute_install(self, package_name: str, policy_args: list[str]) -> Any:
         """
         Execute installation asynchronously.
         
@@ -62,7 +62,7 @@ class AsyncExecution(AInstallExecutionStrategy):
                 error=str(e)
             )
     
-    async def _async_install(self, package_name: str, policy_args: List[str]) -> InstallResult:
+    async def _async_install(self, package_name: str, policy_args: list[str]) -> InstallResult:
         """
         Async installation implementation.
         

exonware/xwlazy/package/strategies/package_execution_cached.py

@@ -14,7 +14,7 @@ Uses shared utilities from common/services/install_cache_utils.
 import sys
 import subprocess
 from pathlib import Path
-from typing import List, Any, Optional
+from typing import Any, Optional
 from ...package.base import AInstallExecutionStrategy
 from ...package.services.install_result import InstallResult, InstallStatus
 from ...common.services.install_cache_utils import (
@@ -39,7 +39,7 @@ class CachedExecution(AInstallExecutionStrategy):
         """
         self._cache_dir = cache_dir
     
-    def execute_install(self, package_name: str, policy_args: List[str]) -> Any:
+    def execute_install(self, package_name: str, policy_args: list[str]) -> Any:
         """
         Execute installation from cached tree.
         

exonware/xwlazy/package/strategies/package_execution_pip.py

@@ -12,7 +12,7 @@ Pip execution strategy - direct pip install.
 
 import sys
 import subprocess
-from typing import List, Any
+from typing import Any
 from ...package.base import AInstallExecutionStrategy
 from ...package.services.install_result import InstallResult, InstallStatus
 
@@ -23,7 +23,7 @@ class PipExecution(AInstallExecutionStrategy):
     This is the default execution strategy that uses pip install.
     """
     
-    def execute_install(self, package_name: str, policy_args: List[str]) -> Any:
+    def execute_install(self, package_name: str, policy_args: list[str]) -> Any:
         """
         Execute installation using pip.
         

exonware/xwlazy/package/strategies/package_execution_wheel.py

@@ -14,7 +14,7 @@ Uses shared utilities from common/services/install_cache_utils.
 import sys
 import subprocess
 from pathlib import Path
-from typing import List, Any, Optional
+from typing import Any, Optional
 from ...package.base import AInstallExecutionStrategy
 from ...package.services.install_result import InstallResult, InstallStatus
 from ...common.services.install_cache_utils import (
@@ -40,7 +40,7 @@ class WheelExecution(AInstallExecutionStrategy):
         """
         self._cache_dir = cache_dir
     
-    def execute_install(self, package_name: str, policy_args: List[str]) -> Any:
+    def execute_install(self, package_name: str, policy_args: list[str]) -> Any:
         """
         Execute installation from wheel file.
         

exonware/xwlazy/package/strategies/package_mapping_discovery_first.py

@@ -10,7 +10,7 @@ Generation Date: 15-Nov-2025
 Discovery-first mapping strategy - discovery takes precedence over manifest.
 """
 
-from typing import Optional, List
+from typing import Optional
 from ...package.base import AMappingStrategy
 from ...package.services.manifest import get_manifest_loader
 
@@ -72,7 +72,7 @@ class DiscoveryFirstMapping(AMappingStrategy):
         common_mappings = discovery.COMMON_MAPPINGS
         return common_mappings.get(import_name)
     
-    def map_package_to_imports(self, package_name: str) -> List[str]:
+    def map_package_to_imports(self, package_name: str) -> list[str]:
         """
         Map package name to possible import names.
         

exonware/xwlazy/package/strategies/package_mapping_hybrid.py

@@ -10,7 +10,7 @@ Generation Date: 15-Nov-2025
 Hybrid mapping strategy - tries both manifest and discovery, uses best match.
 """
 
-from typing import Optional, List
+from typing import Optional
 from ...package.base import AMappingStrategy
 from ...package.services.manifest import get_manifest_loader
 
@@ -74,7 +74,7 @@ class HybridMapping(AMappingStrategy):
         common_mappings = discovery.COMMON_MAPPINGS
         return common_mappings.get(import_name)
     
-    def map_package_to_imports(self, package_name: str) -> List[str]:
+    def map_package_to_imports(self, package_name: str) -> list[str]:
         """
         Map package name to possible import names.
         

exonware/xwlazy/package/strategies/package_mapping_manifest_first.py

@@ -10,7 +10,7 @@ Generation Date: 15-Nov-2025
 Manifest-first mapping strategy - manifest takes precedence over discovery.
 """
 
-from typing import Optional, List
+from typing import Optional
 from ...package.base import AMappingStrategy
 from ...package.services.manifest import get_manifest_loader
 
@@ -72,7 +72,7 @@ class ManifestFirstMapping(AMappingStrategy):
         common_mappings = discovery.COMMON_MAPPINGS
         return common_mappings.get(import_name)
     
-    def map_package_to_imports(self, package_name: str) -> List[str]:
+    def map_package_to_imports(self, package_name: str) -> list[str]:
         """
         Map package name to possible import names.
         

exonware/xwlazy/package/strategies/package_policy_allow_list.py

@@ -10,7 +10,7 @@ Generation Date: 15-Nov-2025
 Allow list policy - only allows packages in the allow list.
 """
 
-from typing import Tuple, List, Set
+from typing import
 from ...package.base import APolicyStrategy
 
 class AllowListPolicy(APolicyStrategy):
@@ -20,7 +20,7 @@ class AllowListPolicy(APolicyStrategy):
     Only packages explicitly in the allow list can be installed.
     """
     
-    def __init__(self, allowed_packages: Set[str]):
+    def __init__(self, allowed_packages: set[str]):
         """
         Initialize allow list policy.
         
@@ -29,7 +29,7 @@ class AllowListPolicy(APolicyStrategy):
         """
         self._allowed = {pkg.lower() for pkg in allowed_packages}
     
-    def is_allowed(self, package_name: str) -> Tuple[bool, str]:
+    def is_allowed(self, package_name: str) -> tuple[bool, str]:
         """
         Check if package is allowed to be installed.
         
@@ -43,7 +43,7 @@ class AllowListPolicy(APolicyStrategy):
             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]:
+    def get_pip_args(self, package_name: str) -> list[str]:
         """
         Get pip arguments based on policy.
         

exonware/xwlazy/package/strategies/package_policy_deny_list.py

@@ -10,7 +10,7 @@ Generation Date: 15-Nov-2025
 Deny list policy - blocks packages in the deny list.
 """
 
-from typing import Tuple, List, Set
+from typing import
 from ...package.base import APolicyStrategy
 
 class DenyListPolicy(APolicyStrategy):
@@ -20,7 +20,7 @@ class DenyListPolicy(APolicyStrategy):
     Packages in the deny list cannot be installed.
     """
     
-    def __init__(self, denied_packages: Set[str]):
+    def __init__(self, denied_packages: set[str]):
         """
         Initialize deny list policy.
         
@@ -29,7 +29,7 @@ class DenyListPolicy(APolicyStrategy):
         """
         self._denied = {pkg.lower() for pkg in denied_packages}
     
-    def is_allowed(self, package_name: str) -> Tuple[bool, str]:
+    def is_allowed(self, package_name: str) -> tuple[bool, str]:
         """
         Check if package is allowed to be installed.
         
@@ -43,7 +43,7 @@ class DenyListPolicy(APolicyStrategy):
             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]:
+    def get_pip_args(self, package_name: str) -> list[str]:
         """
         Get pip arguments based on policy.
         

exonware/xwlazy/package/strategies/package_policy_permissive.py

@@ -10,7 +10,7 @@ Generation Date: 15-Nov-2025
 Permissive policy - allows all packages (default).
 """
 
-from typing import Tuple, List
+from typing import
 from ...package.base import APolicyStrategy
 
 class PermissivePolicy(APolicyStrategy):
@@ -20,7 +20,7 @@ class PermissivePolicy(APolicyStrategy):
     This is the default policy that doesn't restrict any packages.
     """
     
-    def is_allowed(self, package_name: str) -> Tuple[bool, str]:
+    def is_allowed(self, package_name: str) -> tuple[bool, str]:
         """
         Check if package is allowed to be installed.
         
@@ -32,7 +32,7 @@ class PermissivePolicy(APolicyStrategy):
         """
         return (True, "Permissive policy allows all packages")
     
-    def get_pip_args(self, package_name: str) -> List[str]:
+    def get_pip_args(self, package_name: str) -> list[str]:
         """
         Get pip arguments based on policy.
         

exonware/xwlazy/package/strategies/package_timing_clean.py

@@ -10,7 +10,7 @@ Generation Date: 15-Nov-2025
 Clean timing - install on usage + uninstall after completion.
 """
 
-from typing import List, Any
+from typing import Any
 from ...package.base import AInstallTimingStrategy
 
 class CleanTiming(AInstallTimingStrategy):
@@ -51,7 +51,7 @@ class CleanTiming(AInstallTimingStrategy):
         """
         return True
     
-    def get_install_priority(self, packages: List[str]) -> List[str]:
+    def get_install_priority(self, packages: list[str]) -> list[str]:
         """
         Get priority order for installing packages.
         

exonware/xwlazy/package/strategies/package_timing_full.py

@@ -10,7 +10,7 @@ Generation Date: 15-Nov-2025
 Full timing - install all dependencies upfront.
 """
 
-from typing import List, Any
+from typing import Any
 from ...package.base import AInstallTimingStrategy
 
 class FullTiming(AInstallTimingStrategy):
@@ -50,7 +50,7 @@ class FullTiming(AInstallTimingStrategy):
         """
         return False
     
-    def get_install_priority(self, packages: List[str]) -> List[str]:
+    def get_install_priority(self, packages: list[str]) -> list[str]:
         """
         Get priority order for installing packages.
         

exonware/xwlazy/package/strategies/package_timing_smart.py

@@ -10,7 +10,7 @@ Generation Date: 15-Nov-2025
 Smart timing - install on first usage (on-demand).
 """
 
-from typing import List, Any
+from typing import Any
 from ...package.base import AInstallTimingStrategy
 from ...defs import LazyInstallMode
 
@@ -52,7 +52,7 @@ class SmartTiming(AInstallTimingStrategy):
         """
         return False
     
-    def get_install_priority(self, packages: List[str]) -> List[str]:
+    def get_install_priority(self, packages: list[str]) -> list[str]:
         """
         Get priority order for installing packages.
         

exonware/xwlazy/package/strategies/package_timing_temporary.py

@@ -10,7 +10,7 @@ Generation Date: 15-Nov-2025
 Temporary timing - always uninstall after use (more aggressive than CLEAN).
 """
 
-from typing import List, Any
+from typing import Any
 from ...package.base import AInstallTimingStrategy
 
 class TemporaryTiming(AInstallTimingStrategy):
@@ -50,7 +50,7 @@ class TemporaryTiming(AInstallTimingStrategy):
         """
         return True
     
-    def get_install_priority(self, packages: List[str]) -> List[str]:
+    def get_install_priority(self, packages: list[str]) -> list[str]:
         """
         Get priority order for installing packages.
         

exonware/xwlazy/runtime/adaptive_learner.py

@@ -14,7 +14,7 @@ This module provides adaptive learning for ADAPTIVE mode.
 
 import time
 import threading
-from typing import Dict, List, Tuple, Optional
+from typing import Optional
 from collections import defaultdict, deque
 
 # Logger not used in this module, removed to avoid circular dependency
@@ -33,9 +33,9 @@ class AdaptiveLearner:
         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._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:
@@ -82,14 +82,14 @@ class AdaptiveLearner:
             # 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]:
+    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] = {}
+            candidates: dict[str, float] = {}
             
             # Predict based on current module chain (lock-free read of dict)
             if current_module:
@@ -105,7 +105,7 @@ class AdaptiveLearner:
             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]:
+    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(

exonware/xwlazy/runtime/base.py

@@ -14,7 +14,7 @@ This module defines the abstract base class for runtime services.
 
 import threading
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Any, Tuple
+from typing import Optional, Any
 
 from ..contracts import (
     IRuntime,
@@ -63,19 +63,19 @@ class ARuntimeHelper(IRuntime, ABC):
         self._auto_state: Optional[bool] = None
         
         # From IMetricsCollector
-        self._metrics: Dict[str, List[float]] = {}
+        self._metrics: dict[str, list[float]] = {}
         
         # From IPerformanceMonitor
-        self._load_times: Dict[str, List[float]] = {}
-        self._access_counts: Dict[str, int] = {}
+        self._load_times: dict[str, list[float]] = {}
+        self._access_counts: dict[str, int] = {}
         
         # From IMultiTierCache
-        self._l1_cache: Dict[str, Any] = {}
-        self._l2_cache: Dict[str, Any] = {}
-        self._l3_cache: Dict[str, Any] = {}
+        self._l1_cache: dict[str, Any] = {}
+        self._l2_cache: dict[str, Any] = {}
+        self._l3_cache: dict[str, Any] = {}
         
         # From IRegistry
-        self._registry: Dict[str, Any] = {}
+        self._registry: dict[str, Any] = {}
         
         # Common
         self._lock = threading.RLock()
@@ -112,7 +112,7 @@ class ARuntimeHelper(IRuntime, ABC):
         pass
     
     @abstractmethod
-    def predict_next_imports(self, current_module: str, count: int = 3) -> List[str]:
+    def predict_next_imports(self, current_module: str, count: int = 3) -> list[str]:
         """Predict next likely imports based on patterns (from IAdaptiveLearner)."""
         pass
     
@@ -137,12 +137,12 @@ class ARuntimeHelper(IRuntime, ABC):
         pass
     
     @abstractmethod
-    def get_optimal_mode(self, load_level: Any) -> Tuple[Any, Any]:
+    def get_optimal_mode(self, load_level: Any) -> tuple[Any, Any]:
         """Get optimal mode for a load level (from IIntelligentSelector)."""
         pass
     
     @abstractmethod
-    def update_mode_map(self, mode_map: Dict[Any, Tuple[Any, Any]]) -> None:
+    def update_mode_map(self, mode_map: dict[Any, tuple[Any, Any]]) -> None:
         """Update mode mapping with benchmark results (from IIntelligentSelector)."""
         pass
     
@@ -158,12 +158,12 @@ class ARuntimeHelper(IRuntime, ABC):
             self._metrics[name].append(value)
     
     @abstractmethod
-    def get_metric_stats(self, name: str) -> Dict[str, Any]:
+    def get_metric_stats(self, name: str) -> dict[str, Any]:
         """Get statistics for a metric (from IMetricsCollector)."""
         pass
     
     @abstractmethod
-    def get_all_stats(self) -> Dict[str, Dict[str, Any]]:
+    def get_all_stats(self) -> dict[str, dict[str, Any]]:
         """Get statistics for all metrics (from IMetricsCollector)."""
         pass
     
@@ -189,7 +189,7 @@ class ARuntimeHelper(IRuntime, ABC):
             self._access_counts[module] = self._access_counts.get(module, 0) + 1
     
     @abstractmethod
-    def get_performance_stats(self) -> Dict[str, Any]:
+    def get_performance_stats(self) -> dict[str, Any]:
         """Get performance statistics (from IPerformanceMonitor)."""
         pass
     

exonware/xwlazy/runtime/facade.py

@@ -5,7 +5,7 @@ Main facade: XWRuntimeHelper extends ARuntimeHelper
 Provides concrete implementation for all runtime services.
 """
 
-from typing import Dict, List, Optional, Tuple, Any
+from typing import Optional, Any
 from .base import ARuntimeHelper
 from ..defs import LazyLoadMode, LazyInstallMode
 
@@ -26,7 +26,7 @@ class XWRuntimeHelper(ARuntimeHelper):
         # TODO: Implement import recording
         pass
     
-    def predict_next_imports(self, current_module: str, count: int = 3) -> List[str]:
+    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 []
@@ -48,17 +48,17 @@ class XWRuntimeHelper(ARuntimeHelper):
         from .intelligent_selector import LoadLevel
         return LoadLevel.LIGHT
     
-    def get_optimal_mode(self, load_level) -> Tuple[LazyLoadMode, LazyInstallMode]:
+    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:
+    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]:
+    def get_metric_stats(self, name: str) -> dict[str, Any]:
         """Get statistics for a metric."""
         with self._lock:
             values = self._metrics.get(name, [])
@@ -72,12 +72,12 @@ class XWRuntimeHelper(ARuntimeHelper):
                 'max': max(values)
             }
     
-    def get_all_stats(self) -> Dict[str, Dict[str, Any]]:
+    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]:
+    def get_performance_stats(self) -> dict[str, Any]:
         """Get performance statistics."""
         with self._lock:
             return {

exonware/xwlazy/runtime/intelligent_selector.py

@@ -12,7 +12,7 @@ Generation Date: 19-Nov-2025
 This module provides intelligent mode switching based on load level.
 """
 
-from typing import Dict, Tuple, Optional
+from typing import Optional
 
 from ..defs import LazyLoadMode, LazyInstallMode, LoadLevel
 
@@ -32,7 +32,7 @@ def _get_logger():
 # 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]] = {
+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)
@@ -42,7 +42,7 @@ INTELLIGENT_MODE_MAP: Dict[LoadLevel, Tuple[LazyLoadMode, LazyInstallMode]] = {
 class IntelligentModeSelector:
     """Selects optimal mode based on current load characteristics."""
     
-    def __init__(self, mode_map: Optional[Dict[LoadLevel, Tuple[LazyLoadMode, LazyInstallMode]]] = None):
+    def __init__(self, mode_map: Optional[dict[LoadLevel, tuple[LazyLoadMode, LazyInstallMode]]] = None):
         """
         Initialize intelligent mode selector.
         
@@ -55,7 +55,7 @@ class IntelligentModeSelector:
         self._total_import_time = 0.0
         self._import_count = 0
     
-    def update_mode_map(self, mode_map: Dict[LoadLevel, Tuple[LazyLoadMode, LazyInstallMode]]) -> None:
+    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}")
@@ -111,7 +111,7 @@ class IntelligentModeSelector:
         
         return self._current_load_level
     
-    def get_optimal_mode(self, load_level: Optional[LoadLevel] = None) -> Tuple[LazyLoadMode, LazyInstallMode]:
+    def get_optimal_mode(self, load_level: Optional[LoadLevel] = None) -> tuple[LazyLoadMode, LazyInstallMode]:
         """
         Get optimal mode combination for given load level.
         
@@ -134,7 +134,7 @@ class IntelligentModeSelector:
     
     def should_switch_mode(
         self,
-        current_mode: Tuple[LazyLoadMode, LazyInstallMode],
+        current_mode: tuple[LazyLoadMode, LazyInstallMode],
         detected_level: LoadLevel
     ) -> bool:
         """

exonware/xwlazy/runtime/metrics.py

@@ -4,7 +4,7 @@ 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 typing import Any, Optional
 from datetime import datetime
 from collections import defaultdict
 
@@ -13,9 +13,9 @@ class MetricsCollector:
     
     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)
+        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."""
@@ -25,7 +25,7 @@ class MetricsCollector:
             timestamp = datetime.now()
         self._timestamps[name].append(timestamp)
     
-    def get_metric_stats(self, name: str) -> Dict[str, Any]:
+    def get_metric_stats(self, name: str) -> dict[str, Any]:
         """Get statistics for a specific metric."""
         values = self._metrics.get(name, [])
         if not values:
@@ -39,7 +39,7 @@ class MetricsCollector:
             'max': max(values),
         }
     
-    def get_all_stats(self) -> Dict[str, Dict[str, Any]]:
+    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()}
     

exonware/xwlazy/runtime/performance.py

@@ -4,7 +4,7 @@ Performance monitoring for lazy loading system.
 This module contains LazyPerformanceMonitor extracted from lazy_core.py Section 4.
 """
 
-from typing import Dict, Any
+from typing import Any
 
 class LazyPerformanceMonitor:
     """Performance monitor for lazy loading operations."""
@@ -13,9 +13,9 @@ class LazyPerformanceMonitor:
     
     def __init__(self):
         """Initialize performance monitor."""
-        self._load_times: Dict[str, float] = {}
-        self._access_counts: Dict[str, int] = {}
-        self._memory_usage: Dict[str, Any] = {}
+        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."""
@@ -25,7 +25,7 @@ class LazyPerformanceMonitor:
         """Record module access."""
         self._access_counts[module] = self._access_counts.get(module, 0) + 1
     
-    def get_stats(self) -> Dict[str, Any]:
+    def get_stats(self) -> dict[str, Any]:
         """Get performance statistics."""
         return {
             'load_times': self._load_times.copy(),

exonware/xwlazy/version.py

@@ -14,13 +14,13 @@ All version references should import from this module to ensure consistency.
 # =============================================================================
 
 # Main version - update this to change version across entire project
-__version__ = "0.1.0.21"
+__version__ = "0.1.0.23"
 
 # Version components for programmatic access
 VERSION_MAJOR = 0
 VERSION_MINOR = 1
 VERSION_PATCH = 0
-VERSION_BUILD = 21  # Set to None for releases, or build number for dev builds
+VERSION_BUILD = 23  # Set to None for releases, or build number for dev builds
 
 # Version metadata
 VERSION_SUFFIX = ""  # e.g., "dev", "alpha", "beta", "rc1"

{exonware_xwlazy-0.1.0.21.dist-info → exonware_xwlazy-0.1.0.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exonware-xwlazy
-Version: 0.1.0.21
+Version: 0.1.0.23
 Summary: Marker package that enables lazy install features across the eXonware suite.
 Project-URL: Homepage, https://exonware.com
 Project-URL: Repository, https://github.com/exonware/xwlazy
@@ -15,13 +15,9 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
+Requires-Python: >=3.12
 Requires-Dist: tomli>=2.0.1; python_version < '3.11'
 Description-Content-Type: text/markdown