exonware-xwsystem 0.1.0.1__py3-none-any.whl → 0.1.0.4__py3-none-any.whl

exonware/xwsystem/caching/facade.py

@@ -0,0 +1,253 @@
+#exonware/xwsystem/src/exonware/xwsystem/caching/facade.py
+"""
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.4
+Generation Date: January 2026
+
+XWCache - Unified Caching Facade
+
+Simplified API for all caching strategies:
+- LRU, LFU, TTL
+- Memory-bounded, Two-tier, Secure
+- Async support
+- Decorator support
+"""
+
+from typing import Any, Optional, Callable
+from functools import wraps
+
+from . import (
+    LRUCache, AsyncLRUCache,
+    LFUCache, AsyncLFUCache,
+    TTLCache, AsyncTTLCache,
+    OptimizedLFUCache, AsyncOptimizedLFUCache,
+    MemoryBoundedLRUCache, MemoryBoundedLFUCache,
+    TwoTierCache,
+    SecureLRUCache, SecureLFUCache, SecureTTLCache,
+    xwcached, xw_async_cached,
+)
+from .factory import CacheFactory, CacheType
+from ..config.logging_setup import get_logger
+
+logger = get_logger(__name__)
+
+
+class XWCache:
+    """
+    Unified caching facade - simple API for all cache strategies.
+    
+    Examples:
+        >>> # Simple LRU cache
+        >>> cache = XWCache(strategy="LRU", capacity=1000)
+        >>> cache.put("key", "value")
+        >>> value = cache.get("key")
+        
+        >>> # Named cache instance
+        >>> user_cache = XWCache(strategy="LRU", name="users", capacity=500)
+        
+        >>> # TTL cache
+        >>> session_cache = XWCache(strategy="TTL", ttl=3600)
+        
+        >>> # Async cache
+        >>> async_cache = XWCache(strategy="LRU", async=True, capacity=1000)
+        
+        >>> # Advanced features
+        >>> cache = XWCache(
+        ...     strategy="LRU",
+        ...     capacity=1000,
+        ...     memory_bounded=True,
+        ...     two_tier=True,
+        ... )
+        
+        >>> # Decorator
+        >>> @XWCache.cached(strategy="LRU", ttl=3600)
+        >>> def expensive_function(x):
+        ...     return x * 2
+    """
+    
+    # Registry for named caches
+    _cache_registry: dict[str, Any] = {}
+    
+    def __init__(
+        self,
+        strategy: str = "LRU",
+        *,
+        name: Optional[str] = None,
+        capacity: int = 1000,
+        ttl: Optional[int] = None,
+        async_mode: bool = False,
+        memory_bounded: bool = False,
+        two_tier: bool = False,
+        secure: bool = False,
+        **kwargs
+    ):
+        """
+        Initialize unified cache.
+        
+        Args:
+            strategy: Cache strategy ("LRU", "LFU", "TTL", "OPTIMIZED_LFU")
+            name: Optional name for cache instance (for multiple caches)
+            capacity: Maximum cache size
+            ttl: Time to live in seconds (for TTL strategy)
+            async_mode: Use async cache implementation
+            memory_bounded: Use memory-bounded cache
+            two_tier: Use two-tier cache (memory + disk)
+            secure: Use secure cache (with rate limiting)
+            **kwargs: Additional cache-specific options
+        """
+        self.strategy = strategy.upper()
+        self.name = name
+        self.capacity = capacity
+        self.ttl = ttl
+        self.async_mode = async_mode
+        self.memory_bounded = memory_bounded
+        self.two_tier = two_tier
+        self.secure = secure
+        self.kwargs = kwargs
+        
+        # Create cache instance
+        self._cache = self._create_cache()
+        
+        # Register named cache
+        if name:
+            XWCache._cache_registry[name] = self._cache
+    
+    def _create_cache(self):
+        """Create cache instance based on strategy and options."""
+        strategy_map = {
+            "LRU": (LRUCache, AsyncLRUCache),
+            "LFU": (LFUCache, AsyncLFUCache),
+            "TTL": (TTLCache, AsyncTTLCache),
+            "OPTIMIZED_LFU": (OptimizedLFUCache, AsyncOptimizedLFUCache),
+        }
+        
+        # Secure variants
+        if self.secure:
+            secure_map = {
+                "LRU": SecureLRUCache,
+                "LFU": SecureLFUCache,
+                "TTL": SecureTTLCache,
+            }
+            if self.strategy in secure_map:
+                cache_class = secure_map[self.strategy]
+                return cache_class(capacity=self.capacity, ttl=self.ttl, **self.kwargs)
+        
+        # Memory-bounded variants
+        if self.memory_bounded:
+            if self.strategy == "LRU":
+                return MemoryBoundedLRUCache(capacity=self.capacity, **self.kwargs)
+            elif self.strategy == "LFU":
+                return MemoryBoundedLFUCache(capacity=self.capacity, **self.kwargs)
+        
+        # Two-tier cache
+        if self.two_tier:
+            return TwoTierCache(
+                namespace=self.name or "default",
+                memory_capacity=self.capacity,
+                **self.kwargs
+            )
+        
+        # Standard cache
+        if self.strategy not in strategy_map:
+            raise ValueError(f"Unknown cache strategy: {self.strategy}")
+        
+        cache_class = strategy_map[self.strategy][1 if self.async_mode else 0]
+        
+        # TTL-specific handling
+        if self.strategy == "TTL" and self.ttl:
+            return cache_class(capacity=self.capacity, ttl=self.ttl, **self.kwargs)
+        
+        return cache_class(capacity=self.capacity, **self.kwargs)
+    
+    def get(self, key: Any, default: Any = None) -> Any:
+        """Get value from cache."""
+        return self._cache.get(key, default)
+    
+    def put(self, key: Any, value: Any) -> None:
+        """Put value in cache."""
+        self._cache.put(key, value)
+    
+    def delete(self, key: Any) -> bool:
+        """Delete value from cache."""
+        return self._cache.delete(key)
+    
+    def clear(self) -> None:
+        """Clear all cache entries."""
+        self._cache.clear()
+    
+    def size(self) -> int:
+        """Get cache size."""
+        return self._cache.size()
+    
+    def __getitem__(self, key: Any) -> Any:
+        """Support dict-like access."""
+        return self.get(key)
+    
+    def __setitem__(self, key: Any, value: Any) -> None:
+        """Support dict-like access."""
+        self.put(key, value)
+    
+    def __delitem__(self, key: Any) -> None:
+        """Support dict-like access."""
+        self.delete(key)
+    
+    @classmethod
+    def get_cache(cls, name: str) -> Any:
+        """Get named cache instance."""
+        return cls._cache_registry.get(name)
+    
+    @classmethod
+    def cached(
+        cls,
+        strategy: str = "LRU",
+        capacity: int = 1000,
+        ttl: Optional[int] = None,
+        async_mode: bool = False,
+        **kwargs
+    ):
+        """
+        Decorator for caching function results.
+        
+        Examples:
+            >>> @XWCache.cached(strategy="LRU", ttl=3600)
+            >>> def expensive_function(x):
+            ...     return x * 2
+        """
+        # Create cache instance based on strategy
+        strategy_map = {
+            "LRU": (LRUCache, AsyncLRUCache),
+            "LFU": (LFUCache, AsyncLFUCache),
+            "TTL": (TTLCache, AsyncTTLCache),
+        }
+        
+        if strategy.upper() not in strategy_map:
+            raise ValueError(f"Unknown cache strategy: {strategy}")
+        
+        cache_class = strategy_map[strategy.upper()][1 if async_mode else 0]
+        
+        if strategy.upper() == "TTL" and ttl:
+            cache = cache_class(capacity=capacity, ttl=ttl, **kwargs)
+        else:
+            cache = cache_class(capacity=capacity, **kwargs)
+        
+        if async_mode:
+            return xw_async_cached(cache=cache, ttl=ttl, **kwargs)
+        else:
+            return xwcached(cache=cache, ttl=ttl, **kwargs)
+    
+    @classmethod
+    def create(
+        cls,
+        strategy: str = "LRU",
+        capacity: int = 1000,
+        **kwargs
+    ) -> "XWCache":
+        """
+        Factory method for creating cache instances.
+        
+        Examples:
+            >>> cache = XWCache.create(strategy="LRU", capacity=1000)
+        """
+        return cls(strategy=strategy, capacity=capacity, **kwargs)

