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

wappa/persistence/memory/handlers/user_handler.py

@@ -5,7 +5,7 @@ Provides user-specific cache operations using in-memory storage.
 """
 
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -18,196 +18,216 @@ logger = logging.getLogger("MemoryUser")
 class MemoryUser:
     """
     Memory-based user cache handler.
-    
+
     Mirrors RedisUser functionality using in-memory storage.
     Maintains the same API for seamless cache backend switching.
     """
-    
+
     def __init__(self, tenant: str, user_id: str):
         """
         Initialize Memory user handler.
-        
+
         Args:
             tenant: Tenant identifier
             user_id: User identifier
         """
         if not tenant or not user_id:
-            raise ValueError(f"Missing required parameters: tenant={tenant}, user_id={user_id}")
-        
+            raise ValueError(
+                f"Missing required parameters: tenant={tenant}, user_id={user_id}"
+            )
+
         self.tenant = tenant
         self.user_id = user_id
         self.keys = default_key_factory
-    
+
     def _key(self) -> str:
         """Build user key using KeyFactory (same as Redis)."""
         return self.keys.user(self.tenant, self.user_id)
-    
+
     # ---- Public API matching RedisUser ----
     async def get(self, models: type[BaseModel] | None = None) -> dict[str, Any] | None:
         """
         Get full user data.
-        
+
         Args:
             models: Optional BaseModel class for deserialization
-        
+
         Returns:
             User data dictionary or BaseModel instance, None if not found
         """
         key = self._key()
-        return await storage_manager.get("users", self.tenant, self.user_id, key, models)
-    
-    async def upsert(self, data: dict[str, Any] | BaseModel, ttl: int | None = None) -> bool:
+        return await storage_manager.get(
+            "users", self.tenant, self.user_id, key, models
+        )
+
+    async def upsert(
+        self, data: dict[str, Any] | BaseModel, ttl: int | None = None
+    ) -> bool:
         """
         Create or update user data.
-        
+
         Args:
             data: User data to store
             ttl: Time to live in seconds
-        
+
         Returns:
             True if successful, False otherwise
         """
         key = self._key()
-        return await storage_manager.set("users", self.tenant, self.user_id, key, data, ttl)
-    
+        return await storage_manager.set(
+            "users", self.tenant, self.user_id, key, data, ttl
+        )
+
     async def delete(self) -> int:
         """
         Delete user data.
-        
+
         Returns:
             1 if deleted, 0 if didn't exist
         """
         key = self._key()
         success = await storage_manager.delete("users", self.tenant, self.user_id, key)
         return 1 if success else 0
-    
+
     async def exists(self) -> bool:
         """
         Check if user data exists.
-        
+
         Returns:
             True if exists, False otherwise
         """
         key = self._key()
         return await storage_manager.exists("users", self.tenant, self.user_id, key)
-    
+
     async def get_field(self, field: str) -> Any | None:
         """
         Get a specific field from user data.
-        
+
         Args:
             field: Field name
-        
+
         Returns:
             Field value or None if not found
         """
         user_data = await self.get()
         if user_data is None:
             return None
-        
+
         if isinstance(user_data, dict):
             return user_data.get(field)
         else:
             # BaseModel instance
             return getattr(user_data, field, None)
-    
-    async def update_field(self, field: str, value: Any, ttl: int | None = None) -> bool:
+
+    async def update_field(
+        self, field: str, value: Any, ttl: int | None = None
+    ) -> bool:
         """
         Update a specific field in user data.
-        
+
         Args:
             field: Field name
             value: New value
             ttl: Time to live in seconds
-        
+
         Returns:
             True if successful, False otherwise
         """
         user_data = await self.get()
         if user_data is None:
             user_data = {}
-        
+
         if isinstance(user_data, BaseModel):
             user_data = user_data.model_dump()
-        
+
         user_data[field] = value
         return await self.upsert(user_data, ttl)
-    
-    async def increment_field(self, field: str, increment: int = 1, ttl: int | None = None) -> int | None:
+
+    async def increment_field(
+        self, field: str, increment: int = 1, ttl: int | None = None
+    ) -> int | None:
         """
         Atomically increment an integer field.
