wappa 0.1.0__py3-none-any.whl

wappa/persistence/redis/redis_handler/user.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from ..ops import hdel, hget, hincrby_with_expire
+from .utils.serde import loads
+from .utils.tenant_cache import TenantCache
+
+logger = logging.getLogger("RedisUser")
+
+
+class RedisUser(TenantCache):
+    """
+    Repository for user-specific operations.
+
+    Extracted from RedisHandler SECTION: User-specific Methods:
+    - get_user_data() -> get()
+    - get_field() -> get_field()
+    - update_user_field() -> update_field()
+    - increment_user_field() -> increment_field()
+    - append_to_user_list_field() -> append_to_list()
+    - create_user_record() -> upsert()
+    - find_user_by_field() -> find_by_field()
+    - delete_user_record() -> delete()
+    - delete_user_hash_field() -> delete_field()
+    - user_exists() -> exists()
+
+    Single Responsibility: User data management only
+
+    Example usage:
+        user = RedisUser(tenant="mimeia", user_id="user123")
+        await user.upsert({"name": "Alice", "score": 100})
+        data = await user.get()
+        name = await user.get_field("name")
+    """
+
+    user_id: str = Field(..., min_length=1)
+    redis_alias: str = "user"
+
+    def _key(self) -> str:
+        """Build user key using KeyFactory"""
+        return self.keys.user(self.tenant, self.user_id)
+
+    # ---- Public API extracted from RedisHandler User methods ----------------
+    async def get(self, models: type[BaseModel] | None = None) -> dict[str, Any] | None:
+        """
+        Get full user data hash (was get_user_data)
+
+        Args:
+            models: Optional BaseModel class for full object reconstruction
+                   e.g., User (will automatically handle nested UserProfile, UserPreferences)
+        """
+        key = self._key()
+        result = await self._get_hash(key, models=models)
+        if not result:
+            logger.debug(
+                f"User data not found for user_id '{self.user_id}' (key: '{key}')"
+            )
+        return result
+
+    async def upsert(self, data: dict[str, Any], ttl: int | None = None) -> bool:
+        """Create or update user record with multiple fields (Redis HSET upsert behavior)"""
+        key = self._key()
+        return await self._hset_with_ttl(key, data, ttl)
+
+    async def update_field(
+        self, field: str, value: Any, ttl: int | None = None
+    ) -> bool:
+        """Update single field in user hash"""
+        key = self._key()
+        return await self._hset_with_ttl(key, {field: value}, ttl)
+
+    async def increment_field(
+        self, field: str, increment: int = 1, ttl: int | None = None
+    ) -> int | None:
+        """Atomically increment integer field (was increment_user_field)"""
+        key = self._key()
+
+        new_value, expire_res = await hincrby_with_expire(
+            key=key,
+            field=field,
+            increment=increment,
+            ttl=ttl or self.ttl_default,
+            alias=self.redis_alias,
+        )
+
+        if new_value is not None and expire_res:
+            return new_value
+        else:
+            logger.warning(
+                f"Failed to increment user field '{field}' for user_id '{self.user_id}'"
+            )
+            return None
+
+    async def append_to_list(
+        self, field: str, value: Any, ttl: int | None = None
+    ) -> bool:
+        """Append value to list field (was append_to_user_list_field)"""
+        key = self._key()
+        return await self._append_to_list_field(key, field, value, ttl)
+
+    async def find_by_field(
+        self, field: str, value: Any, models: type[BaseModel] | None = None
+    ) -> dict[str, Any] | None:
+        """
+        Find first user where field matches value (was find_user_by_field)
+
+        Args:
+            field: Field name to search
+            value: Value to match
+            models: Optional BaseModel class for full object reconstruction
+        """
+        pattern = self.keys.user(self.tenant, "*")
+        return await self._find_by_field(pattern, field, value, models=models)
+
+    async def delete(self) -> int:
+        """Delete entire user record (was delete_user_record)"""
+        key = self._key()
+        return await self.delete_key(key)
+
+    async def delete_field(self, field: str) -> int:
+        """Delete specific field from user hash (was delete_user_hash_field)"""
+        key = self._key()
+        return await hdel(key, field, alias=self.redis_alias)
+
+    async def exists(self) -> bool:
+        """Check if user exists (was user_exists)"""
+        key = self._key()
+        return await self.key_exists(key)
+
+    async def get_field(self, field: str) -> Any | None:
+        """Get a specific field from the user's data"""
+        key = self._key()
+        raw_value = await hget(key, field, alias=self.redis_alias)
+        return loads(raw_value) if raw_value is not None else None

