Ignore empty attributes in delete_by_attributes instead of raising error

- Changed delete_by_attributes() to return {} when attributes is empty
- Changed adelete_by_attributes() to return {} when attributes is empty
- Updated tests to verify empty attributes are ignored without calling API
- This prevents accidentally calling API with empty dict which would cause 400 error

Co-authored-by: abrookins <[email protected]>

Author: Copilot

redisvl/extensions/cache/llm/langcache.py

@@ -582,20 +582,14 @@ def delete_by_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
 
         Args:
             attributes (Dict[str, Any]): Attributes to match for deletion.
-                Cannot be empty.
+                If empty, no deletion is performed.
 
         Returns:
             Dict[str, Any]: Result of the deletion operation.
-
-        Raises:
-            ValueError: If attributes is empty.
         """
         if not attributes:
-            raise ValueError(
-                "attributes cannot be empty. Provide specific attributes to match, "
-                "use delete() or clear() to delete all entries, "
-                "or use delete_by_id(entry_id) to delete individual entries."
-            )
+            # No attributes provided, return empty result without calling API
+            return {}
         result = self._client.delete_query(attributes=attributes)
         # Convert DeleteQueryResponse to dict
         return result.model_dump() if hasattr(result, "model_dump") else {}
@@ -605,20 +599,14 @@ async def adelete_by_attributes(self, attributes: Dict[str, Any]) -> Dict[str, A
 
         Args:
             attributes (Dict[str, Any]): Attributes to match for deletion.
-                Cannot be empty.
+                If empty, no deletion is performed.
 
         Returns:
             Dict[str, Any]: Result of the deletion operation.
-
-        Raises:
-            ValueError: If attributes is empty.
         """
         if not attributes:
-            raise ValueError(
-                "attributes cannot be empty. Provide specific attributes to match, "
-                "use adelete() or aclear() to delete all entries, "
-                "or use adelete_by_id(entry_id) to delete individual entries."
-            )
+            # No attributes provided, return empty result without calling API
+            return {}
         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,19 +455,24 @@ def test_delete_by_attributes_with_valid_attributes(self, mock_langcache_client)
         assert result == {"deleted_count": 5}
         mock_client.delete_query.assert_called_once_with(attributes={"topic": "python"})
 
-    def test_delete_by_attributes_with_empty_attributes_raises_error(
+    def test_delete_by_attributes_with_empty_attributes_returns_empty(
         self, mock_langcache_client
     ):
-        """Test that delete_by_attributes raises ValueError with empty attributes."""
+        """Test that delete_by_attributes returns empty dict with empty attributes."""
+        _, mock_client = mock_langcache_client
+
         cache = LangCacheSemanticCache(
             name="test",
             server_url="https://api.example.com",
             cache_id="test-cache",
             api_key="test-key",
         )
 
-        with pytest.raises(ValueError, match="attributes cannot be empty"):
-            cache.delete_by_attributes({})
+        result = cache.delete_by_attributes({})
+
+        # Should return empty dict without calling delete_query
+        assert result == {}
+        mock_client.delete_query.assert_not_called()
 
     @pytest.mark.asyncio
     async def test_adelete_by_attributes_with_valid_attributes(
@@ -495,19 +500,24 @@ async def test_adelete_by_attributes_with_valid_attributes(
         )
 
     @pytest.mark.asyncio
-    async def test_adelete_by_attributes_with_empty_attributes_raises_error(
+    async def test_adelete_by_attributes_with_empty_attributes_returns_empty(
         self, mock_langcache_client
     ):
-        """Test that async delete_by_attributes raises ValueError with empty attributes."""
+        """Test that async delete_by_attributes returns empty dict with empty attributes."""
+        _, mock_client = mock_langcache_client
+
         cache = LangCacheSemanticCache(
             name="test",
             server_url="https://api.example.com",
             cache_id="test-cache",
             api_key="test-key",
         )
 
-        with pytest.raises(ValueError, match="attributes cannot be empty"):
-            await cache.adelete_by_attributes({})
+        result = await cache.adelete_by_attributes({})
+
+        # Should return empty dict without calling delete_query_async
+        assert result == {}
+        mock_client.delete_query_async.assert_not_called()
 
     def test_update_not_supported(self, mock_langcache_client):
         """Test that update raises NotImplementedError."""