fastapi-cachex 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

fastapi_cachex/__init__.py

@@ -1,7 +1,27 @@
 """FastAPI-CacheX: A powerful and flexible caching extension for FastAPI."""
 
+import logging
+
 from .cache import cache as cache
+from .cache import default_key_builder as default_key_builder
 from .dependencies import CacheBackend as CacheBackend
 from .dependencies import get_cache_backend as get_cache_backend
 from .proxy import BackendProxy as BackendProxy
 from .routes import add_routes as add_routes
+from .types import CacheKeyBuilder as CacheKeyBuilder
+
+_package_logger = logging.getLogger("fastapi_cachex")
+_package_logger.addHandler(
+    logging.NullHandler()
+)  # Attach a NullHandler to avoid "No handler found" warnings in user applications.
+
+# Session management (optional feature)
+__all__ = [
+    "BackendProxy",
+    "CacheBackend",
+    "CacheKeyBuilder",
+    "add_routes",
+    "cache",
+    "default_key_builder",
+    "get_cache_backend",
+]

fastapi_cachex/backends/__init__.py

@@ -1,9 +1,9 @@
 """Cache backend implementations for FastAPI-CacheX."""
 
-from fastapi_cachex.backends.base import BaseCacheBackend
-from fastapi_cachex.backends.memcached import MemcachedBackend
-from fastapi_cachex.backends.memory import MemoryBackend
-from fastapi_cachex.backends.redis import AsyncRedisCacheBackend
+from .base import BaseCacheBackend
+from .memcached import MemcachedBackend
+from .memory import MemoryBackend
+from .redis import AsyncRedisCacheBackend
 
 __all__ = [
     "AsyncRedisCacheBackend",

fastapi_cachex/backends/memcached.py

@@ -1,17 +1,21 @@
 """Memcached cache backend implementation."""
 
+import logging
 import warnings
 
-from fastapi_cachex.backends.base import BaseCacheBackend
 from fastapi_cachex.exceptions import CacheXError
 from fastapi_cachex.types import ETagContent
 
+from .base import BaseCacheBackend
+
 try:
     import orjson as json
 
 except ImportError:  # pragma: no cover
     import json  # type: ignore[no-redef]  # pragma: no cover
 
+logger = logging.getLogger(__name__)
+
 # Default Memcached key prefix for fastapi-cachex
 DEFAULT_MEMCACHE_PREFIX = "fastapi_cachex:"
 
@@ -70,11 +74,13 @@ class MemcachedBackend(BaseCacheBackend):
         prefixed_key = self._make_key(key)
         value = self.client.get(prefixed_key)
         if value is None:
+            logger.debug("Memcached MISS; key=%s", key)
             return None
 
         # Memcached stores data as bytes; deserialize from JSON
         try:
             data = json.loads(value.decode("utf-8"))
+            logger.debug("Memcached HIT; key=%s", key)
             return ETagContent(
                 etag=data["etag"],
                 content=data["content"].encode()
@@ -82,6 +88,7 @@ class MemcachedBackend(BaseCacheBackend):
                 else data["content"],
             )
         except (json.JSONDecodeError, KeyError, ValueError):
+            logger.debug("Memcached DESERIALIZE ERROR; key=%s", key)
             return None
 
     async def set(self, key: str, value: ETagContent, ttl: int | None = None) -> None:
@@ -119,6 +126,7 @@ class MemcachedBackend(BaseCacheBackend):
             serialized_bytes,
             expire=ttl if ttl is not None else 0,
         )
+        logger.debug("Memcached SET; key=%s ttl=%s", key, ttl)
 
     async def delete(self, key: str) -> None:
         """Delete value from cache.
@@ -127,6 +135,7 @@ class MemcachedBackend(BaseCacheBackend):
             key: Cache key to delete
         """
         self.client.delete(self._make_key(key))
+        logger.debug("Memcached DELETE; key=%s", key)
 
     async def clear(self) -> None:
         """Clear all values from cache.
@@ -142,6 +151,7 @@ class MemcachedBackend(BaseCacheBackend):
             stacklevel=2,
         )
         self.client.flush_all()
+        logger.debug("Memcached CLEAR; flush_all issued")
 
     async def clear_path(self, path: str, include_params: bool = False) -> int:
         """Clear cached responses for a specific path.
