redis 5.3.0b5__py3-none-any.whl → 6.0.0b2__py3-none-any.whl

redis/commands/helpers.py

@@ -79,29 +79,6 @@ def parse_list_to_dict(response):
     return res
 
 
-def parse_to_dict(response):
-    if response is None:
-        return {}
-
-    res = {}
-    for det in response:
-        if not isinstance(det, list) or not det:
-            continue
-        if len(det) == 1:
-            res[det[0]] = True
-        elif isinstance(det[1], list):
-            res[det[0]] = parse_list_to_dict(det[1])
-        else:
-            try:  # try to set the attribute. may be provided without value
-                try:  # try to convert the value to float
-                    res[det[0]] = float(det[1])
-                except (TypeError, ValueError):
-                    res[det[0]] = det[1]
-            except IndexError:
-                pass
-    return res
-
-
 def random_string(length=10):
     """
     Returns a random N character long string.
@@ -111,26 +88,6 @@ def random_string(length=10):
     )
 
 
-def quote_string(v):
-    """
-    RedisGraph strings must be quoted,
-    quote_string wraps given v with quotes incase
-    v is a string.
-    """
-
-    if isinstance(v, bytes):
-        v = v.decode()
-    elif not isinstance(v, str):
-        return v
-    if len(v) == 0:
-        return '""'
-
-    v = v.replace("\\", "\\\\")
-    v = v.replace('"', '\\"')
-
-    return f'"{v}"'
-
-
 def decode_dict_keys(obj):
     """Decode the keys of the given dictionary with utf-8."""
     newobj = copy.copy(obj)
@@ -141,33 +98,6 @@ def decode_dict_keys(obj):
     return newobj
 
 
-def stringify_param_value(value):
-    """
-    Turn a parameter value into a string suitable for the params header of
-    a Cypher command.
-    You may pass any value that would be accepted by `json.dumps()`.
-
-    Ways in which output differs from that of `str()`:
-        * Strings are quoted.
-        * None --> "null".
-        * In dictionaries, keys are _not_ quoted.
-
-    :param value: The parameter value to be turned into a string.
-    :return: string
-    """
-
-    if isinstance(value, str):
-        return quote_string(value)
-    elif value is None:
-        return "null"
-    elif isinstance(value, (list, tuple)):
-        return f'[{",".join(map(stringify_param_value, value))}]'
-    elif isinstance(value, dict):
-        return f'{{{",".join(f"{k}:{stringify_param_value(v)}" for k, v in value.items())}}}'  # noqa
-    else:
-        return str(value)
-
-
 def get_protocol_version(client):
     if isinstance(client, redis.Redis) or isinstance(client, redis.asyncio.Redis):
         return client.connection_pool.connection_kwargs.get("protocol")

redis/commands/redismodules.py

@@ -72,15 +72,13 @@ class RedisModuleCommands:
         tdigest = TDigestBloom(client=self)
         return tdigest
 
-    def graph(self, index_name="idx"):
-        """Access the graph namespace, providing support for
-        redis graph data.
-        """
+    def vset(self):
+        """Access the VectorSet commands namespace."""
 
-        from .graph import Graph
+        from .vectorset import VectorSet
 
-        g = Graph(client=self, name=index_name)
-        return g
+        vset = VectorSet(client=self)
+        return vset
 
 
 class AsyncRedisModuleCommands(RedisModuleCommands):
@@ -91,13 +89,3 @@ class AsyncRedisModuleCommands(RedisModuleCommands):
 
         s = AsyncSearch(client=self, index_name=index_name)
         return s
-
-    def graph(self, index_name="idx"):
-        """Access the graph namespace, providing support for
-        redis graph data.
-        """
-
-        from .graph import AsyncGraph
-
-        g = AsyncGraph(client=self, name=index_name)
-        return g

redis/commands/search/aggregation.py

@@ -1,5 +1,7 @@
 from typing import List, Union
 
+from redis.commands.search.dialect import DEFAULT_DIALECT
+
 FIELDNAME = object()
 
 
@@ -110,7 +112,7 @@ class AggregateRequest:
         self._with_schema = False
         self._verbatim = False
         self._cursor = []
-        self._dialect = None
+        self._dialect = DEFAULT_DIALECT
         self._add_scores = False
         self._scorer = "TFIDF"
 

redis/commands/search/commands.py

@@ -5,12 +5,13 @@ from typing import Dict, List, Optional, Union
 from redis.client import NEVER_DECODE, Pipeline
 from redis.utils import deprecated_function
 
-from ..helpers import get_protocol_version, parse_to_dict
+from ..helpers import get_protocol_version
 from ._util import to_string
 from .aggregation import AggregateRequest, AggregateResult, Cursor
 from .document import Document
 from .field import Field
-from .indexDefinition import IndexDefinition
+from .index_definition import IndexDefinition
+from .profile_information import ProfileInformation
 from .query import Query
 from .result import Result
 from .suggestion import SuggestionParser
@@ -67,7 +68,7 @@ class SearchCommands:
 
     def _parse_results(self, cmd, res, **kwargs):
         if get_protocol_version(self.client) in ["3", 3]:
-            return res
+            return ProfileInformation(res) if cmd == "FT.PROFILE" else res
         else:
             return self._RESP2_MODULE_CALLBACKS[cmd](res, **kwargs)
 
@@ -101,7 +102,7 @@ class SearchCommands:
                 with_scores=query._with_scores,
             )
 
-        return result, parse_to_dict(res[1])
+        return result, ProfileInformation(res[1])
 
     def _parse_spellcheck(self, res, **kwargs):
         corrections = {}
@@ -254,8 +255,18 @@ class SearchCommands:
 
         For more information see `FT.DROPINDEX <https://redis.io/commands/ft.dropindex>`_.
         """  # noqa