-        
+
         Args:
             field: Field name
             increment: Amount to increment by
             ttl: Time to live in seconds
-        
+
         Returns:
             New value after increment or None on error
         """
         user_data = await self.get()
         if user_data is None:
             user_data = {}
-        
+
         if isinstance(user_data, BaseModel):
             user_data = user_data.model_dump()
-        
+
         current_value = user_data.get(field, 0)
-        if not isinstance(current_value, (int, float)):
-            logger.warning(f"Cannot increment non-numeric field '{field}': {current_value}")
+        if not isinstance(current_value, int | float):
+            logger.warning(
+                f"Cannot increment non-numeric field '{field}': {current_value}"
+            )
             return None
-        
+
         new_value = int(current_value) + increment
         user_data[field] = new_value
-        
+
         success = await self.upsert(user_data, ttl)
         return new_value if success else None
-    
-    async def append_to_list(self, field: str, value: Any, ttl: int | None = None) -> bool:
+
+    async def append_to_list(
+        self, field: str, value: Any, ttl: int | None = None
+    ) -> bool:
         """
         Append value to a list field.
-        
+
         Args:
             field: Field name containing list
             value: Value to append
             ttl: Time to live in seconds
-        
+
         Returns:
             True if successful, False otherwise
         """
         user_data = await self.get()
         if user_data is None:
             user_data = {}
-        
+
         if isinstance(user_data, BaseModel):
             user_data = user_data.model_dump()
-        
+
         current_list = user_data.get(field, [])
         if not isinstance(current_list, list):
             current_list = []
-        
+
         current_list.append(value)
         user_data[field] = current_list
-        
+
         return await self.upsert(user_data, ttl)
-    
+
     async def get_ttl(self, key: str) -> int:
         """
         Get remaining time to live.
-        
+
         Returns:
             Remaining TTL in seconds, -1 if no expiry, -2 if doesn't exist
         """
-        return await storage_manager.get_ttl("users", self.tenant, self.user_id, self._key())
-    
+        return await storage_manager.get_ttl(
+            "users", self.tenant, self.user_id, self._key()
+        )
+
     async def renew_ttl(self, key: str, ttl: int) -> bool:
         """
         Renew time to live.
-        
+
         Args:
             ttl: New time to live in seconds
-        
+
         Returns:
             True if successful, False otherwise
         """
-        return await storage_manager.set_ttl("users", self.tenant, self.user_id, self._key(), ttl)
+        return await storage_manager.set_ttl(
+            "users", self.tenant, self.user_id, self._key(), ttl
+        )

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

@@ -8,4 +8,4 @@ across all cache implementations.
 from ....redis.redis_handler.utils.key_factory import KeyFactory, default_key_factory
 
 # Export the same key factory used by Redis for consistency
-__all__ = ["KeyFactory", "default_key_factory"]
+__all__ = ["KeyFactory", "default_key_factory"]

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

@@ -8,7 +8,7 @@ and automatic expiration cleanup.
 import asyncio
 import logging
 from datetime import datetime, timedelta
-from typing import Any, Dict, Optional, Tuple
+from typing import Any
 
 logger = logging.getLogger("MemoryStore")
 
@@ -16,62 +16,62 @@ logger = logging.getLogger("MemoryStore")
 class MemoryStore:
     """
     Thread-safe in-memory store with TTL support.
-    
+
     Storage Structure:
     {
         "users": {context_key: {key: (data, expires_at)}},
         "tables": {context_key: {key: (data, expires_at)}},
         "states": {context_key: {key: (data, expires_at)}}
     }
