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

wappa/persistence/json/handlers/user_handler.py

@@ -5,9 +5,9 @@ Provides user-specific cache operations using JSON file storage.
 """
 
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from ..storage_manager import storage_manager
 from .utils.key_factory import default_key_factory
@@ -18,196 +18,212 @@ logger = logging.getLogger("JSONUser")
 class JSONUser:
     """
     JSON-based user cache handler.
-    
+
     Mirrors RedisUser functionality using file-based JSON storage.
     Maintains the same API for seamless cache backend switching.
     """
-    
+
     def __init__(self, tenant: str, user_id: str):
         """
         Initialize JSON 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)
-    
+
     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, ttl)
+        return await storage_manager.set_ttl("users", self.tenant, self.user_id, ttl)

wappa/persistence/json/handlers/utils/file_manager.py

@@ -7,9 +7,8 @@ Handles cache directory creation, file I/O, and project root detection.
 import asyncio
 import json
 import logging
-import os
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 
 from .serialization import from_json_string, to_json_string
 
@@ -18,76 +17,80 @@ logger = logging.getLogger("JSONFileManager")
 
 class FileManager:
     """Manages file operations for JSON cache."""
-    
+
     def __init__(self):
-        self._cache_root: Optional[Path] = None
-        self._file_locks: Dict[str, asyncio.Lock] = {}
-    
+        self._cache_root: Path | None = None
+        self._file_locks: dict[str, asyncio.Lock] = {}
+
     def _get_file_lock(self, file_path: str) -> asyncio.Lock:
         """Get or create a lock for a specific file path."""
         if file_path not in self._file_locks:
             self._file_locks[file_path] = asyncio.Lock()
         return self._file_locks[file_path]
-    
+
     def get_cache_root(self) -> Path:
         """Get or detect the cache root directory."""
         if self._cache_root is None:
             self._cache_root = self._detect_project_root()
         return self._cache_root
-    
+
     def _detect_project_root(self) -> Path:
         """
         Detect project root by looking for main.py with Wappa.run().
-        
+
         Searches from current working directory upwards.
         Falls back to current directory if not found.
         """
         current_dir = Path.cwd()
-        
+
         # Search upwards for main.py containing Wappa.run()
         for directory in [current_dir] + list(current_dir.parents):
             main_py = directory / "main.py"
             if main_py.exists():
                 try:
-                    content = main_py.read_text(encoding='utf-8')
-                    if "Wappa" in content and (".run()" in content or "app.run()" in content):
+                    content = main_py.read_text(encoding="utf-8")
+                    if "Wappa" in content and (
+                        ".run()" in content or "app.run()" in content
+                    ):
                         cache_dir = directory / "cache"
                         logger.info(f"Detected project root: {directory}")
                         return cache_dir
-                except (IOError, UnicodeDecodeError):
+                except (OSError, UnicodeDecodeError):
                     continue
-        
+
         # Fallback to current directory + cache
         fallback_cache = current_dir / "cache"
         logger.info(f"Project root not detected, using fallback: {fallback_cache}")
         return fallback_cache
-    
+
     def ensure_cache_directories(self) -> None:
         """Create cache directory structure if it doesn't exist."""
         cache_root = self.get_cache_root()
         cache_root.mkdir(exist_ok=True)
-        
+
         # Create subdirectories
         (cache_root / "users").mkdir(exist_ok=True)
         (cache_root / "tables").mkdir(exist_ok=True)
         (cache_root / "states").mkdir(exist_ok=True)
-        
+
         logger.debug(f"Cache directories ensured at: {cache_root}")
-    
-    def get_cache_file_path(self, cache_type: str, tenant_id: str, user_id: str = None) -> Path:
+
+    def get_cache_file_path(
+        self, cache_type: str, tenant_id: str, user_id: str = None
+    ) -> Path:
         """
         Get the file path for a cache file.
-        
+
         Args:
             cache_type: "users", "tables", or "states"
             tenant_id: Tenant identifier
             user_id: User identifier (required for users and states)
-        
+
         Returns:
             Path to cache file
         """
         cache_root = self.get_cache_root()
-        
+
         if cache_type == "users":
             if not user_id:
                 raise ValueError("user_id is required for users cache")
@@ -100,39 +103,39 @@ class FileManager:
             return cache_root / "states" / f"{tenant_id}_{user_id}_state.json"
         else:
             raise ValueError(f"Invalid cache_type: {cache_type}")
-    
-    async def read_file(self, file_path: Path) -> Dict[str, Any]:
+
+    async def read_file(self, file_path: Path) -> dict[str, Any]:
         """Read and parse JSON file with file locking."""
         async with self._get_file_lock(str(file_path)):
             if not file_path.exists():
                 return {}
-            
+
             try:
-                content = await asyncio.to_thread(file_path.read_text, encoding='utf-8')
+                content = await asyncio.to_thread(file_path.read_text, encoding="utf-8")
                 return from_json_string(content)
-            except (IOError, json.JSONDecodeError) as e:
+            except (OSError, json.JSONDecodeError) as e:
                 logger.error(f"Failed to read file {file_path}: {e}")
                 return {}
