redis 6.4.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

redis/commands/helpers.py

@@ -72,26 +72,6 @@ def parse_to_list(response):
     return res
 
 
-def parse_list_to_dict(response):
-    res = {}
-    for i in range(0, len(response), 2):
-        if isinstance(response[i], list):
-            res["Child iterators"].append(parse_list_to_dict(response[i]))
-            try:
-                if isinstance(response[i + 1], list):
-                    res["Child iterators"].append(parse_list_to_dict(response[i + 1]))
-            except IndexError:
-                pass
-        elif isinstance(response[i + 1], list):
-            res["Child iterators"] = [parse_list_to_dict(response[i + 1])]
-        else:
-            try:
-                res[response[i]] = float(response[i + 1])
-            except (TypeError, ValueError):
-                res[response[i]] = response[i + 1]
-    return res
-
-
 def random_string(length=10):
     """
     Returns a random N character long string.

redis/commands/json/commands.py

@@ -14,7 +14,7 @@ class JSONCommands:
     """json commands."""
 
     def arrappend(
-        self, name: str, path: Optional[str] = Path.root_path(), *args: List[JsonType]
+        self, name: str, path: Optional[str] = Path.root_path(), *args: JsonType
     ) -> List[Optional[int]]:
         """Append the objects ``args`` to the array under the
         ``path` in key ``name``.
@@ -52,7 +52,7 @@ class JSONCommands:
         return self.execute_command("JSON.ARRINDEX", *pieces, keys=[name])
 
     def arrinsert(
-        self, name: str, path: str, index: int, *args: List[JsonType]
+        self, name: str, path: str, index: int, *args: JsonType
     ) -> List[Optional[int]]:
         """Insert the objects ``args`` to the array at index ``index``
         under the ``path` in key ``name``.

redis/commands/search/__init__.py