-        delete_str = "DD" if delete_documents else ""
-        return self.execute_command(DROPINDEX_CMD, self.index_name, delete_str)
+        args = [DROPINDEX_CMD, self.index_name]
+
+        delete_str = (
+            "DD"
+            if isinstance(delete_documents, bool) and delete_documents is True
+            else ""
+        )
+
+        if delete_str:
+            args.append(delete_str)
+
+        return self.execute_command(*args)
 
     def _add_document(
         self,
@@ -499,7 +510,7 @@ class SearchCommands:
         For more information see `FT.SEARCH <https://redis.io/commands/ft.search>`_.
         """  # noqa
         args, query = self._mk_query_args(query, query_params=query_params)
-        st = time.time()
+        st = time.monotonic()
 
         options = {}
         if get_protocol_version(self.client) not in ["3", 3]:
@@ -511,7 +522,7 @@ class SearchCommands:
             return res
 
         return self._parse_results(
-            SEARCH_CMD, res, query=query, duration=(time.time() - st) * 1000.0
+            SEARCH_CMD, res, query=query, duration=(time.monotonic() - st) * 1000.0
         )
 
     def explain(
@@ -585,7 +596,7 @@ class SearchCommands:
 
     def profile(
         self,
-        query: Union[str, Query, AggregateRequest],
+        query: Union[Query, AggregateRequest],
         limited: bool = False,
         query_params: Optional[Dict[str, Union[str, int, float]]] = None,
     ):
@@ -595,13 +606,13 @@ class SearchCommands:
 
         ### Parameters
 
-        **query**: This can be either an `AggregateRequest`, `Query` or string.
+        **query**: This can be either an `AggregateRequest` or `Query`.
         **limited**: If set to True, removes details of reader iterator.
         **query_params**: Define one or more value parameters.
         Each parameter has a name and a value.
 
         """
-        st = time.time()
+        st = time.monotonic()
         cmd = [PROFILE_CMD, self.index_name, ""]
         if limited:
             cmd.append("LIMITED")
@@ -620,7 +631,7 @@ class SearchCommands:
         res = self.execute_command(*cmd)
 
         return self._parse_results(
-            PROFILE_CMD, res, query=query, duration=(time.time() - st) * 1000.0
+            PROFILE_CMD, res, query=query, duration=(time.monotonic() - st) * 1000.0
         )
 
     def spellcheck(self, query, distance=None, include=None, exclude=None):
@@ -691,6 +702,10 @@ class SearchCommands:
         cmd = [DICT_DUMP_CMD, name]
         return self.execute_command(*cmd)
 
+    @deprecated_function(
+        version="8.0.0",
+        reason="deprecated since Redis 8.0, call config_set from core module instead",
+    )
     def config_set(self, option: str, value: str) -> bool:
         """Set runtime configuration option.
 
@@ -705,6 +720,10 @@ class SearchCommands:
         raw = self.execute_command(*cmd)
         return raw == "OK"
 
+    @deprecated_function(
+        version="8.0.0",
+        reason="deprecated since Redis 8.0, call config_get from core module instead",
+    )
     def config_get(self, option: str) -> str:
         """Get runtime configuration option value.
 
@@ -931,7 +950,7 @@ class AsyncSearchCommands(SearchCommands):
         For more information see `FT.SEARCH <https://redis.io/commands/ft.search>`_.
         """  # noqa
         args, query = self._mk_query_args(query, query_params=query_params)
-        st = time.time()
+        st = time.monotonic()
 
         options = {}
         if get_protocol_version(self.client) not in ["3", 3]:
@@ -943,7 +962,7 @@ class AsyncSearchCommands(SearchCommands):
             return res
 
         return self._parse_results(
-            SEARCH_CMD, res, query=query, duration=(time.time() - st) * 1000.0
+            SEARCH_CMD, res, query=query, duration=(time.monotonic() - st) * 1000.0
         )
 
     async def aggregate(
@@ -1006,6 +1025,10 @@ class AsyncSearchCommands(SearchCommands):
 
         return self._parse_results(SPELLCHECK_CMD, res)
 
+    @deprecated_function(
+        version="8.0.0",
+        reason="deprecated since Redis 8.0, call config_set from core module instead",
+    )
     async def config_set(self, option: str, value: str) -> bool:
         """Set runtime configuration option.
 
@@ -1020,6 +1043,10 @@ class AsyncSearchCommands(SearchCommands):
         raw = await self.execute_command(*cmd)
         return raw == "OK"
 
+    @deprecated_function(
+        version="8.0.0",
+        reason="deprecated since Redis 8.0, call config_get from core module instead",
+    )
     async def config_get(self, option: str) -> str:
         """Get runtime configuration option value.
 

redis/commands/search/dialect.py

@@ -0,0 +1,3 @@
+# Value for the default dialect to be used as a part of
+# Search or Aggregate query.
+DEFAULT_DIALECT = 2

redis/commands/search/profile_information.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+
+class ProfileInformation:
+    """
+    Wrapper around FT.PROFILE response
+    """
+
+    def __init__(self, info: Any) -> None:
+        self._info: Any = info
+
+    @property
+    def info(self) -> Any:
+        return self._info

redis/commands/search/query.py

@@ -1,5 +1,7 @@
 from typing import List, Optional, Union
 
+from redis.commands.search.dialect import DEFAULT_DIALECT
+
 
 class Query:
     """
@@ -40,7 +42,7 @@ class Query:
         self._highlight_fields: List = []
         self._language: Optional[str] = None
         self._expander: Optional[str] = None
-        self._dialect: Optional[int] = None
+        self._dialect: int = DEFAULT_DIALECT
 
     def query_string(self) -> str:
         """Return the query string of this query only."""
@@ -177,6 +179,8 @@ class Query:
         Use a different scoring function to evaluate document relevance.
         Default is `TFIDF`.
 
+        Since Redis 8.0 default was changed to BM25STD.
+
         :param scorer: The scoring function to use
                        (e.g. `TFIDF.DOCNORM` or `BM25`)
         """

redis/commands/vectorset/__init__.py

@@ -0,0 +1,46 @@
+import json
+
+from redis._parsers.helpers import pairs_to_dict
+from redis.commands.vectorset.utils import (
+    parse_vemb_result,
+    parse_vlinks_result,
+    parse_vsim_result,
+)
+
+from ..helpers import get_protocol_version
+from .commands import (
+    VEMB_CMD,
+    VGETATTR_CMD,
+    VINFO_CMD,
+    VLINKS_CMD,
+    VSIM_CMD,
+    VectorSetCommands,
+)
+
+
+class VectorSet(VectorSetCommands):
+    def __init__(self, client, **kwargs):
+        """Create a new VectorSet client."""
+        # Set the module commands' callbacks
+        self._MODULE_CALLBACKS = {
+            VEMB_CMD: parse_vemb_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 = {}
+
+        self.client = client
+        self.execute_command = client.execute_command
+
+        if get_protocol_version(self.client) in ["3", 3]:
+            self._MODULE_CALLBACKS.update(self._RESP3_MODULE_CALLBACKS)
+        else:
+            self._MODULE_CALLBACKS.update(self._RESP2_MODULE_CALLBACKS)
+
+        for k, v in self._MODULE_CALLBACKS.items():
+            self.client.set_response_callback(k, v)