Adding YIELD_SCORE_AS tests and clearing up support for the keyword

Author: petyaslavova

redis/commands/search/hybrid_query.py

@@ -14,9 +14,7 @@ def __init__(
         self,
         query_string: str,
         scorer: Optional[str] = None,
-        yield_score_as: Optional[
-            str
-        ] = None,  ## TODO check if this will be supported or it should be removed!
+        yield_score_as: Optional[str] = None,
     ) -> None:
         """
         Create a new hybrid search query object.
@@ -42,13 +40,18 @@ def scorer(self, scorer: str) -> "HybridSearchQuery":
         self._scorer = scorer
         return self
 
+    def yield_score_as(self, alias: str) -> "HybridSearchQuery":
+        """
+        Yield the score as a field.
+        """
+        self._yield_score_as = alias
+        return self
+
     def get_args(self) -> List[str]:
         args = ["SEARCH", self._query_string]
         if self._scorer:
             args.extend(("SCORER", self._scorer))
-        if (
-            self._yield_score_as
-        ):  # TODO check if this will be supported or it should be removed!
+        if self._yield_score_as:
             args.extend(("YIELD_SCORE_AS", self._yield_score_as))
         return args
 
@@ -109,7 +112,7 @@ def vsim_method_params(
             for key, value in kwargs.items():
                 vsim_method_params.extend((key, value))
         self._vsim_method_params = vsim_method_params
-        print(self._vsim_method_params)
+
         return self
 
     def filter(self, flt: "HybridFilter") -> "HybridVsimQuery":
@@ -171,17 +174,13 @@ def __init__(self) -> None:
     def combine(
         self,
         method: Literal["RRF", "LINEAR"],
-        yield_score_as: Optional[
-            str
-        ] = None,  # TODO check if this will be supported or it should be removed!
         **kwargs,
     ) -> Self:
         """
         Add combine parameters to the query.
 
         Args:
             method: The combine method to use - RRF or LINEAR.
