exonware-xwlazy 0.1.0.22__tar.gz → 1.0.1.2__tar.gz

{exonware_xwlazy-0.1.0.22 → exonware_xwlazy-1.0.1.2}/.gitignore

@@ -5,6 +5,10 @@
 # CI/CD Tools (keep private)
 .ci/
 
+# Migration/legacy directories (may contain paths too long for Windows)
+MIGRAT/
+MIGRATE/
+
 # ========================================
 # Python
 # ========================================

{exonware_xwlazy-0.1.0.22 → exonware_xwlazy-1.0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exonware-xwlazy
-Version: 0.1.0.22
+Version: 1.0.1.2
 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
 
@@ -178,6 +174,10 @@ After `pip install -e .`, xwlazy automatically enables lazy loading for your pac
 ## 📖 Documentation
 
 - **[Architecture Reference](docs/REF_ARCH.md)** - System design, patterns, and structure
+- **[Integration Guide](docs/INTEGRATION_GUIDE.md)** - Integration with xw libraries
+- **[Best Practices](docs/BEST_PRACTICES.md)** - Usage guidelines and recommendations
+- **[Troubleshooting Guide](docs/TROUBLESHOOTING.md)** - Common issues and solutions
+- **[Production Deployment](docs/PRODUCTION_DEPLOYMENT.md)** - Production deployment guide
 - **[Keyword Detection Guide](docs/KEYWORD_DETECTION.md)** - Zero-code integration
 - **[Competition Benchmarks](benchmarks/competition_tests/)** - Performance comparisons
 - **[Performance Analysis](benchmarks/competition_tests/PERFORMANCE_ANALYSIS.md)** - Optimization recommendations

{exonware_xwlazy-0.1.0.22 → exonware_xwlazy-1.0.1.2}/README.md

@@ -151,6 +151,10 @@ After `pip install -e .`, xwlazy automatically enables lazy loading for your pac
 ## 📖 Documentation
 
 - **[Architecture Reference](docs/REF_ARCH.md)** - System design, patterns, and structure
+- **[Integration Guide](docs/INTEGRATION_GUIDE.md)** - Integration with xw libraries
+- **[Best Practices](docs/BEST_PRACTICES.md)** - Usage guidelines and recommendations
+- **[Troubleshooting Guide](docs/TROUBLESHOOTING.md)** - Common issues and solutions
+- **[Production Deployment](docs/PRODUCTION_DEPLOYMENT.md)** - Production deployment guide
 - **[Keyword Detection Guide](docs/KEYWORD_DETECTION.md)** - Zero-code integration
 - **[Competition Benchmarks](benchmarks/competition_tests/)** - Performance comparisons
 - **[Performance Analysis](benchmarks/competition_tests/PERFORMANCE_ANALYSIS.md)** - Optimization recommendations

{exonware_xwlazy-0.1.0.22 → exonware_xwlazy-1.0.1.2}/pyproject.toml

@@ -7,7 +7,7 @@ name = "exonware-xwlazy"
 dynamic = ["version"]
 description = "Marker package that enables lazy install features across the eXonware suite."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.12"
 keywords = ["lazy", "exonware", "xwlazy"]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -15,10 +15,6 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
@@ -42,6 +38,9 @@ Subtree = "https://github.com/Exonware/XWLazy.git"
 [tool.hatch.version]
 path = "src/exonware/xwlazy/version.py"
 
+# Fallback: use static version if version.py doesn't exist
+# __version__ = "1.0.1"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/exonware", "src/xwlazy"]
 

exonware_xwlazy-1.0.1.2/src/_old/exonware/__init__.py

@@ -0,0 +1,42 @@
+"""
+exonware package - Enterprise-grade Python framework ecosystem
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Generation Date: 2025-01-03
+
+This is a namespace package allowing multiple exonware subpackages
+to coexist (xwsystem, xwnode, xwdata, xwlazy, etc.)
+"""
+
+# Make this a namespace package FIRST
+# This allows both exonware.xwsystem and exonware.xwlazy to coexist
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)
+
+# Import version from xwlazy - required, no fallback
+from exonware.xwlazy.version import __version__
+
+__author__ = 'Eng. Muhammad AlShehri'
+__email__ = 'connect@exonware.com'
+__company__ = 'eXonware.com'
+
+# NOW enable lazy mode (after namespace package is set up)
+import sys
+import importlib
+try:
+    # Use importlib to import after namespace is ready
+    if 'exonware.xwlazy' not in sys.modules:
+        xwlazy_module = importlib.import_module('exonware.xwlazy')
+        auto_enable_lazy = getattr(xwlazy_module, 'auto_enable_lazy', None)
+        if auto_enable_lazy:
+            auto_enable_lazy("xwsystem", mode="smart")
+            print("✅ Lazy mode enabled for xwsystem")
+    else:
+        # Module already loaded, use it directly
+        from exonware.xwlazy import auto_enable_lazy
+        auto_enable_lazy("xwsystem", mode="smart")
+        print("✅ Lazy mode enabled for xwsystem")
+except (ImportError, AttributeError):
+    print("❌ Lazy mode not enabled for xwsystem (xwlazy not installed)")
+    pass  # xwlazy not installed - silently continue

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/__init__.py

