exonware-xwlazy 0.1.0.1__py3-none-any.whl → 0.1.0.8__py3-none-any.whl

exonware/xwlazy/common/services/spec_cache.py

@@ -1,165 +0,0 @@
-"""
-#exonware/xwlazy/src/exonware/xwlazy/discovery/spec_cache.py
-
-Spec cache utilities for module specification caching.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 10-Oct-2025
-
-This module provides multi-level caching (L1: memory, L2: disk) for module specs
-to optimize import performance.
-"""
-
-import os
-import sys
-import time
-import threading
-import importlib
-import importlib.machinery
-import importlib.util
-from pathlib import Path
-from typing import Optional
-from collections import OrderedDict
-from functools import lru_cache
-
-# Environment variables
-_SPEC_CACHE_MAX = int(os.environ.get("XWLAZY_SPEC_CACHE_MAX", "512") or 512)
-_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()
-
-# Multi-level cache: L1 (in-memory) + L2 (disk)
-_CACHE_L2_DIR = Path(
-    os.environ.get(
-        "XWLAZY_CACHE_DIR",
-        os.path.join(os.path.expanduser("~"), ".xwlazy", "cache"),
-    )
-)
-_CACHE_L2_DIR.mkdir(parents=True, exist_ok=True)
-
-# Stdlib module set
-try:
-    _STDLIB_MODULE_SET: set[str] = set(sys.stdlib_module_names)  # type: ignore[attr-defined]
-except AttributeError:
-    _STDLIB_MODULE_SET = set()
-_STDLIB_MODULE_SET.update(sys.builtin_module_names)
-
-@lru_cache(maxsize=1024)
-def _cached_stdlib_check(module_name: str) -> bool:
-    """Check if module is part of stdlib or built-in modules."""
-    try:
-        spec = importlib.util.find_spec(module_name)
-        if spec is None:
-            return False
-        if spec.origin in ("built-in", None):
-            return True
-        origin = spec.origin or ""
-        return (
-            "python" in origin.lower()
-            and "site-packages" not in origin.lower()
-            and "dist-packages" not in origin.lower()
-        )
-    except Exception:
-        return False
-
-def _spec_cache_prune_locked(now: Optional[float] = None) -> None:
-    """Prune expired entries from spec cache (must be called with lock held)."""
-    if not _spec_cache:
-        return
-    current = now or time.monotonic()
-    while _spec_cache:
-        fullname, (_, ts) = next(iter(_spec_cache.items()))
-        if current - ts <= _SPEC_CACHE_TTL and len(_spec_cache) <= _SPEC_CACHE_MAX:
-            break
-        _spec_cache.popitem(last=False)
-
-def _spec_cache_get(fullname: str) -> Optional[importlib.machinery.ModuleSpec]:
-    """Get spec from multi-level cache (L1: memory, L2: disk)."""
-    with _spec_cache_lock:
-        _spec_cache_prune_locked()
-        entry = _spec_cache.get(fullname)
-        if entry is not None:
-            spec, _ = entry
-            _spec_cache.move_to_end(fullname)
-            return spec
-        
-        # L2 cache: Check disk cache
-        try:
-            cache_file = _CACHE_L2_DIR / f"{fullname.replace('.', '_')}.spec"
-            if cache_file.exists():
-                mtime = cache_file.stat().st_mtime
-                age = time.time() - mtime
-                if age < _SPEC_CACHE_TTL:
-                    try:
-                        import pickle
-                        with open(cache_file, 'rb') as f:
-                            spec = pickle.load(f)
-                        # Promote to L1 cache
-                        _spec_cache[fullname] = (spec, time.monotonic())
-                        _spec_cache.move_to_end(fullname)
-                        return spec
-                    except Exception:
-                        pass
-        except Exception:
-            pass
-        
-        return None
-
-def _spec_cache_put(fullname: str, spec: Optional[importlib.machinery.ModuleSpec]) -> None:
-    """Put spec in multi-level cache (L1: memory, L2: disk)."""
-    if spec is None:
-        return
-    with _spec_cache_lock:
-        # L1 cache: In-memory
-        _spec_cache[fullname] = (spec, time.monotonic())
-        _spec_cache.move_to_end(fullname)
-        _spec_cache_prune_locked()
-        
-        # L2 cache: Disk (async, non-blocking)
-        try:
-            cache_file = _CACHE_L2_DIR / f"{fullname.replace('.', '_')}.spec"
-            import pickle
-            # Use protocol 5 for better performance
-            with open(cache_file, 'wb') as f:
-                pickle.dump(spec, f, protocol=5)
-        except Exception:
-            pass  # Fail silently for disk cache
-
-def _spec_cache_clear(fullname: Optional[str] = None) -> None:
-    """Clear spec cache entries."""
-    with _spec_cache_lock:
-        if fullname is None:
-            _spec_cache.clear()
-        else:
-            _spec_cache.pop(fullname, None)
-
-def _cache_spec_if_missing(fullname: str) -> None:
-    """Ensure a ModuleSpec is cached for a known-good module."""
-    if _spec_cache_get(fullname):
-        return
-    try:
-        spec = importlib.util.find_spec(fullname)
-    except Exception:
-        spec = None
-    if spec is not None:
-        _spec_cache_put(fullname, spec)
-
-def get_stdlib_module_set() -> set[str]:
-    """Get the set of stdlib module names."""
-    return _STDLIB_MODULE_SET.copy()
-
-__all__ = [
-    '_cached_stdlib_check',
-    '_spec_cache_get',
-    '_spec_cache_put',
-    '_spec_cache_clear',
-    '_spec_cache_prune_locked',
-    '_cache_spec_if_missing',
-    'get_stdlib_module_set',
-]
-