@@ -175,9 +185,15 @@ class MemcachedBackend(BaseCacheBackend):
         except Exception:  # noqa: BLE001
             return 0
         else:
+            logger.debug(
+                "Memcached CLEAR_PATH; path=%s include_params=%s removed=%s",
+                path,
+                include_params,
+                1 if result else 0,
+            )
             return 1 if result else 0
 
-    async def clear_pattern(self, pattern: str) -> int:  # noqa: ARG002
+    async def clear_pattern(self, pattern: str) -> int:
         """Clear cached responses matching a pattern.
 
         Memcached does not support pattern matching or key scanning.
@@ -197,6 +213,7 @@ class MemcachedBackend(BaseCacheBackend):
             RuntimeWarning,
             stacklevel=2,
         )
+        logger.debug("Memcached CLEAR_PATTERN unsupported; pattern=%s", pattern)
         return 0
 
     async def get_all_keys(self) -> list[str]:
@@ -218,6 +235,7 @@ class MemcachedBackend(BaseCacheBackend):
             RuntimeWarning,
             stacklevel=2,
         )
+        logger.debug("Memcached GET_ALL_KEYS unsupported; returning empty list")
         return []
 
     async def get_cache_data(self) -> dict[str, tuple[ETagContent, float | None]]:
@@ -236,4 +254,5 @@ class MemcachedBackend(BaseCacheBackend):
             RuntimeWarning,
             stacklevel=2,
         )
+        logger.debug("Memcached GET_CACHE_DATA unsupported; returning empty dict")
         return {}

fastapi_cachex/backends/memory.py

@@ -3,14 +3,18 @@
 import asyncio
 import contextlib
 import fnmatch
+import logging
 import time
 
+from fastapi_cachex.types import CACHE_KEY_SEPARATOR
 from fastapi_cachex.types import CacheItem
 from fastapi_cachex.types import ETagContent
 
 from .base import BaseCacheBackend
 
-# Cache keys are formatted as: method:host:path:query_params
+logger = logging.getLogger(__name__)
+
+# Cache keys are formatted as: method|||host|||path|||query_params
 # Minimum parts required to extract path component
 _MIN_KEY_PARTS = 3
 # Maximum parts to split (method, host, path, query_params)
@@ -43,6 +47,10 @@ class MemoryBackend(BaseCacheBackend):
             with contextlib.suppress(RuntimeError):
                 # No event loop yet; will be created on first async operation
                 self._cleanup_task = asyncio.create_task(self._cleanup_task_impl())
+                logger.debug(
+                    "Started memory backend cleanup task (interval=%s)",
+                    self.cleanup_interval,
+                )
 
     def start_cleanup(self) -> None:
         """Start the cleanup task if it's not already running.
@@ -56,6 +64,7 @@ class MemoryBackend(BaseCacheBackend):
         if self._cleanup_task is not None:
             self._cleanup_task.cancel()
             self._cleanup_task = None
+            logger.debug("Stopped memory backend cleanup task")
 
     async def get(self, key: str) -> ETagContent | None:
         """Retrieve a cached response.
@@ -69,10 +78,13 @@ class MemoryBackend(BaseCacheBackend):
             cached_item = self.cache.get(key)
             if cached_item:
                 if cached_item.expiry is None or cached_item.expiry > time.time():
+                    logger.debug("Memory cache HIT; key=%s", key)
                     return cached_item.value
                 # Entry has expired; clean it up
                 del self.cache[key]
+                logger.debug("Memory cache EXPIRED; key=%s removed", key)
                 return None
+            logger.debug("Memory cache MISS; key=%s", key)
             return None
 
     async def set(self, key: str, value: ETagContent, ttl: int | None = None) -> None:
@@ -86,16 +98,19 @@ class MemoryBackend(BaseCacheBackend):
         async with self.lock:
             expiry = time.time() + ttl if ttl is not None else None
             self.cache[key] = CacheItem(value=value, expiry=expiry)
+            logger.debug("Memory cache SET; key=%s ttl=%s", key, ttl)
 
     async def delete(self, key: str) -> None:
         """Remove a response from the cache."""
         async with self.lock:
             self.cache.pop(key, None)
+            logger.debug("Memory cache DELETE; key=%s", key)
 
     async def clear(self) -> None:
         """Clear all cached responses."""
         async with self.lock:
             self.cache.clear()
+            logger.debug("Memory cache CLEAR; all entries removed")
 
     async def clear_path(self, path: str, include_params: bool = False) -> int:
         """Clear cached responses for a specific path.