-    
-    async def write_file(self, file_path: Path, data: Dict[str, Any]) -> bool:
+
+    async def write_file(self, file_path: Path, data: dict[str, Any]) -> bool:
         """Write data to JSON file with file locking."""
         async with self._get_file_lock(str(file_path)):
             try:
                 # Ensure parent directory exists
                 file_path.parent.mkdir(parents=True, exist_ok=True)
-                
+
                 # Write to temporary file first, then rename (atomic operation)
-                temp_file = file_path.with_suffix(file_path.suffix + '.tmp')
+                temp_file = file_path.with_suffix(file_path.suffix + ".tmp")
                 content = to_json_string(data)
-                
-                await asyncio.to_thread(temp_file.write_text, content, encoding='utf-8')
+
+                await asyncio.to_thread(temp_file.write_text, content, encoding="utf-8")
                 await asyncio.to_thread(temp_file.replace, file_path)
-                
+
                 return True
-            except IOError as e:
+            except OSError as e:
                 logger.error(f"Failed to write file {file_path}: {e}")
                 return False
-    
+
     async def delete_file(self, file_path: Path) -> bool:
         """Delete file with file locking."""
         async with self._get_file_lock(str(file_path)):
@@ -140,14 +143,14 @@ class FileManager:
                 if file_path.exists():
                     await asyncio.to_thread(file_path.unlink)
                 return True
-            except IOError as e:
+            except OSError as e:
                 logger.error(f"Failed to delete file {file_path}: {e}")
                 return False
-    
+
     async def file_exists(self, file_path: Path) -> bool:
         """Check if file exists."""
         return await asyncio.to_thread(file_path.exists)
 
 
 # Global file manager instance
-file_manager = FileManager()
+file_manager = FileManager()

wappa/persistence/json/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/json/handlers/utils/serialization.py

@@ -60,30 +60,32 @@ def deserialize_from_json(data: Any, model: type[BaseModel] | None = None) -> An
     """Deserialize data from JSON storage."""
     if data is None:
         return None
-    
+
     # Convert datetime strings back to datetime objects
     data = _convert_iso_strings_to_datetime(data)
-    
+
     if model is not None:
         return model.model_validate(data)
-    
+
     return data
 
 
-def create_cache_file_data(data: dict[str, Any], ttl: int | None = None) -> dict[str, Any]:
+def create_cache_file_data(
+    data: dict[str, Any], ttl: int | None = None
+) -> dict[str, Any]:
     """Create JSON cache file structure with metadata."""
     now = datetime.now()
     expires_at = None
     if ttl:
         expires_at = datetime.fromtimestamp(now.timestamp() + ttl)
-    
+
     return {
         "_metadata": {
             "created_at": now.isoformat(),
             "expires_at": expires_at.isoformat() if expires_at else None,
-            "version": "1.0"
+            "version": "1.0",
         },
-        "data": serialize_for_json(data)
+        "data": serialize_for_json(data),
     }
 
 
@@ -91,10 +93,10 @@ def extract_cache_file_data(file_data: dict[str, Any]) -> dict[str, Any] | None:
     """Extract data from JSON cache file, checking expiration."""
     if not isinstance(file_data, dict):
         return None
-    
+
     metadata = file_data.get("_metadata", {})
     expires_at_str = metadata.get("expires_at")
-    
+
     # Check expiration
     if expires_at_str:
         try:
@@ -103,7 +105,7 @@ def extract_cache_file_data(file_data: dict[str, Any]) -> dict[str, Any] | None:
                 return None  # Expired
         except ValueError:
             logger.warning(f"Invalid expires_at format: {expires_at_str}")
-    
+
     return file_data.get("data", {})
 
 
@@ -118,4 +120,4 @@ def from_json_string(json_str: str) -> Any:
         return json.loads(json_str)
     except json.JSONDecodeError as e:
         logger.error(f"Failed to parse JSON: {e}")
-        raise
+        raise

wappa/persistence/json/json_cache_factory.py

@@ -20,7 +20,7 @@ class JSONCacheFactory(ICacheFactory):
 
     Uses file-based JSON storage with proper file management:
     - State cache: Uses states subdirectory
-    - User cache: Uses users subdirectory  
+    - User cache: Uses users subdirectory
     - Table cache: Uses tables subdirectory
 
     All instances implement the ICache interface through adapters.
@@ -45,9 +45,7 @@ class JSONCacheFactory(ICacheFactory):
         Returns:
             ICache adapter wrapping JSONStateHandler
         """
-        return JSONStateCacheAdapter(
-            tenant_id=self.tenant_id, user_id=self.user_id
-        )
+        return JSONStateCacheAdapter(tenant_id=self.tenant_id, user_id=self.user_id)
 
     def create_user_cache(self) -> ICache:
         """
@@ -59,9 +57,7 @@ class JSONCacheFactory(ICacheFactory):
         Returns:
             ICache adapter wrapping JSONUser
         """
-        return JSONUserCacheAdapter(
-            tenant_id=self.tenant_id, user_id=self.user_id
-        )
+        return JSONUserCacheAdapter(tenant_id=self.tenant_id, user_id=self.user_id)
 
     def create_table_cache(self) -> ICache:
         """
@@ -73,4 +69,4 @@ class JSONCacheFactory(ICacheFactory):
         Returns:
             ICache adapter wrapping JSONTable
         """
-        return JSONTableCacheAdapter(tenant_id=self.tenant_id)
+        return JSONTableCacheAdapter(tenant_id=self.tenant_id)