Applying review comments - part 1

Author: petyaslavova

redis/commands/search/commands.py

@@ -5,6 +5,7 @@
 from redis._parsers.helpers import pairs_to_dict
 from redis.client import NEVER_DECODE, Pipeline
 from redis.commands.search.hybrid_query import (
+    CombineResultsMethod,
     HybridCursorQuery,
     HybridPostProcessingConfig,
     HybridQuery,
@@ -562,6 +563,7 @@ def search(
     def hybrid_search(
         self,
         query: HybridQuery,
+        combine_method: Optional[CombineResultsMethod] = None,
         post_processing: Optional[HybridPostProcessingConfig] = None,
         params_substitution: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
         timeout: Optional[int] = None,
@@ -573,6 +575,8 @@ def hybrid_search(
         Args:
             - **query**: HybridQuery object
                         Contains the text and vector queries
+            - **combine_method**: CombineResultsMethod object
+                        Contains the combine method and parameters
             - **post_processing**: HybridPostProcessingConfig object
                         Contains the post processing configuration
             - **params_substitution**: Dict[str, Union[str, int, float, bytes]]
@@ -587,6 +591,8 @@ def hybrid_search(
         options = {}
         pieces = [HYBRID_CMD, index]
         pieces.extend(query.get_args())
+        if combine_method:
+            pieces.extend(combine_method.get_args())
         if post_processing:
             pieces.extend(post_processing.build_args())
         if params_substitution:
@@ -1050,6 +1056,7 @@ async def search(
     async def hybrid_search(
         self,
         query: HybridQuery,
+        combine_method: Optional[CombineResultsMethod] = None,
         post_processing: Optional[HybridPostProcessingConfig] = None,
         params_substitution: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
         timeout: Optional[int] = None,
@@ -1061,6 +1068,8 @@ async def hybrid_search(
         Args:
             - **query**: HybridQuery object
                         Contains the text and vector queries
+            - **combine_method**: CombineResultsMethod object
+                        Contains the combine method and parameters
             - **post_processing**: HybridPostProcessingConfig object
                         Contains the post processing configuration
             - **params_substitution**: Dict[str, Union[str, int, float, bytes]]
@@ -1075,6 +1084,8 @@ async def hybrid_search(
         options = {}
         pieces = [HYBRID_CMD, index]
         pieces.extend(query.get_args())
+        if combine_method:
+            pieces.extend(combine_method.get_args())
         if post_processing:
             pieces.extend(post_processing.build_args())
         if params_substitution:

redis/commands/search/hybrid_query.py

@@ -1,3 +1,4 @@
+from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Union
 
 try:
@@ -35,7 +36,7 @@ def query_string(self) -> str:
     def scorer(self, scorer: str) -> "HybridSearchQuery":
         """
         Scoring algorithm for text search query.
-        Allowed values are "TFIDF" or  "BM25"
+        Allowed values are "TFIDF", "DISMAX", "DOCSCORE", "BM25", etc.
         """
         self._scorer = scorer
         return self
@@ -56,12 +57,17 @@ def get_args(self) -> List[str]:
         return args
 
 
+class VectorSearchMethods(Enum):
+    KNN = "KNN"
+    RANGE = "RANGE"
+
+
 class HybridVsimQuery:
     def __init__(
         self,
         vector_field_name: str,
         vector_data: Union[bytes, str],
-        vsim_search_method: Optional[str] = None,
+        vsim_search_method: Optional[VectorSearchMethods] = None,
         vsim_search_method_params: Optional[Dict[str, Any]] = None,
         filter: Optional["Filter"] = None,
     ) -> None:
@@ -70,11 +76,22 @@ def __init__(
 
         Args:
             vector_field_name: Vector field name.
+
             vector_data: Vector data for the search.
+
             vsim_search_method: Search method that will be used for the vsim search.
-                Allowed values are "KNN" or "RANGE".
+
             vsim_search_method_params: Search method parameters. Use the param names
-                for keys and the values for the values. Example: {"K": 10, "EF_RUNTIME": 100}.
+                for keys and the values for the values.
+                Example for KNN: {"K": 10, "EF_RUNTIME": 100}
+                                    where K is mandatory and defines the number of results
+                                    and EF_RUNTIME is optional and definesthe exploration factor.
+                Example for RANGE: {"RADIUS": 10, "EPSILON": 0.1}
+                                    where RADIUS is mandatory and defines the radius of the search
+                                    and EPSILON is optional and defines the accuracy of the search.
+                For both KNN and RANGE, the following parameter is optional:
+                    YIELD_SCORE_AS: The name of the field to yield the calculated score as.
+
             filter: If defined, a filter will be applied on the vsim query results.
         """
         self._vector_field = vector_field_name
@@ -95,7 +112,7 @@ def vector_data(self) -> Union[bytes, str]:
 
     def vsim_method_params(
         self,
-        method: str,
+        method: VectorSearchMethods,
         **kwargs,
     ) -> "HybridVsimQuery":
         """
@@ -106,7 +123,7 @@ def vsim_method_params(
             kwargs: Search method parameters. Use the param names for keys and the
                 values for the values. Example: {"K": 10, "EF_RUNTIME": 100}.
         """
-        vsim_method_params: List[Union[str, int]] = [method]
+        vsim_method_params: List[Union[str, int]] = [method.value]
         if kwargs:
             vsim_method_params.append(len(kwargs.items()) * 2)
             for key, value in kwargs.items():
@@ -158,40 +175,44 @@ def get_args(self) -> List[str]:
         return args
 
 
+class CombinationMethods(Enum):
+    RRF = "RRF"
+    LINEAR = "LINEAR"
+
+
+class CombineResultsMethod:
+    def __init__(self, method: CombinationMethods, **kwargs) -> None:
+        """
+        Create a new combine results method object.
+
+        Args:
+            method: The combine method to use - RRF or LINEAR.
+            kwargs: Additional combine parameters.
+        """
+        self._method = method
+        self._kwargs = kwargs
+
+    def get_args(self) -> List[Union[str, int]]:
+        args: List[Union[str, int]] = ["COMBINE", self._method.value]
+        if self._kwargs:
+            args.append(len(self._kwargs.items()) * 2)
+            for key, value in self._kwargs.items():
+                args.extend((key, value))
+        return args
+
+
 class HybridPostProcessingConfig:
     def __init__(self) -> None:
         """
         Create a new hybrid post processing configuration object.
         """
-        self._combine = []
         self._load_fields = []
         self._groupby = []
         self._apply = []
         self._sortby_fields = []
         self._filter = None
         self._limit = None
 
-    def combine(
-        self,
-        method: Literal["RRF", "LINEAR"],
-        **kwargs,
-    ) -> Self:
-        """
-        Add combine parameters to the query.
-
-        Args:
-            method: The combine method to use - RRF or LINEAR.
-            kwargs: Additional combine parameters.
-        """
-        self._combine: List[Union[str, int]] = [method]
-
-        self._combine.append(len(kwargs) * 2)
-
-        for key, value in kwargs.items():
-            self._combine.extend([key, value])
-
-        return self
-
     def load(self, *fields: str) -> Self:
         """
         Add load parameters to the query.
@@ -267,8 +288,6 @@ def limit(self, offset: int, num: int) -> Self:
 
     def build_args(self) -> List[str]:
         args = []
-        if self._combine:
-            args.extend(("COMBINE", *self._combine))
         if self._load_fields:
             fields_str = " ".join(self._load_fields)
             fields = fields_str.split(" ")