@@ -115,8 +130,8 @@ class MemoryBackend(BaseCacheBackend):
         async with self.lock:
             keys_to_delete = []
             for key in self.cache:
-                # Keys are formatted as: method:host:path:query_params
-                parts = key.split(":", _MAX_KEY_PARTS)
+                # Keys are formatted as: method|||host|||path|||query_params
+                parts = key.split(CACHE_KEY_SEPARATOR, _MAX_KEY_PARTS)
                 if len(parts) >= _MIN_KEY_PARTS:
                     cache_path = parts[2]
                     has_params = len(parts) > _MIN_KEY_PARTS
@@ -127,6 +142,12 @@ class MemoryBackend(BaseCacheBackend):
             for key in keys_to_delete:
                 del self.cache[key]
 
+        logger.debug(
+            "Memory cache CLEAR_PATH; path=%s include_params=%s removed=%s",
+            path,
+            include_params,
+            cleared_count,
+        )
         return cleared_count
 
     async def clear_pattern(self, pattern: str) -> int:
@@ -145,8 +166,8 @@ class MemoryBackend(BaseCacheBackend):
         async with self.lock:
             keys_to_delete = []
             for key in self.cache:
-                # Extract path component (method:host:path:query_params)
-                parts = key.split(":", _MAX_KEY_PARTS)
+                # Extract path component (method|||host|||path|||query_params)
+                parts = key.split(CACHE_KEY_SEPARATOR, _MAX_KEY_PARTS)
                 if len(parts) >= _MIN_KEY_PARTS:
                     cache_path = parts[2]
                     if fnmatch.fnmatch(cache_path, pattern):
@@ -156,6 +177,9 @@ class MemoryBackend(BaseCacheBackend):
             for key in keys_to_delete:
                 del self.cache[key]
 
+        logger.debug(
+            "Memory cache CLEAR_PATTERN; pattern=%s removed=%s", pattern, cleared_count
+        )
         return cleared_count
 
     async def get_all_keys(self) -> list[str]:
@@ -196,3 +220,7 @@ class MemoryBackend(BaseCacheBackend):
             ]
             for key in expired_keys:
                 self.cache.pop(key, None)
+            if expired_keys:
+                logger.debug(
+                    "Memory cache CLEANUP; expired removed=%s", len(expired_keys)
+                )

fastapi_cachex/backends/redis.py

@@ -1,13 +1,16 @@
 """Redis cache backend implementation."""
 
+import logging
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Literal
 
-from fastapi_cachex.backends.base import BaseCacheBackend
 from fastapi_cachex.exceptions import CacheXError
+from fastapi_cachex.types import CACHE_KEY_SEPARATOR
 from fastapi_cachex.types import ETagContent
 
+from .base import BaseCacheBackend
+
 if TYPE_CHECKING:
     from redis.asyncio import Redis as AsyncRedis
 
@@ -17,6 +20,8 @@ try:
 except ImportError:  # pragma: no cover
     import json  # type: ignore[no-redef]  # pragma: no cover
 
+logger = logging.getLogger(__name__)
+
 # Default Redis key prefix for fastapi-cachex
 DEFAULT_REDIS_PREFIX = "fastapi_cachex:"
 
@@ -116,7 +121,9 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
     async def get(self, key: str) -> ETagContent | None:
         """Retrieve a cached response."""
         result = await self.client.get(self._make_key(key))
-        return self._deserialize(result)
+        value = self._deserialize(result)
+        logger.debug("Redis %s; key=%s", "HIT" if value else "MISS", key)
+        return value
 
     async def set(self, key: str, value: ETagContent, ttl: int | None = None) -> None:
         """Store a response in the cache."""
@@ -126,10 +133,12 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
             await self.client.setex(prefixed_key, ttl, serialized)
         else:
             await self.client.set(prefixed_key, serialized)
+        logger.debug("Redis SET; key=%s ttl=%s", key, ttl)
 
     async def delete(self, key: str) -> None:
         """Remove a response from the cache."""
         await self.client.delete(self._make_key(key))