@@ -1,4 +1,4 @@
-import redis
+from redis.client import Pipeline as RedisPipeline
 
 from ...asyncio.client import Pipeline as AsyncioPipeline
 from .commands import (
@@ -181,7 +181,7 @@ class AsyncSearch(Search, AsyncSearchCommands):
         return p
 
 
-class Pipeline(SearchCommands, redis.client.Pipeline):
+class Pipeline(SearchCommands, RedisPipeline):
     """Pipeline for the module."""
 
 

redis/commands/search/aggregation.py

@@ -1,4 +1,4 @@
-from typing import List, Union
+from typing import List, Optional, Tuple, Union
 
 from redis.commands.search.dialect import DEFAULT_DIALECT
 
@@ -27,9 +27,9 @@ class Reducer:
     NAME = None
 
     def __init__(self, *args: str) -> None:
-        self._args = args
-        self._field = None
-        self._alias = None
+        self._args: Tuple[str, ...] = args
+        self._field: Optional[str] = None
+        self._alias: Optional[str] = None
 
     def alias(self, alias: str) -> "Reducer":
         """
@@ -49,13 +49,14 @@ class Reducer:
         if alias is FIELDNAME:
             if not self._field:
                 raise ValueError("Cannot use FIELDNAME alias with no field")
-            # Chop off initial '@'
-            alias = self._field[1:]
+            else:
+                # Chop off initial '@'
+                alias = self._field[1:]
         self._alias = alias
         return self
 
     @property
-    def args(self) -> List[str]:
+    def args(self) -> Tuple[str, ...]:
         return self._args
 
 
@@ -64,7 +65,7 @@ class SortDirection:
     This special class is used to indicate sort direction.
     """
 
-    DIRSTRING = None
+    DIRSTRING: Optional[str] = None
 
     def __init__(self, field: str) -> None:
         self.field = field
@@ -104,17 +105,17 @@ class AggregateRequest:
         All member methods (except `build_args()`)
         return the object itself, making them useful for chaining.
         """
-        self._query = query
-        self._aggregateplan = []
-        self._loadfields = []
-        self._loadall = False
-        self._max = 0
-        self._with_schema = False
-        self._verbatim = False
-        self._cursor = []
-        self._dialect = DEFAULT_DIALECT
-        self._add_scores = False
-        self._scorer = "TFIDF"
+        self._query: str = query
+        self._aggregateplan: List[str] = []
+        self._loadfields: List[str] = []
+        self._loadall: bool = False
+        self._max: int = 0
+        self._with_schema: bool = False
+        self._verbatim: bool = False
+        self._cursor: List[str] = []
+        self._dialect: int = DEFAULT_DIALECT
+        self._add_scores: bool = False
+        self._scorer: str = "TFIDF"
 
     def load(self, *fields: str) -> "AggregateRequest":
         """
@@ -133,7 +134,7 @@ class AggregateRequest:
         return self
 
     def group_by(
-        self, fields: List[str], *reducers: Union[Reducer, List[Reducer]]
+        self, fields: Union[str, List[str]], *reducers: Reducer
     ) -> "AggregateRequest":
         """
         Specify by which fields to group the aggregation.
@@ -147,7 +148,6 @@ class AggregateRequest:
             `aggregation` module.
         """
         fields = [fields] if isinstance(fields, str) else fields
-        reducers = [reducers] if isinstance(reducers, Reducer) else reducers
 
         ret = ["GROUPBY", str(len(fields)), *fields]
         for reducer in reducers:
@@ -251,12 +251,10 @@ class AggregateRequest:
             .sort_by(Desc("@paid"), max=10)
         ```
         """
-        if isinstance(fields, (str, SortDirection)):
-            fields = [fields]
 
         fields_args = []
         for f in fields:
-            if isinstance(f, SortDirection):
+            if isinstance(f, (Asc, Desc)):
                 fields_args += [f.field, f.DIRSTRING]
             else:
                 fields_args += [f]
@@ -356,7 +354,7 @@ class AggregateRequest:
             ret.extend(self._loadfields)
 
         if self._dialect:
-            ret.extend(["DIALECT", self._dialect])
+            ret.extend(["DIALECT", str(self._dialect)])
 
         ret.extend(self._aggregateplan)
 
@@ -393,7 +391,7 @@ class AggregateResult:
         self.cursor = cursor
         self.schema = schema
 
-    def __repr__(self) -> (str, str):
+    def __repr__(self) -> str:
         cid = self.cursor.cid if self.cursor else -1
         return (
             f"<{self.__class__.__name__} at 0x{id(self):x} "

redis/commands/search/commands.py

@@ -221,7 +221,7 @@ class SearchCommands:
 
         return self.execute_command(*args)
 
-    def alter_schema_add(self, fields: List[str]):
+    def alter_schema_add(self, fields: Union[Field, List[Field]]):
         """
         Alter the existing search index by adding new fields. The index
         must already exist.
@@ -336,11 +336,11 @@ class SearchCommands:
         doc_id: str,
         nosave: bool = False,
         score: float = 1.0,
-        payload: bool = None,
+        payload: Optional[bool] = None,
         replace: bool = False,
         partial: bool = False,
         language: Optional[str] = None,
-        no_create: str = False,
+        no_create: bool = False,
         **fields: List[str],
     ):
         """
@@ -464,7 +464,7 @@ class SearchCommands:
         return self._parse_results(INFO_CMD, res)
 
     def get_params_args(
-        self, query_params: Union[Dict[str, Union[str, int, float, bytes]], None]
+        self, query_params: Optional[Dict[str, Union[str, int, float, bytes]]]
     ):
         if query_params is None:
             return []
@@ -478,7 +478,7 @@ class SearchCommands:
         return args
 
     def _mk_query_args(
-        self, query, query_params: Union[Dict[str, Union[str, int, float, bytes]], None]
+        self, query, query_params: Optional[Dict[str, Union[str, int, float, bytes]]]
     ):
         args = [self.index_name]
 
@@ -528,7 +528,7 @@ class SearchCommands:
     def explain(
         self,
         query: Union[str, Query],
-        query_params: Dict[str, Union[str, int, float]] = None,
+        query_params: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
     ):
         """Returns the execution plan for a complex query.
 
@@ -543,7 +543,7 @@ class SearchCommands:
     def aggregate(
         self,
         query: Union[AggregateRequest, Cursor],
-        query_params: Dict[str, Union[str, int, float]] = None,
+        query_params: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
     ):
         """
         Issue an aggregation query.
@@ -598,7 +598,7 @@ class SearchCommands:
         self,
         query: Union[Query, AggregateRequest],
         limited: bool = False,
-        query_params: Optional[Dict[str, Union[str, int, float]]] = None,
+        query_params: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
     ):
         """
         Performs a search or aggregate command and collects performance
@@ -936,7 +936,7 @@ class AsyncSearchCommands(SearchCommands):
     async def search(
         self,
         query: Union[str, Query],
-        query_params: Dict[str, Union[str, int, float]] = None,
+        query_params: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
     ):
         """
         Search the index for a given query, and return a result of documents
@@ -968,7 +968,7 @@ class AsyncSearchCommands(SearchCommands):
     async def aggregate(
         self,
         query: Union[AggregateResult, Cursor],
-        query_params: Dict[str, Union[str, int, float]] = None,
+        query_params: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
     ):
         """
         Issue an aggregation query.

redis/commands/search/field.py

@@ -52,14 +52,14 @@ class Field:
         self.args_suffix = list()
         self.as_name = as_name
 
-        if sortable:
-            self.args_suffix.append(Field.SORTABLE)
         if no_index:
             self.args_suffix.append(Field.NOINDEX)
         if index_missing:
             self.args_suffix.append(Field.INDEX_MISSING)
         if index_empty:
             self.args_suffix.append(Field.INDEX_EMPTY)
+        if sortable:
+            self.args_suffix.append(Field.SORTABLE)
 
         if no_index and not sortable:
             raise ValueError("Non-Sortable non-Indexable fields are ignored")

redis/commands/search/query.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union
+from typing import List, Optional, Tuple, Union
 
 from redis.commands.search.dialect import DEFAULT_DIALECT
 
@@ -9,7 +9,7 @@ class Query:
     the query string. The query string is set in the constructor, and other
     options have setter functions.
 
-    The setter functions return the query object, so they can be chained,
+    The setter functions return the query object so they can be chained.
     i.e. `Query("foo").verbatim().filter(...)` etc.
     """
 
@@ -31,7 +31,7 @@ class Query:
         self._with_scores: bool = False
         self._scorer: Optional[str] = None
         self._filters: List = list()
-        self._ids: Optional[List[str]] = None
+        self._ids: Optional[Tuple[str, ...]] = None
         self._slop: int = -1
         self._timeout: Optional[float] = None
         self._in_order: bool = False
@@ -81,7 +81,7 @@ class Query:
             self._return_fields += ("AS", as_field)
         return self
 
-    def _mk_field_list(self, fields: List[str]) -> List:
+    def _mk_field_list(self, fields: Optional[Union[List[str], str]]) -> List:
         if not fields:
             return []
         return [fields] if isinstance(fields, str) else list(fields)
@@ -95,12 +95,12 @@ class Query:
     ) -> "Query":
         """
         Return an abridged format of the field, containing only the segments of
-        the field which contain the matching term(s).
+        the field that contain the matching term(s).
 
         If `fields` is specified, then only the mentioned fields are
-        summarized; otherwise all results are summarized.
+        summarized; otherwise, all results are summarized.
 
-        Server side defaults are used for each option (except `fields`)
+        Server-side defaults are used for each option (except `fields`)
         if not specified
 
         - **fields** List of fields to summarize. All fields are summarized
@@ -126,11 +126,11 @@ class Query:
 
     def highlight(
         self, fields: Optional[List[str]] = None, tags: Optional[List[str]] = None
-    ) -> None:
+    ) -> "Query":
         """
         Apply specified markup to matched term(s) within the returned field(s).
 
-        - **fields** If specified then only those mentioned fields are
+        - **fields** If specified, then only those mentioned fields are
         highlighted, otherwise all fields are highlighted
         - **tags** A list of two strings to surround the match.
         """
@@ -154,7 +154,7 @@ class Query:
         return self
 
     def slop(self, slop: int) -> "Query":
-        """Allow a maximum of N intervening non matched terms between
+        """Allow a maximum of N intervening non-matched terms between
         phrase terms (0 means exact phrase).
         """
         self._slop = slop
@@ -169,7 +169,7 @@ class Query:
         """
         Match only documents where the query terms appear in
         the same order in the document.
-        i.e. for the query "hello world", we do not match "world hello"
+        i.e., for the query "hello world", we do not match "world hello"
         """
         self._in_order = True
         return self
@@ -187,16 +187,16 @@ class Query:
         self._scorer = scorer
         return self
 
-    def get_args(self) -> List[str]:
+    def get_args(self) -> List[Union[str, int, float]]:
         """Format the redis arguments for this query and return them."""
-        args = [self._query_string]
+        args: List[Union[str, int, float]] = [self._query_string]
         args += self._get_args_tags()
         args += self._summarize_fields + self._highlight_fields
         args += ["LIMIT", self._offset, self._num]
         return args
 
-    def _get_args_tags(self) -> List[str]:
-        args = []
+    def _get_args_tags(self) -> List[Union[str, int, float]]:
+        args: List[Union[str, int, float]] = []
         if self._no_content:
             args.append("NOCONTENT")
         if self._fields:
@@ -258,7 +258,7 @@ class Query:
         return self
 
     def verbatim(self) -> "Query":
-        """Set the query to be verbatim, i.e. use no query expansion
+        """Set the query to be verbatim, i.e., use no query expansion
         or stemming.
         """
         self._verbatim = True
@@ -288,20 +288,20 @@ class Query:
         self._with_scores = True
         return self
 
-    def limit_fields(self, *fields: List[str]) -> "Query":
+    def limit_fields(self, *fields: str) -> "Query":
         """
         Limit the search to specific TEXT fields only.
 
-        - **fields**: A list of strings, case sensitive field names
+        - **fields**: Each element should be a string, case sensitive field name
         from the defined schema.
         """
-        self._fields = fields
+        self._fields = list(fields)
         return self
 
     def add_filter(self, flt: "Filter") -> "Query":
         """
         Add a numeric or geo filter to the query.
-        **Currently only one of each filter is supported by the engine**
+        **Currently, only one of each filter is supported by the engine**
 
         - **flt**: A NumericFilter or GeoFilter object, used on a
         corresponding field
@@ -315,14 +315,14 @@ class Query:
         Add a sortby field to the query.
 
         - **field** - the name of the field to sort by
-        - **asc** - when `True`, sorting will be done in asceding order
+        - **asc** - when `True`, sorting will be done in ascending order
         """
         self._sortby = SortbyField(field, asc)
         return self
 
     def expander(self, expander: str) -> "Query":
         """
-        Add a expander field to the query.
+        Add an expander field to the query.
 
         - **expander** - the name of the expander
         """
@@ -340,7 +340,7 @@ class Query:
 
 
 class Filter:
-    def __init__(self, keyword: str, field: str, *args: List[str]) -> None:
+    def __init__(self, keyword: str, field: str, *args: Union[str, float]) -> None:
         self.args = [keyword, field] + list(args)
 
 

redis/commands/vectorset/__init__.py

@@ -24,12 +24,12 @@ class VectorSet(VectorSetCommands):
         # Set the module commands' callbacks
         self._MODULE_CALLBACKS = {
             VEMB_CMD: parse_vemb_result,
+            VSIM_CMD: parse_vsim_result,
             VGETATTR_CMD: lambda r: r and json.loads(r) or None,
         }
 
         self._RESP2_MODULE_CALLBACKS = {
             VINFO_CMD: lambda r: r and pairs_to_dict(r) or None,
-            VSIM_CMD: parse_vsim_result,
             VLINKS_CMD: parse_vlinks_result,
         }
         self._RESP3_MODULE_CALLBACKS = {}

redis/commands/vectorset/commands.py

@@ -1,6 +1,6 @@
 import json
 from enum import Enum
-from typing import Awaitable, Dict, List, Optional, Union
+from typing import Any, Awaitable, Dict, List, Optional, Union
 
 from redis.client import NEVER_DECODE
 from redis.commands.helpers import get_protocol_version
@@ -19,6 +19,15 @@ VSETATTR_CMD = "VSETATTR"
 VGETATTR_CMD = "VGETATTR"
 VRANDMEMBER_CMD = "VRANDMEMBER"
 
+# Return type for vsim command
+VSimResult = Optional[
+    List[
+        Union[
+            List[EncodableT], Dict[EncodableT, Number], Dict[EncodableT, Dict[str, Any]]
+        ]
+    ]
+]
+
 
 class QuantizationOptions(Enum):
     """Quantization options for the VADD command."""
@@ -33,6 +42,7 @@ class CallbacksOptions(Enum):
 
     RAW = "RAW"
     WITHSCORES = "WITHSCORES"
+    WITHATTRIBS = "WITHATTRIBS"
     ALLOW_DECODING = "ALLOW_DECODING"
     RESP3 = "RESP3"
 
@@ -77,7 +87,7 @@ class VectorSetCommands(CommandsProtocol):
         ``numlinks`` sets the number of links to create for the vector.
                 If not provided, the default number of links is used.
 
-        For more information see https://redis.io/commands/vadd
+        For more information, see https://redis.io/commands/vadd.
         """
         if not vector or not element:
             raise DataError("Both vector and element must be provided")
@@ -123,6 +133,7 @@ class VectorSetCommands(CommandsProtocol):
         key: KeyT,
         input: Union[List[float], bytes, str],
         with_scores: Optional[bool] = False,
+        with_attribs: Optional[bool] = False,
         count: Optional[int] = None,
         ef: Optional[Number] = None,
         filter: Optional[str] = None,
@@ -130,25 +141,24 @@ class VectorSetCommands(CommandsProtocol):
         truth: Optional[bool] = False,
         no_thread: Optional[bool] = False,
         epsilon: Optional[Number] = None,
-    ) -> Union[
-        Awaitable[Optional[List[Union[List[EncodableT], Dict[EncodableT, Number]]]]],
-        Optional[List[Union[List[EncodableT], Dict[EncodableT, Number]]]],
-    ]:
+    ) -> Union[Awaitable[VSimResult], VSimResult]:
         """
         Compare a vector or element ``input``  with the other vectors in a vector set ``key``.
 
-        ``with_scores`` sets if the results should be returned with the
-                similarity scores of the elements in the result.
+        ``with_scores`` sets if similarity scores should be returned for each element in the result.
+
+        ``with_attribs`` ``with_attribs`` sets if the results should be returned with the
+                attributes of the elements in the result, or None when no attributes are present.
 
         ``count`` sets the number of results to return.
 
         ``ef`` sets the exploration factor.
 
-        ``filter`` sets filter that should be applied for the search.
+        ``filter`` sets the filter that should be applied for the search.
 
         ``filter_ef`` sets the max filtering effort.
 
-        ``truth`` when enabled forces the command to perform linear scan.
+        ``truth`` when enabled, forces the command to perform a linear scan.
 
         ``no_thread`` when enabled forces the command to execute the search
                 on the data structure in the main thread.
@@ -156,7 +166,7 @@ class VectorSetCommands(CommandsProtocol):
         ``epsilon`` floating point between 0 and 1, if specified will return
                 only elements with distance no further than the specified one.
 
-        For more information see https://redis.io/commands/vsim
+        For more information, see https://redis.io/commands/vsim.
         """
 
         if not input:
@@ -173,9 +183,17 @@ class VectorSetCommands(CommandsProtocol):
         else:
             pieces.extend(["ELE", input])
 
-        if with_scores:
-            pieces.append("WITHSCORES")
-            options[CallbacksOptions.WITHSCORES.value] = True
+        if with_scores or with_attribs:
+            if get_protocol_version(self.client) in ["3", 3]:
+                options[CallbacksOptions.RESP3.value] = True
+
+            if with_scores:
+                pieces.append("WITHSCORES")
+                options[CallbacksOptions.WITHSCORES.value] = True
+
+            if with_attribs:
+                pieces.append("WITHATTRIBS")
+                options[CallbacksOptions.WITHATTRIBS.value] = True
 
         if count:
             pieces.extend(["COUNT", count])
@@ -210,7 +228,7 @@ class VectorSetCommands(CommandsProtocol):
 
         Raises `redis.exceptions.ResponseError` if the vector set doesn't exist.
 
-        For more information see https://redis.io/commands/vdim
+        For more information, see https://redis.io/commands/vdim.
         """
         return self.execute_command(VDIM_CMD, key)
 
@@ -220,7 +238,7 @@ class VectorSetCommands(CommandsProtocol):
 
         Raises `redis.exceptions.ResponseError` if the vector set doesn't exist.
 
-        For more information see https://redis.io/commands/vcard
+        For more information, see https://redis.io/commands/vcard.
         """
         return self.execute_command(VCARD_CMD, key)
 
@@ -228,7 +246,7 @@ class VectorSetCommands(CommandsProtocol):
         """
         Remove an element from a vector set.
 
-        For more information see https://redis.io/commands/vrem
+        For more information, see https://redis.io/commands/vrem.
         """
         return self.execute_command(VREM_CMD, key, element)
 
@@ -242,10 +260,10 @@ class VectorSetCommands(CommandsProtocol):
         Get the approximated vector of an element ``element`` from vector set ``key``.
 
         ``raw`` is a boolean flag that indicates whether to return the
-                interal representation used by the vector.
+                internal representation used by the vector.
 
 
-        For more information see https://redis.io/commands/vembed
+        For more information, see https://redis.io/commands/vemb.
         """
         options = {}
         pieces = []
@@ -293,7 +311,7 @@ class VectorSetCommands(CommandsProtocol):
         If the ``WITHSCORES`` option is provided, the result is a list of dicts,
         where each dict contains the neighbors for one level, with the scores as values.
 
-        For more information see https://redis.io/commands/vlinks
+        For more information, see https://redis.io/commands/vlinks
         """
         options = {}
         pieces = []
@@ -309,7 +327,7 @@ class VectorSetCommands(CommandsProtocol):
         """
         Get information about a vector set.
 
-        For more information see https://redis.io/commands/vinfo
+        For more information, see https://redis.io/commands/vinfo.
         """
         return self.execute_command(VINFO_CMD, key)
 
@@ -320,7 +338,7 @@ class VectorSetCommands(CommandsProtocol):
         Associate or remove JSON attributes ``attributes`` of element ``element``
         for vector set ``key``.
 
-        For more information see https://redis.io/commands/vsetattr
+        For more information, see https://redis.io/commands/vsetattr
         """
         if attributes is None:
             attributes_json = "{}"
@@ -336,12 +354,12 @@ class VectorSetCommands(CommandsProtocol):
         self, key: KeyT, element: str
     ) -> Union[Optional[Awaitable[dict]], Optional[dict]]:
         """
-        Retrieve the JSON attributes of an element ``elemet`` for vector set ``key``.
+        Retrieve the JSON attributes of an element ``element `` for vector set ``key``.
 
         If the element does not exist, or if the vector set does not exist, None is
         returned.
 
-        For more information see https://redis.io/commands/vgetattr
+        For more information, see https://redis.io/commands/vgetattr.
         """
         return self.execute_command(VGETATTR_CMD, key, element)
 
@@ -365,7 +383,7 @@ class VectorSetCommands(CommandsProtocol):
 
         If the vector set does not exist, ``None`` is returned.
 
-        For more information see https://redis.io/commands/vrandmember
+        For more information, see https://redis.io/commands/vrandmember.
         """
         pieces = []
         pieces.append(key)