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

wappa/persistence/json/storage_manager.py

@@ -7,7 +7,7 @@ BaseModel serialization, and atomic file operations.
 
 import logging
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -24,69 +24,69 @@ logger = logging.getLogger("JSONStorageManager")
 
 class JSONStorageManager:
     """High-level JSON storage operations manager."""
-    
+
     def __init__(self):
         # Ensure cache directories exist on initialization
         file_manager.ensure_cache_directories()
-    
+
     async def get(
-        self, 
-        cache_type: str, 
-        tenant_id: str, 
-        user_id: Optional[str], 
+        self,
+        cache_type: str,
+        tenant_id: str,
+        user_id: str | None,
         key: str,
-        model: type[BaseModel] | None = None
+        model: type[BaseModel] | None = None,
     ) -> Any:
         """
         Get value from JSON 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
         """
         try:
             file_path = file_manager.get_cache_file_path(cache_type, tenant_id, user_id)
             file_data = await file_manager.read_file(file_path)
-            
+
             if not file_data:
                 return None
-            
+
             # Extract data and check expiration
             cache_data = extract_cache_file_data(file_data)
             if cache_data is None:
                 # Expired - delete the file
                 await file_manager.delete_file(file_path)
                 return None
-            
+
             # Get specific key data
             if key not in cache_data:
                 return None
-            
+
             value_data = cache_data[key]
             return deserialize_from_json(value_data, model)
-            
+
         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 JSON cache.
-        
+
         Args:
             cache_type: "users", "tables", or "states"
             tenant_id: Tenant identifier
@@ -94,192 +94,179 @@ class JSONStorageManager:
             key: Cache key
             value: Value to cache
             ttl: Time to live in seconds
-        
+
         Returns:
             True if successful, False otherwise
         """
         try:
             file_path = file_manager.get_cache_file_path(cache_type, tenant_id, user_id)
-            
+
             # Read existing data
             file_data = await file_manager.read_file(file_path)
             cache_data = extract_cache_file_data(file_data) if file_data else {}
             if cache_data is None:
                 cache_data = {}
-            
+
             # Update key
             cache_data[key] = serialize_for_json(value)
-            
+
             # Create new file data with TTL
             new_file_data = create_cache_file_data(cache_data, ttl)
-            
+
             # Write file
             return await file_manager.write_file(file_path, new_file_data)
-            
+
         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 JSON 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
         """
         try:
             file_path = file_manager.get_cache_file_path(cache_type, tenant_id, user_id)
-            
+
             # Read existing data
             file_data = await file_manager.read_file(file_path)
             if not file_data:
                 return True  # Already doesn't exist
-            
+
             cache_data = extract_cache_file_data(file_data)
             if cache_data is None or key not in cache_data:
                 return True  # Already doesn't exist
-            
+
             # Remove key
             del cache_data[key]
-            
+
             # If no keys left, delete the file
             if not cache_data:
                 return await file_manager.delete_file(file_path)
-            
+
             # Otherwise update file
             new_file_data = create_cache_file_data(cache_data)
             return await file_manager.write_file(file_path, new_file_data)
-            
+
         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 JSON 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
         """
         try:
             file_path = file_manager.get_cache_file_path(cache_type, tenant_id, user_id)
             file_data = await file_manager.read_file(file_path)
-            
+
             if not file_data:
                 return False
-            
+
             cache_data = extract_cache_file_data(file_data)
             if cache_data is None:
                 # Expired - delete the file
                 await file_manager.delete_file(file_path)
                 return False
-            
+
             return key in cache_data
-            
+
         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]
+        self, cache_type: str, tenant_id: str, user_id: str | None
     ) -> int:
         """
         Get remaining TTL for cache file.