+        logger.debug("Redis DELETE; key=%s", key)
 
     async def clear(self) -> None:
         """Clear all cached responses for this namespace.
@@ -160,6 +169,7 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
                 batch = keys_to_delete[i : i + batch_size]
                 if batch:
                     await self.client.delete(*batch)
+        logger.debug("Redis CLEAR; removed=%s", len(keys_to_delete))
 
     async def clear_path(self, path: str, include_params: bool = False) -> int:
         """Clear cached responses for a specific path.
@@ -175,11 +185,13 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
         """
         # Pattern includes the HTTP method, host, and path components
         if include_params:
-            # Clear all variations: *:path:*
-            pattern = f"{self.key_prefix}*:{path}:*"
+            # Clear all variations: *|||path|||*
+            pattern = (
+                f"{self.key_prefix}*{CACHE_KEY_SEPARATOR}{path}{CACHE_KEY_SEPARATOR}*"
+            )
         else:
-            # Clear only exact path (no query params): *:path
-            pattern = f"{self.key_prefix}*:{path}"
+            # Clear only exact path (no query params): *|||path
+            pattern = f"{self.key_prefix}*{CACHE_KEY_SEPARATOR}{path}"
 
         cursor = 0
         batch_size = 100
@@ -206,6 +218,12 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
                     deleted = await self.client.delete(*batch)
                     cleared_count += deleted
 
+        logger.debug(
+            "Redis CLEAR_PATH; path=%s include_params=%s removed=%s",
+            path,
+            include_params,
+            cleared_count,
+        )
         return cleared_count
 
     async def clear_pattern(self, pattern: str) -> int:
@@ -250,6 +268,9 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
                     deleted = await self.client.delete(*batch)
                     cleared_count += deleted
 
+        logger.debug(
+            "Redis CLEAR_PATTERN; pattern=%s removed=%s", full_pattern, cleared_count
+        )
         return cleared_count
 
     async def get_all_keys(self) -> list[str]:
@@ -275,6 +296,7 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
             if cursor == 0:
                 break
 
+        logger.debug("Redis GET_ALL_KEYS; count=%s", len(all_keys))
         return all_keys
 
     async def get_cache_data(self) -> dict[str, tuple[ETagContent, float | None]]:
@@ -297,4 +319,5 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
             if value is not None:
                 cache_data[original_key] = (value, None)
 
+        logger.debug("Redis GET_CACHE_DATA; keys=%s", len(cache_data))
         return cache_data

fastapi_cachex/cache.py

@@ -2,6 +2,7 @@
 
 import hashlib
 import inspect
+import logging
 from collections.abc import Awaitable
 from collections.abc import Callable
 from functools import update_wrapper
@@ -11,29 +12,53 @@ from inspect import Signature
 from typing import TYPE_CHECKING
 from typing import Any
 from typing import Literal
-from typing import TypeVar
-from typing import Union
 
 from fastapi import Request
 from fastapi import Response
 from fastapi.datastructures import DefaultPlaceholder
 from starlette.status import HTTP_304_NOT_MODIFIED
 
-from fastapi_cachex.backends import MemoryBackend
-from fastapi_cachex.directives import DirectiveType
-from fastapi_cachex.exceptions import BackendNotFoundError
-from fastapi_cachex.exceptions import CacheXError
-from fastapi_cachex.exceptions import RequestNotFoundError
-from fastapi_cachex.proxy import BackendProxy
-from fastapi_cachex.types import ETagContent
+from .backends import MemoryBackend
+from .directives import DirectiveType
+from .exceptions import BackendNotFoundError
+from .exceptions import CacheXError
+from .exceptions import RequestNotFoundError
+from .proxy import BackendProxy
+from .types import CACHE_KEY_SEPARATOR
+from .types import CacheKeyBuilder
+from .types import ETagContent
 
 if TYPE_CHECKING:
     from fastapi.routing import APIRoute
 
-T = TypeVar("T", bound=Response)
-AsyncCallable = Callable[..., Awaitable[T]]
-SyncCallable = Callable[..., T]
-AnyCallable = Union[AsyncCallable[T], SyncCallable[T]]  # noqa: UP007
+# Handler callable accepted by @cache: can return any type (sync or async).
+HandlerCallable = Callable[..., Awaitable[object]] | Callable[..., object]
+
+# Wrapper callable produced by @cache: always async and returns Response.
+AsyncResponseCallable = Callable[..., Awaitable[Response]]
+
+logger = logging.getLogger(__name__)
+
+
+def default_key_builder(request: Request) -> str:
+    """Default cache key builder function.
+
+    Generates cache key in format: method|||host|||path|||query_params
+
+    Args:
+        request: The FastAPI Request object
+
+    Returns:
+        Generated cache key string
+    """
+    key = (
+        f"{request.method}{CACHE_KEY_SEPARATOR}"
+        f"{request.headers.get('host', 'unknown')}{CACHE_KEY_SEPARATOR}"
+        f"{request.url.path}{CACHE_KEY_SEPARATOR}"
+        f"{request.query_params}"
+    )
+    logger.debug("Built cache key: %s", key)
+    return key
 
 
 class CacheControl:
@@ -61,7 +86,7 @@ class CacheControl:
 
 
 async def get_response(
-    __func: AnyCallable[Response],
+    __func: HandlerCallable,
     __request: Request,
     /,
     *args: Any,
@@ -96,6 +121,7 @@ async def get_response(
 def cache(  # noqa: C901
     ttl: int | None = None,
     stale_ttl: int | None = None,
+    *,
     stale: Literal["error", "revalidate"] | None = None,
     no_cache: bool = False,
     no_store: bool = False,
@@ -103,7 +129,8 @@ def cache(  # noqa: C901
     private: bool = False,
     immutable: bool = False,
     must_revalidate: bool = False,
-) -> Callable[[AnyCallable[Response]], AsyncCallable[Response]]:
+    key_builder: CacheKeyBuilder | None = None,
+) -> Callable[[HandlerCallable], AsyncResponseCallable]:
     """Cache decorator for FastAPI route handlers.
 
     Args:
