wappa 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

wappa/persistence/memory/handlers/utils/ttl_manager.py

@@ -5,10 +5,8 @@ Provides additional TTL management functionality beyond the basic
 memory store implementation.
 """
 
-import asyncio
 import logging
 from datetime import datetime, timedelta
-from typing import Optional
 
 from .memory_store import get_memory_store
 
@@ -18,36 +16,36 @@ logger = logging.getLogger("TTLManager")
 class TTLManager:
     """
     Advanced TTL management for memory cache.
-    
+
     Provides utilities for TTL monitoring, batch operations,
     and advanced expiration handling.
     """
-    
+
     def __init__(self):
         self.memory_store = get_memory_store()
-    
+
     async def get_ttl_info(self, namespace: str, context_key: str, key: str) -> dict:
         """
         Get detailed TTL information for a key.
-        
+
         Args:
             namespace: Cache namespace
             context_key: Context identifier
             key: Cache key
-        
+
         Returns:
             Dictionary with TTL details
         """
         ttl_seconds = await self.memory_store.get_ttl(namespace, context_key, key)
-        
+
         info = {
             "key": key,
             "namespace": namespace,
             "context_key": context_key,
             "ttl_seconds": ttl_seconds,
-            "status": "unknown"
+            "status": "unknown",
         }
-        
+
         if ttl_seconds == -2:
             info["status"] = "not_found"
             info["message"] = "Key does not exist"
@@ -58,140 +56,134 @@ class TTLManager:
             info["status"] = "expires"
             info["expires_at"] = datetime.now() + timedelta(seconds=ttl_seconds)
             info["message"] = f"Key expires in {ttl_seconds} seconds"
-        
+
         return info
-    
+
     async def extend_ttl(
-        self, 
-        namespace: str, 
-        context_key: str, 
-        key: str, 
-        additional_seconds: int
+        self, namespace: str, context_key: str, key: str, additional_seconds: int
     ) -> bool:
         """
         Extend TTL by adding additional seconds to current TTL.
-        
+
         Args:
             namespace: Cache namespace
             context_key: Context identifier
             key: Cache key
             additional_seconds: Seconds to add to current TTL
-        
+
         Returns:
             True if successful, False otherwise
         """
         current_ttl = await self.memory_store.get_ttl(namespace, context_key, key)
-        
+
         if current_ttl == -2:
             # Key doesn't exist
             return False
         elif current_ttl == -1:
             # No current expiry, set new TTL
-            return await self.memory_store.set_ttl(namespace, context_key, key, additional_seconds)
+            return await self.memory_store.set_ttl(
+                namespace, context_key, key, additional_seconds
+            )
         else:
             # Extend current TTL
             new_ttl = current_ttl + additional_seconds
             return await self.memory_store.set_ttl(namespace, context_key, key, new_ttl)
-    
+
     async def refresh_ttl(
-        self, 
-        namespace: str, 
-        context_key: str, 
-        key: str, 
-        ttl_seconds: int
+        self, namespace: str, context_key: str, key: str, ttl_seconds: int
     ) -> bool:
         """
         Refresh TTL to a new value (reset expiration timer).
-        
+
         Args:
             namespace: Cache namespace
             context_key: Context identifier
             key: Cache key
             ttl_seconds: New TTL in seconds
-        
+
         Returns:
             True if successful, False otherwise
         """
         return await self.memory_store.set_ttl(namespace, context_key, key, ttl_seconds)
-    
+
     async def clear_ttl(self, namespace: str, context_key: str, key: str) -> bool:
         """
         Remove TTL from key (make it persistent).
-        
+
         Note: This is achieved by setting a very long TTL (100 years).
-        
+
         Args:
             namespace: Cache namespace
             context_key: Context identifier
             key: Cache key
