Address CodeRabbit review feedback

- Replace truthiness checks with explicit None checks in BasePydanticAdapter to correctly handle empty dicts/lists
- Validate missing 'items' wrapper for list models instead of silently accepting malformed payloads
- Restrict list model detection to only 'list' type (not all Sequence types) in DataclassAdapter
- Update @bear_spray comment to accurately describe why it's needed
- Include type in error message for missing type argument
- Add edge-case tests for empty list TTL and missing 'items' wrapper scenarios
- All 28 adapter tests passing, linting and type checking clean

Co-authored-by: William Easton <strawgate@users.noreply.github.com>

Author: github-actions[bot]

key-value/key-value-aio/src/key_value/aio/adapters/base/adapter.py

@@ -53,7 +53,12 @@ def _validate_model(self, value: dict[str, Any]) -> T | None:
         """
         try:
             if self._is_list_model:
-                return self._type_adapter.validate_python(value.get("items", []))
+                if "items" not in value:
+                    if self._raise_on_validation_error:
+                        msg = f"Invalid {self._get_model_type_name()} payload: missing 'items' wrapper"
+                        raise DeserializationError(msg)
+                    return None
+                return self._type_adapter.validate_python(value["items"])
 
             return self._type_adapter.validate_python(value)
         except ValidationError as e:
@@ -115,7 +120,8 @@ async def get(self, key: str, *, collection: str | None = None, default: T | Non
         """
         collection = collection or self._default_collection
 
-        if value := await self._key_value.get(key=key, collection=collection):
+        value = await self._key_value.get(key=key, collection=collection)
+        if value is not None:
             validated = self._validate_model(value=value)
             if validated is not None:
                 return validated
@@ -218,7 +224,8 @@ async def ttl(self, key: str, *, collection: str | None = None) -> tuple[T | Non
         if entry is None:
             return (None, None)
 
-        if validated_model := self._validate_model(value=entry):
+        validated_model = self._validate_model(value=entry)
+        if validated_model is not None:
             return (validated_model, ttl_info)
 
         return (None, None)
@@ -229,4 +236,4 @@ async def ttl_many(self, keys: Sequence[str], *, collection: str | None = None)
 
         entries: list[tuple[dict[str, Any] | None, float | None]] = await self._key_value.ttl_many(keys=keys, collection=collection)
 
-        return [(self._validate_model(value=entry) if entry else None, ttl_info) for entry, ttl_info in entries]
+        return [(self._validate_model(value=entry) if entry is not None else None, ttl_info) for entry, ttl_info in entries]

key-value/key-value-aio/src/key_value/aio/adapters/dataclass/adapter.py

@@ -1,4 +1,3 @@
-from collections.abc import Sequence
 from dataclasses import is_dataclass
 from typing import Any, TypeVar, get_args, get_origin
 
@@ -20,8 +19,8 @@ class DataclassAdapter(BasePydanticAdapter[T]):
 
     _inner_type: type[Any]
 
-    # Beartype doesn't like our `type[T]` includes a bound on Sequence[...] as the subscript is not checkable at runtime
-    # For just the next 20 or so lines we are no longer bear bros but have no fear, we will be back soon!
+    # Beartype cannot handle the parameterized type annotation (type[T]) used here for this generic dataclass adapter.
+    # Using @bear_spray to bypass beartype's runtime checks for this specific method.
     @bear_spray
     def __init__(
         self,
@@ -44,13 +43,13 @@ def __init__(
         self._key_value = key_value
 
         origin = get_origin(dataclass_type)
-        self._is_list_model = origin is not None and isinstance(origin, type) and issubclass(origin, Sequence)
+        self._is_list_model = origin is list
 
         # Extract the inner type for list models
         if self._is_list_model:
             args = get_args(dataclass_type)
             if not args:
-                msg = "List type must have a type argument"
+                msg = f"List type {dataclass_type} must have a type argument"
                 raise TypeError(msg)
             self._inner_type = args[0]
         else:

key-value/key-value-aio/tests/adapters/test_dataclass.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from datetime import datetime, timezone
+from typing import Any
 
 import pytest
 from inline_snapshot import snapshot
@@ -225,3 +226,28 @@ async def test_default_collection(self, store: MemoryStore):
         assert cached_user == SAMPLE_USER
 
         assert await adapter.delete(key=TEST_KEY)
+
+    async def test_ttl_with_empty_list(self, product_list_adapter: DataclassAdapter[list[Product]]):
+        """Test that TTL with empty list returns correctly (not None)."""
+        await product_list_adapter.put(collection=TEST_COLLECTION, key=TEST_KEY, value=[], ttl=10)
+        value, ttl = await product_list_adapter.ttl(collection=TEST_COLLECTION, key=TEST_KEY)
+        assert value == []
+        assert ttl is not None
+        assert ttl > 0
+
+    async def test_list_payload_missing_items_returns_none(self, product_list_adapter: DataclassAdapter[list[Product]], store: MemoryStore):
+        """Test that list payload without 'items' wrapper returns None when raise_on_validation_error is False."""
+        # Manually insert malformed payload without the 'items' wrapper
+        # The payload is a dict but without the expected 'items' key for list models
+        malformed_payload: dict[str, Any] = {"wrong": []}
+        await store.put(collection=TEST_COLLECTION, key=TEST_KEY, value=malformed_payload)
+        assert await product_list_adapter.get(collection=TEST_COLLECTION, key=TEST_KEY) is None
+
+    async def test_list_payload_missing_items_raises(self, product_list_adapter: DataclassAdapter[list[Product]], store: MemoryStore):
+        """Test that list payload without 'items' wrapper raises DeserializationError when configured."""
+        product_list_adapter._raise_on_validation_error = True  # pyright: ignore[reportPrivateUsage]
+        # Manually insert malformed payload without the 'items' wrapper
+        malformed_payload: dict[str, Any] = {"wrong": []}
+        await store.put(collection=TEST_COLLECTION, key=TEST_KEY, value=malformed_payload)
+        with pytest.raises(DeserializationError, match="missing 'items'"):
+            await product_list_adapter.get(collection=TEST_COLLECTION, key=TEST_KEY)