-            yield_score_as: Optional field name to yield the score as.
             kwargs: Additional combine parameters.
         """
         self._combine: List[Union[str, int]] = [method]
@@ -191,10 +190,6 @@ def combine(
         for key, value in kwargs.items():
             self._combine.extend([key, value])
 
-        if (
-            yield_score_as
-        ):  # TODO check if this will be supported or it should be removed!
-            self._combine.extend(["YIELD_SCORE_AS", yield_score_as])
         return self
 
     def load(self, *fields: str) -> Self:

tests/test_asyncio/test_search.py

@@ -2605,6 +2605,70 @@ async def test_hybrid_search_query_with_vsim_range(self, decoded_r):
             assert res["warnings"] == []
             assert res["execution_time"] > 0
 
+    @pytest.mark.redismod
+    @skip_if_server_version_lt("8.3.224")
+    async def test_hybrid_search_query_with_combine_all_score_aliases(self, decoded_r):
+        # Create index and add data
+        await self._create_hybrid_search_index(decoded_r)
+        await self._add_data_for_hybrid_search(
+            decoded_r, items_sets=1, use_random_str_data=True
+        )
+
+        search_query = HybridSearchQuery("shoes")
+        search_query.yield_score_as("search_score")
+
+        vsim_query = HybridVsimQuery(
+            vector_field_name="@embedding-hnsw",
+            vector_data="abcd1234efgh5678",
+            vsim_search_method="KNN",
+            vsim_search_method_params={
+                "K": 3,
+                "EF_RUNTIME": 1,
+                "YIELD_SCORE_AS": "vsim_score",
+            },
+        )
+
+        hybrid_query = HybridQuery(search_query, vsim_query)
+
+        posprocessing_config = HybridPostProcessingConfig()
+        posprocessing_config.combine(
+            "LINEAR", ALPHA=0.5, BETA=0.5, YIELD_SCORE_AS="combined_score"
+        )
+
+        res = await decoded_r.ft().hybrid_search(
+            query=hybrid_query, post_processing=posprocessing_config, timeout=10
+        )
+
+        if is_resp2_connection(decoded_r):
+            assert len(res.results) > 0
+            assert res.warnings == []
+            for item in res.results:
+                assert item["combined_score"] is not None
+                assert "__score" not in item
+                if item["__key"] in [b"item:0", b"item:1", b"item:4"]:
+                    assert item["search_score"] is not None
+                else:
+                    assert "search_score" not in item
+                if item["__key"] in [b"item:0", b"item:1", b"item:2"]:
+                    assert item["vsim_score"] is not None
+                else:
+                    assert "vsim_score" not in item
+
+        else:
+            assert len(res["results"]) > 0
+            assert res["warnings"] == []
+            for item in res["results"]:
+                assert item["combined_score"] is not None
+                assert "__score" not in item
+                if item["__key"] in ["item:0", "item:1", "item:4"]:
+                    assert item["search_score"] is not None
+                else:
+                    assert "search_score" not in item
+                if item["__key"] in ["item:0", "item:1", "item:2"]:
+                    assert item["vsim_score"] is not None
+                else:
+                    assert "vsim_score" not in item
+
     @pytest.mark.redismod
     @skip_if_server_version_lt("8.3.224")
     async def test_hybrid_search_query_with_combine(self, decoded_r):

tests/test_search.py

@@ -4281,6 +4281,193 @@ def test_hybrid_search_query_with_vsim_filter(self, client):
                 assert item["price"] in ["15", "16"]
                 assert item["size"] in ["10", "11"]
 
+    @pytest.mark.redismod
+    @skip_if_server_version_lt("8.3.224")
+    def test_hybrid_search_query_with_search_score_aliases(self, client):
+        # Create index and add data
+        self._create_hybrid_search_index(client)
+        self._add_data_for_hybrid_search(client, items_sets=1, use_random_str_data=True)
+
+        search_query = HybridSearchQuery("shoes")
+        search_query.yield_score_as("search_score")
+
+        vsim_query = HybridVsimQuery(
+            vector_field_name="@embedding",
+            vector_data="abcd1234efgh5678",
+        )
+
+        hybrid_query = HybridQuery(search_query, vsim_query)
+
+        res = client.ft().hybrid_search(query=hybrid_query, timeout=10)
+
+        if is_resp2_connection(client):
+            assert len(res.results) > 0
+            assert res.warnings == []
+            for item in res.results:
+                if item["__key"] in [b"item:0", b"item:1", b"item:4"]:
+                    assert item["search_score"] is not None
+                    assert item["__score"] is not None
+                else:
+                    assert "search_score" not in item
+                    assert item["__score"] is not None
+
+        else:
+            assert len(res["results"]) > 0
+            assert res["warnings"] == []
+            for item in res["results"]:
+                if item["__key"] in ["item:0", "item:1", "item:4"]:
+                    assert item["search_score"] is not None
+                    assert item["__score"] is not None
+                else:
+                    assert "search_score" not in item
+                    assert item["__score"] is not None
+
+    @pytest.mark.redismod
+    @skip_if_server_version_lt("8.3.224")
+    def test_hybrid_search_query_with_vsim_score_aliases(self, client):
+        # Create index and add data
+        self._create_hybrid_search_index(client)
+        self._add_data_for_hybrid_search(client, items_sets=1, use_random_str_data=True)
+
+        search_query = HybridSearchQuery("shoes")
+
+        vsim_query = HybridVsimQuery(
+            vector_field_name="@embedding-hnsw",
+            vector_data="abcd1234efgh5678",
+            vsim_search_method="KNN",
+            vsim_search_method_params={
+                "K": 3,
+                "EF_RUNTIME": 1,
+                "YIELD_SCORE_AS": "vsim_score",
+            },
+        )
+
+        hybrid_query = HybridQuery(search_query, vsim_query)
+
+        res = client.ft().hybrid_search(query=hybrid_query, timeout=10)
+
+        if is_resp2_connection(client):
+            assert len(res.results) > 0
+            assert res.warnings == []
+            for item in res.results:
+                if item["__key"] in [b"item:0", b"item:1", b"item:2"]:
+                    assert item["vsim_score"] is not None
+                    assert item["__score"] is not None
+                else:
+                    assert "vsim_score" not in item
+                    assert item["__score"] is not None
+
+        else:
+            assert len(res["results"]) > 0
+            assert res["warnings"] == []
+            for item in res["results"]:
+                if item["__key"] in ["item:0", "item:1", "item:2"]:
+                    assert item["vsim_score"] is not None
+                    assert item["__score"] is not None
+                else:
+                    assert "vsim_score" not in item
+                    assert item["__score"] is not None
+
+    @pytest.mark.redismod
+    @skip_if_server_version_lt("8.3.224")
+    def test_hybrid_search_query_with_combine_score_aliases(self, client):
+        # Create index and add data
+        self._create_hybrid_search_index(client)
+        self._add_data_for_hybrid_search(client, items_sets=1, use_random_str_data=True)
+
+        search_query = HybridSearchQuery("shoes")
+
+        vsim_query = HybridVsimQuery(
+            vector_field_name="@embedding-hnsw", vector_data="abcd1234efgh5678"
+        )
+
+        hybrid_query = HybridQuery(search_query, vsim_query)
+
+        posprocessing_config = HybridPostProcessingConfig()
+        posprocessing_config.combine(
+            "LINEAR", ALPHA=0.5, BETA=0.5, YIELD_SCORE_AS="combined_score"
+        )
+
+        res = client.ft().hybrid_search(
+            query=hybrid_query, post_processing=posprocessing_config, timeout=10
+        )
+
+        if is_resp2_connection(client):
+            assert len(res.results) > 0
+            assert res.warnings == []
+            for item in res.results:
+                assert item["combined_score"] is not None
+                assert "__score" not in item
+
+        else:
+            assert len(res["results"]) > 0
+            assert res["warnings"] == []
+            for item in res["results"]:
+                assert item["combined_score"] is not None
+                assert "__score" not in item
+
+    @pytest.mark.redismod
+    @skip_if_server_version_lt("8.3.224")
+    def test_hybrid_search_query_with_combine_all_score_aliases(self, client):
+        # Create index and add data
+        self._create_hybrid_search_index(client)
+        self._add_data_for_hybrid_search(client, items_sets=1, use_random_str_data=True)
+
+        search_query = HybridSearchQuery("shoes")
+        search_query.yield_score_as("search_score")
+
+        vsim_query = HybridVsimQuery(
+            vector_field_name="@embedding-hnsw",
+            vector_data="abcd1234efgh5678",
+            vsim_search_method="KNN",
+            vsim_search_method_params={
+                "K": 3,
+                "EF_RUNTIME": 1,
+                "YIELD_SCORE_AS": "vsim_score",
+            },
+        )
+
+        hybrid_query = HybridQuery(search_query, vsim_query)
+
+        posprocessing_config = HybridPostProcessingConfig()
+        posprocessing_config.combine(
+            "LINEAR", ALPHA=0.5, BETA=0.5, YIELD_SCORE_AS="combined_score"
+        )
+
+        res = client.ft().hybrid_search(
+            query=hybrid_query, post_processing=posprocessing_config, timeout=10
+        )
+
+        if is_resp2_connection(client):
+            assert len(res.results) > 0
+            assert res.warnings == []
+            for item in res.results:
+                assert item["combined_score"] is not None
+                assert "__score" not in item
+                if item["__key"] in [b"item:0", b"item:1", b"item:4"]:
+                    assert item["search_score"] is not None
+                else:
+                    assert "search_score" not in item
+                if item["__key"] in [b"item:0", b"item:1", b"item:2"]:
+                    assert item["vsim_score"] is not None
+                else:
+                    assert "vsim_score" not in item
+
+        else:
+            assert len(res["results"]) > 0
+            assert res["warnings"] == []
+            for item in res["results"]:
+                assert item["combined_score"] is not None
+                assert "__score" not in item
+                if item["__key"] in ["item:0", "item:1", "item:4"]:
+                    assert item["search_score"] is not None
+                else:
+                    assert "search_score" not in item
+                if item["__key"] in ["item:0", "item:1", "item:2"]:
+                    assert item["vsim_score"] is not None
+                else:
+                    assert "vsim_score" not in item
+
     @pytest.mark.redismod
     @skip_if_server_version_lt("8.3.224")
     def test_hybrid_search_query_with_vsim_knn(self, client):