-        
+
         Returns:
             True if successful, False otherwise
         """
         # Set TTL to 100 years (effectively no expiry)
         very_long_ttl = 100 * 365 * 24 * 3600  # 100 years in seconds
-        return await self.memory_store.set_ttl(namespace, context_key, key, very_long_ttl)
-    
+        return await self.memory_store.set_ttl(
+            namespace, context_key, key, very_long_ttl
+        )
+
     async def get_expiring_keys(
-        self, 
-        namespace: str, 
-        context_key: str, 
-        within_seconds: int = 300
+        self, namespace: str, context_key: str, within_seconds: int = 300
     ) -> list[dict]:
         """
         Get keys that will expire within specified seconds.
-        
+
         Args:
             namespace: Cache namespace
             context_key: Context identifier
             within_seconds: Time window in seconds (default: 5 minutes)
-        
+
         Returns:
             List of dictionaries with key info for expiring keys
         """
         expiring_keys = []
-        
+
         # Get all keys for the context
         all_keys = await self.memory_store.get_all_keys(namespace, context_key)
-        
-        for key in all_keys.keys():
+
+        for key in all_keys:
             ttl_info = await self.get_ttl_info(namespace, context_key, key)
-            if ttl_info["status"] == "expires" and ttl_info["ttl_seconds"] <= within_seconds:
+            if (
+                ttl_info["status"] == "expires"
+                and ttl_info["ttl_seconds"] <= within_seconds
+            ):
                 expiring_keys.append(ttl_info)
-        
+
         return expiring_keys
-    
+
     async def batch_refresh_ttl(
-        self, 
-        namespace: str, 
-        context_key: str, 
-        keys: list[str], 
-        ttl_seconds: int
+        self, namespace: str, context_key: str, keys: list[str], ttl_seconds: int
     ) -> dict[str, bool]:
         """
         Refresh TTL for multiple keys in batch.
-        
+
         Args:
             namespace: Cache namespace
             context_key: Context identifier
             keys: List of cache keys
             ttl_seconds: New TTL in seconds
-        
+
         Returns:
             Dictionary mapping key -> success status
         """
         results = {}
         for key in keys:
-            results[key] = await self.refresh_ttl(namespace, context_key, key, ttl_seconds)
+            results[key] = await self.refresh_ttl(
+                namespace, context_key, key, ttl_seconds
+            )
         return results
-    
+
     async def get_namespace_stats(self, namespace: str) -> dict:
         """
         Get statistics for a namespace.
-        
+
         Args:
             namespace: Cache namespace
-        
+
         Returns:
             Dictionary with namespace statistics
         """
@@ -201,22 +193,22 @@ class TTLManager:
             "total_keys": 0,
             "keys_with_ttl": 0,
             "keys_persistent": 0,
-            "estimated_cleanup_needed": 0
+            "estimated_cleanup_needed": 0,
         }
-        
+
         # This would require access to the internal store structure
         # For now, we'll provide basic stats that can be calculated
         # without breaking encapsulation
-        
+
         try:
             # Access the store directly for stats (this is a utility function)
             store = self.memory_store._store[namespace]
             stats["total_contexts"] = len(store)
-            
+
             for context_key, context_store in store.items():
                 stats["total_keys"] += len(context_store)
-                
-                for key in context_store.keys():
+
+                for key in context_store:
                     ttl = await self.memory_store.get_ttl(namespace, context_key, key)
                     if ttl == -1:
                         stats["keys_persistent"] += 1
@@ -224,12 +216,12 @@ class TTLManager:
                         stats["keys_with_ttl"] += 1
                     else:
                         stats["estimated_cleanup_needed"] += 1
-        
+
         except Exception as e:
             logger.warning(f"Failed to calculate namespace stats for {namespace}: {e}")
-        
+
         return stats
 
 
 # Global TTL manager instance
-ttl_manager = TTLManager()
+ttl_manager = TTLManager()

wappa/persistence/memory/memory_cache_factory.py

@@ -45,9 +45,7 @@ class MemoryCacheFactory(ICacheFactory):
         Returns:
             ICache adapter wrapping MemoryStateHandler
         """
