fastapi-cachex 0.2.5__tar.gz → 0.2.7__tar.gz

{fastapi_cachex-0.2.5 → fastapi_cachex-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachex
-Version: 0.2.5
+Version: 0.2.7
 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.5 → fastapi_cachex-0.2.7}/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.5 → fastapi_cachex-0.2.7}/fastapi_cachex/session/dependencies.py

@@ -17,7 +17,11 @@ if TYPE_CHECKING:
 
 
 # HTTPBearer security scheme for OpenAPI UI
-_http_bearer = HTTPBearer(auto_error=False)
+_http_bearer = HTTPBearer(
+    scheme_name="SessionBearer",
+    description="Session authentication using Bearer token",
+    auto_error=False,
+)
 
 
 def get_optional_session(

{fastapi_cachex-0.2.5 → fastapi_cachex-0.2.7}/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.5 → fastapi_cachex-0.2.7}/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.5 → fastapi_cachex-0.2.7}/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.5 → fastapi_cachex-0.2.7}/pyproject.toml

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