exonware/xwsystem/caching/factory.py

@@ -0,0 +1,300 @@
+#exonware/xwsystem/src/exonware/xwsystem/caching/factory.py
+"""
+Cache Factory - Configurable cache creation utility.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.4
+Generation Date: January 2025
+
+Provides configurable cache factory that allows choosing different caching engines
+via settings/environment variables. Defaults to FunctoolsLRUCache (fastest Python cache - 3,333 ops/sec MIXED, 33,335 ops/sec GET).
+"""
+
+import os
+from typing import Any, Optional, Type
+from enum import Enum
+
+from ..config.logging_setup import get_logger
+from .base import ACache
+from .lru_cache import LRUCache
+from .lfu_cache import LFUCache
+from .ttl_cache import TTLCache
+from .lfu_optimized import OptimizedLFUCache
+from .memory_bounded import MemoryBoundedLRUCache, MemoryBoundedLFUCache
+from .secure_cache import SecureLRUCache, SecureLFUCache, SecureTTLCache
+from .external_caching_python import FunctoolsLRUCache
+
+logger = get_logger("xwsystem.caching.factory")
+
+
+class CacheType(str, Enum):
+    """Supported cache types."""
+    FUNCTOOLS_LRU = "functools_lru"  # Default - fastest Python cache (3,333 ops/sec MIXED, 33,335 ops/sec GET)
+    LRU = "lru"
+    LFU = "lfu"
+    TTL = "ttl"
+    OPTIMIZED_LFU = "optimized_lfu"
+    MEMORY_BOUNDED_LRU = "memory_bounded_lru"
+    MEMORY_BOUNDED_LFU = "memory_bounded_lfu"
+    SECURE_LRU = "secure_lru"
+    SECURE_LFU = "secure_lfu"
+    SECURE_TTL = "secure_ttl"
+
+
+class CacheFactory:
+    """
+    Configurable cache factory.
+    
+    Allows choosing different caching engines via:
+    - Environment variable: XWSYSTEM_CACHE_TYPE (default: 'functools_lru')
+    - Settings: 'xwsystem.cache.type' (default: 'functools_lru')
+    - Per-instance configuration
+    
+    Supported cache types:
+    - 'functools_lru' (default) - FunctoolsLRUCache - Fastest Python cache (3,333 ops/sec MIXED, 33,335 ops/sec GET)
+    - 'lfu' - LFUCache - Least Frequently Used
+    - 'lru' - LRUCache - Least Recently Used
+    - 'ttl' - TTLCache - Time-To-Live expiration
+    - 'optimized_lfu' - OptimizedLFUCache - O(1) LFU eviction
+    - 'memory_bounded_lru' - MemoryBoundedLRUCache - Memory-bounded LRU
+    - 'memory_bounded_lfu' - MemoryBoundedLFUCache - Memory-bounded LFU
+    - 'secure_lru' - SecureLRUCache - Secure LRU with rate limiting
+    - 'secure_lfu' - SecureLFUCache - Secure LFU with rate limiting
+    - 'secure_ttl' - SecureTTLCache - Secure TTL with rate limiting
+    
+    Example:
+        # Use default (FunctoolsLRUCache - fastest)
+        cache = CacheFactory.create(capacity=1000)
+        
+        # Override via environment variable
+        # export XWSYSTEM_CACHE_TYPE=lru
+        cache = CacheFactory.create(capacity=1000)
+        
+        # Override programmatically
+        cache = CacheFactory.create(capacity=1000, cache_type='ttl', ttl=3600)
+        
+        # Package-specific override
+        cache = CacheFactory.create(capacity=1000, namespace='xwstorage')
+    """
+    
+    # Global settings registry (can be set by packages)
+    _settings: dict[str, Any] = {}
+    
+    # Cache type registry
+    _cache_types: dict[str, Type[ACache]] = {
+        CacheType.FUNCTOOLS_LRU: FunctoolsLRUCache,  # Default - fastest Python cache
+        CacheType.LRU: LRUCache,
+        CacheType.LFU: LFUCache,
+        CacheType.TTL: TTLCache,
+        CacheType.OPTIMIZED_LFU: OptimizedLFUCache,
+        CacheType.MEMORY_BOUNDED_LRU: MemoryBoundedLRUCache,
+        CacheType.MEMORY_BOUNDED_LFU: MemoryBoundedLFUCache,
+        CacheType.SECURE_LRU: SecureLRUCache,
+        CacheType.SECURE_LFU: SecureLFUCache,
+        CacheType.SECURE_TTL: SecureTTLCache,
+    }
+    
+    @classmethod
+    def set_setting(cls, key: str, value: Any) -> None:
+        """
+        Set factory setting.
+        
+        Args:
+            key: Setting key (e.g., 'cache.type', 'cache.default_capacity')
+            value: Setting value
+        """
+        cls._settings[key] = value
+        logger.debug(f"CacheFactory setting updated: {key}={value}")
+    
+    @classmethod
+    def get_setting(cls, key: str, default: Any = None) -> Any:
+        """
+        Get factory setting.
+        
+        Args:
+            key: Setting key
+            default: Default value if not found
+            
+        Returns:
+            Setting value or default
+        """
+        return cls._settings.get(key, default)
+    
+    @classmethod
+    def get_cache_type(cls, namespace: Optional[str] = None) -> str:
+        """
+        Get cache type from configuration.
+        
+        Priority:
+        1. Namespace-specific setting: 'cache.type.{namespace}'
+        2. Global setting: 'cache.type' or 'xwsystem.cache.type'
+        3. Environment variable: XWSYSTEM_CACHE_TYPE or XWSYSTEM_CACHE_TYPE_{NAMESPACE}
+        4. Default: 'functools_lru' (fastest Python cache - 3,333 ops/sec MIXED, 33,335 ops/sec GET)
+        
+        Args:
+            namespace: Optional namespace for namespace-specific configuration
+            
+        Returns:
+            Cache type string
+        """
+        # Check namespace-specific setting first
+        if namespace:
+            # Namespace-specific setting
+            ns_key = f'cache.type.{namespace}'
+            cache_type = cls.get_setting(ns_key)
+            if cache_type:
+                return cache_type
+            
+            # Namespace-specific environment variable
+            env_key = f'XWSYSTEM_CACHE_TYPE_{namespace.upper()}'
+            cache_type = os.getenv(env_key)
+            if cache_type:
+                return cache_type.lower()
+        
+        # Check global setting
+        cache_type = cls.get_setting('cache.type') or cls.get_setting('xwsystem.cache.type')
+        if cache_type:
+            return cache_type
+        
+        # Check environment variable
+        cache_type = os.getenv('XWSYSTEM_CACHE_TYPE', 'functools_lru')
+        return cache_type.lower()
+    
+    @classmethod
+    def create(
+        cls,
+        capacity: int = 128,
+        cache_type: Optional[str] = None,
+        namespace: Optional[str] = None,
+        name: Optional[str] = None,
+        **kwargs
+    ) -> ACache:
+        """
+        Create cache instance based on configuration.
+        
+        Args:
+            capacity: Cache capacity (default: 128)
+            cache_type: Override cache type (optional)
+            namespace: Namespace for namespace-specific configuration (optional)
+            name: Cache name for debugging (optional)
+            **kwargs: Additional cache-specific parameters (e.g., ttl, memory_budget_mb)
+            
+        Returns:
+            Cache instance
+            
+        Raises:
+            ValueError: If cache type is invalid
+        """
+        # Determine cache type
+        if cache_type is None:
+            cache_type = cls.get_cache_type(namespace)
+        else:
+            cache_type = cache_type.lower()
+        
+        # Get cache class
+        cache_class = cls._cache_types.get(cache_type)
+        if cache_class is None:
+            # Try to find by partial match
+            cache_class = next(
+                (cls._cache_types[ct] for ct in cls._cache_types.keys() 
+                 if cache_type in ct.lower() or ct.lower() in cache_type),
+                None
+            )
+            if cache_class is None:
+                logger.warning(
+                    f"Unknown cache type '{cache_type}', using default FunctoolsLRU. "
+                    f"Available types: {list(cls._cache_types.keys())}"
+                )
+                cache_class = FunctoolsLRUCache
+                cache_type = CacheType.FUNCTOOLS_LRU
+        
+        # Prepare cache parameters
+        cache_params = {'capacity': capacity}
+        if name:
+            cache_params['name'] = name
+        
+        # Add cache-specific parameters
+        if cache_type == CacheType.TTL or cache_type == CacheType.SECURE_TTL:
+            if 'ttl' not in kwargs:
+                # Get TTL from settings or use default
+                ttl = cls.get_setting('cache.ttl') or cls.get_setting('xwsystem.cache.ttl') or 3600
+                cache_params['ttl'] = float(ttl)
+            else:
+                cache_params['ttl'] = kwargs.pop('ttl')
+        
+        if cache_type in (CacheType.MEMORY_BOUNDED_LRU, CacheType.MEMORY_BOUNDED_LFU):
+            if 'memory_budget_mb' not in kwargs:
+                memory_budget = cls.get_setting('cache.memory_budget_mb') or 100.0
+                cache_params['memory_budget_mb'] = float(memory_budget)
+            else:
+                cache_params['memory_budget_mb'] = kwargs.pop('memory_budget_mb')
+        
+        # Add any remaining kwargs
+        cache_params.update(kwargs)
+        
+        # Create cache instance
+        try:
+            cache = cache_class(**cache_params)
+            logger.debug(
+                f"Created {cache_type} cache: capacity={capacity}, "
+                f"namespace={namespace}, name={name}"
+            )
+            return cache
+        except Exception as e:
+            logger.error(f"Failed to create {cache_type} cache: {e}, falling back to FunctoolsLRU")
+            return FunctoolsLRUCache(capacity=capacity, name=name)
+    
+    @classmethod
+    def register_cache_type(cls, cache_type: str, cache_class: Type[ACache]) -> None:
+        """
+        Register custom cache type.
+        
+        Args:
+            cache_type: Cache type identifier
+            cache_class: Cache class
+        """
+        cls._cache_types[cache_type.lower()] = cache_class
+        logger.info(f"Registered custom cache type: {cache_type}")
+    
+    @classmethod
+    def get_available_types(cls) -> list[str]:
+        """Get list of available cache types."""
+        return list(cls._cache_types.keys())
+
+
+# Convenience function for easy access
+def create_cache(
+    capacity: int = 128,
+    cache_type: Optional[str] = None,
+    namespace: Optional[str] = None,
+    name: Optional[str] = None,
+    **kwargs
+) -> ACache:
+    """
+    Create cache instance (convenience function).
+    
+    Example:
+        from exonware.xwsystem.caching import create_cache
+        
+        # Use default (FunctoolsLRUCache - fastest Python cache)
+        cache = create_cache(capacity=1000)
+        
+        # Override type
+        cache = create_cache(capacity=1000, cache_type='lru')
+        
+        # Namespace-specific
+        cache = create_cache(capacity=1000, namespace='xwstorage')
+        
+        # Override via environment variable
+        # export XWSYSTEM_CACHE_TYPE=lfu
+        cache = create_cache(capacity=1000)
+    """
+    return CacheFactory.create(
+        capacity=capacity,
+        cache_type=cache_type,
+        namespace=namespace,
+        name=name,
+        **kwargs
+    )