-        return MemoryStateCacheAdapter(
-            tenant_id=self.tenant_id, user_id=self.user_id
-        )
+        return MemoryStateCacheAdapter(tenant_id=self.tenant_id, user_id=self.user_id)
 
     def create_user_cache(self) -> ICache:
         """
@@ -59,9 +57,7 @@ class MemoryCacheFactory(ICacheFactory):
         Returns:
             ICache adapter wrapping MemoryUser
         """
-        return MemoryUserCacheAdapter(
-            tenant_id=self.tenant_id, user_id=self.user_id
-        )
+        return MemoryUserCacheAdapter(tenant_id=self.tenant_id, user_id=self.user_id)
 
     def create_table_cache(self) -> ICache:
         """
@@ -73,4 +69,4 @@ class MemoryCacheFactory(ICacheFactory):
         Returns:
             ICache adapter wrapping MemoryTable
         """
-        return MemoryTableCacheAdapter(tenant_id=self.tenant_id)
+        return MemoryTableCacheAdapter(tenant_id=self.tenant_id)

wappa/persistence/memory/storage_manager.py

@@ -6,7 +6,7 @@ BaseModel serialization, and thread-safe operations.
 """
 
 import logging
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -17,44 +17,44 @@ logger = logging.getLogger("MemoryStorageManager")
 
 class MemoryStorageManager:
     """High-level memory storage operations manager."""
-    
+
     def __init__(self):
         self.memory_store = get_memory_store()
-    
+
     def _serialize_data(self, data: Any) -> Any:
         """Serialize data for memory storage (BaseModel -> dict)."""
         if isinstance(data, BaseModel):
             return data.model_dump()
         return data
-    
+
     def _deserialize_data(self, data: Any, model: type[BaseModel] | None = None) -> Any:
         """Deserialize data from memory storage."""
         if data is None:
             return None
-        
+
         if model is not None and isinstance(data, dict):
             return model.model_validate(data)
-        
+
         return data
-    
+
     async def get(
         self,
         cache_type: str,
         tenant_id: str,
-        user_id: Optional[str],
+        user_id: str | None,
         key: str,
-        model: type[BaseModel] | None = None
+        model: type[BaseModel] | None = None,
     ) -> Any:
         """
         Get value from memory cache.
-        
+
         Args:
             cache_type: "users", "tables", or "states"
             tenant_id: Tenant identifier
             user_id: User identifier (required for users/states)
             key: Cache key
             model: Optional BaseModel for deserialization
-        
+
         Returns:
             Cached value or None if not found/expired
         """
@@ -65,19 +65,19 @@ class MemoryStorageManager:
         except Exception as e:
             logger.error(f"Failed to get key '{key}' from {cache_type} cache: {e}")
             return None
-    
+
     async def set(
         self,
         cache_type: str,
         tenant_id: str,
-        user_id: Optional[str],
+        user_id: str | None,
         key: str,
         value: Any,
-        ttl: Optional[int] = None
+        ttl: int | None = None,
     ) -> bool:
         """
         Set value in memory cache.
-        
+
         Args:
             cache_type: "users", "tables", or "states"
             tenant_id: Tenant identifier
@@ -85,34 +85,32 @@ class MemoryStorageManager:
             key: Cache key
             value: Value to cache
             ttl: Time to live in seconds
-        
+
         Returns:
             True if successful, False otherwise
         """
         try:
             context_key = self._build_context_key(cache_type, tenant_id, user_id)
             serialized_value = self._serialize_data(value)
-            return await self.memory_store.set(cache_type, context_key, key, serialized_value, ttl)
+            return await self.memory_store.set(
+                cache_type, context_key, key, serialized_value, ttl
+            )
         except Exception as e:
             logger.error(f"Failed to set key '{key}' in {cache_type} cache: {e}")
             return False
-    
+
     async def delete(
-        self,
-        cache_type: str,
-        tenant_id: str,
-        user_id: Optional[str],
-        key: str
+        self, cache_type: str, tenant_id: str, user_id: str | None, key: str
     ) -> bool:
         """
         Delete key from memory cache.
