fastapi-cachex 0.2.6__tar.gz → 0.2.8__tar.gz

{fastapi_cachex-0.2.6 → fastapi_cachex-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachex
-Version: 0.2.6
+Version: 0.2.8
 Summary: A caching library for FastAPI with support for Cache-Control, ETag, and multiple backends.
 Keywords: fastapi,cache,etag,cache-control,redis,memcached,in-memory
 Author: allen0099

{fastapi_cachex-0.2.6 → fastapi_cachex-0.2.8}/fastapi_cachex/backends/redis.py

@@ -128,11 +128,16 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
         return serialized.decode() if isinstance(serialized, bytes) else serialized
 
     def _deserialize(self, value: str | None) -> ETagContent | None:
-        """Deserialize JSON string to ETagContent."""
+        """Deserialize JSON string to ETagContent.
+
+        Converts string content back to bytes to maintain consistency with
+        other backends and standard Response.body type (bytes).
+        """
         if value is None:
             return None
         try:
             data = json.loads(value)
+            logger.debug("Content type in JSON: %s", type(data["content"]))
             return ETagContent(
                 etag=data["etag"],
                 content=data["content"].encode()

fastapi_cachex-0.2.8/fastapi_cachex/proxy.py

@@ -0,0 +1,100 @@
+"""Backend proxy for managing cache backend instances."""
+
+from __future__ import annotations
+
+import warnings
+from logging import getLogger
+from typing import Generic
+from typing import TypeVar
+
+from .backends import BaseCacheBackend
+from .exceptions import BackendNotFoundError
+from .session.manager import SessionManager
+
+ProxyInstance = TypeVar("ProxyInstance")
+
+logger = getLogger(__name__)
+
+
+class ProxyMeta(type):
+    """Metaclass for BackendProxy to prevent instantiation."""
+
+    def __call__(cls) -> None:
+        """Prevent instantiation of BackendProxy."""
+        msg = "Proxy class cannot be instantiated. Use static methods instead."
+        raise TypeError(msg)
+
+
+class ProxyBase(Generic[ProxyInstance], metaclass=ProxyMeta):
+    """Abstract base class for proxy classes."""
+
+    _instance: ProxyInstance | None = None
+
+    @classmethod
+    def get(cls) -> ProxyInstance:
+        """Get the current instance of the proxy.
+
+        Returns:
+            The current instance
+        """
+        if cls._instance is None:
+            msg = "Instance is not set. Please set the instance first."
+            raise BackendNotFoundError(msg)
+        return cls._instance
+
+    @classmethod
+    def set(cls, instance: ProxyInstance | None) -> None:
+        """Set the instance for the proxy.
+
+        Args:
+            instance: The instance to set, or None to clear
+        """
+        logger.info(
+            "Setting instance to: <%s>",
+            instance.__class__.__name__ if instance else "None",
+        )
+        cls._instance = instance
+
+
+class BackendProxy(ProxyBase[BaseCacheBackend]):
+    """FastAPI CacheX Proxy for backend management."""
+
+    @staticmethod
+    def get_backend() -> BaseCacheBackend:
+        """Get the current backend instance.
+
+        .. deprecated:: 0.3.0
+            Use :meth:`get` instead. Will be removed in version 0.4.0.
+
+        Returns:
+            The current backend instance
+        """
+        warnings.warn(
+            "get_backend() is deprecated, use get() instead. "
+            "Will be removed in version 0.4.0.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return BackendProxy.get()
+
+    @staticmethod
+    def set_backend(backend: BaseCacheBackend | None) -> None:
+        """Set the backend instance.
+
+        .. deprecated:: 0.3.0
+            Use :meth:`set` instead. Will be removed in version 0.4.0.
+
+        Args:
+            backend: The backend instance to set, or None to clear
+        """
+        warnings.warn(
+            "set_backend() is deprecated, use set() instead. "
+            "Will be removed in version 0.4.0.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        BackendProxy.set(backend)
+
+
+class SessionManagerProxy(ProxyBase[SessionManager]):
+    """FastAPI CacheX Proxy for session manager management."""

{fastapi_cachex-0.2.6 → fastapi_cachex-0.2.8}/fastapi_cachex/session/models.py

@@ -13,9 +13,6 @@ from pydantic import Field
 
 logger = logging.getLogger(__name__)
 
-# Token format constant
-TOKEN_PARTS_COUNT = 3
-
 
 class SessionStatus(str, Enum):
     """Session status enumeration."""
@@ -145,41 +142,3 @@ class SessionToken(BaseModel):
     session_id: str
     signature: str
     issued_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-
-    def to_string(self) -> str:
-        """Convert token to string format.
-
-        Format: {session_id}.{signature}.{timestamp}
-        """
-        timestamp = int(self.issued_at.timestamp())
-
-        logger.debug("SessionToken to_string called; id=%s", self.session_id)
-        return f"{self.session_id}.{self.signature}.{timestamp}"
-
-    @classmethod
-    def from_string(cls, token_str: str) -> "SessionToken":
-        """Parse token from string format.
-
-        Args:
-            token_str: Token string in format {session_id}.{signature}.{timestamp}
-
-        Returns:
-            SessionToken instance
-
-        Raises:
-            ValueError: If token format is invalid
-        """
-        parts = token_str.split(".")
-        if len(parts) != TOKEN_PARTS_COUNT:
-            msg = "Invalid token format"
-            raise ValueError(msg)
-
-        session_id, signature, timestamp = parts
-        try:
-            issued_at = datetime.fromtimestamp(int(timestamp), tz=timezone.utc)
-        except (ValueError, OSError) as e:
-            msg = f"Invalid timestamp in token: {e}"
-            raise ValueError(msg) from e
-
-        logger.debug("SessionToken parsed from string; id=%s", session_id)
-        return cls(session_id=session_id, signature=signature, issued_at=issued_at)

{fastapi_cachex-0.2.6 → fastapi_cachex-0.2.8}/fastapi_cachex/session/token_serializers.py

@@ -25,6 +25,9 @@ if TYPE_CHECKING:  # Import for typing only to avoid circular import concerns
 
 logger = logging.getLogger(__name__)
 
+# Token format constant - 3 parts: session_id, signature, timestamp
+TOKEN_PARTS_COUNT = 3
+
 
 class TokenSerializer(Protocol):
     """Protocol for token serialization strategies."""
@@ -42,12 +45,49 @@ class SimpleTokenSerializer:
     """Serializer for the default simple token format."""
 
     def to_string(self, token: SessionToken) -> str:
-        """Serialize using the built-in simple format."""
-        return token.to_string()
+        """Convert token to string format.
+
+        Format: {session_id}.{signature}.{timestamp}
+
+        Args:
+            token: SessionToken instance to serialize
+
+        Returns:
+            Token string in format {session_id}.{signature}.{timestamp}
+        """
+        timestamp = int(token.issued_at.timestamp())
+
+        logger.debug("SimpleTokenSerializer to_string called; id=%s", token.session_id)
+        return f"{token.session_id}.{token.signature}.{timestamp}"
 
     def from_string(self, token_str: str) -> SessionToken:
-        """Parse the built-in simple token format."""
-        return SessionToken.from_string(token_str)
+        """Parse token from string format.
+
+        Args:
+            token_str: Token string in format {session_id}.{signature}.{timestamp}
+
+        Returns:
+            SessionToken instance
+
+        Raises:
+            ValueError: If token format is invalid
+        """
+        parts = token_str.split(".")
+        if len(parts) != TOKEN_PARTS_COUNT:
+            msg = "Invalid token format"
+            raise ValueError(msg)
+
+        session_id, signature, timestamp = parts
+        try:
+            issued_at = datetime.fromtimestamp(int(timestamp), tz=timezone.utc)
+        except (ValueError, OSError) as e:
+            msg = f"Invalid timestamp in token: {e}"
+            raise ValueError(msg) from e
+
+        logger.debug("SimpleTokenSerializer parsed from string; id=%s", session_id)
+        return SessionToken(
+            session_id=session_id, signature=signature, issued_at=issued_at
+        )
 
 
 class JWTTokenSerializer:

{fastapi_cachex-0.2.6 → fastapi_cachex-0.2.8}/fastapi_cachex/state/manager.py

@@ -108,7 +108,9 @@ class StateManager:
 
         # Extract content from ETagContent
         json_content = cached_etag_content.content
-        if not isinstance(json_content, str):
+        if isinstance(json_content, bytes):
+            json_content = json_content.decode("utf-8")
+        elif not isinstance(json_content, str):
             msg = "Unexpected state data format"
             logger.error(
                 "Unexpected content type in state; state=%s type=%s",
@@ -164,7 +166,16 @@ class StateManager:
 
         # Extract content from ETagContent
         json_content = cached_etag_content.content
-        if not isinstance(json_content, str):
+        if isinstance(json_content, bytes):
+            try:
+                json_content = json_content.decode("utf-8")
+            except UnicodeDecodeError:
+                logger.exception(
+                    "Failed to decode bytes content in state; state=%s",
+                    state,
+                )
+                return False
+        elif not isinstance(json_content, str):
             logger.error(
                 "Unexpected content type in state; state=%s type=%s",
                 state,
@@ -174,19 +185,11 @@ class StateManager:
 
         try:
             state_dict: dict[str, Any] = json.loads(json_content)
-        except json.JSONDecodeError:
-            logger.exception(
-                "Failed to parse state data during validation; state=%s",
-                state,
-            )
-            return False
-
-        # Validate and create StateData model
-        try:
+            # Validate and create StateData model
             state_data = StateData(**state_dict)
-        except ValueError:
+        except (json.JSONDecodeError, ValueError):
             logger.exception(
-                "Failed to create StateData model during validation; state=%s",
+                "Failed to parse or validate state data; state=%s",
                 state,
             )
             return False
@@ -216,7 +219,16 @@ class StateManager:
 
         # Extract content from ETagContent
         json_content = cached_etag_content.content
-        if not isinstance(json_content, str):
+        if isinstance(json_content, bytes):
+            try:
+                json_content = json_content.decode("utf-8")
+            except UnicodeDecodeError:
+                logger.exception(
+                    "Failed to decode bytes content in state; state=%s",
+                    state,
+                )
+                return None
+        elif not isinstance(json_content, str):
             logger.error(
                 "Unexpected content type in state; state=%s type=%s",
                 state,
@@ -226,15 +238,10 @@ class StateManager:
 
         try:
             state_dict: dict[str, Any] = json.loads(json_content)
-        except json.JSONDecodeError:
-            logger.exception("Failed to parse state data; state=%s", state)
-            return None
-
-        # Validate and create StateData model
-        try:
+            # Validate and create StateData model
             state_data = StateData(**state_dict)
-        except ValueError:
-            logger.exception("Failed to create StateData model; state=%s", state)
+        except (json.JSONDecodeError, ValueError):
+            logger.exception("Failed to parse or validate state data; state=%s", state)
             return None
 
         # Check expiry

{fastapi_cachex-0.2.6 → fastapi_cachex-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-cachex"
-version = "0.2.6"
+version = "0.2.8"
 description = "A caching library for FastAPI with support for Cache-Control, ETag, and multiple backends."
 readme = "README.md"
 requires-python = ">=3.10"

fastapi_cachex-0.2.6/fastapi_cachex/proxy.py

@@ -1,43 +0,0 @@
-"""Backend proxy for managing cache backend instances."""
-
-from logging import getLogger
-
-from .backends import BaseCacheBackend
-from .exceptions import BackendNotFoundError
-
-_default_backend: BaseCacheBackend | None = None
-logger = getLogger(__name__)
-
-
-class BackendProxy:
-    """FastAPI CacheX Proxy for backend management."""
-
-    @staticmethod
-    def get_backend() -> BaseCacheBackend:
-        """Get the current cache backend instance.
-
-        Returns:
-            The current cache backend
-
-        Raises:
-            BackendNotFoundError: If no backend has been set
-        """
-        if _default_backend is None:
-            msg = "Backend is not set. Please set the backend first."
-            raise BackendNotFoundError(msg)
-
-        return _default_backend
-
-    @staticmethod
-    def set_backend(backend: BaseCacheBackend | None) -> None:
-        """Set the backend for caching.
-
-        Args:
-            backend: The backend to use for caching, or None to clear the current backend
-        """
-        global _default_backend
-        logger.info(
-            "Setting backend to: <%s>",
-            backend.__class__.__name__ if backend else "None",
-        )
-        _default_backend = backend