exonware/xwsystem/caching/fluent.py

@@ -1,16 +1,19 @@
 #!/usr/bin/env python3
+#exonware/xwsystem/src/exonware/xwsystem/caching/fluent.py
 #exonware/xwsystem/caching/fluent.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.1.0.1
+Version: 0.1.0.4
 Generation Date: 01-Nov-2025
 
 Fluent API wrappers for caching module.
-Usability Priority #2 - Method chaining for better developer experience.
+Usability Priority #2 - Method chaining for developer experience.
 """
 
+from __future__ import annotations
+
 from typing import Any, Optional, Hashable
 from .lru_cache import LRUCache
 from .lfu_cache import LFUCache
@@ -30,7 +33,7 @@ class FluentLRUCache(LRUCache):
         cache.delete("k1").delete("k2").clear()  # Chain operations
     """
     
-    def put(self, key: Hashable, value: Any) -> 'FluentLRUCache':
+    def put(self, key: Hashable, value: Any) -> FluentLRUCache:
         """
         Put value and return self for chaining.
         
@@ -44,7 +47,7 @@ class FluentLRUCache(LRUCache):
         super().put(key, value)
         return self
     
-    def delete(self, key: Hashable) -> 'FluentLRUCache':
+    def delete(self, key: Hashable) -> FluentLRUCache:
         """
         Delete key and return self for chaining.
         