-        
+
         Args:
             cache_type: "users", "tables", or "states"
             tenant_id: Tenant identifier
             user_id: User identifier (required for users/states)
             key: Cache key to delete
-        
+
         Returns:
             True if deleted or didn't exist, False on error
         """
@@ -122,23 +120,19 @@ class MemoryStorageManager:
         except Exception as e:
             logger.error(f"Failed to delete key '{key}' from {cache_type} cache: {e}")
             return False
-    
+
     async def exists(
-        self,
-        cache_type: str,
-        tenant_id: str,
-        user_id: Optional[str],
-        key: str
+        self, cache_type: str, tenant_id: str, user_id: str | None, key: str
     ) -> bool:
         """
         Check if key exists in memory cache.
-        
+
         Args:
             cache_type: "users", "tables", or "states"
             tenant_id: Tenant identifier
             user_id: User identifier (required for users/states)
             key: Cache key to check
-        
+
         Returns:
             True if exists and not expired, False otherwise
         """
@@ -146,19 +140,17 @@ class MemoryStorageManager:
             context_key = self._build_context_key(cache_type, tenant_id, user_id)
             return await self.memory_store.exists(cache_type, context_key, key)
         except Exception as e:
-            logger.error(f"Failed to check existence of key '{key}' in {cache_type} cache: {e}")
+            logger.error(
+                f"Failed to check existence of key '{key}' in {cache_type} cache: {e}"
+            )
             return False
-    
+
     async def get_ttl(
-        self,
-        cache_type: str,
-        tenant_id: str,
-        user_id: Optional[str],
-        key: str
+        self, cache_type: str, tenant_id: str, user_id: str | None, key: str
     ) -> int:
         """
         Get remaining TTL for key.
-        
+
         Returns:
             Remaining TTL in seconds, -1 if no expiry, -2 if doesn't exist
         """
@@ -166,23 +158,20 @@ class MemoryStorageManager:
             context_key = self._build_context_key(cache_type, tenant_id, user_id)
             return await self.memory_store.get_ttl(cache_type, context_key, key)
         except Exception as e:
-            logger.error(f"Failed to get TTL for key '{key}' in {cache_type} cache: {e}")
+            logger.error(
+                f"Failed to get TTL for key '{key}' in {cache_type} cache: {e}"
+            )
             return -2
-    
+
     async def set_ttl(
-        self,
-        cache_type: str,
-        tenant_id: str,
-        user_id: Optional[str],
-        key: str,
-        ttl: int
+        self, cache_type: str, tenant_id: str, user_id: str | None, key: str, ttl: int
     ) -> bool:
         """
         Set TTL for key.
-        
+
         Args:
             ttl: Time to live in seconds
-        
+
         Returns:
             True if successful, False otherwise
         """
@@ -190,23 +179,22 @@ class MemoryStorageManager:
             context_key = self._build_context_key(cache_type, tenant_id, user_id)
             return await self.memory_store.set_ttl(cache_type, context_key, key, ttl)
         except Exception as e:
-            logger.error(f"Failed to set TTL for key '{key}' in {cache_type} cache: {e}")
+            logger.error(
+                f"Failed to set TTL for key '{key}' in {cache_type} cache: {e}"
+            )
             return False
-    
+
     async def get_all_keys(
-        self,
-        cache_type: str,
-        tenant_id: str,
-        user_id: Optional[str]
+        self, cache_type: str, tenant_id: str, user_id: str | None
     ) -> dict[str, Any]:
         """
         Get all keys for a context.
-        
+
         Args:
             cache_type: "users", "tables", or "states"
             tenant_id: Tenant identifier
             user_id: User identifier (required for users/states)