@@ -63,6 +63,10 @@ from .facade import (
     configure_lazy_mode,
     preload_modules,
     optimize_lazy_mode,
+    # One-line activation API
+    auto_enable_lazy,
+    # Lazy-loader compatible API
+    attach,
     # Public API functions
     enable_lazy_install,
     disable_lazy_install,
@@ -167,6 +171,10 @@ def __getattr__(name: str) -> Any:
     elif name == "XWRuntimeHelper":
         from .runtime import XWRuntimeHelper
         return XWRuntimeHelper
+    elif name == "manifest":
+        # Import manifest module for lazy access
+        from .package.services import manifest
+        return manifest
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 # Import core classes for advanced usage
@@ -210,7 +218,7 @@ from .module.importer_engine import (
     _mark_import_started,
     _mark_import_finished,
     _lazy_aware_import_module,
-    _patch_import_module,
+    # _patch_import_module removed - deprecated, use sys.meta_path hooks instead
     _unpatch_import_module,
 )
 
@@ -245,6 +253,10 @@ __all__ = [
     "configure_lazy_mode",
     "preload_modules",
     "optimize_lazy_mode",
+    # One-line activation API
+    "auto_enable_lazy",
+    # Lazy-loader compatible API
+    "attach",
     # Public API functions
     "enable_lazy_install",
     "disable_lazy_install",
@@ -361,7 +373,6 @@ __all__ = [
     "_mark_import_started",
     "_mark_import_finished",
     "_lazy_aware_import_module",
-    "_patch_import_module",
+    # "_patch_import_module",  # Removed - deprecated, use sys.meta_path hooks instead
     "_unpatch_import_module",
 ]
-

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/common/__init__.py

@@ -28,6 +28,11 @@ from .cache import (
     InstallationCache,
 )
 
+from .utils import (
+    find_project_root,
+    find_config_file,
+)
+
 __all__ = [
     # Logger
     'get_logger',
@@ -43,5 +48,7 @@ __all__ = [
     'MultiTierCache',
     'BytecodeCache',
     'InstallationCache',
+    # Utils
+    'find_project_root',
+    'find_config_file',
 ]
-

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/common/base.py

@@ -12,13 +12,21 @@ Abstract base classes for shared/common strategies.
 
 from abc import ABC, abstractmethod
 from typing import Optional, Any
-from ..contracts import ICachingStrategy
+from ..contracts import ICachingStrategy, ICacheStrategy
 
 # =============================================================================
 # ABSTRACT CACHING STRATEGY
 # =============================================================================
 
 class ACachingStrategy(ICachingStrategy, ABC):
+    """
+    Abstract base class for caching strategies (legacy name).
+    
+    Note: Use ACacheStrategy for new code (ICacheStrategy interface).
+    """
+    pass
+
+class ACacheStrategy(ICacheStrategy, ABC):
     """
     Abstract base class for caching strategies.
     
@@ -51,6 +59,6 @@ class ACachingStrategy(ICachingStrategy, ABC):
 # =============================================================================
 
 __all__ = [
-    'ACachingStrategy',
+    'ACachingStrategy',  # Legacy name
+    'ACacheStrategy',    # New name for ICacheStrategy interface
 ]
-

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/common/cache.py

@@ -15,7 +15,6 @@ All cache code is centralized here to avoid duplication.
 
 import os
 import sys
-import json
 import time
 import pickle
 import struct
@@ -23,10 +22,11 @@ import importlib
 import importlib.util
 import threading
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Any, Set
+from typing import Optional, Any
 from collections import OrderedDict
 from queue import Queue
 
+from exonware.xwsystem.io.serialization.auto_serializer import AutoSerializer
 from .logger import get_logger
 
 logger = get_logger("xwlazy.cache")
@@ -59,7 +59,7 @@ class MultiTierCache:
         self._l2_dir = l2_dir or Path.home() / ".xwlazy_cache"
         self._l2_dir.mkdir(parents=True, exist_ok=True)
         self._enable_l3 = enable_l3
-        self._l3_patterns: Dict[str, Tuple[int, float]] = {}
+        self._l3_patterns: dict[str, tuple[int, float]] = {}
         self._lock = threading.RLock()
         
         self._l2_write_queue: Queue = Queue()
@@ -192,7 +192,7 @@ class MultiTierCache:
                 for old_key, _ in sorted_patterns[:1000]:
                     del self._l3_patterns[old_key]
     
-    def get_predictive_keys(self, limit: int = 10) -> List[str]:
+    def get_predictive_keys(self, limit: int = 10) -> list[str]:
         """
         Get keys likely to be accessed soon (for preloading).
         
@@ -370,7 +370,7 @@ class InstallationCache:
         
         self._cache_file = cache_file
         self._lock = threading.RLock()
-        self._cache: Dict[str, Dict[str, Any]] = {}
+        self._cache: dict[str, dict[str, Any]] = {}
         self._dirty = False
         
         # Load cache on init
@@ -384,15 +384,15 @@ class InstallationCache:
         
         try:
             with self._lock:
-                with open(self._cache_file, 'r', encoding='utf-8') as f:
-                    data = json.load(f)
-                    # Validate format
-                    if isinstance(data, dict):
-                        self._cache = {k: v for k, v in data.items() 
-                                     if isinstance(v, dict) and 'installed' in v}
-                    else:
-                        self._cache = {}
-        except (json.JSONDecodeError, IOError, OSError) as e:
+                auto_serializer = AutoSerializer()
+                data = auto_serializer.auto_load_file(self._cache_file, format_hint='json')
+                # Validate format
+                if isinstance(data, dict):
+                    self._cache = {k: v for k, v in data.items() 
+                                 if isinstance(v, dict) and 'installed' in v}
+                else:
+                    self._cache = {}
+        except Exception as e:
             logger.debug(f"Failed to load installation cache: {e}")
             self._cache = {}
     
@@ -406,15 +406,16 @@ class InstallationCache:
                 # Create parent directory if needed
                 self._cache_file.parent.mkdir(parents=True, exist_ok=True)
                 
-                # Write atomically using temp file
-                temp_file = self._cache_file.with_suffix('.tmp')
-                with open(temp_file, 'w', encoding='utf-8') as f:
-                    json.dump(self._cache, f, indent=2, sort_keys=True)
-                
-                # Atomic rename
-                temp_file.replace(self._cache_file)
+                auto_serializer = AutoSerializer()
+                auto_serializer.auto_save_file(
+                    self._cache, 
+                    self._cache_file, 
+                    format_hint='json', 
+                    indent=2, 
+                    sort_keys=True
+                )
                 self._dirty = False
-        except (IOError, OSError) as e:
+        except Exception as e:
             logger.warning(f"Failed to save installation cache: {e}")
     
     def is_installed(self, package_name: str) -> bool:
@@ -487,7 +488,7 @@ class InstallationCache:
             self._dirty = True
             self._save_cache()
     
-    def get_all_installed(self) -> Set[str]:
+    def get_all_installed(self) -> set[str]:
         """
         Get set of all packages marked as installed.
         
@@ -501,4 +502,3 @@ class InstallationCache:
     def __len__(self) -> int:
         """Return number of cached packages."""
         return len(self._cache)
-

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/common/logger.py

@@ -17,7 +17,7 @@ import os
 import sys
 import logging
 import io
-from typing import Dict, Optional
+from typing import Optional
 from datetime import datetime
 
 # =============================================================================
@@ -37,7 +37,7 @@ _EMOJI_MAP = {
 }
 
 # Default log category states
-_CATEGORY_DEFAULTS: Dict[str, bool] = {
+_CATEGORY_DEFAULTS: dict[str, bool] = {
     "install": True,
     "hook": False,
     "enhance": False,
@@ -52,7 +52,7 @@ _CATEGORY_DEFAULTS: Dict[str, bool] = {
 # =============================================================================
 
 _configured = False
-_category_overrides: Dict[str, bool] = {}
+_category_overrides: dict[str, bool] = {}
 
 # =============================================================================
 # HELPER FUNCTIONS
@@ -186,7 +186,7 @@ def set_log_category(category: str, enabled: bool) -> None:
     """
     _category_overrides[_normalize_category(category)] = bool(enabled)
 
-def set_log_categories(overrides: Dict[str, bool]) -> None:
+def set_log_categories(overrides: dict[str, bool]) -> None:
     """
     Bulk update multiple log categories.
     
@@ -196,7 +196,7 @@ def set_log_categories(overrides: Dict[str, bool]) -> None:
     for category, enabled in overrides.items():
         set_log_category(category, enabled)
 
-def get_log_categories() -> Dict[str, bool]:
+def get_log_categories() -> dict[str, bool]:
     """
     Return the effective state for each built-in log category.
     
@@ -254,4 +254,3 @@ def print_formatted(flag: str, message: str, same_line: bool = False) -> None:
         sys.stdout.flush()
     else:
         print(formatted)
-

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/common/services/__init__.py

@@ -69,4 +69,3 @@ __all__ = [
     'async_install_package',
     'async_uninstall_package',
 ]
-

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/common/services/dependency_mapper.py

@@ -5,7 +5,7 @@ This module contains DependencyMapper class extracted from lazy_core.py Section
 """
 
 import threading
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Optional
 
 # Lazy import to avoid circular dependency
 def _get_logger():
@@ -59,14 +59,14 @@ class DependencyMapper:
     def __init__(self, package_name: str = 'default'):
         """Initialize dependency mapper."""
         self._discovery = None  # Lazy init to avoid circular imports
-        self._package_import_mapping: Dict[str, List[str]] = {}
-        self._import_package_mapping: Dict[str, str] = {}
+        self._package_import_mapping: dict[str, list[str]] = {}
+        self._import_package_mapping: dict[str, str] = {}
         self._cached = False
         self._lock = threading.RLock()
         self._package_name = package_name
         self._manifest_generation = -1
-        self._manifest_dependencies: Dict[str, str] = {}
-        self._manifest_signature: Optional[Tuple[str, float, float]] = None
+        self._manifest_dependencies: dict[str, str] = {}
+        self._manifest_signature: Optional[tuple[str, float, float]] = None
         self._manifest_empty = False
 
     def set_package_name(self, package_name: str) -> None:
@@ -115,7 +115,7 @@ class DependencyMapper:
         manifest = loader.get_manifest(self._package_name)
         current_generation = loader.generation
 
-        dependencies: Dict[str, str] = {}
+        dependencies: dict[str, str] = {}
         manifest_empty = True
         if manifest and manifest.dependencies:
             dependencies = {
@@ -143,7 +143,7 @@ class DependencyMapper:
             _cache_spec_if_missing(module_name)
         return needs_cache
 
-    DENY_LIST: Set[str] = {
+    DENY_LIST: set[str] = {
         # POSIX-only modules that don't exist on Windows but try to auto-install
         "pwd",
         "grp",
@@ -191,7 +191,9 @@ class DependencyMapper:
         1. Skip checks (stdlib, deny list)
         2. Manifest dependencies (explicit user configuration - highest priority)
         3. Spec cache (module already exists - skip auto-install)
-        4. Discovery mappings (automatic discovery)
+        4. Discovery mappings (automatic discovery from project configs)
+        5. Common mappings (quick access list - works without project configs)
+        6. Fallback to import_name itself
         """
         if self._should_skip_auto_install(import_name):
             return None
@@ -206,27 +208,42 @@ class DependencyMapper:
         if manifest_hit:
             return manifest_hit
         
-        # Check spec cache - if module already exists, skip auto-install
+        # Check common mappings BEFORE spec cache (common mappings are reliable)
+        # This is important for exonware projects to work immediately
+        # Common mappings take precedence over spec cache because spec cache can be stale
+        discovery = self._get_discovery()
+        common_mappings = getattr(discovery, 'COMMON_MAPPINGS', {})
+        common_hit = common_mappings.get(import_name)
+        if common_hit:
+            return common_hit
+        
+        # Check spec cache - if module already exists AND we don't have a common mapping, skip auto-install
+        # Note: We check this AFTER common mappings because spec cache can be stale after uninstallation
         if _spec_cache_get(import_name):
             return None
 
+        # Try discovery mappings (from project configs)
         self._ensure_mappings_cached()
-        return self._import_package_mapping.get(import_name, import_name)
+        discovery_hit = self._import_package_mapping.get(import_name)
+        if discovery_hit:
+            return discovery_hit
+        
+        # Fallback: assume import name matches package name
+        return import_name
     
-    def get_import_names(self, package_name: str) -> List[str]:
+    def get_import_names(self, package_name: str) -> list[str]:
         """Get all possible import names for a package."""
         self._ensure_mappings_cached()
         return self._package_import_mapping.get(package_name, [package_name])
     
-    def get_package_import_mapping(self) -> Dict[str, List[str]]:
+    def get_package_import_mapping(self) -> dict[str, list[str]]:
         """Get complete package to import names mapping."""
         self._ensure_mappings_cached()
         return self._package_import_mapping.copy()
     
-    def get_import_package_mapping(self) -> Dict[str, str]:
+    def get_import_package_mapping(self) -> dict[str, str]:
         """Get complete import to package name mapping."""
         self._ensure_mappings_cached()
         return self._import_package_mapping.copy()
 
 __all__ = ['DependencyMapper']
-

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/common/services/install_async_utils.py

@@ -13,11 +13,12 @@ Used by both execution strategies and LazyInstaller.
 
 import os
 import sys
-import json
 import asyncio
 import subprocess
 from typing import Optional
 
+from exonware.xwsystem.io.serialization.auto_serializer import AutoSerializer
+
 # Lazy imports
 def _get_logger():
     """Get logger (lazy import to avoid circular dependency)."""
@@ -31,6 +32,11 @@ def _ensure_logging_initialized():
     global logger
     if logger is None:
         logger = _get_logger()
+        # Fallback if get_logger returns None (should not happen but safety first)
+        if logger is None:
+            import logging
+            logger = logging.getLogger("xwlazy.install_async_utils.fallback")
+            logger.addHandler(logging.NullHandler())
 
 async def get_package_size_mb(package_name: str) -> Optional[float]:
     """
@@ -73,7 +79,8 @@ async def get_package_size_mb(package_name: str) -> Optional[float]:
         import urllib.request
         url = f"https://pypi.org/pypi/{package_name}/json"
         with urllib.request.urlopen(url, timeout=5) as response:
-            data = json.loads(response.read())
+            auto_serializer = AutoSerializer()
+            data = auto_serializer.detect_and_deserialize(response.read(), format_hint='json')
             if 'urls' in data and data['urls']:
                 latest = data['urls'][0]
                 if 'size' in latest:
@@ -162,4 +169,3 @@ __all__ = [
     'async_install_package',
     'async_uninstall_package',
 ]
-

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/common/services/install_cache_utils.py

@@ -19,7 +19,7 @@ import tempfile
 import subprocess
 import zipfile
 from pathlib import Path
-from typing import Optional, List
+from typing import Optional
 from contextlib import suppress
 
 # Lazy imports
@@ -77,7 +77,7 @@ def get_site_packages_dir() -> Path:
     path.mkdir(parents=True, exist_ok=True)
     return path
 
-def pip_install_from_path(wheel_path: Path, policy_args: Optional[List[str]] = None) -> bool:
+def pip_install_from_path(wheel_path: Path, policy_args: Optional[list[str]] = None) -> bool:
     """Install a wheel file using pip."""
     try:
         pip_args = [
@@ -104,7 +104,7 @@ def pip_install_from_path(wheel_path: Path, policy_args: Optional[List[str]] = N
 
 def ensure_cached_wheel(
     package_name: str,
-    policy_args: Optional[List[str]] = None,
+    policy_args: Optional[list[str]] = None,
     cache_dir: Optional[Path] = None
 ) -> Optional[Path]:
     """Ensure a wheel is cached, downloading it if necessary."""
@@ -220,7 +220,7 @@ def has_cached_install_tree(
 
 def install_from_cached_wheel(
     package_name: str,
-    policy_args: Optional[List[str]] = None,
+    policy_args: Optional[list[str]] = None,
     cache_dir: Optional[Path] = None
 ) -> bool:
     """Install from a cached wheel file."""
@@ -242,4 +242,3 @@ __all__ = [
     'has_cached_install_tree',
     'install_from_cached_wheel',
 ]
-

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/common/services/keyword_detection.py

@@ -280,4 +280,3 @@ def _detect_lazy_installation(package_name: str) -> bool:
         _lazy_detection_cache[package_name] = detected
 
     return detected
-

{exonware_xwlazy-0.1.0.22/src → exonware_xwlazy-1.0.1.2/src/_old}/exonware/xwlazy/common/services/spec_cache.py

@@ -21,7 +21,7 @@ import importlib
 import importlib.machinery
 import importlib.util
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import Optional
 from collections import OrderedDict
 from functools import lru_cache
 
@@ -31,7 +31,7 @@ _SPEC_CACHE_TTL = float(os.environ.get("XWLAZY_SPEC_CACHE_TTL", "60") or 60.0)
 
 # Cache storage
 _spec_cache_lock = threading.RLock()
-_spec_cache: OrderedDict[str, Tuple[importlib.machinery.ModuleSpec, float]] = OrderedDict()
+_spec_cache: OrderedDict[str, tuple[importlib.machinery.ModuleSpec, float]] = OrderedDict()
 
 # Multi-level cache: L1 (in-memory) + L2 (disk)
 _CACHE_L2_DIR = Path(
@@ -162,4 +162,3 @@ __all__ = [
     '_cache_spec_if_missing',
     'get_stdlib_module_set',
 ]
-