@@ -57,7 +60,7 @@ class FluentLRUCache(LRUCache):
         super().delete(key)
         return self
     
-    def clear(self) -> 'FluentLRUCache':
+    def clear(self) -> FluentLRUCache:
         """
         Clear cache and return self for chaining.
         
@@ -77,17 +80,17 @@ class FluentLFUCache(LFUCache):
         cache.put("k1", "v1").put("k2", "v2").put("k3", "v3")
     """
     
-    def put(self, key: Hashable, value: Any) -> 'FluentLFUCache':
+    def put(self, key: Hashable, value: Any) -> FluentLFUCache:
         """Put value and return self for chaining."""
         super().put(key, value)
         return self
     
-    def delete(self, key: Hashable) -> 'FluentLFUCache':
+    def delete(self, key: Hashable) -> FluentLFUCache:
         """Delete key and return self for chaining."""
         super().delete(key)
         return self
     
-    def clear(self) -> 'FluentLFUCache':
+    def clear(self) -> FluentLFUCache:
         """Clear cache and return self for chaining."""
         super().clear()
         return self
@@ -102,17 +105,17 @@ class FluentTTLCache(TTLCache):
         cache.put("k1", "v1").put("k2", "v2", ttl=60.0).put("k3", "v3")
     """
     
-    def put(self, key: str, value: Any, ttl: Optional[float] = None) -> 'FluentTTLCache':
+    def put(self, key: str, value: Any, ttl: Optional[float] = None) -> FluentTTLCache:
         """Put value and return self for chaining."""
         super().put(key, value, ttl)
         return self
     
-    def delete(self, key: str) -> 'FluentTTLCache':
+    def delete(self, key: str) -> FluentTTLCache:
         """Delete key and return self for chaining."""
         super().delete(key)
         return self
     
-    def clear(self) -> 'FluentTTLCache':
+    def clear(self) -> FluentTTLCache:
         """Clear cache and return self for chaining."""
         super().clear()
         return self
@@ -123,4 +126,3 @@ __all__ = [
     'FluentLFUCache',
     'FluentTTLCache',
 ]
-

exonware/xwsystem/caching/integrity.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
+#exonware/xwsystem/src/exonware/xwsystem/caching/integrity.py
 #exonware/xwsystem/caching/integrity.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.1.0.1
+Version: 0.1.0.4
 Generation Date: 01-Nov-2025
 
 Cache integrity verification - Security Priority #1.
@@ -55,12 +56,27 @@ class CacheEntry:
                     f"Cache may have been tampered with."
                 )
             return True
+        except CacheIntegrityError:
+            # Re-raise integrity errors as-is (already properly formatted)
+            raise
+        except (ValueError, TypeError, AttributeError) as e:
+            # Handle specific errors that can occur during checksum computation
+            # This follows GUIDE_TEST.md by handling specific exceptions
+            # rather than catching all exceptions
+            raise CacheIntegrityError(
+                f"Integrity verification failed for key {self.key}: "
+                f"Cannot compute checksum - {type(e).__name__}: {e}. "
+                f"This may indicate corrupted cache data."
+            ) from e
         except Exception as e:
-            if isinstance(e, CacheIntegrityError):
-                raise
+            # Catch-all for unexpected errors during integrity check
+            # This is acceptable per GUIDE_TEST.md as we're wrapping it
+            # in a proper CacheIntegrityError with context
             raise CacheIntegrityError(
-                f"Integrity verification failed: {e}"
-            )
+                f"Unexpected error during integrity verification for key {self.key}: "
+                f"{type(e).__name__}: {e}. "
+                f"Cache integrity cannot be verified."
+            ) from e
 
 
 def create_secure_entry(
@@ -126,4 +142,3 @@ __all__ = [
     'verify_entry_integrity',
     'update_entry_checksum',
 ]
-