-        
+
         Returns:
             Dictionary of all non-expired key-value pairs
         """
@@ -216,8 +204,10 @@ class MemoryStorageManager:
         except Exception as e:
             logger.error(f"Failed to get all keys from {cache_type} cache: {e}")
             return {}
-    
-    def _build_context_key(self, cache_type: str, tenant_id: str, user_id: Optional[str]) -> str:
+
+    def _build_context_key(
+        self, cache_type: str, tenant_id: str, user_id: str | None
+    ) -> str:
         """Build context key for isolation."""
         if cache_type == "tables":
             # Tables only use tenant_id for context
@@ -232,4 +222,4 @@ class MemoryStorageManager:
 
 
 # Global storage manager instance
-storage_manager = MemoryStorageManager()
+storage_manager = MemoryStorageManager()

wappa/persistence/redis/cache_adapters.py

@@ -141,15 +141,15 @@ class RedisUserCacheAdapter(ICache):
 class RedisTableCacheAdapter(ICache):
     """
     Adapter that makes RedisTable implement ICache interface.
-    
+
     Table Key Format Guide:
     Use create_table_key(table_name, pkid) to generate proper keys.
-    
+
     Examples:
         # Good - using helper method
         key = cache.create_table_key("user_profiles", "12345")
         await cache.set(key, user_data)
-        
+
         # Also supported - manual format
         key = "user_profiles:12345"
         await cache.set(key, user_data)
@@ -157,29 +157,29 @@ class RedisTableCacheAdapter(ICache):
 
     def __init__(self, tenant_id: str, redis_alias: str = "table"):
         self._handler = RedisTable(tenant=tenant_id, redis_alias=redis_alias)
-    
+
     def create_table_key(self, table_name: str, pkid: str) -> str:
         """
         Create a properly formatted table cache key.
-        
+
         Args:
             table_name: Name of the table (e.g., "user_profiles", "message_logs")
             pkid: Primary key ID (e.g., user_id, message_id)
-            
+
         Returns:
             Formatted key string for use with cache methods
-            
+
         Example:
             key = cache.create_table_key("user_profiles", "12345")
             # Returns: "user_profiles:12345"
         """
         if not table_name or not pkid:
             raise ValueError("Both table_name and pkid must be provided and non-empty")
-        
+
         # Sanitize inputs to avoid conflicts
         safe_table_name = str(table_name).replace(":", "_")
         safe_pkid = str(pkid).replace(":", "_")
-        
+
         return f"{safe_table_name}:{safe_pkid}"
 
     async def get(
@@ -250,36 +250,42 @@ class RedisTableCacheAdapter(ICache):
     def _parse_key(self, key: str) -> tuple[str, str]:
         """
         Parse key into table_name and pkid with validation.
-        
+
         Args:
             key: Cache key in format "table_name:pkid"
-            
+
         Returns:
             Tuple of (table_name, pkid)
-            
+
         Raises:
             ValueError: If key format is invalid
         """
         if not key:
             raise ValueError("Key cannot be empty")
-            
+
         if ":" not in key:
             raise ValueError(
                 f"Invalid table cache key format: '{key}'. "
                 f"Expected format: 'table_name:pkid'. "
                 f"Use create_table_key(table_name, pkid) to generate proper keys."
             )
-        
+
         parts = key.split(":", 1)
         if len(parts) != 2:
-            raise ValueError(f"Invalid table cache key format: '{key}'. Expected exactly one ':' separator.")
-            
+            raise ValueError(
+                f"Invalid table cache key format: '{key}'. Expected exactly one ':' separator."
+            )
+
         table_name, pkid = parts
-        
+
         if not table_name.strip():
-            raise ValueError(f"Invalid table cache key: '{key}'. Table name cannot be empty.")
-            
+            raise ValueError(
+                f"Invalid table cache key: '{key}'. Table name cannot be empty."
+            )
+
         if not pkid.strip():
-            raise ValueError(f"Invalid table cache key: '{key}'. Primary key ID cannot be empty.")
-            
+            raise ValueError(
+                f"Invalid table cache key: '{key}'. Primary key ID cannot be empty."
+            )
+
         return table_name.strip(), pkid.strip()