wappa/persistence/redis/redis_handler/utils/__init__.py

@@ -0,0 +1,12 @@
+"""
+Redis Handler Utils
+
+Infrastructure and support utilities for Redis repositories.
+Contains key building, serialization, and base functionality.
+"""
+
+from .key_factory import KeyFactory
+from .serde import dumps, loads
+from .tenant_cache import TenantCache
+
+__all__ = ["KeyFactory", "dumps", "loads", "TenantCache"]

wappa/persistence/redis/redis_handler/utils/key_factory.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import logging
+
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger("RedisKeyFactory")
+
+
+class KeyFactory(BaseModel):
+    """Pure stateless helpers for Wappa cache key generation."""
+
+    user_prefix: str = Field(default="user")
+    handler_prefix: str = Field(default="state")
+    table_prefix: str = Field(default="df")
+    pk_marker: str = Field(default="pkid")
+
+    # ---- builders ---------------------------------------------------------
+    def user(self, tenant: str, user_id: str) -> str:
+        return f"{tenant}:{self.user_prefix}:{user_id}"
+
+    def handler(self, tenant: str, name: str, user_id: str) -> str:
+        return f"{tenant}:{self.handler_prefix}:{name}:{user_id}"
+
+    def table(self, tenant: str, table: str, pkid: str) -> str:
+        safe_tbl = table.replace(":", "_")
+        safe_pk = pkid.replace(":", "_")
+        return f"{tenant}:{self.table_prefix}:{safe_tbl}:{self.pk_marker}:{safe_pk}"
+
+
+# Default instance for global use
+default_key_factory = KeyFactory()

