refactor: rename SerializationWrapper methods to be backend-agnostic (#28)

Remove Redis-specific naming from the generic serialization wrapper:
- wrap_for_redis() → wrap()
- unwrap_from_redis() → unwrap()

The SerializationWrapper creates a JSON envelope with base64-encoded
payload - this format is backend-agnostic and works with any cache
backend (Redis, CachekitIO, Memcached, etc.). The "redis" naming was
a historical artifact that incorrectly implied Redis coupling.

Also updated related docstrings/comments in cache_handler.py to use
"cache" instead of "Redis" for consistency.

Pre-commit fix: Use venv basedpyright directly with --level error to
avoid uv.lock modification and match Makefile behavior.

Author: 27Bslash6

.pre-commit-config.yaml

@@ -17,9 +17,10 @@ repos:
   - repo: local
     hooks:
       # Python type checking with basedpyright
+      # Uses venv directly to avoid uv run modifying uv.lock
       - id: basedpyright
         name: basedpyright
-        entry: uv run basedpyright src/
+        entry: .venv/bin/basedpyright src/ --level error
         language: system
         types: [python]
         pass_filenames: false

src/cachekit/cache_handler.py

@@ -339,7 +339,7 @@ class CacheSerializationHandler:
     - Tenant extraction: For multi-tenant encryption key isolation (FAIL CLOSED)
 
     Modes:
-    - encryption=False: Direct serialization (plaintext in Redis)
+    - encryption=False: Direct serialization (plaintext in cache)
     - encryption=True, tenant_extractor=None: Single-tenant encrypted (nil UUID)
     - encryption=True, tenant_extractor provided: Multi-tenant encrypted (FAIL CLOSED)
 
@@ -602,7 +602,7 @@ def serialize_data(
         kwargs: dict[str, Any] | None = None,
         cache_key: str = "",
     ) -> bytes:
-        """Serialize data for Redis storage with optional tenant context for encryption.
+        """Serialize data for cache storage with optional tenant context for encryption.
 
         Args:
             data: Data to serialize
@@ -612,7 +612,7 @@ def serialize_data(
                       Required when encryption is enabled to prevent ciphertext substitution.
 
         Returns:
-            Serialized data wrapped for Redis storage
+            Serialized data wrapped for cache storage
 
         Raises:
             ValueError: If tenant extraction fails in multi-tenant mode (FAIL CLOSED)
@@ -685,7 +685,7 @@ def serialize_data(
 
             # Convert metadata to dict if needed
             metadata_dict = metadata.to_dict() if hasattr(metadata, "to_dict") else {}
-            return SerializationWrapper.wrap_for_redis(serialized_data, metadata_dict, self._serializer_string_name)
+            return SerializationWrapper.wrap(serialized_data, metadata_dict, self._serializer_string_name)
         except ValueError:
             # Tenant extraction or cache_key missing - FAIL CLOSED (re-raise, don't catch)
             # This is a security violation: encryption requires valid tenant_id and cache_key
@@ -696,10 +696,10 @@ def serialize_data(
             raise SerializationError(f"Failed to serialize data with {self.serializer_name}: {e}") from e
 
     def deserialize_data(self, data: str | bytes, cache_key: str = "") -> Any:
-        """Deserialize data from Redis storage with cache_key verification.
+        """Deserialize data from cache storage with cache_key verification.
 
         Args:
-            data: Serialized data from Redis (may be encrypted)
+            data: Serialized data from cache (may be encrypted)
             cache_key: Cache key for AAD verification (SECURITY CRITICAL for encrypted data).
                       Required when data is encrypted to verify ciphertext binding.
 
@@ -743,8 +743,8 @@ def deserialize_data(self, data: str | bytes, cache_key: str = "") -> Any:
             True
         """
         try:
-            # Unwrap Redis data envelope
-            serialized_data, metadata_dict, serializer_name = SerializationWrapper.unwrap_from_redis(data)
+            # Unwrap cache data envelope
+            serialized_data, metadata_dict, serializer_name = SerializationWrapper.unwrap(data)
 
             # Convert metadata
             serialization_metadata = _get_cached_serializer_class("metadata", "cachekit.serializers.SerializationMetadata")

src/cachekit/serializers/wrapper.py

@@ -1,7 +1,7 @@
-"""Standard serialization wrapper for Redis storage.
+"""Standard serialization wrapper for cache storage.
 
 This module provides utilities for wrapping and unwrapping data with metadata
-for consistent Redis serialization across the codebase.
+for consistent serialization across all cache backends.
 """
 
 import base64
@@ -10,41 +10,54 @@
 
 
 class SerializationWrapper:
-    """Standard wrapper/unwrapper for Redis serialization data.
+    """Standard wrapper/unwrapper for cache serialization data.
 
-    Wraps serialized bytes with JSON envelope containing metadata for Redis storage.
+    Wraps serialized bytes with JSON envelope containing metadata for cache storage.
     The envelope format enables introspection of cached data without deserialization.
 
+    This wrapper is backend-agnostic and works with any cache backend (Redis,
+    CachekitIO, Memcached, etc.).
+
     Examples:
         Wrap and unwrap data:
 
         >>> data = b"serialized_bytes"
         >>> metadata = {"format": "msgpack", "compressed": True}
-        >>> wrapped = SerializationWrapper.wrap_for_redis(data, metadata, "auto")
+        >>> wrapped = SerializationWrapper.wrap(data, metadata, "auto")
         >>> isinstance(wrapped, bytes)
         True
 
         Unwrap returns original data, metadata, and serializer name:
 
-        >>> unwrapped_data, unwrapped_meta, serializer = SerializationWrapper.unwrap_from_redis(wrapped)
+        >>> unwrapped_data, unwrapped_meta, serializer = SerializationWrapper.unwrap(wrapped)
         >>> unwrapped_data == data
         True
         >>> unwrapped_meta["format"]
         'msgpack'
         >>> serializer
         'auto'
 
-        Works with string input (from Redis):
+        Works with string input (from cache backend):
 
         >>> wrapped_str = wrapped.decode("utf-8")
-        >>> unwrapped_data, _, _ = SerializationWrapper.unwrap_from_redis(wrapped_str)
+        >>> unwrapped_data, _, _ = SerializationWrapper.unwrap(wrapped_str)
         >>> unwrapped_data == data
         True
     """
 
     @staticmethod
-    def wrap_for_redis(data: bytes, metadata: dict, serializer_name: str, version: str = "2.0") -> bytes:
-        """Standard wrapper for Redis storage."""
+    def wrap(data: bytes, metadata: dict, serializer_name: str, version: str = "2.0") -> bytes:
+        """Wrap serialized data with metadata envelope for cache storage.
+
+        Args:
+            data: Serialized bytes to wrap
+            metadata: Serialization metadata dict (must include "format" key)
+            serializer_name: Name of serializer used (e.g., "default", "auto")
+            version: Envelope format version
+
+        Returns:
+            JSON-encoded bytes containing base64 data and metadata
+        """
         wrapper = {
             "data": base64.b64encode(data).decode("ascii"),
             "metadata": metadata,
@@ -54,16 +67,19 @@ def wrap_for_redis(data: bytes, metadata: dict, serializer_name: str, version: s
         return json.dumps(wrapper, ensure_ascii=False).encode("utf-8")
 
     @staticmethod
-    def unwrap_from_redis(redis_data: Union[str, bytes]) -> tuple[bytes, dict, str]:
-        """Standard unwrapper for Redis data.
+    def unwrap(wrapped_data: Union[str, bytes]) -> tuple[bytes, dict, str]:
+        """Unwrap data envelope from cache storage.
+
+        Args:
+            wrapped_data: JSON envelope (bytes or string) from cache backend
 
         Returns:
             tuple: (data_bytes, metadata_dict, serializer_name)
         """
-        if isinstance(redis_data, bytes):
-            redis_data = redis_data.decode("utf-8")
+        if isinstance(wrapped_data, bytes):
+            wrapped_data = wrapped_data.decode("utf-8")
 
-        wrapper = json.loads(redis_data)
+        wrapper = json.loads(wrapped_data)
         data = base64.b64decode(wrapper["data"].encode("ascii"))
         metadata = wrapper.get("metadata", {})
         serializer_name = wrapper.get("serializer", "unknown")

tests/unit/test_context_leak_regression.py

@@ -618,9 +618,9 @@ def ttl_refresh_mock_backend():
     # Serialize the value - returns (bytes, SerializationMetadata)
     serializer = StandardSerializer()
     raw_bytes, metadata = serializer.serialize(42)
-    # Convert metadata to dict for wrap_for_redis (needs "format" key)
+    # Convert metadata to dict for wrap (needs "format" key)
     metadata_dict = metadata.to_dict()
-    wrapped_data = SerializationWrapper.wrap_for_redis(
+    wrapped_data = SerializationWrapper.wrap(
         data=raw_bytes,
         metadata=metadata_dict,  # Must include "format" key from actual metadata
         serializer_name="default",  # Match StandardSerializer
@@ -810,7 +810,7 @@ def backend_without_ttl():
     serializer = StandardSerializer()
     raw_bytes, metadata = serializer.serialize(42)
     metadata_dict = metadata.to_dict()
-    wrapped_data = SerializationWrapper.wrap_for_redis(
+    wrapped_data = SerializationWrapper.wrap(
         data=raw_bytes,
         metadata=metadata_dict,
         serializer_name="default",