Raise ValueError for empty attributes in delete_by_attributes

- Changed delete_by_attributes() to raise ValueError instead of returning {"deleted_entries_count": 0}
- Changed adelete_by_attributes() to raise ValueError instead of returning {"deleted_entries_count": 0}
- Updated docstrings to indicate attributes cannot be empty and document the ValueError
- Updated tests to verify ValueError is raised with empty attributes
- Error message: "Cannot delete by attributes with an empty attributes dictionary."

Co-authored-by: abrookins <97182+abrookins@users.noreply.github.com>

Author: Copilot

redisvl/extensions/cache/llm/langcache.py

@@ -582,14 +582,18 @@ def delete_by_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
 
         Args:
             attributes (Dict[str, Any]): Attributes to match for deletion.
-                If empty, no deletion is performed.
+                Cannot be empty.
 
         Returns:
             Dict[str, Any]: Result of the deletion operation.
+
+        Raises:
+            ValueError: If attributes is an empty dictionary.
         """
         if not attributes:
-            # No attributes provided, return result with zero deletions
-            return {"deleted_entries_count": 0}
+            raise ValueError(
+                "Cannot delete by attributes with an empty attributes dictionary."
+            )
         result = self._client.delete_query(attributes=attributes)
         # Convert DeleteQueryResponse to dict
         return result.model_dump() if hasattr(result, "model_dump") else {}
@@ -599,14 +603,18 @@ async def adelete_by_attributes(self, attributes: Dict[str, Any]) -> Dict[str, A
 
         Args:
             attributes (Dict[str, Any]): Attributes to match for deletion.
-                If empty, no deletion is performed.
+                Cannot be empty.
 
         Returns:
             Dict[str, Any]: Result of the deletion operation.
+
+        Raises:
+            ValueError: If attributes is an empty dictionary.
         """
         if not attributes:
-            # No attributes provided, return result with zero deletions
-            return {"deleted_entries_count": 0}
+            raise ValueError(
+                "Cannot delete by attributes with an empty attributes dictionary."
+            )
         result = await self._client.delete_query_async(attributes=attributes)
         # Convert DeleteQueryResponse to dict
         return result.model_dump() if hasattr(result, "model_dump") else {}

tests/unit/test_langcache_semantic_cache.py

@@ -455,24 +455,22 @@ def test_delete_by_attributes_with_valid_attributes(self, mock_langcache_client)
         assert result == {"deleted_entries_count": 5}
         mock_client.delete_query.assert_called_once_with(attributes={"topic": "python"})
 
-    def test_delete_by_attributes_with_empty_attributes_returns_empty(
+    def test_delete_by_attributes_with_empty_attributes_raises_error(
         self, mock_langcache_client
     ):
-        """Test that delete_by_attributes returns correct shape with empty attributes."""
-        _, mock_client = mock_langcache_client
-
+        """Test that delete_by_attributes raises ValueError with empty attributes."""
         cache = LangCacheSemanticCache(
             name="test",
             server_url="https://api.example.com",
             cache_id="test-cache",
             api_key="test-key",
         )
 
-        result = cache.delete_by_attributes({})
-
-        # Should return dict with correct shape without calling delete_query
-        assert result == {"deleted_entries_count": 0}
-        mock_client.delete_query.assert_not_called()
+        with pytest.raises(
+            ValueError,
+            match="Cannot delete by attributes with an empty attributes dictionary",
+        ):
+            cache.delete_by_attributes({})
 
     @pytest.mark.asyncio
     async def test_adelete_by_attributes_with_valid_attributes(
@@ -500,24 +498,22 @@ async def test_adelete_by_attributes_with_valid_attributes(
         )
 
     @pytest.mark.asyncio
-    async def test_adelete_by_attributes_with_empty_attributes_returns_empty(
+    async def test_adelete_by_attributes_with_empty_attributes_raises_error(
         self, mock_langcache_client
     ):
-        """Test that async delete_by_attributes returns correct shape with empty attributes."""
-        _, mock_client = mock_langcache_client
-
+        """Test that async delete_by_attributes raises ValueError with empty attributes."""
         cache = LangCacheSemanticCache(
             name="test",
             server_url="https://api.example.com",
             cache_id="test-cache",
             api_key="test-key",
         )
 
-        result = await cache.adelete_by_attributes({})
-
-        # Should return dict with correct shape without calling delete_query_async
-        assert result == {"deleted_entries_count": 0}
-        mock_client.delete_query_async.assert_not_called()
+        with pytest.raises(
+            ValueError,
+            match="Cannot delete by attributes with an empty attributes dictionary",
+        ):
+            await cache.adelete_by_attributes({})
 
     def test_update_not_supported(self, mock_langcache_client):
         """Test that update raises NotImplementedError."""