exonware/xwlazy/common/services/state_manager.py

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from pathlib import Path
-from typing import Optional
-
-def _get_base_config_dir() -> Path:
-    """Determine a cross-platform directory for storing lazy configuration."""
-    if os.name == "nt":
-        appdata = os.getenv("APPDATA")
-        if appdata:
-            return Path(appdata) / "exonware" / "lazy"
-        return Path.home() / "AppData" / "Roaming" / "exonware" / "lazy"
-
-    # POSIX-style
-    xdg_config = os.getenv("XDG_CONFIG_HOME")
-    if xdg_config:
-        return Path(xdg_config) / "exonware" / "lazy"
-    return Path.home() / ".config" / "exonware" / "lazy"
-
-class LazyStateManager:
-    """Persist and retrieve lazy installation state."""
-
-    def __init__(self, package_name: str) -> None:
-        self._package = package_name.lower()
-        self._state_path = _get_base_config_dir() / "state.json"
-        self._state: dict[str, dict[str, bool]] = self._load_state()
-
-    # --------------------------------------------------------------------- #
-    # Persistence helpers
-    # --------------------------------------------------------------------- #
-    def _load_state(self) -> dict[str, dict[str, bool]]:
-        if not self._state_path.exists():
-            return {}
-        try:
-            with self._state_path.open("r", encoding="utf-8") as fh:
-                data = json.load(fh)
-                if isinstance(data, dict):
-                    return data
-        except Exception:
-            pass
-        return {}
-
-    def _save_state(self) -> None:
-        self._state_path.parent.mkdir(parents=True, exist_ok=True)
-        with self._state_path.open("w", encoding="utf-8") as fh:
-            json.dump(self._state, fh, indent=2, sort_keys=True)
-
-    def _ensure_entry(self) -> dict[str, bool]:
-        return self._state.setdefault(self._package, {})
-
-    # --------------------------------------------------------------------- #
-    # Manual state management
-    # --------------------------------------------------------------------- #
-    def get_manual_state(self) -> Optional[bool]:
-        entry = self._state.get(self._package, {})
-        value = entry.get("manual")
-        return bool(value) if isinstance(value, bool) else None
-
-    def set_manual_state(self, value: Optional[bool]) -> None:
-        entry = self._ensure_entry()
-        if value is None:
-            entry.pop("manual", None)
-        else:
-            entry["manual"] = bool(value)
-        self._save_state()
-
-    # --------------------------------------------------------------------- #
-    # Auto detection cache
-    # --------------------------------------------------------------------- #
-    def get_cached_auto_state(self) -> Optional[bool]:
-        entry = self._state.get(self._package, {})
-        value = entry.get("auto")
-        return bool(value) if isinstance(value, bool) else None
-
-    def set_auto_state(self, value: Optional[bool]) -> None:
-        entry = self._ensure_entry()
-        if value is None:
-            entry.pop("auto", None)
-        else:
-            entry["auto"] = bool(value)
-        self._save_state()
-

exonware/xwlazy/common/strategies/__init__.py

@@ -1,28 +0,0 @@
-"""
-Common Caching Strategies - Shared by modules and packages.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Generic caching strategies that work with ANY data type.
-"""
-
-from .caching_dict import DictCache
-from .caching_lru import LRUCache
-from .caching_lfu import LFUCache
-from .caching_ttl import TTLCache
-from .caching_multitier import MultiTierCacheStrategy
-from .caching_installation import InstallationCacheWrapper
-
-__all__ = [
-    'DictCache',
-    'LRUCache',
-    'LFUCache',
-    'TTLCache',
-    'MultiTierCacheStrategy',
-    'InstallationCacheWrapper',
-]
-

exonware/xwlazy/common/strategies/caching_dict.py

@@ -1,44 +0,0 @@
-"""
-Dict Cache Strategy - Simple dictionary-based caching.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Simple dict-based cache implementation.
-Works with ANY data type (modules, packages, etc.).
-"""
-
-from typing import Optional, Any
-from ...common.base import ACachingStrategy
-
-class DictCache(ACachingStrategy):
-    """
-    Simple dictionary-based cache.
-    
-    No eviction policy - grows unbounded.
-    Use for small applications or when memory is not a concern.
-    """
-    
-    def __init__(self):
-        """Initialize dict cache."""
-        self._cache: dict[str, Any] = {}
-    
-    def get(self, key: str) -> Optional[Any]:
-        """Get value from cache."""
-        return self._cache.get(key)
-    
-    def set(self, key: str, value: Any) -> None:
-        """Set value in cache."""
-        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_installation.py

