Implement .values() method for dictionary field projection

Add Django-style .values() method to return query results as dictionaries:
- .values() returns all fields as dicts
- .values('field1', 'field2') returns specific fields as dicts
- Uses Redis RETURN clause for efficient field projection
- Extensible design supports future .only() method for partial models

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: abrookins

aredis_om/model/model.py

@@ -420,6 +420,7 @@ def __init__(
         sort_fields: Optional[List[str]] = None,
         projected_fields: Optional[List[str]] = None,
         nocontent: bool = False,
+        return_as_dict: bool = False,
     ):
         if not has_redisearch(model.db()):
             raise RedisModelError(
@@ -448,6 +449,8 @@ def __init__(
         else:
             self.projected_fields = []
 
+        self.return_as_dict = return_as_dict
+
         self._expression = None
         self._query: Optional[str] = None
         self._pagination: List[str] = []
@@ -461,7 +464,9 @@ def dict(self) -> Dict[str, Any]:
             limit=self.limit,
             expressions=copy(self.expressions),
             sort_fields=copy(self.sort_fields),
+            projected_fields=copy(self.projected_fields),
             nocontent=self.nocontent,
+            return_as_dict=self.return_as_dict,
         )
 
     def copy(self, **kwargs):
@@ -946,9 +951,15 @@ async def execute(
             return raw_result
         count = raw_result[0]
 
-        # If we're using field projection, return dictionaries instead of model instances
-        if self.projected_fields:
-            results = self._parse_projected_results(raw_result)
+        # If we're using field projection or explicitly requesting dict output, 
+        # return dictionaries instead of model instances
+        if self.projected_fields or self.return_as_dict:
+            if self.projected_fields:
+                results = self._parse_projected_results(raw_result)
+            else:
+                # Return all fields as dicts - need to convert from model instances
+                model_results = self.model.from_redis(raw_result, self.knn)
+                results = [model.model_dump() for model in model_results]
         else:
             results = self.model.from_redis(raw_result, self.knn)
         self._model_cache += results
@@ -1005,10 +1016,23 @@ def sort_by(self, *fields: str):
             return self
         return self.copy(sort_fields=list(fields))
 
-    def return_fields(self, *fields: str):
+    def values(self, *fields: str):
+        """
+        Return query results as dictionaries instead of model instances.
+        
+        If no fields are specified, returns all fields.
+        If fields are specified, returns only those fields.
+        
+        Usage:
+            await Model.find().values()  # All fields as dicts
+            await Model.find().values('name', 'email')  # Only specified fields
+        """
         if not fields:
-            return self
-        return self.copy(projected_fields=list(fields))
+            # Return all fields as dicts
+            return self.copy(return_as_dict=True)
+        else:
+            # Return specific fields as dicts
+            return self.copy(return_as_dict=True, projected_fields=list(fields))
 
     async def update(self, use_transaction=True, **field_values):
         """

tests/test_hash_model.py

@@ -1134,14 +1134,15 @@ class Meta:
 
 
 @py_test_mark_asyncio
-async def test_return_specified_fields(members, m):
+async def test_values_method_with_specific_fields(members, m):
     member1, member2, member3 = members
-    actual = (
-        await m.Member.find(
+    actual = await (
+        m.Member.find(
             (m.Member.first_name == "Andrew") & (m.Member.last_name == "Brookins")
             | (m.Member.last_name == "Smith")
         )
-        .return_fields("first_name", "last_name")
+        .sort_by("last_name")
+        .values("first_name", "last_name")
         .all()
     )
     assert actual == [
@@ -1150,6 +1151,23 @@ async def test_return_specified_fields(members, m):
     ]
 
 
+@py_test_mark_asyncio
+async def test_values_method_all_fields(members, m):
+    member1, member2, member3 = members
+    actual = await m.Member.find(m.Member.first_name == "Andrew").values().all()
+    
+    # Check that it returns all fields as dicts
+    assert len(actual) == 2  # Should find Andrew Brookins and Andrew Smith
+    # Verify it contains all fields as dictionaries
+    for result in actual:
+        assert "first_name" in result
+        assert "last_name" in result
+        assert "email" in result
+        assert "age" in result
+        assert "pk" in result  # Should include primary key
+        assert result["first_name"] == "Andrew"
+
+
 @py_test_mark_asyncio
 async def test_can_search_on_multiple_fields_with_geo_filter(key_prefix, redis):
     class Location(HashModel, index=True):

tests/test_json_model.py

@@ -957,14 +957,15 @@ class TypeWithUuid(JsonModel, index=True):
 
 
 @py_test_mark_asyncio
-async def test_return_specified_fields(members, m):
+async def test_values_method_with_specific_fields(members, m):
     member1, member2, member3 = members
-    actual = (
-        await m.Member.find(
+    actual = await (
+        m.Member.find(
             (m.Member.first_name == "Andrew") & (m.Member.last_name == "Brookins")
             | (m.Member.last_name == "Smith")
         )
-        .return_fields("first_name", "last_name")
+        .sort_by("last_name")
+        .values("first_name", "last_name")
         .all()
     )
     assert actual == [
@@ -973,6 +974,23 @@ async def test_return_specified_fields(members, m):
     ]
 
 
+@py_test_mark_asyncio
+async def test_values_method_all_fields(members, m):
+    member1, member2, member3 = members
+    actual = await m.Member.find(m.Member.first_name == "Andrew").values().all()
+    
+    # Check that it returns all fields as dicts
+    assert len(actual) == 2  # Should find Andrew Brookins and Andrew Smith
+    # Verify it contains all fields as dictionaries
+    for result in actual:
+        assert "first_name" in result
+        assert "last_name" in result
+        assert "email" in result
+        assert "age" in result
+        assert "pk" in result  # Should include primary key
+        assert result["first_name"] == "Andrew"
+
+
 @py_test_mark_asyncio
 async def test_type_with_enum():
     class TestEnum(Enum):