-    
+
     Where context_key is typically "{tenant_id}_{user_id}" for isolation.
     """
-    
+
     def __init__(self):
-        self._store: Dict[str, Dict[str, Dict[str, Tuple[Any, Optional[datetime]]]]] = {
+        self._store: dict[str, dict[str, dict[str, tuple[Any, datetime | None]]]] = {
             "users": {},
             "tables": {},
-            "states": {}
+            "states": {},
         }
         self._locks = {
             "users": asyncio.Lock(),
             "tables": asyncio.Lock(),
-            "states": asyncio.Lock()
+            "states": asyncio.Lock(),
         }
-        self._cleanup_task: Optional[asyncio.Task] = None
+        self._cleanup_task: asyncio.Task | None = None
         self._cleanup_interval = 300  # 5 minutes
-        
+
     def start_cleanup_task(self):
         """Start background TTL cleanup task."""
         if self._cleanup_task is None or self._cleanup_task.done():
             self._cleanup_task = asyncio.create_task(self._cleanup_expired_entries())
             logger.info("Started memory store TTL cleanup task")
-    
+
     def stop_cleanup_task(self):
         """Stop background TTL cleanup task."""
         if self._cleanup_task and not self._cleanup_task.done():
             self._cleanup_task.cancel()
             logger.info("Stopped memory store TTL cleanup task")
-    
+
     async def get(self, namespace: str, context_key: str, key: str) -> Any:
         """
         Get value with automatic expiration check.
-        
+
         Args:
             namespace: Cache namespace ("users", "tables", "states")
             context_key: Context identifier (e.g., "{tenant_id}_{user_id}")
             key: Cache key
-        
+
         Returns:
             Cached value or None if not found/expired
         """
         if namespace not in self._locks:
             raise ValueError(f"Invalid namespace: {namespace}")
-        
+
         async with self._locks[namespace]:
             store = self._store[namespace]
             context_store = store.get(context_key, {})
-            
+
             if key in context_store:
                 data, expires_at = context_store[key]
                 if expires_at and datetime.now() > expires_at:
@@ -80,64 +80,64 @@ class MemoryStore:
                     return None
                 return data
             return None
-    
+
     async def set(
-        self, 
-        namespace: str, 
-        context_key: str, 
-        key: str, 
-        data: Any, 
-        ttl: Optional[int] = None
+        self,
+        namespace: str,
+        context_key: str,
+        key: str,
+        data: Any,
+        ttl: int | None = None,
     ) -> bool:
         """
         Set value with optional TTL.
-        
+
         Args:
             namespace: Cache namespace
             context_key: Context identifier
             key: Cache key
             data: Value to store
             ttl: Time to live in seconds
-        
+
         Returns:
             True if successful, False otherwise
         """
         if namespace not in self._locks:
             raise ValueError(f"Invalid namespace: {namespace}")
-        
+
         expires_at = None
         if ttl:
             expires_at = datetime.now() + timedelta(seconds=ttl)
-        
+
         try:
             async with self._locks[namespace]:
                 store = self._store[namespace]
                 if context_key not in store:
                     store[context_key] = {}
                 store[context_key][key] = (data, expires_at)
-                
+
                 # Start cleanup task if not running
                 self.start_cleanup_task()
                 return True
         except Exception as e:
             logger.error(f"Failed to set key '{key}' in {namespace}: {e}")
             return False
-    
+
     async def delete(self, namespace: str, context_key: str, key: str) -> bool:
         """
         Delete key from store.
-        
+
         Args:
             namespace: Cache namespace
             context_key: Context identifier
             key: Cache key
-        
+
         Returns:
             True if deleted or didn't exist, False on error
         """
         if namespace not in self._locks:
             raise ValueError(f"Invalid namespace: {namespace}")
-        
+
         try:
             async with self._locks[namespace]:
                 store = self._store[namespace]
@@ -151,73 +151,75 @@ class MemoryStore:
         except Exception as e:
             logger.error(f"Failed to delete key '{key}' from {namespace}: {e}")
             return False
-    
+
     async def exists(self, namespace: str, context_key: str, key: str) -> bool:
         """
         Check if key exists and is not expired.
-        
+
         Args:
             namespace: Cache namespace
             context_key: Context identifier
             key: Cache key
-        
+
         Returns:
             True if exists and not expired, False otherwise
         """
         value = await self.get(namespace, context_key, key)
         return value is not None
-    
+
     async def get_ttl(self, namespace: str, context_key: str, key: str) -> int:
         """
         Get remaining TTL for key.
