fastapi-cachex 0.2.11__tar.gz → 0.3.0__tar.gz

{fastapi_cachex-0.2.11 → fastapi_cachex-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachex
-Version: 0.2.11
+Version: 0.3.0
 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
@@ -23,7 +23,7 @@ Requires-Dist: fastapi
 Requires-Dist: pydantic
 Requires-Dist: pyjwt>=2.9.0 ; extra == 'jwt'
 Requires-Dist: pymemcache ; extra == 'memcache'
-Requires-Dist: redis[hiredis] ; extra == 'redis'
+Requires-Dist: redis[hiredis]>=5.3.0 ; extra == 'redis'
 Requires-Dist: orjson ; extra == 'redis'
 Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/allen0099/FastAPI-CacheX
@@ -146,6 +146,44 @@ async def remove_cache(cache: CacheBackend):
     await cache.clear_pattern("/path/to/clear/*")  # Clear cache for a specific pattern
 ```
 
+### Application-Level Caching (Manual Get/Set)
+
+Beyond HTTP response caching via `@cache`, you can cache arbitrary JSON-serializable
+Python values directly in your business logic using `CacheManager`. It's a thin,
+namespaced wrapper around whichever backend is configured via `BackendProxy`.
+
+```python
+from fastapi_cachex import AppCache, CacheManager
+
+@app.get("/expensive")
+async def expensive_operation(cache: AppCache):
+    result = await cache.get("expensive:result")
+    if result is None:
+        result = perform_expensive_calculation()
+        await cache.set("expensive:result", result, ttl=300)
+    return result
+
+
+# Or instantiate directly, e.g. outside of a request:
+manager = CacheManager(key_prefix="myapp:", default_ttl=60)
+await manager.set("user:42", {"name": "Alice"})
+user = await manager.get("user:42")  # {"name": "Alice"}
+await manager.delete("user:42")
+await manager.clear_prefix()  # clear everything under "myapp:"
+```
+
+`CacheManager.get()` returns `None` (or a supplied `default=`) on a cache miss —
+it never raises for missing or corrupted entries. `CacheManager` keys live under
+their own `cache:`-prefixed namespace by default, separate from the HTTP route
+cache and OAuth state, so `clear()`/`clear_prefix()` never touch unrelated cache
+entries.
+
+**Note**: `clear()`/`clear_prefix()` are implemented via the backend's
+`get_all_keys()`. Since Memcached doesn't support key enumeration (see
+[Memcached limitations](#memcached)), these two methods are no-ops on a
+Memcached backend — `get()`/`set()`/`delete()`/`has()` work normally. Use
+Redis or the in-memory backend if you need bulk clearing.
+
 ## Backend Configuration
 
 FastAPI-CacheX supports multiple caching backends. You can easily switch between them using the `BackendProxy`.
@@ -166,6 +204,8 @@ This ensures that:
 
 All backends automatically namespace keys with a prefix (e.g., `fastapi_cachex:`) to avoid conflicts with other applications.
 
+`CacheManager` (see [Application-Level Caching](#application-level-caching-manual-getset)) uses a separate, simpler `cache:`-prefixed key namespace instead of this `|||`-separated format, since its keys aren't tied to HTTP requests.
+
 ### Cache Hit Behavior
 
 When a cached entry is valid (within TTL):

{fastapi_cachex-0.2.11 → fastapi_cachex-0.3.0}/README.md

@@ -110,6 +110,44 @@ async def remove_cache(cache: CacheBackend):
     await cache.clear_pattern("/path/to/clear/*")  # Clear cache for a specific pattern
 ```
 
+### Application-Level Caching (Manual Get/Set)
+
+Beyond HTTP response caching via `@cache`, you can cache arbitrary JSON-serializable
+Python values directly in your business logic using `CacheManager`. It's a thin,
+namespaced wrapper around whichever backend is configured via `BackendProxy`.
+
+```python
+from fastapi_cachex import AppCache, CacheManager
+
+@app.get("/expensive")
+async def expensive_operation(cache: AppCache):
+    result = await cache.get("expensive:result")
+    if result is None:
+        result = perform_expensive_calculation()
+        await cache.set("expensive:result", result, ttl=300)
+    return result
+
+
+# Or instantiate directly, e.g. outside of a request:
+manager = CacheManager(key_prefix="myapp:", default_ttl=60)
+await manager.set("user:42", {"name": "Alice"})
+user = await manager.get("user:42")  # {"name": "Alice"}
+await manager.delete("user:42")
+await manager.clear_prefix()  # clear everything under "myapp:"
+```
+
+`CacheManager.get()` returns `None` (or a supplied `default=`) on a cache miss —
+it never raises for missing or corrupted entries. `CacheManager` keys live under
+their own `cache:`-prefixed namespace by default, separate from the HTTP route
+cache and OAuth state, so `clear()`/`clear_prefix()` never touch unrelated cache
+entries.
+
+**Note**: `clear()`/`clear_prefix()` are implemented via the backend's
+`get_all_keys()`. Since Memcached doesn't support key enumeration (see
+[Memcached limitations](#memcached)), these two methods are no-ops on a
+Memcached backend — `get()`/`set()`/`delete()`/`has()` work normally. Use
+Redis or the in-memory backend if you need bulk clearing.
+
 ## Backend Configuration
 
 FastAPI-CacheX supports multiple caching backends. You can easily switch between them using the `BackendProxy`.
@@ -130,6 +168,8 @@ This ensures that:
 
 All backends automatically namespace keys with a prefix (e.g., `fastapi_cachex:`) to avoid conflicts with other applications.
 
+`CacheManager` (see [Application-Level Caching](#application-level-caching-manual-getset)) uses a separate, simpler `cache:`-prefixed key namespace instead of this `|||`-separated format, since its keys aren't tied to HTTP requests.
+
 ### Cache Hit Behavior
 
 When a cached entry is valid (within TTL):

fastapi_cachex-0.3.0/fastapi_cachex/__init__.py

@@ -0,0 +1,78 @@
+"""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 AppCache as AppCache
+from .dependencies import CacheBackend as CacheBackend
+from .dependencies import get_app_cache as get_app_cache
+from .dependencies import get_cache_backend as get_cache_backend
+from .manager import CacheManager as CacheManager
+from .manager_proxy import CacheManagerProxy as CacheManagerProxy
+from .proxy import BackendProxy as BackendProxy
+from .routes import add_routes as add_routes
+from .session import Session as Session
+from .session import SessionConfig as SessionConfig
+from .session import SessionManager as SessionManager
+from .session import SessionManagerProxy as SessionManagerProxy
+from .session import SessionMiddleware as SessionMiddleware
+from .session import SessionUser as SessionUser
+from .session import get_optional_session as get_optional_session
+from .session import get_session as get_session
+from .session import get_session_manager as get_session_manager
+from .session import require_session as require_session
+from .session.exceptions import SessionError as SessionError
+from .session.exceptions import SessionExpiredError as SessionExpiredError
+from .session.exceptions import SessionInvalidError as SessionInvalidError
+from .session.exceptions import SessionNotFoundError as SessionNotFoundError
+from .session.exceptions import SessionSecurityError as SessionSecurityError
+from .session.exceptions import SessionTokenError as SessionTokenError
+from .state import InvalidStateError as InvalidStateError
+from .state import StateData as StateData
+from .state import StateDataError as StateDataError
+from .state import StateError as StateError
+from .state import StateExpiredError as StateExpiredError
+from .state import StateManager as StateManager
+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.
+
+__all__ = [
+    "AppCache",
+    "BackendProxy",
+    "CacheBackend",
+    "CacheKeyBuilder",
+    "CacheManager",
+    "CacheManagerProxy",
+    "InvalidStateError",
+    "Session",
+    "SessionConfig",
+    "SessionError",
+    "SessionExpiredError",
+    "SessionInvalidError",
+    "SessionManager",
+    "SessionManagerProxy",
+    "SessionMiddleware",
+    "SessionNotFoundError",
+    "SessionSecurityError",
+    "SessionTokenError",
+    "SessionUser",
+    "StateData",
+    "StateDataError",
+    "StateError",
+    "StateExpiredError",
+    "StateManager",
+    "add_routes",
+    "cache",
+    "default_key_builder",
+    "get_app_cache",
+    "get_cache_backend",
+    "get_optional_session",
+    "get_session",
+    "get_session_manager",
+    "require_session",
+]

{fastapi_cachex-0.2.11 → fastapi_cachex-0.3.0}/fastapi_cachex/backends/base.py

@@ -4,18 +4,18 @@ from abc import ABC
 from abc import abstractmethod
 from typing import Any
 
-from fastapi_cachex.types import ETagContent
+from fastapi_cachex.types import CacheEntry
 
 
 class BaseCacheBackend(ABC):
     """Base class for all cache backends."""
 
     @abstractmethod
-    async def get(self, key: str) -> ETagContent | None:
+    async def get(self, key: str) -> CacheEntry | None:
         """Retrieve a cached response."""
 
     @abstractmethod
-    async def set(self, key: str, value: ETagContent, ttl: int | None = None) -> None:
+    async def set(self, key: str, value: CacheEntry, ttl: int | None = None) -> None:
         """Store a response in the cache."""
 
     @abstractmethod

fastapi_cachex-0.3.0/fastapi_cachex/backends/config.py

@@ -0,0 +1,40 @@
+"""Configuration models for cache backends."""
+
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import SecretStr
+
+DEFAULT_REDIS_PREFIX = "fastapi_cachex:"
+
+
+class RedisConfig(BaseModel):
+    """Configuration for Redis backend."""
+
+    host: str = Field(default="localhost", description="Redis server address")
+    port: int = Field(default=6379, ge=1, le=65535, description="Redis server port")
+    password: SecretStr | None = Field(
+        default=None, description="Redis server password"
+    )
+    db: int = Field(default=0, ge=0, description="Redis database number")
+    encoding: str = Field(default="utf-8", description="Character encoding to use")
+    socket_timeout: float = Field(
+        default=1.0, description="Timeout for socket operations in seconds"
+    )
+    socket_connect_timeout: float = Field(
+        default=1.0, description="Timeout for socket connection in seconds"
+    )
+    key_prefix: str = Field(
+        default=DEFAULT_REDIS_PREFIX,
+        description="Prefix applied to all cache keys",
+    )
+    protocol: int = Field(
+        default=2,
+        ge=2,
+        le=3,
+        description=(
+            "RESP protocol version (2 or 3). "
+            "Keep at 2 (default) unless you need RESP3 features and your hiredis "
+            "version supports it (hiredis >= 3.0 is required for RESP3). "
+            "Redis 8.0 supports RESP3 but older hiredis builds do not."
+        ),
+    )

{fastapi_cachex-0.2.11 → fastapi_cachex-0.3.0}/fastapi_cachex/backends/memcached.py

@@ -1,10 +1,11 @@
 """Memcached cache backend implementation."""
 
+import asyncio
 import logging
 import warnings
 
 from fastapi_cachex.exceptions import CacheXError
-from fastapi_cachex.types import ETagContent
+from fastapi_cachex.types import CacheEntry
 
 from .base import BaseCacheBackend
 
@@ -62,55 +63,52 @@ class MemcachedBackend(BaseCacheBackend):
         """Add prefix to cache key."""
         return f"{self.key_prefix}{key}"
 
-    async def get(self, key: str) -> ETagContent | None:
+    async def get(self, key: str) -> CacheEntry | None:
         """Get value from cache.
 
         Args:
             key: Cache key to retrieve
 
         Returns:
-            Optional[ETagContent]: Cached value with ETag if exists, None otherwise
+            Cached entry if found, None otherwise
         """
         prefixed_key = self._make_key(key)
-        value = self.client.get(prefixed_key)
+        value = await asyncio.to_thread(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"))
+            data = json.loads(value)
             logger.debug("Memcached HIT; key=%s", key)
-            return ETagContent(
-                etag=data["etag"],
-                content=data["content"].encode()
-                if isinstance(data["content"], str)
-                else data["content"],
+            return CacheEntry(
+                fingerprint=data["fingerprint"],
+                content=data["content"].encode("latin-1"),
+                media_type=data.get("media_type"),
             )
         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:
+    async def set(self, key: str, value: CacheEntry, ttl: int | None = None) -> None:
         """Set value in cache.
 
         Args:
             key: Cache key
-            value: ETagContent to store
+            value: CacheEntry instance to store
             ttl: Time to live in seconds
         """
         prefixed_key = self._make_key(key)
 
-        # Prepare content for JSON serialization
-        if isinstance(value.content, bytes):
-            content = value.content.decode()
-        else:
-            content = value.content
+        # Use latin-1 to round-trip arbitrary bytes through JSON storage
+        content = value.content.decode("latin-1")
 
         serialized_data: str | bytes = json.dumps(
             {
-                "etag": value.etag,
+                "fingerprint": value.fingerprint,
                 "content": content,
+                "media_type": value.media_type,
             },
         )
 
@@ -121,11 +119,8 @@ class MemcachedBackend(BaseCacheBackend):
             else serialized_data.encode("utf-8")
         )
 
-        self.client.set(
-            prefixed_key,
-            serialized_bytes,
-            expire=ttl if ttl is not None else 0,
-        )
+        expire = ttl if ttl is not None else 0
+        await asyncio.to_thread(self.client.set, prefixed_key, serialized_bytes, expire)
         logger.debug("Memcached SET; key=%s ttl=%s", key, ttl)
 
     async def delete(self, key: str) -> None:
@@ -134,7 +129,8 @@ class MemcachedBackend(BaseCacheBackend):
         Args:
             key: Cache key to delete
         """
-        self.client.delete(self._make_key(key))
+        prefixed = self._make_key(key)
+        await asyncio.to_thread(self.client.delete, prefixed)
         logger.debug("Memcached DELETE; key=%s", key)
 
     async def clear(self) -> None:
@@ -150,7 +146,7 @@ class MemcachedBackend(BaseCacheBackend):
             RuntimeWarning,
             stacklevel=2,
         )
-        self.client.flush_all()
+        await asyncio.to_thread(self.client.flush_all)
         logger.debug("Memcached CLEAR; flush_all issued")
 
     async def clear_path(self, path: str, include_params: bool = False) -> int:
@@ -181,7 +177,7 @@ class MemcachedBackend(BaseCacheBackend):
         # Try to delete the prefixed key (exact match only)
         prefixed_key = self._make_key(path)
         try:
-            result = self.client.delete(prefixed_key, noreply=False)
+            result = await asyncio.to_thread(self.client.delete, prefixed_key, False)
         except Exception:  # noqa: BLE001
             return 0
         else:
@@ -238,7 +234,7 @@ class MemcachedBackend(BaseCacheBackend):
         logger.debug("Memcached GET_ALL_KEYS unsupported; returning empty list")
         return []
 
-    async def get_cache_data(self) -> dict[str, tuple[ETagContent, float | None]]:
+    async def get_cache_data(self) -> dict[str, tuple[CacheEntry, float | None]]:
         """Get all cache data with expiry information.
 
         Note: Memcached does not support key enumeration or pattern matching.

{fastapi_cachex-0.2.11 → fastapi_cachex-0.3.0}/fastapi_cachex/backends/memory.py

@@ -1,14 +1,13 @@
 """In-memory cache backend implementation."""
 
 import asyncio
-import contextlib
 import fnmatch
 import logging
 import time
 
 from fastapi_cachex.types import CACHE_KEY_SEPARATOR
+from fastapi_cachex.types import CacheEntry
 from fastapi_cachex.types import CacheItem
-from fastapi_cachex.types import ETagContent
 
 from .base import BaseCacheBackend
 
@@ -44,13 +43,16 @@ class MemoryBackend(BaseCacheBackend):
     def _ensure_cleanup_started(self) -> None:
         """Ensure cleanup task is started in proper async context."""
         if self._cleanup_task is None or self._cleanup_task.done():
-            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,
-                )
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                # No running event loop yet; defer until first real async call.
+                return
+            self._cleanup_task = loop.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.
@@ -66,7 +68,7 @@ class MemoryBackend(BaseCacheBackend):
             self._cleanup_task = None
             logger.debug("Stopped memory backend cleanup task")
 
-    async def get(self, key: str) -> ETagContent | None:
+    async def get(self, key: str) -> CacheEntry | None:
         """Retrieve a cached response.
 
         Expired entries are skipped and return None.
@@ -87,7 +89,7 @@ class MemoryBackend(BaseCacheBackend):
             logger.debug("Memory cache MISS; key=%s", key)
             return None
 
-    async def set(self, key: str, value: ETagContent, ttl: int | None = None) -> None:
+    async def set(self, key: str, value: CacheEntry, ttl: int | None = None) -> None:
         """Store a response in the cache.
 
         Args:
@@ -199,11 +201,11 @@ class MemoryBackend(BaseCacheBackend):
         async with self.lock:
             return list(self.cache.keys())
 
-    async def get_cache_data(self) -> dict[str, tuple[ETagContent, float | None]]:
+    async def get_cache_data(self) -> dict[str, tuple[CacheEntry, float | None]]:
         """Get all cache data with expiry information.
 
         Returns:
-            Dictionary mapping cache keys to (ETagContent, expiry) tuples
+            Dictionary mapping cache keys to (CacheEntry, expiry) tuples
         """
         async with self.lock:
             return {key: (item.value, item.expiry) for key, item in self.cache.items()}

{fastapi_cachex-0.2.11 → fastapi_cachex-0.3.0}/fastapi_cachex/backends/redis.py

@@ -5,10 +5,13 @@ from typing import TYPE_CHECKING
 from typing import Any
 from typing import Literal
 
+from fastapi_cachex.backends.config import (
+    DEFAULT_REDIS_PREFIX as DEFAULT_REDIS_PREFIX,  # noqa: PLC0414
+)
 from fastapi_cachex.backends.config import RedisConfig
 from fastapi_cachex.exceptions import CacheXError
 from fastapi_cachex.types import CACHE_KEY_SEPARATOR
-from fastapi_cachex.types import ETagContent
+from fastapi_cachex.types import CacheEntry
 
 from .base import BaseCacheBackend
 
@@ -23,8 +26,7 @@ except ImportError:  # pragma: no cover
 
 logger = logging.getLogger(__name__)
 
-# Default Redis key prefix for fastapi-cachex
-DEFAULT_REDIS_PREFIX = "fastapi_cachex:"
+# Default Redis key prefix for fastapi-cachex — re-exported from config for convenience
 
 
 class AsyncRedisCacheBackend(BaseCacheBackend):
@@ -48,6 +50,7 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
         socket_timeout: float = 1.0,
         socket_connect_timeout: float = 1.0,
         key_prefix: str = DEFAULT_REDIS_PREFIX,
+        protocol: int = 2,
         **kwargs: Any,
     ) -> None:
         """Initialize async Redis cache backend.
@@ -62,6 +65,9 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
             socket_timeout: Timeout for socket operations (in seconds)
             socket_connect_timeout: Timeout for socket connection (in seconds)
             key_prefix: Prefix for all cache keys (default: 'fastapi_cachex:')
+            protocol: RESP protocol version (2 or 3). Defaults to 2 (RESP2) for
+                broadest compatibility. Use 3 only when hiredis >= 3.0 is installed
+                and Redis 8.0+ RESP3 features are required.
             **kwargs: Additional arguments to pass to Redis client
         """
         try:
@@ -76,6 +82,9 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
             )
             raise CacheXError(msg)
 
+        # `protocol` is not in the types-redis stubs (added in redis-py 5.x).
+        # Pass it via **kwargs so mypy doesn't complain about an unknown keyword.
+        kwargs.setdefault("protocol", protocol)
         self.client = AsyncRedis(
             host=host,
             port=port,
@@ -104,31 +113,36 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
             password=config.password.get_secret_value()
             if config.password is not None
             else None,
+            db=config.db,
+            encoding=config.encoding,
+            socket_timeout=config.socket_timeout,
+            socket_connect_timeout=config.socket_connect_timeout,
+            key_prefix=config.key_prefix,
+            protocol=config.protocol,
         )
 
     def _make_key(self, key: str) -> str:
         """Add prefix to cache key."""
         return f"{self.key_prefix}{key}"
 
-    def _serialize(self, value: ETagContent) -> str:
-        """Serialize ETagContent to JSON string."""
-        if isinstance(value.content, bytes):
-            content = value.content.decode()
-        else:
-            content = value.content
+    def _serialize(self, value: CacheEntry) -> str:
+        """Serialize CacheEntry to JSON string."""
+        # Use latin-1 to round-trip arbitrary bytes through JSON/UTF-8 Redis storage
+        content = value.content.decode("latin-1")
 
         serialized: str | bytes = json.dumps(
             {
-                "etag": value.etag,
+                "fingerprint": value.fingerprint,
                 "content": content,
+                "media_type": value.media_type,
             },
         )
 
         # orjson returns bytes, stdlib json returns str
         return serialized.decode() if isinstance(serialized, bytes) else serialized
 
-    def _deserialize(self, value: str | None) -> ETagContent | None:
-        """Deserialize JSON string to ETagContent.
+    def _deserialize(self, value: str | None) -> CacheEntry | None:
+        """Deserialize JSON string to CacheEntry.
 
         Converts string content back to bytes to maintain consistency with
         other backends and standard Response.body type (bytes).
@@ -138,30 +152,26 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
         try:
             data = json.loads(value)
             logger.debug("Content type in JSON: %s", type(data["content"]))
-            return ETagContent(
-                etag=data["etag"],
-                content=data["content"].encode()
-                if isinstance(data["content"], str)
-                else data["content"],
+            return CacheEntry(
+                fingerprint=data["fingerprint"],
+                content=data["content"].encode("latin-1"),
+                media_type=data.get("media_type"),
             )
-        except (json.JSONDecodeError, KeyError):
+        except (json.JSONDecodeError, KeyError, AttributeError):
             return None
 
-    async def get(self, key: str) -> ETagContent | None:
+    async def get(self, key: str) -> CacheEntry | None:
         """Retrieve a cached response."""
         result = await self.client.get(self._make_key(key))
         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:
+    async def set(self, key: str, value: CacheEntry, ttl: int | None = None) -> None:
         """Store a response in the cache."""
         serialized = self._serialize(value)
         prefixed_key = self._make_key(key)
-        if ttl is not None:
-            await self.client.setex(prefixed_key, ttl, serialized)
-        else:
-            await self.client.set(prefixed_key, serialized)
+        await self.client.set(prefixed_key, serialized, ex=ttl)
         logger.debug("Redis SET; key=%s ttl=%s", key, ttl)
 
     async def delete(self, key: str) -> None:
@@ -317,7 +327,7 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
         """Get all cache keys in the backend.
 
         Returns:
-            List of all cache keys currently stored in the backend
+            List of logical cache keys (without the backend key prefix)
         """
         pattern = f"{self.key_prefix}*"
         cursor = 0
@@ -336,28 +346,34 @@ class AsyncRedisCacheBackend(BaseCacheBackend):
             if cursor == 0:
                 break
 
-        logger.debug("Redis GET_ALL_KEYS; count=%s", len(all_keys))
-        return all_keys
+        logical_keys = [k.removeprefix(self.key_prefix) for k in all_keys]
+        logger.debug("Redis GET_ALL_KEYS; count=%s", len(logical_keys))
+        return logical_keys
 
-    async def get_cache_data(self) -> dict[str, tuple[ETagContent, float | None]]:
+    async def get_cache_data(self) -> dict[str, tuple[CacheEntry, float | None]]:
         """Get all cache data with expiry information.
 
         Returns:
-            Dictionary mapping cache keys to (ETagContent, expiry) tuples.
+            Dictionary mapping cache keys to (CacheEntry, expiry) tuples.
             Note: Redis stores TTL but not absolute expiry time, so this
             returns None for expiry (no expiry tracking in Redis backend).
         """
         all_keys = await self.get_all_keys()
-        cache_data: dict[str, tuple[ETagContent, float | None]] = {}
+        cache_data: dict[str, tuple[CacheEntry, float | None]] = {}
+
+        if not all_keys:
+            return cache_data
 
-        for prefixed_key in all_keys:
-            # Remove prefix to get the original cache key
-            original_key = prefixed_key.removeprefix(self.key_prefix)
+        # Fetch all values in a single pipeline round-trip instead of N+1 GETs
+        pipe = self.client.pipeline()
+        for key in all_keys:
+            pipe.get(self._make_key(key))
+        raw_values: list[str | None] = await pipe.execute()
 
-            # Get the value using the original key (get() adds prefix internally)
-            value = await self.get(original_key)
+        for key, raw in zip(all_keys, raw_values, strict=False):
+            value = self._deserialize(raw)
             if value is not None:
-                cache_data[original_key] = (value, None)
+                cache_data[key] = (value, None)
 
         logger.debug("Redis GET_CACHE_DATA; keys=%s", len(cache_data))
         return cache_data