-        
+
         Returns:
             Remaining TTL in seconds, -1 if no expiry, -2 if doesn't exist
         """
         try:
             file_path = file_manager.get_cache_file_path(cache_type, tenant_id, user_id)
             file_data = await file_manager.read_file(file_path)
-            
+
             if not file_data:
                 return -2  # Doesn't exist
-            
+
             metadata = file_data.get("_metadata", {})
             expires_at_str = metadata.get("expires_at")
-            
+
             if not expires_at_str:
                 return -1  # No expiry
-            
+
             try:
                 expires_at = datetime.fromisoformat(expires_at_str)
                 now = datetime.now()
-                
+
                 if now >= expires_at:
                     return -2  # Already expired
-                
+
                 return int((expires_at - now).total_seconds())
-                
+
             except ValueError:
                 return -1  # Invalid expiry format, treat as no expiry
-                
+
         except Exception as e:
             logger.error(f"Failed to get TTL for {cache_type} cache: {e}")
             return -2
-    
+
     async def set_ttl(
-        self,
-        cache_type: str,
-        tenant_id: str,
-        user_id: Optional[str],
-        ttl: int
+        self, cache_type: str, tenant_id: str, user_id: str | None, ttl: int
     ) -> bool:
         """
         Set TTL for cache file.
-        
+
         Args:
             ttl: Time to live in seconds
-        
+
         Returns:
             True if successful, False otherwise
         """
         try:
             file_path = file_manager.get_cache_file_path(cache_type, tenant_id, user_id)
             file_data = await file_manager.read_file(file_path)
-            
+
             if not file_data:
                 return False  # File doesn't exist
-            
+
             cache_data = extract_cache_file_data(file_data)
             if cache_data is None:
                 return False  # Already expired
-            
+
             # Create new file data with updated TTL
             new_file_data = create_cache_file_data(cache_data, ttl)
             return await file_manager.write_file(file_path, new_file_data)
-            
+
         except Exception as e:
             logger.error(f"Failed to set TTL for {cache_type} cache: {e}")
             return False
 
 
 # Global storage manager instance
-storage_manager = JSONStorageManager()
+storage_manager = JSONStorageManager()

wappa/persistence/memory/__init__.py

@@ -11,4 +11,4 @@ Usage:
 
 from .memory_cache_factory import MemoryCacheFactory
 
-__all__ = ["MemoryCacheFactory"]
+__all__ = ["MemoryCacheFactory"]

wappa/persistence/memory/cache_adapters.py

@@ -28,7 +28,9 @@ class MemoryStateCacheAdapter(ICache):
         """Get cached data by key."""
         return await self._handler.get(key, models=models)
 
-    async def set(self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None) -> bool:
+    async def set(
+        self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None
+    ) -> bool:
         """Set cached data with optional TTL."""
         return await self._handler.upsert(key, data, ttl=ttl)
 
@@ -84,7 +86,9 @@ class MemoryUserCacheAdapter(ICache):
         """Get cached data by key. For user cache, key is ignored as it uses user_id."""
         return await self._handler.get(models=models)
 
-    async def set(self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None) -> bool:
+    async def set(
+        self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None
+    ) -> bool:
         """Set cached data with optional TTL."""
         return await self._handler.upsert(data, ttl=ttl)
 
@@ -131,15 +135,15 @@ class MemoryUserCacheAdapter(ICache):
 class MemoryTableCacheAdapter(ICache):
     """
     Adapter that makes MemoryTable 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)
@@ -147,29 +151,29 @@ class MemoryTableCacheAdapter(ICache):
 
     def __init__(self, tenant_id: str):
         self._handler = MemoryTable(tenant=tenant_id)
-    
+
     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(
@@ -179,7 +183,9 @@ class MemoryTableCacheAdapter(ICache):
         table_name, pkid = self._parse_key(key)
         return await self._handler.get(table_name, pkid, models=models)
 
-    async def set(self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None) -> bool:
+    async def set(
+        self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None
+    ) -> bool:
         """Set cached data with optional TTL."""
         table_name, pkid = self._parse_key(key)
         return await self._handler.upsert(table_name, pkid, data, ttl=ttl)
@@ -236,36 +242,42 @@ class MemoryTableCacheAdapter(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.")
-            
-        return table_name.strip(), pkid.strip()
+            raise ValueError(
+                f"Invalid table cache key: '{key}'. Primary key ID cannot be empty."
+            )
+
+        return table_name.strip(), pkid.strip()