@@ -116,18 +143,20 @@ def cache(  # noqa: C901
         private: Whether responses are for single user only
         immutable: Whether cached responses never change
         must_revalidate: Whether to force revalidation when stale
+        key_builder: Custom function to build cache keys. If None, uses default_key_builder
 
     Returns:
         Decorator function that wraps route handlers with caching logic
     """
 
-    def decorator(func: AnyCallable[Response]) -> AsyncCallable[Response]:  # noqa: C901
+    def decorator(func: HandlerCallable) -> AsyncResponseCallable:  # noqa: C901
         try:
             cache_backend = BackendProxy.get_backend()
         except BackendNotFoundError:
             # Fallback to memory backend if no backend is set
             cache_backend = MemoryBackend()
             BackendProxy.set_backend(cache_backend)
+            logger.debug("No backend configured; using MemoryBackend fallback")
 
         # Analyze the original function's signature
         sig: Signature = inspect.signature(func)
@@ -205,11 +234,14 @@ def cache(  # noqa: C901
 
             # Only cache GET requests
             if req.method != "GET":
+                logger.debug(
+                    "Non-GET request; bypassing cache for method=%s", req.method
+                )
                 return await get_response(func, req, *args, **kwargs)
 
-            # Generate cache key: method:host:path:query_params[:vary]
-            # Include host to avoid cross-host cache pollution
-            cache_key = f"{req.method}:{req.headers.get('host', 'unknown')}:{req.url.path}:{req.query_params}"
+            # Generate cache key using custom builder or default
+            builder = key_builder or default_key_builder
+            cache_key = builder(req)
             client_etag = req.headers.get("if-none-match")
             cache_control = await get_cache_control(CacheControl())
 
@@ -219,6 +251,7 @@ def cache(  # noqa: C901
                 cc = CacheControl()
                 cc.add(DirectiveType.NO_STORE)
                 response.headers["Cache-Control"] = str(cc)
+                logger.debug("no-store active; bypassed cache for key=%s", cache_key)
                 return response
 
             # Check cache and handle ETag validation
@@ -237,6 +270,7 @@ def cache(  # noqa: C901
 
                     if client_etag == current_etag:
                         # For no-cache, compare fresh data with client's ETag
+                        logger.debug("304 Not Modified via no-cache; key=%s", cache_key)
                         return Response(
                             status_code=HTTP_304_NOT_MODIFIED,
                             headers={
@@ -250,6 +284,9 @@ def cache(  # noqa: C901
                     cached_data and client_etag == cached_data.etag
                 ):  # pragma: no branch
                     # Cache hit with matching ETag: return 304 Not Modified
+                    logger.debug(
+                        "304 Not Modified (cached ETag match); key=%s", cache_key
+                    )
                     return Response(
                         status_code=HTTP_304_NOT_MODIFIED,
                         headers={
@@ -263,6 +300,7 @@ def cache(  # noqa: C901
             if cached_data and not no_cache and ttl is not None:
                 # We have a cached entry and TTL-based caching is enabled
                 # Return the cached content directly with 200 OK without revalidation
+                logger.debug("Cache HIT (TTL valid); key=%s", cache_key)
                 return Response(
                     content=cached_data.content,
                     status_code=200,
@@ -276,6 +314,7 @@ def cache(  # noqa: C901
                 # Retrieve the current response if not already done
                 current_response = await get_response(func, req, *args, **kwargs)
                 current_etag = f'W/"{hashlib.md5(current_response.body).hexdigest()}"'  # noqa: S324
+                logger.debug("Cache MISS; computed fresh ETag for key=%s", cache_key)
 
             # Set ETag header
             current_response.headers["ETag"] = current_etag
@@ -288,6 +327,7 @@ def cache(  # noqa: C901
                     ETagContent(current_etag, current_response.body),
                     ttl=ttl,
                 )
+                logger.debug("Updated cache entry; key=%s ttl=%s", cache_key, ttl)
 
             current_response.headers["Cache-Control"] = cache_control
             return current_response

fastapi_cachex/dependencies.py

@@ -4,8 +4,8 @@ from typing import Annotated
 
 from fastapi import Depends
 
-from fastapi_cachex.backends.base import BaseCacheBackend
-from fastapi_cachex.proxy import BackendProxy
+from .backends.base import BaseCacheBackend
+from .proxy import BackendProxy
 
 
 def get_cache_backend() -> BaseCacheBackend:

fastapi_cachex/proxy.py

@@ -1,9 +1,12 @@
 """Backend proxy for managing cache backend instances."""
 
-from fastapi_cachex.backends import BaseCacheBackend
-from fastapi_cachex.exceptions import BackendNotFoundError
+from logging import getLogger
+
+from .backends import BaseCacheBackend
+from .exceptions import BackendNotFoundError
 
 _default_backend: BaseCacheBackend | None = None
+logger = getLogger(__name__)
 
 
 class BackendProxy:
@@ -33,4 +36,8 @@ class BackendProxy:
             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

fastapi_cachex/routes.py

@@ -4,9 +4,10 @@ import time
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from fastapi_cachex.backends import BaseCacheBackend
-from fastapi_cachex.exceptions import BackendNotFoundError
-from fastapi_cachex.proxy import BackendProxy
+from .backends import BaseCacheBackend
+from .exceptions import BackendNotFoundError
+from .proxy import BackendProxy
+from .types import CACHE_KEY_SEPARATOR
 
 if TYPE_CHECKING:
     from fastapi import FastAPI
@@ -93,12 +94,12 @@ def _parse_cache_key(cache_key: str) -> tuple[str, str, str, str]:
     """Parse cache key into components.
 
     Args:
-        cache_key: Cache key in format method:host:path:query_params
+        cache_key: Cache key in format method|||host|||path|||query_params
 
     Returns:
         Tuple of (method, host, path, query_params)
     """
-    key_parts = cache_key.split(":", CACHE_KEY_MAX_PARTS)
+    key_parts = cache_key.split(CACHE_KEY_SEPARATOR, CACHE_KEY_MAX_PARTS)
     if len(key_parts) >= CACHE_KEY_MIN_PARTS:
         method, host, path = key_parts[0], key_parts[1], key_parts[2]
         query_params = key_parts[3] if len(key_parts) > CACHE_KEY_MIN_PARTS else ""

fastapi_cachex/session/__init__.py

@@ -0,0 +1,21 @@
+"""Session management extension for FastAPI-CacheX."""
+
+from .config import SessionConfig
+from .dependencies import get_optional_session
+from .dependencies import get_session
+from .dependencies import require_session
+from .manager import SessionManager
+from .middleware import SessionMiddleware
+from .models import Session
+from .models import SessionUser
+
+__all__ = [
+    "Session",
+    "SessionConfig",
+    "SessionManager",
+    "SessionMiddleware",
+    "SessionUser",
+    "get_optional_session",
+    "get_session",
+    "require_session",
+]