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

exonware/xwlazy/package/services/lazy_installer.py

@@ -20,7 +20,7 @@ import subprocess
 import importlib
 import importlib.util
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Set, Any
+from typing import Optional, Any
 from collections import OrderedDict
 from types import ModuleType
 
@@ -154,10 +154,13 @@ class LazyInstaller(
         self._async_enabled = False
         self._async_workers = 1
         self._async_loop: Optional[asyncio.AbstractEventLoop] = None
-        self._async_tasks: Dict[str, Any] = {}
+        self._async_tasks: dict[str, Any] = {}
         self._known_missing: OrderedDict[str, float] = OrderedDict()
         self._async_cache_dir = _DEFAULT_ASYNC_CACHE_DIR
         self._loop_thread: Optional[threading.Thread] = None
+        # Hard force disable async installs to prevent any potential issues
+        # This overrides any env vars or manifest settings
+        self._async_enabled = False
         
         # ROOT CAUSE FIX: Load persistent installation cache
         # This cache tracks installed packages across Python restarts
@@ -166,6 +169,7 @@ class LazyInstaller(
     
     def install_package(self, package_name: str, module_name: str = None) -> bool:
         """Install a package using pip."""
+        sys.stderr.write(f"DEBUG: install_package called for {package_name}\n")
         _ensure_logging_initialized()
         # CRITICAL: Set flag FIRST before ANY operations to prevent recursion
         if getattr(_installing, 'active', False):
@@ -188,11 +192,22 @@ class LazyInstaller(
                 if package_name in self._installed_packages:
                     return True
                 
+                # ROOT CAUSE FIX: Check if already importable (handles pre-installed packages not in cache)
+                # This prevents unnecessary pip calls and handles cache desync
+                check_name = module_name or package_name.replace('-', '_')
+                if check_name and self._is_module_importable(check_name):
+                    _log("install", logger.info, f"Package {package_name} found in environment, marking as installed")
+                    # Update caches
+                    self._installed_packages.add(package_name)
+                    version = self._get_installed_version(package_name)
+                    self._install_cache.mark_installed(package_name, version)
+                    return True
+                
                 if package_name in self._failed_packages:
                     return False
                 
                 if self._mode == LazyInstallMode.DISABLED or self._mode == LazyInstallMode.NONE:
-                    _log("install", f"Lazy installation disabled for {self._package_name}, skipping {package_name}")
+                    _log("install", logger.info, f"Lazy installation disabled for {self._package_name}, skipping {package_name}")
                     return False
                 
                 if self._mode == LazyInstallMode.WARN:
@@ -211,7 +226,7 @@ class LazyInstaller(
                 
                 if self._mode == LazyInstallMode.INTERACTIVE:
                     if not self._ask_user_permission(package_name, module_name or package_name):
-                        _log("install", f"User declined installation of {package_name}")
+                        _log("install", logger.info, f"User declined installation of {package_name}")
                         self._failed_packages.add(package_name)
                         return False
                 
@@ -414,6 +429,12 @@ class LazyInstaller(
     
     def _is_module_importable(self, module_name: str) -> bool:
         """Check if module can be imported without installation."""
+        # CRITICAL FIX: Check if import is already in progress to prevent recursion
+        from ...module.importer_engine import _is_import_in_progress
+        if _is_import_in_progress(module_name):
+            # Import is already in progress, don't check again to avoid recursion
+            return False
+        
         try:
             spec = importlib.util.find_spec(module_name)
             return spec is not None and spec.loader is not None
@@ -457,15 +478,20 @@ class LazyInstaller(
         
         return False
     
-    def install_and_import(self, module_name: str, package_name: str = None) -> Tuple[Optional[ModuleType], bool]:
+    def install_and_import(self, module_name: str, package_name: str = None) -> tuple[Optional[ModuleType], bool]:
         """
         Install package and import module.
         
         ROOT CAUSE FIX: Check if module is importable FIRST before attempting
         installation. This prevents circular imports and unnecessary installations.
         """
+        # CRITICAL: Initialize lazy imports first
+        _ensure_logging_initialized()
+        
+        sys.stderr.write(f"DEBUG: install_and_import called for {module_name}\n")
         # CRITICAL: Prevent recursion - if installation is already in progress, skip
         if getattr(_installing, 'active', False):
+            sys.stderr.write(f"DEBUG: Recursion guard hit for {module_name}\n")
             logger.debug(
                 f"Installation in progress, skipping install_and_import for {module_name} "
                 f"to prevent recursion"
@@ -473,27 +499,71 @@ class LazyInstaller(
             return None, False
         
         if not self.is_enabled():
+            sys.stderr.write(f"DEBUG: Installer disabled for {module_name}\n")
             return None, False
         
         # Get package name early for cache check
         if package_name is None:
             package_name = self._dependency_mapper.get_package_name(module_name)
         
+        sys.stderr.write(f"DEBUG: package_name for {module_name} is {package_name}\n")
+        
         # ROOT CAUSE FIX: Check persistent cache FIRST (fastest, no importability check)
         if package_name and self._install_cache.is_installed(package_name):
             # Package is in persistent cache - import directly
+            # CRITICAL: Remove finders before importing to prevent recursion
+            xwlazy_finder_names = {'LazyMetaPathFinder', 'LazyPathFinder', 'LazyLoader'}
+            xwlazy_finders = [f for f in sys.meta_path if type(f).__name__ in xwlazy_finder_names]
+            for finder in xwlazy_finders:
+                try:
+                    sys.meta_path.remove(finder)
+                except ValueError:
+                    pass
+            
             try:
                 module = importlib.import_module(module_name)
                 self._clear_module_missing(module_name)
-                _spec_cache_put(module_name, importlib.util.find_spec(module_name))
+                # Also remove finders before find_spec to prevent recursion
+                spec = importlib.util.find_spec(module_name)
+                _spec_cache_put(module_name, spec)
                 logger.debug(f"Module {module_name} is in persistent cache, imported directly")
                 return module, True
             except ImportError as e:
-                logger.debug(f"Module {module_name} in cache but import failed: {e}")
-                # Cache might be stale - fall through to importability check
+                _log("install", logger.warning, f"Module {module_name} in cache but import failed: {e}")
+                # ROOT CAUSE FIX: Cache is stale - invalidate it so we try to install properly
+                if package_name:
+                    logger.debug(f"Invalidating stale cache entry for {package_name}")
+                    self._install_cache.mark_uninstalled(package_name)
+                    with self._lock:
+                        self._installed_packages.discard(package_name)
+                        # Also clear from failed packages so we can retry installation
+                        self._failed_packages.discard(package_name)
+                # Fall through to importability check and installation
+            finally:
+                # Restore finders
+                for finder in reversed(xwlazy_finders):
+                    if finder not in sys.meta_path:
+                        sys.meta_path.insert(0, finder)
         
         # ROOT CAUSE FIX: Check if module is ALREADY importable BEFORE doing anything else
-        if self._is_module_importable(module_name):
+        # But first, remove finders to prevent recursion
+        xwlazy_finder_names = {'LazyMetaPathFinder', 'LazyPathFinder', 'LazyLoader'}
+        xwlazy_finders = [f for f in sys.meta_path if type(f).__name__ in xwlazy_finder_names]
+        for finder in xwlazy_finders:
+            try:
+                sys.meta_path.remove(finder)
+            except ValueError:
+                pass
+
+        try:
+            is_importable = self._is_module_importable(module_name)
+        finally:
+            # Restore finders
+            for finder in reversed(xwlazy_finders):
+                if finder not in sys.meta_path:
+                    sys.meta_path.insert(0, finder)
+
+        if is_importable:
             # Module is already importable - import it directly
             if package_name:
                 version = self._get_installed_version(package_name)
@@ -505,7 +575,15 @@ class LazyInstaller(
                 logger.debug(f"Module {module_name} is already importable, imported directly")
                 return module, True
             except ImportError as e:
-                logger.debug(f"Module {module_name} appeared importable but import failed: {e}")
+                _log("install", logger.warning, f"Module {module_name} appeared importable but import failed: {e}")
+                # ROOT CAUSE FIX: If importability check passed but import failed, invalidate cache
+                if package_name:
+                    logger.debug(f"Invalidating stale cache entry for {package_name} (importability check was wrong)")
+                    self._install_cache.mark_uninstalled(package_name)
+                    with self._lock:
+                        self._installed_packages.discard(package_name)
+                        # Also clear from failed packages so we can retry installation
+                        self._failed_packages.discard(package_name)
         
         # Package name should already be set from cache check above
         if package_name is None:
@@ -573,6 +651,7 @@ class LazyInstaller(
                             if finder not in sys.meta_path:
                                 sys.meta_path.insert(0, finder)
                 except ImportError as e:
+                    _log("install", logger.warning, f"Import retry {attempt} failed for {module_name}: {e}")
                     if attempt < 2:
                         time.sleep(0.1 * (attempt + 1))
                     else:
@@ -582,11 +661,11 @@ class LazyInstaller(
         self._mark_module_missing(module_name)
         return None, False
     
-    def _check_security_policy(self, package_name: str) -> Tuple[bool, str]:
+    def _check_security_policy(self, package_name: str) -> tuple[bool, str]:
         """Check security policy for package."""
         return LazyInstallPolicy.is_package_allowed(self._package_name, package_name)
     
-    def _run_pip_install(self, package_name: str, args: List[str]) -> bool:
+    def _run_pip_install(self, package_name: str, args: list[str]) -> bool:
         """Run pip install with arguments."""
         if self._install_from_cached_wheel(package_name):
             return True
@@ -599,6 +678,7 @@ class LazyInstaller(
                 '--disable-pip-version-check',
                 '--no-input',
             ] + args + [package_name]
+            _log("install", logger.info, f"Running pip install for {package_name}...")
             result = subprocess.run(
                 pip_args,
                 capture_output=True,
@@ -607,22 +687,27 @@ class LazyInstaller(
             )
             if result.returncode == 0:
                 self._ensure_cached_wheel(package_name)
+                _log("install", logger.info, f"Pip install successful for {package_name}")
                 return True
+            _log("install", logger.error, f"Pip failed for {package_name}: {result.stderr}")
+            print(f"DEBUG: Pip failed for {package_name}: {result.stderr}")
             return False
-        except subprocess.CalledProcessError:
+        except subprocess.CalledProcessError as e:
+            _log("install", logger.error, f"Pip error for {package_name}: {e.stderr if hasattr(e, 'stderr') else e}")
+            print(f"DEBUG: Pip error for {package_name}: {e.stderr if hasattr(e, 'stderr') else e}")
             return False
     
-    def get_installed_packages(self) -> Set[str]:
+    def get_installed_packages(self) -> set[str]:
         """Get set of installed package names."""
         with self._lock:
             return self._installed_packages.copy()
     
-    def get_failed_packages(self) -> Set[str]:
+    def get_failed_packages(self) -> set[str]:
         """Get set of failed package names."""
         with self._lock:
             return self._failed_packages.copy()
     
-    def get_async_tasks(self) -> Dict[str, Any]:
+    def get_async_tasks(self) -> dict[str, Any]:
         """Get dictionary of async installation tasks."""
         with self._lock:
             return {
@@ -633,7 +718,7 @@ class LazyInstaller(
                 for module_name, task in self._async_tasks.items()
             }
     
-    def get_stats(self) -> Dict[str, Any]:
+    def get_stats(self) -> dict[str, Any]:
         """Get installation statistics (extends base class method)."""
         base_stats = super().get_stats()
         with self._lock:

exonware/xwlazy/package/services/manifest.py

@@ -24,7 +24,7 @@ import json
 import os
 from pathlib import Path
 from threading import RLock
-from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
+from typing import Any, Iterable, Optional
 
 try:  # Python 3.11+
     import tomllib  # type: ignore[attr-defined]
@@ -34,7 +34,7 @@ except Exception:  # pragma: no cover - fallback for <=3.10
     except ImportError:  # pragma: no cover
         tomllib = None  # type: ignore
 
-DEFAULT_MANIFEST_FILENAMES: Tuple[str, ...] = (
+DEFAULT_MANIFEST_FILENAMES: tuple[str, ...] = (
     "xwlazy.manifest.json",
     "lazy.manifest.json",
     ".xwlazy.manifest.json",
@@ -53,8 +53,8 @@ def _normalize_prefix(prefix: str) -> str:
         prefix = f"{prefix}."
     return prefix
 
-def _normalize_wrap_hints(values: Iterable[Any]) -> List[str]:
-    hints: List[str] = []
+def _normalize_wrap_hints(values: Iterable[Any]) -> list[str]:
+    hints: list[str] = []
     for value in values:
         if value is None:
             continue
@@ -79,18 +79,18 @@ class LazyManifestLoader:
     def __init__(
         self,
         default_root: Optional[Path] = None,
-        package_roots: Optional[Dict[str, Path]] = None,
+        package_roots: Optional[dict[str, Path]] = None,
     ) -> None:
         self._default_root = default_root
         self._provided_roots = {
             _normalize_package_name(name): Path(path)
             for name, path in (package_roots or {}).items()
         }
-        self._manifest_cache: Dict[str, PackageManifest] = {}
-        self._source_signatures: Dict[str, Tuple[str, float, float]] = {}
-        self._pyproject_cache: Dict[Path, Tuple[float, Dict[str, Any]]] = {}
-        self._shared_dependency_maps: Dict[
-            Tuple[str, float, float], Dict[str, Dict[str, str]]
+        self._manifest_cache: dict[str, PackageManifest] = {}
+        self._source_signatures: dict[str, tuple[str, float, float]] = {}
+        self._pyproject_cache: dict[Path, tuple[float, dict[str, Any]]] = {}
+        self._shared_dependency_maps: dict[
+            tuple[str, float, float], dict[str, dict[str, str]]
         ] = {}
         self._lock = RLock()
         self._generation = 0
@@ -163,7 +163,7 @@ class LazyManifestLoader:
             self._generation += 1
             return manifest
 
-    def get_manifest_signature(self, package_name: Optional[str]) -> Optional[Tuple[str, float, float]]:
+    def get_manifest_signature(self, package_name: Optional[str]) -> Optional[tuple[str, float, float]]:
         key = _normalize_package_name(package_name)
         with self._lock:
             signature = self._source_signatures.get(key)
@@ -177,8 +177,8 @@ class LazyManifestLoader:
     def get_shared_dependencies(
         self,
         package_name: Optional[str],
-        signature: Optional[Tuple[str, float, float]],
-    ) -> Optional[Dict[str, str]]:
+        signature: Optional[tuple[str, float, float]],
+    ) -> Optional[dict[str, str]]:
         if signature is None:
             return None
         with self._lock:
@@ -222,7 +222,7 @@ class LazyManifestLoader:
         )
         return manifest
 
-    def _compute_signature(self, package_key: str) -> Optional[Tuple[str, float, float]]:
+    def _compute_signature(self, package_key: str) -> Optional[tuple[str, float, float]]:
         root = self._resolve_project_root(package_key)
         pyproject_path = root / "pyproject.toml"
         pyproject_mtime = pyproject_path.stat().st_mtime if pyproject_path.exists() else 0.0
@@ -258,20 +258,27 @@ class LazyManifestLoader:
 
     @staticmethod
     def _walk_to_project_root(start: Path) -> Optional[Path]:
-        current = start
-        while True:
-            if (current / "pyproject.toml").exists():
-                return current
-            parent = current.parent
-            if parent == current:
-                break
-            current = parent
-        return None
+        """Walk up from start path to find project root."""
+        from ...common.utils import find_project_root
+        # Use utility function, but start from the provided path
+        try:
+            return find_project_root(start)
+        except Exception:
+            # Fallback: simple walk-up logic
+            current = start
+            while True:
+                if (current / "pyproject.toml").exists():
+                    return current
+                parent = current.parent
+                if parent == current:
+                    break
+                current = parent
+            return None
 
     # ------------------------------- #
     # Pyproject helpers
     # ------------------------------- #
-    def _load_pyproject(self, path: Path) -> Dict[str, Any]:
+    def _load_pyproject(self, path: Path) -> dict[str, Any]:
         if not path.exists() or tomllib is None:
             return {}
 
@@ -291,9 +298,9 @@ class LazyManifestLoader:
 
     def _extract_pyproject_entry(
         self,
-        pyproject_data: Dict[str, Any],
+        pyproject_data: dict[str, Any],
         package_key: str,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         tool_section = pyproject_data.get("tool", {})
         lazy_section = tool_section.get("xwlazy", {})
         packages = lazy_section.get("packages", {})
@@ -362,8 +369,8 @@ class LazyManifestLoader:
     def _load_json_manifest(
         self,
         root: Path,
-        pyproject_data: Dict[str, Any],
-    ) -> Tuple[Dict[str, Any], Optional[Path]]:
+        pyproject_data: dict[str, Any],
+    ) -> tuple[dict[str, Any], Optional[Path]]:
         manifest_path = self._resolve_manifest_path(root, root / "pyproject.toml")
         if not manifest_path:
             return {}, None
@@ -381,12 +388,12 @@ class LazyManifestLoader:
     def _merge_sources(
         self,
         package_key: str,
-        pyproject_data: Dict[str, Any],
-        json_data: Dict[str, Any],
-    ) -> Dict[str, Any]:
-        merged_dependencies: Dict[str, str] = {}
-        merged_watched: List[str] = []
-        merged_wrap_hints: List[str] = []
+        pyproject_data: dict[str, Any],
+        json_data: dict[str, Any],
+    ) -> dict[str, Any]:
+        merged_dependencies: dict[str, str] = {}
+        merged_watched: list[str] = []
+        merged_wrap_hints: list[str] = []
 
         # Pyproject first (acts as baseline)
         py_entry = self._extract_pyproject_entry(pyproject_data, package_key)
@@ -436,8 +443,8 @@ class LazyManifestLoader:
                 if "async_workers" in entry:
                     async_workers = entry.get("async_workers", async_workers)
 
-        seen_wrap: Set[str] = set()
-        ordered_wrap_hints: List[str] = []
+        seen_wrap: set[str] = set()
+        ordered_wrap_hints: list[str] = []
         for hint in merged_wrap_hints:
             if hint not in seen_wrap:
                 seen_wrap.add(hint)

exonware/xwlazy/package/services/strategy_registry.py

@@ -11,7 +11,7 @@ Registry to store custom strategies per package for both package and module oper
 """
 
 import threading
-from typing import Dict, Optional, Any, TYPE_CHECKING
+from typing import Optional, Any, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ...contracts import (
@@ -23,22 +23,39 @@ if TYPE_CHECKING:
         IModuleHelperStrategy,
         IModuleManagerStrategy,
         ICachingStrategy,
+        IInstallStrategy,
+        ILoadStrategy,
+        ICacheStrategy,
     )
 
 class StrategyRegistry:
-    """Registry to store custom strategies per package."""
+    """
+    Registry to store custom strategies per package and enable runtime strategy swapping.
     
-    # Package strategies
-    _package_execution_strategies: Dict[str, 'IInstallExecutionStrategy'] = {}
-    _package_timing_strategies: Dict[str, 'IInstallTimingStrategy'] = {}
-    _package_discovery_strategies: Dict[str, 'IDiscoveryStrategy'] = {}
-    _package_policy_strategies: Dict[str, 'IPolicyStrategy'] = {}
-    _package_mapping_strategies: Dict[str, 'IMappingStrategy'] = {}
+    Supports both:
+    - Per-package strategies (different strategies for different packages)
+    - Global strategy swapping (change default strategies used by all packages)
+    """
     
-    # Module strategies
-    _module_helper_strategies: Dict[str, 'IModuleHelperStrategy'] = {}
-    _module_manager_strategies: Dict[str, 'IModuleManagerStrategy'] = {}
-    _module_caching_strategies: Dict[str, 'ICachingStrategy'] = {}
+    # Package strategies (per-package)
+    _package_execution_strategies: dict[str, 'IInstallExecutionStrategy'] = {}
+    _package_timing_strategies: dict[str, 'IInstallTimingStrategy'] = {}
+    _package_discovery_strategies: dict[str, 'IDiscoveryStrategy'] = {}
+    _package_policy_strategies: dict[str, 'IPolicyStrategy'] = {}
+    _package_mapping_strategies: dict[str, 'IMappingStrategy'] = {}
+    
+    # Module strategies (per-package)
+    _module_helper_strategies: dict[str, 'IModuleHelperStrategy'] = {}
+    _module_manager_strategies: dict[str, 'IModuleManagerStrategy'] = {}
+    _module_caching_strategies: dict[str, 'ICachingStrategy'] = {}
+    
+    # Global strategies (for runtime swapping)
+    _global_install_strategies: dict[str, 'IInstallStrategy'] = {}
+    _global_load_strategies: dict[str, 'ILoadStrategy'] = {}
+    _global_cache_strategies: dict[str, 'ICacheStrategy'] = {}
+    _default_install_strategy: Optional[str] = None
+    _default_load_strategy: Optional[str] = None
+    _default_cache_strategy: Optional[str] = None
     
     _lock = threading.RLock()
     
@@ -181,6 +198,127 @@ class StrategyRegistry:
         """Clear all strategies (package and module) for a package."""
         cls.clear_package_strategies(package_name)
         cls.clear_module_strategies(package_name)
+    
+    # ========================================================================
+    # Global Strategy Management (for runtime swapping)
+    # ========================================================================
+    
+    @classmethod
+    def register_install_strategy(cls, name: str, strategy: 'IInstallStrategy') -> None:
+        """
+        Register a global installation strategy for runtime swapping.
+        
+        Args:
+            name: Strategy name (e.g., 'pip', 'wheel', 'async', 'cached')
+            strategy: Strategy instance implementing IInstallStrategy
+        """
+        with cls._lock:
+            cls._global_install_strategies[name] = strategy
+            if cls._default_install_strategy is None:
+                cls._default_install_strategy = name
+    
+    @classmethod
+    def get_install_strategy(cls, name: Optional[str] = None) -> Optional['IInstallStrategy']:
+        """
+        Get global installation strategy by name.
+        
+        Args:
+            name: Strategy name (uses default if None)
+            
+        Returns:
+            Strategy instance or None if not found
+        """
+        with cls._lock:
+            if name is None:
+                name = cls._default_install_strategy
+            return cls._global_install_strategies.get(name) if name else None
+    
+    @classmethod
+    def register_load_strategy(cls, name: str, strategy: 'ILoadStrategy') -> None:
+        """
+        Register a global loading strategy for runtime swapping.
+        
+        Args:
+            name: Strategy name (e.g., 'lazy', 'simple', 'advanced')
+            strategy: Strategy instance implementing ILoadStrategy
+        """
+        with cls._lock:
+            cls._global_load_strategies[name] = strategy
+            if cls._default_load_strategy is None:
+                cls._default_load_strategy = name
+    
+    @classmethod
+    def get_load_strategy(cls, name: Optional[str] = None) -> Optional['ILoadStrategy']:
+        """
+        Get global loading strategy by name.
+        
+        Args:
+            name: Strategy name (uses default if None)
+            
+        Returns:
+            Strategy instance or None if not found
+        """
+        with cls._lock:
+            if name is None:
+                name = cls._default_load_strategy
+            return cls._global_load_strategies.get(name) if name else None
+    
+    @classmethod
+    def register_cache_strategy(cls, name: str, strategy: 'ICacheStrategy') -> None:
+        """
+        Register a global caching strategy for runtime swapping.
+        
+        Args:
+            name: Strategy name (e.g., 'lru', 'lfu', 'ttl', 'multitier')
+            strategy: Strategy instance implementing ICacheStrategy
+        """
+        with cls._lock:
+            cls._global_cache_strategies[name] = strategy
+            if cls._default_cache_strategy is None:
+                cls._default_cache_strategy = name
+    
+    @classmethod
+    def get_cache_strategy(cls, name: Optional[str] = None) -> Optional['ICacheStrategy']:
+        """
+        Get global caching strategy by name.
+        
+        Args:
+            name: Strategy name (uses default if None)
+            
+        Returns:
+            Strategy instance or None if not found
+        """
+        with cls._lock:
+            if name is None:
+                name = cls._default_cache_strategy
+            return cls._global_cache_strategies.get(name) if name else None
+    
+    @classmethod
+    def swap_install_strategy(cls, name: str) -> bool:
+        """Swap to a different global installation strategy."""
+        with cls._lock:
+            if name in cls._global_install_strategies:
+                cls._default_install_strategy = name
+                return True
+            return False
+    
+    @classmethod
+    def swap_load_strategy(cls, name: str) -> bool:
+        """Swap to a different global loading strategy."""
+        with cls._lock:
+            if name in cls._global_load_strategies:
+                cls._default_load_strategy = name
+                return True
+            return False
+    
+    @classmethod
+    def swap_cache_strategy(cls, name: str) -> bool:
+        """Swap to a different global caching strategy."""
+        with cls._lock:
+            if name in cls._global_cache_strategies:
+                cls._default_cache_strategy = name
+                return True
+            return False
 
 __all__ = ['StrategyRegistry']
 

exonware/xwlazy/package/strategies/package_discovery_file.py

@@ -11,7 +11,7 @@ File-based discovery - discovers dependencies from project files.
 """
 
 from pathlib import Path
-from typing import Dict, Optional, Any
+from typing import Optional, Any
 from ...package.base import ADiscoveryStrategy
 
 class FileBasedDiscovery(ADiscoveryStrategy):
@@ -49,7 +49,7 @@ class FileBasedDiscovery(ADiscoveryStrategy):
         
         return cwd
     
-    def discover(self, project_root: Any = None) -> Dict[str, str]:
+    def discover(self, project_root: Any = None) -> dict[str, str]:
         """
         Discover dependencies from project files.
         

exonware/xwlazy/package/strategies/package_discovery_hybrid.py

@@ -11,7 +11,7 @@ Hybrid discovery - combines file-based and manifest-based discovery.
 """
 
 from pathlib import Path
-from typing import Dict, Optional, Any
+from typing import Optional, Any
 from ...package.base import ADiscoveryStrategy
 from .package_discovery_file import FileBasedDiscovery
 from .package_discovery_manifest import ManifestBasedDiscovery
@@ -36,7 +36,7 @@ class HybridDiscovery(ADiscoveryStrategy):
         self._file_discovery = FileBasedDiscovery(project_root)
         self._manifest_discovery = ManifestBasedDiscovery(package_name, project_root)
     
-    def discover(self, project_root: Any = None) -> Dict[str, str]:
+    def discover(self, project_root: Any = None) -> dict[str, str]:
         """
         Discover dependencies from all sources.
         

exonware/xwlazy/package/strategies/package_discovery_manifest.py

@@ -11,7 +11,7 @@ Manifest-based discovery - discovers dependencies from manifest files.
 """
 
 from pathlib import Path
-from typing import Dict, Optional, Any
+from typing import Optional, Any
 from ...package.base import ADiscoveryStrategy
 
 class ManifestBasedDiscovery(ADiscoveryStrategy):
@@ -51,7 +51,7 @@ class ManifestBasedDiscovery(ADiscoveryStrategy):
         
         return cwd
     
-    def discover(self, project_root: Any = None) -> Dict[str, str]:
+    def discover(self, project_root: Any = None) -> dict[str, str]:
         """
         Discover dependencies from manifest files.