@@ -1,88 +0,0 @@
-"""
-Installation Cache Strategy - Wrapper for existing InstallationCache.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-Wraps existing InstallationCache to implement ICachingStrategy interface.
-"""
-
-from typing import Optional, Any
-from pathlib import Path
-from ..cache import InstallationCache
-from ..base import ACachingStrategy
-from ...package.data import PackageData
-
-class InstallationCacheWrapper(ACachingStrategy):
-    """
-    Installation cache strategy wrapper.
-    
-    Wraps existing InstallationCache to implement ICachingStrategy interface.
-    Used for package installation status caching.
-    """
-    
-    def __init__(self, cache_file: Optional[Path] = None):
-        """
-        Initialize installation cache wrapper.
-        
-        Args:
-            cache_file: Optional path to cache file
-        """
-        self._cache = InstallationCache(cache_file)
-    
-    def get(self, key: str) -> Optional[Any]:
-        """
-        Get package from cache.
-        
-        Args:
-            key: Package name
-            
-        Returns:
-            PackageData if found, None otherwise
-        """
-        if self._cache.is_installed(key):
-            version = self._cache.get_version(key)
-            return PackageData(
-                name=key,
-                installed=True,
-                version=version
-            )
-        return None
-    
-    def set(self, key: str, value: Any) -> None:
-        """
-        Cache a package.
-        
-        Args:
-            key: Package name
-            value: PackageData or dict with installed/version info
-        """
-        if isinstance(value, PackageData):
-            if value.installed:
-                self._cache.mark_installed(key, value.version)
-            else:
-                self._cache.mark_uninstalled(key)
-        elif isinstance(value, dict):
-            if value.get('installed', False):
-                self._cache.mark_installed(key, value.get('version'))
-            else:
-                self._cache.mark_uninstalled(key)
-    
-    def invalidate(self, key: str) -> None:
-        """
-        Invalidate cached package.
-        
-        Args:
-            key: Package name
-        """
-        self._cache.mark_uninstalled(key)
-    
-    def clear(self) -> None:
-        """Clear all cached packages."""
-        # InstallationCache doesn't have clear, so we'd need to extend it
-        # For now, just mark all as uninstalled (would need cache iteration)
-        pass
-

exonware/xwlazy/common/strategies/caching_lfu.py

@@ -1,66 +0,0 @@
-"""
-LFU Cache Strategy - Least Frequently Used eviction.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-LFU cache implementation with size limit.
-Works with ANY data type (modules, packages, etc.).
-"""
-
-from typing import Optional, Any
-from collections import Counter
-from ...common.base import ACachingStrategy
-
-class LFUCache(ACachingStrategy):
-    """
-    LFU (Least Frequently Used) cache with size limit.
-    
-    Evicts least frequently accessed items when cache is full.
-    Good for access pattern-based caching.
-    """
-    
-    def __init__(self, max_size: int = 1000):
-        """
-        Initialize LFU cache.
-        
-        Args:
-            max_size: Maximum number of items in cache
-        """
-        self._cache: dict[str, Any] = {}
-        self._freq: Counter[str] = Counter()
-        self._max_size = max_size
-    
-    def get(self, key: str) -> Optional[Any]:
-        """Get value from cache (increments frequency)."""
-        if key in self._cache:
-            self._freq[key] += 1
-            return self._cache[key]
-        return None
-    
-    def set(self, key: str, value: Any) -> None:
-        """Set value in cache (evicts least frequent if full)."""
-        if key not in self._cache and len(self._cache) >= self._max_size:
-            # Evict least frequent
-            if self._freq:
-                least_frequent = min(self._freq.items(), key=lambda x: x[1])[0]
-                self._cache.pop(least_frequent, None)
-                self._freq.pop(least_frequent, None)
-        
-        self._cache[key] = value
-        if key not in self._freq:
-            self._freq[key] = 0
-    
-    def invalidate(self, key: str) -> None:
-        """Invalidate cached value."""
-        self._cache.pop(key, None)
-        self._freq.pop(key, None)
-    
-    def clear(self) -> None:
-        """Clear all cached values."""
-        self._cache.clear()
-        self._freq.clear()
-

exonware/xwlazy/common/strategies/caching_lru.py

@@ -1,63 +0,0 @@
-"""
-LRU Cache Strategy - Least Recently Used eviction.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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

@@ -1,59 +0,0 @@
-"""
-Multi-Tier Cache Strategy - Wrapper for existing MultiTierCache.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-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

@@ -1,59 +0,0 @@
-"""
-TTL Cache Strategy - Time-To-Live expiration.
-
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-
-Generation Date: 15-Nov-2025
-
-TTL cache implementation with expiration.
-Works with ANY data type (modules, packages, etc.).
-"""
-
-import time
-from typing import Optional, Any
-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()
-