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

exonware/xwlazy/common/strategies/caching_lru.py

@@ -0,0 +1,64 @@
+"""
+LRU Cache Strategy - Least Recently Used eviction.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+LRU cache implementation with size limit.
+Works with ANY data type (modules, packages, etc.).
+"""
+
+from typing import Optional, Any
+from collections import OrderedDict
+from ...common.base import ACachingStrategy
+
+
+class LRUCache(ACachingStrategy):
+    """
+    LRU (Least Recently Used) cache with size limit.
+    
+    Evicts least recently used items when cache is full.
+    Good for general-purpose caching.
+    """
+    
+    def __init__(self, max_size: int = 1000):
+        """
+        Initialize LRU cache.
+        
+        Args:
+            max_size: Maximum number of items in cache
+        """
+        self._cache: OrderedDict[str, Any] = OrderedDict()
+        self._max_size = max_size
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Get value from cache (moves to end for LRU)."""
+        if key in self._cache:
+            # Move to end (most recently used)
+            self._cache.move_to_end(key)
+            return self._cache[key]
+        return None
+    
+    def set(self, key: str, value: Any) -> None:
+        """Set value in cache (evicts oldest if full)."""
+        if key in self._cache:
+            # Update existing - move to end
+            self._cache.move_to_end(key)
+        else:
+            # New entry - check size limit
+            if len(self._cache) >= self._max_size:
+                # Remove oldest (first item)
+                self._cache.popitem(last=False)
+        self._cache[key] = value
+    
+    def invalidate(self, key: str) -> None:
+        """Invalidate cached value."""
+        self._cache.pop(key, None)
+    
+    def clear(self) -> None:
+        """Clear all cached values."""
+        self._cache.clear()
+

exonware/xwlazy/common/strategies/caching_multitier.py

@@ -0,0 +1,60 @@
+"""
+Multi-Tier Cache Strategy - Wrapper for existing MultiTierCache.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+Wraps existing MultiTierCache to implement ICaching interface.
+Works with ANY data type (modules, packages, etc.).
+"""
+
+from typing import Optional, Any
+from pathlib import Path
+from ...common.cache import MultiTierCache
+from ...common.base import ACachingStrategy
+
+
+class MultiTierCacheStrategy(ACachingStrategy):
+    """
+    Multi-tier cache strategy (L1 memory + L2 disk + L3 predictive).
+    
+    Wraps existing MultiTierCache to implement ICachingStrategy interface.
+    High-performance caching with multiple tiers.
+    """
+    
+    def __init__(self, l1_size: int = 1000, l2_dir: Optional[Path] = None, enable_l3: bool = True):
+        """
+        Initialize multi-tier cache.
+        
+        Args:
+            l1_size: Maximum size of L1 (memory) cache
+            l2_dir: Directory for L2 (disk) cache
+            enable_l3: Enable L3 (predictive) cache
+        """
+        self._cache = MultiTierCache(l1_size=l1_size, l2_dir=l2_dir, enable_l3=enable_l3)
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Get value from cache (L1 -> L2 -> L3)."""
+        return self._cache.get(key)
+    
+    def set(self, key: str, value: Any) -> None:
+        """Set value in cache (L1 + L2 batched)."""
+        self._cache.set(key, value)
+    
+    def invalidate(self, key: str) -> None:
+        """Invalidate cached value."""
+        # MultiTierCache doesn't have invalidate, so we set to None
+        # Or we could extend MultiTierCache to add invalidate
+        self._cache.set(key, None)
+    
+    def clear(self) -> None:
+        """Clear all cached values."""
+        self._cache.clear()
+    
+    def shutdown(self) -> None:
+        """Shutdown cache (flush L2, cleanup threads)."""
+        self._cache.shutdown()
+

exonware/xwlazy/common/strategies/caching_ttl.py