-        
+
         Returns:
             Remaining TTL in seconds, -1 if no expiry, -2 if doesn't exist
         """
         if namespace not in self._locks:
             return -2
-        
+
         async with self._locks[namespace]:
             store = self._store[namespace]
             context_store = store.get(context_key, {})
-            
+
             if key not in context_store:
                 return -2  # Doesn't exist
-            
+
             data, expires_at = context_store[key]
-            
+
             if expires_at is None:
                 return -1  # No expiry
-            
+
             now = datetime.now()
             if now >= expires_at:
                 # Already expired, clean up
                 del context_store[key]
                 return -2
-            
+
             return int((expires_at - now).total_seconds())
-    
-    async def set_ttl(self, namespace: str, context_key: str, key: str, ttl: int) -> bool:
+
+    async def set_ttl(
+        self, namespace: str, context_key: str, key: str, ttl: int
+    ) -> bool:
         """
         Set TTL for existing key.
-        
+
         Args:
             ttl: Time to live in seconds
-        
+
         Returns:
             True if successful, False if key doesn't exist or error
         """
         if namespace not in self._locks:
             return False
-        
+
         try:
             async with self._locks[namespace]:
                 store = self._store[namespace]
                 context_store = store.get(context_key, {})
-                
+
                 if key not in context_store:
                     return False  # Key doesn't exist
-                
+
                 data, _ = context_store[key]  # Get existing data, ignore old TTL
                 expires_at = datetime.now() + timedelta(seconds=ttl)
                 context_store[key] = (data, expires_at)
@@ -225,78 +227,80 @@ class MemoryStore:
         except Exception as e:
             logger.error(f"Failed to set TTL for key '{key}' in {namespace}: {e}")
             return False
-    
-    async def get_all_keys(self, namespace: str, context_key: str) -> Dict[str, Any]:
+
+    async def get_all_keys(self, namespace: str, context_key: str) -> dict[str, Any]:
         """
         Get all non-expired keys for a context.
-        
+
         Args:
             namespace: Cache namespace
             context_key: Context identifier
-        
+
         Returns:
             Dictionary of all non-expired key-value pairs
         """
         if namespace not in self._locks:
             return {}
-        
+
         async with self._locks[namespace]:
             store = self._store[namespace]
             context_store = store.get(context_key, {})
-            
+
             result = {}
             now = datetime.now()
             expired_keys = []
-            
+
             for key, (data, expires_at) in context_store.items():
                 if expires_at and now > expires_at:
                     expired_keys.append(key)
                 else:
                     result[key] = data
-            
+
             # Clean up expired keys
             for key in expired_keys:
                 del context_store[key]
-            
+
             return result
-    
+
     async def _cleanup_expired_entries(self):
         """Background task to clean up expired entries."""
         while True:
             try:
                 await asyncio.sleep(self._cleanup_interval)
-                
+
                 now = datetime.now()
                 total_cleaned = 0
-                
+
                 for namespace in ["users", "tables", "states"]:
                     async with self._locks[namespace]:
                         store = self._store[namespace]
                         empty_contexts = []
-                        
+
                         for context_key, context_store in store.items():
                             expired_keys = []
-                            
+
                             for key, (_, expires_at) in context_store.items():
                                 if expires_at and now > expires_at:
                                     expired_keys.append(key)
-                            
+
                             # Remove expired keys
                             for key in expired_keys:
                                 del context_store[key]
                                 total_cleaned += 1
-                            
+
                             # Mark empty contexts for cleanup
                             if not context_store:
                                 empty_contexts.append(context_key)
-                        
+
                         # Remove empty contexts
                         for context_key in empty_contexts:
                             del store[context_key]
-                
+
                 if total_cleaned > 0:
-                    logger.debug(f"Cleaned up {total_cleaned} expired entries from memory store")
-                    
+                    logger.debug(
+                        f"Cleaned up {total_cleaned} expired entries from memory store"
+                    )
+
             except asyncio.CancelledError:
                 logger.info("Memory store cleanup task cancelled")
                 break
@@ -306,7 +310,7 @@ class MemoryStore:
 
 
 # Global singleton memory store instance
-_global_memory_store: Optional[MemoryStore] = None
+_global_memory_store: MemoryStore | None = None
 
 
 def get_memory_store() -> MemoryStore:
@@ -314,4 +318,4 @@ def get_memory_store() -> MemoryStore:
     global _global_memory_store
     if _global_memory_store is None:
         _global_memory_store = MemoryStore()
-    return _global_memory_store
+    return _global_memory_store