wappa/persistence/redis/redis_handler/utils/serde.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel
+
+logger = logging.getLogger("RedisSerde")
+
+
+def _convert_bools_to_redis(obj: Any) -> Any:
+    """Recursively convert boolean values to Redis-optimized "1"/"0" strings"""
+    if isinstance(obj, bool):
+        return "1" if obj else "0"
+    elif isinstance(obj, dict):
+        return {k: _convert_bools_to_redis(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [_convert_bools_to_redis(item) for item in obj]
+    else:
+        return obj
+
+
+def _convert_redis_to_bools(obj: Any) -> Any:
+    """Recursively convert Redis "1"/"0" strings back to boolean values"""
+    if obj == "1":
+        return True
+    elif obj == "0":
+        return False
+    elif isinstance(obj, dict):
+        return {k: _convert_redis_to_bools(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [_convert_redis_to_bools(item) for item in obj]
+    else:
+        return obj
+
+
+def _datetime_handler(obj: Any) -> str:
+    """Handle datetime objects during JSON serialization"""
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+
+def _convert_iso_strings_to_datetime(obj: Any) -> Any:
+    """Recursively convert ISO datetime strings back to datetime objects"""
+    if isinstance(obj, str):
+        # Try to parse as ISO datetime
+        try:
+            # Check if it looks like an ISO datetime (basic heuristic)
+            if "T" in obj and len(obj) >= 19:  # YYYY-MM-DDTHH:MM:SS minimum
+                return datetime.fromisoformat(obj.replace("Z", "+00:00"))
+        except (ValueError, AttributeError):
+            pass
+        return obj
+    elif isinstance(obj, dict):
+        return {k: _convert_iso_strings_to_datetime(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [_convert_iso_strings_to_datetime(item) for item in obj]
+    else:
+        return obj
+
+
+def dumps(obj: Any) -> str:
+    """Serialize Python object to Redis-compatible string"""
+    if obj is None:
+        return "null"
+    if isinstance(obj, bool):
+        return str(int(obj))
+    if isinstance(obj, int | float):
+        return str(obj)
+    if isinstance(obj, str):
+        return obj
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    if isinstance(obj, Enum):
+        return str(obj.value)
+    if isinstance(obj, BaseModel):
+        # Convert to dict first, then convert bools to "1"/"0", then to JSON
+        model_dict = obj.model_dump()
+        redis_dict = _convert_bools_to_redis(model_dict)
+        return json.dumps(redis_dict, ensure_ascii=False, default=_datetime_handler)
+    try:
+        return json.dumps(obj, ensure_ascii=False, default=_datetime_handler)
+    except TypeError as e:
+        logger.warning(
+            f"Could not JSON serialize value of type {type(obj)}. Falling back to str(). Error: {e}. Value: {obj!r}"
+        )
+        return str(obj)
+
+
+def loads(raw: str | None, model: type[BaseModel] | None = None) -> Any:
+    """Deserialize Redis string back to Python object"""
+    if raw in (None, "null"):
+        return None
+    if raw == "1":
+        return True
+    if raw == "0":
+        return False
+    try:
+        data = json.loads(raw)
+        if model is not None:
+            # Convert Redis "1"/"0" back to bools and handle datetime strings
+            bool_converted_data = _convert_redis_to_bools(data)
+            datetime_converted_data = _convert_iso_strings_to_datetime(
+                bool_converted_data
+            )
+            return model.model_validate(datetime_converted_data)
+        return data
+    except (json.JSONDecodeError, TypeError):
+        return raw
+
+
+def dumps_hash(data: dict[str, Any] | BaseModel) -> dict[str, str]:
+    """Serialize dictionary or BaseModel values for Redis hash storage"""
+    if isinstance(data, BaseModel):
+        # Convert BaseModel to dict first
+        data = data.model_dump()
+    return {field: dumps(value) for field, value in data.items()}
+
+
+def loads_hash(
+    raw_data: dict[str, str] | None, models: type[BaseModel] | None = None
+) -> dict[str, Any] | BaseModel:
+    """
+    Deserialize Redis hash back to Python dictionary or BaseModel
+
+    Args:
+        raw_data: Raw string data from Redis hash
+        models: Optional BaseModel class for full object reconstruction
+                e.g., User (will automatically handle nested UserContact, UserLocation)
+    """
+    if not raw_data:
+        return {}
+
+    # Deserialize all fields normally (no model-specific deserialization)
+    data = {field: loads(value_str) for field, value_str in raw_data.items()}
+
+    if models:
+        # Let Pydantic handle nested model reconstruction with preprocessing
+        # The model_validate will automatically call @model_validator(mode="before") methods
+        return models.model_validate(data)
+    else:
+        return data

wappa/persistence/redis/redis_handler/utils/tenant_cache.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from ...ops import (
+    delete,
+    exists,
+    expire,
+    get_ttl,
+    hget,
+    hgetall,
+    hset_with_expire,
+    scan_keys,
+)
+from ...redis_client import PoolAlias
+from .key_factory import KeyFactory
+from .serde import dumps, dumps_hash, loads, loads_hash
+
+logger = logging.getLogger("TenantCache")
+
+
+class TenantCache(BaseModel):
+    """
+    Base class shared by all Wappa cache repositories.
+    Handles tenant context, TTL management, and common Redis operations.
+
+    Provides common functionality for cache repositories:
+    - Tenant key building and namespace management
+    - TTL management and automatic expiration
+    - Common serialization patterns for cache data
+    """
+
+    tenant: str = Field(..., min_length=1)
+    ttl_default: int = 86400  # 24 hours
+    redis_alias: PoolAlias = "state_handler"  # Default pool
+    keys: KeyFactory = Field(default_factory=KeyFactory)
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    # --------- Low-level helpers extracted from RedisHandler ------------------
+    async def _hset_with_ttl(
+        self,
+        key: str,
+        data: dict[str, Any],
+        ttl: int | None = None,
+        *,
+        alias: PoolAlias | None = None,
+    ) -> bool:
+        """Helper for atomic hash set with expiration"""
+        _alias = alias or self.redis_alias
+        payload = dumps_hash(data)
+        if not payload:
+            logger.warning(f"Setting key '{key}' with empty data. Deleting instead.")
+            return await delete(key, alias=_alias) >= 0
+
+        hset_res, expire_res = await hset_with_expire(
+            key, payload, ttl or self.ttl_default, alias=_alias
+        )
+        success = hset_res is not None and expire_res
+        if not success:
+            logger.warning(
+                f"Failed hset_with_expire for key '{key}'. HSET: {hset_res}, EXPIRE: {expire_res}"
+            )
+        return success
+
+    async def _get_hash(
+        self,
+        key: str,
+        models: type[BaseModel] | None = None,
+        *,
+        alias: PoolAlias | None = None,
+    ) -> dict[str, Any] | None:
+        """
+        Helper to get and deserialize hash data
+
+        Args:
+            key: Redis key
+            models: Optional BaseModel class for full object reconstruction
+                   e.g., User (will automatically handle nested UserProfile, UserSettings)
+            alias: Redis pool alias to use (defaults to self.redis_alias)
+        """
+        _alias = alias or self.redis_alias
+        raw_data = await hgetall(key, alias=_alias)
+        return loads_hash(raw_data, models=models) if raw_data else None
+
+    async def _find_by_field(
+        self,
+        pattern: str,
+        field: str,
+        value: Any,
+        models: type[BaseModel] | None = None,
+        *,
+        alias: PoolAlias | None = None,
+    ) -> dict[str, Any] | None:
+        """
+        Find first hash matching pattern where field equals value.
+        Extracted from _find_hash_by_field_internal in RedisHandler.
+
+        Args:
+            pattern: Redis key pattern to search
+            field: Field name to match
+            value: Value to match
+            models: Optional mapping for BaseModel deserialization
+            alias: Redis pool alias to use (defaults to self.redis_alias)
+        """
+        _alias = alias or self.redis_alias
+        compare_value_str = dumps(value)
+        logger.debug(
+            f"Searching pattern '{pattern}' where field '{field}' == '{compare_value_str}'"
+        )
+
+        cursor = "0"
+        try:
+            while True:
+                next_cursor, keys_batch = await scan_keys(
+                    match_pattern=pattern, cursor=cursor, count=100, alias=_alias
+                )
+
+                for full_key in keys_batch:
+                    current_value_str = await hget(full_key, field, alias=_alias)
+                    if current_value_str == compare_value_str:
+                        logger.info(
+                            f"Match found for field '{field}' in key '{full_key}'"
+                        )
+                        return await self._get_hash(
+                            full_key, models=models, alias=alias
+                        )
+
+                if next_cursor == "0":
+                    logger.debug(
+                        f"SCAN finished for pattern '{pattern}'. No match found."
+                    )
+                    return None
+                cursor = next_cursor
+        except Exception as e:
+            logger.error(
+                f"Error during find_by_field (pattern='{pattern}', field='{field}'): {e}",
+                exc_info=True,
+            )
+            return None
+
+    async def _delete_by_pattern(
+        self, pattern: str, *, alias: PoolAlias | None = None
+    ) -> int:
+        """
+        Delete all keys matching pattern.
+        Extracted from _delete_keys_by_pattern_internal in RedisHandler.
+
+        Args:
+            pattern: Redis key pattern to delete
+            alias: Redis pool alias to use (defaults to self.redis_alias)
+        """
+        _alias = alias or self.redis_alias
+        total_deleted = 0
+        cursor = "0"
+
+        logger.debug(f"Deleting keys matching pattern '{pattern}'")
+        try:
+            while True:
+                next_cursor, keys_batch = await scan_keys(
+                    match_pattern=pattern, cursor=cursor, count=100, alias=_alias
+                )
+
+                if keys_batch:
+                    logger.debug(f"Deleting batch of {len(keys_batch)} keys")
+                    deleted_in_batch = await delete(*keys_batch, alias=_alias)
+                    if deleted_in_batch >= 0:
+                        total_deleted += deleted_in_batch
+
+                if next_cursor == "0":
+                    break
+                cursor = next_cursor
+
+            logger.info(f"Deleted {total_deleted} keys for pattern '{pattern}'")
+        except Exception as e:
+            logger.error(
+                f"Error during delete_by_pattern '{pattern}': {e}", exc_info=True
+            )
+
+        return total_deleted
+
+    async def _append_to_list_field(
+        self,
+        key: str,
+        field: str,
+        value: Any,
+        ttl: int | None = None,
+        *,
+        alias: PoolAlias | None = None,
+    ) -> bool:
+        """
+        Append to a list stored in a hash field.
+        Extracted from _append_to_list_in_hash_field in RedisHandler.
+
+        Args:
+            key: Redis key
+            field: Hash field name
+            value: Value to append to the list
+            ttl: Optional TTL override
+            alias: Redis pool alias to use (defaults to self.redis_alias)
+        """
+        _alias = alias or self.redis_alias
+        try:
+            # Get current value
+            current_raw = await hget(key, field, alias=_alias)
+            current_list = []
+
+            if current_raw:
+                try:
+                    deserialized = loads(current_raw)
+                    if isinstance(deserialized, list):
+                        current_list = deserialized
+                    else:
+                        logger.warning(
+                            f"Field '{field}' in '{key}' is not a list. Overwriting."
+                        )
+                except Exception as e:
+                    logger.warning(f"Could not deserialize list field '{field}': {e}")
+
+            # Append and serialize
+            current_list.append(value)
+            serialized_list = dumps(current_list)
+
+            # Write back atomically
+            hset_res, expire_res = await hset_with_expire(
+                key=key,
+                mapping={field: serialized_list},
+                ttl=ttl or self.ttl_default,
+                alias=_alias,
+            )
+
+            success = hset_res is not None and expire_res
+            if not success:
+                logger.warning(f"Failed list append for field '{field}' in '{key}'")
+            return success
+
+        except Exception as e:
+            logger.error(
+                f"Error in append_to_list_field '{field}' in '{key}': {e}",
+                exc_info=True,
+            )
+            return False
+
+    # --------- Utility methods -----------------------------------------------
+    async def key_exists(self, key: str, *, alias: PoolAlias | None = None) -> bool:
+        """Check if key exists"""
+        _alias = alias or self.redis_alias
+        return await exists(key, alias=_alias) > 0
+
+    async def renew_ttl(
+        self, key: str, ttl: int | None = None, *, alias: PoolAlias | None = None
+    ) -> bool:
+        """Renew TTL for a key"""
+        _alias = alias or self.redis_alias
+        return await expire(key, ttl or self.ttl_default, alias=_alias)
+
+    async def get_ttl(self, key: str, *, alias: PoolAlias | None = None) -> int:
+        """Get remaining TTL for a key"""
+        _alias = alias or self.redis_alias
+        return await get_ttl(key, alias=_alias)
+
+    async def delete_key(self, key: str, *, alias: PoolAlias | None = None) -> int:
+        """Delete a key"""
+        _alias = alias or self.redis_alias
+        return await delete(key, alias=_alias)