@@ -0,0 +1,60 @@
+"""
+TTL Cache Strategy - Time-To-Live expiration.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 15-Nov-2025
+
+TTL cache implementation with expiration.
+Works with ANY data type (modules, packages, etc.).
+"""
+
+import time
+from typing import Dict, Optional, Any, Tuple
+from ...common.base import ACachingStrategy
+
+
+class TTLCache(ACachingStrategy):
+    """
+    TTL (Time-To-Live) cache with expiration.
+    
+    Automatically expires entries after TTL seconds.
+    Good for time-sensitive data.
+    """
+    
+    def __init__(self, ttl_seconds: float = 3600.0):
+        """
+        Initialize TTL cache.
+        
+        Args:
+            ttl_seconds: Time-to-live in seconds (default: 1 hour)
+        """
+        self._cache: Dict[str, Tuple[Any, float]] = {}  # (value, expiry_time)
+        self._ttl = ttl_seconds
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Get value from cache (returns None if expired)."""
+        if key in self._cache:
+            value, expiry = self._cache[key]
+            if time.time() < expiry:
+                return value
+            else:
+                # Expired - remove
+                del self._cache[key]
+        return None
+    
+    def set(self, key: str, value: Any) -> None:
+        """Set value in cache with TTL."""
+        expiry = time.time() + self._ttl
+        self._cache[key] = (value, expiry)
+    
+    def invalidate(self, key: str) -> None:
+        """Invalidate cached value."""
+        self._cache.pop(key, None)
+    
+    def clear(self) -> None:
+        """Clear all cached values."""
+        self._cache.clear()
+

{xwlazy/lazy → exonware/xwlazy}/config.py

@@ -1,36 +1,40 @@
-from __future__ import annotations
+"""
+#exonware/xwlazy/src/exonware/xwlazy/config.py
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.19
+Generation Date: 10-Oct-2025
 
-"""Configuration helpers for the lazy-loading subsystem."""
+Configuration for Lazy Loading System
 
-from dataclasses import dataclass, field
-from typing import Tuple
+This module defines configuration classes for the lazy loading system
+following GUIDE_ARCH.md structure.
+"""
 
-from .lazy_core import (
-    config_package_lazy_install_enabled,
-    disable_lazy_mode,
-    enable_lazy_mode,
-    is_import_hook_installed,
-    is_lazy_install_enabled,
-    is_lazy_mode_enabled,
-    install_import_hook,
-)
+from __future__ import annotations
 
+from typing import Optional, Any, Dict
 
-@dataclass
-class LazyConfig:
-    """Bridge configuration settings with the lazy package implementation."""
+# Import LazyConfig dataclass from defs.py
+from .defs import LazyConfig as _LazyConfigBase
 
-    packages: Tuple[str, ...] = field(
-        default_factory=lambda: ("default",)
-    )
 
+# Extend LazyConfig with methods (dataclass is in defs.py)
+class LazyConfig(_LazyConfigBase):
+    """Bridge configuration settings with the lazy package implementation."""
+    
     def __post_init__(self) -> None:
-        self.packages = tuple(package.lower() for package in self.packages)
+        """Normalize package names."""
+        super().__post_init__()
 
     # High-level API -----------------------------------------------------
     @property
     def lazy_import(self) -> bool:
         """Return whether lazy mode is currently active."""
+        # Import from facade
+        from .facade import is_lazy_mode_enabled
         return is_lazy_mode_enabled()
 
     @lazy_import.setter
@@ -52,6 +56,15 @@ class LazyConfig:
         Includes re-hooking support: If lazy is enabled and install_hook is True,
         ensures the import hook is installed even if it wasn't installed initially.
         """
+        # Import from facade
+        from .facade import (
+            config_package_lazy_install_enabled,
+            disable_lazy_mode,
+            enable_lazy_mode,
+            is_import_hook_installed,
+            install_import_hook,
+        )
+        
         if enabled:
             self._configure_packages(True, mode=mode, install_hook=install_hook)
             enable_lazy_mode(
@@ -99,6 +112,12 @@ class LazyConfig:
         Returns:
             Dictionary with lazy mode status information
         """
+        # Import from facade
+        from .facade import (
+            is_import_hook_installed,
+            is_lazy_install_enabled,
+        )
+        
         try:
             primary_package = self.packages[0] if self.packages else "default"
             return {
@@ -123,6 +142,9 @@ class LazyConfig:
         Returns:
             True if lazy mode is enabled and hook is installed
         """
+        # Import from facade
+        from .facade import is_import_hook_installed
+        
         try:
             primary_package = self.packages[0] if self.packages else "default"
             return self.lazy_import and is_import_hook_installed(primary_package)
@@ -137,6 +159,9 @@ class LazyConfig:
         mode: str = "auto",
         install_hook: bool = True,
     ) -> None:
+        # Import from facade
+        from .facade import config_package_lazy_install_enabled
+        
         for package in self.packages:
             config_package_lazy_install_enabled(
                 package,
@@ -151,6 +176,12 @@ class LazyConfig:
         
         Re-hooking support: Install hook if not already installed.
         """
+        # Import from facade
+        from .facade import (
+            is_import_hook_installed,
+            install_import_hook,
+        )
+        
         try:
             primary_package = self.packages[0] if self.packages else "default"
             if not is_import_hook_installed(primary_package):
@@ -161,3 +192,4 @@ class LazyConfig:
 
 
 DEFAULT_LAZY_CONFIG = LazyConfig()
+