redis 6.0.0b1__py3-none-any.whl → 6.0.0b2__py3-none-any.whl

redis/__init__.py

@@ -42,7 +42,7 @@ def int_or_str(value):
         return value
 
 
-__version__ = "6.0.0b1"
+__version__ = "6.0.0b2"
 VERSION = tuple(map(int_or_str, __version__.split(".")))
 
 

redis/asyncio/client.py

@@ -77,12 +77,14 @@ from redis.utils import (
     get_lib_version,
     safe_str,
     str_if_bytes,
+    truncate_text,
 )
 
 if TYPE_CHECKING and SSL_AVAILABLE:
-    from ssl import TLSVersion
+    from ssl import TLSVersion, VerifyMode
 else:
     TLSVersion = None
+    VerifyMode = None
 
 PubSubHandler = Callable[[Dict[str, str]], Awaitable[None]]
 _KeyT = TypeVar("_KeyT", bound=KeyT)
@@ -227,7 +229,7 @@ class Redis(
         ssl: bool = False,
         ssl_keyfile: Optional[str] = None,
         ssl_certfile: Optional[str] = None,
-        ssl_cert_reqs: str = "required",
+        ssl_cert_reqs: Union[str, VerifyMode] = "required",
         ssl_ca_certs: Optional[str] = None,
         ssl_ca_data: Optional[str] = None,
         ssl_check_hostname: bool = False,
@@ -1513,7 +1515,10 @@ class Pipeline(Redis):  # lgtm [py/init-calls-subclass]
         self, exception: Exception, number: int, command: Iterable[object]
     ) -> None:
         cmd = " ".join(map(safe_str, command))
-        msg = f"Command # {number} ({cmd}) of pipeline caused error: {exception.args}"
+        msg = (
+            f"Command # {number} ({truncate_text(cmd)}) "
+            "of pipeline caused error: {exception.args}"
+        )
         exception.args = (msg,) + exception.args[1:]
 
     async def parse_response(

redis/asyncio/cluster.py

@@ -71,12 +71,14 @@ from redis.utils import (
     get_lib_version,
     safe_str,
     str_if_bytes,
+    truncate_text,
 )
 
 if SSL_AVAILABLE:
-    from ssl import TLSVersion
+    from ssl import TLSVersion, VerifyMode
 else:
     TLSVersion = None
+    VerifyMode = None
 
 TargetNodesT = TypeVar(
     "TargetNodesT", str, "ClusterNode", List["ClusterNode"], Dict[Any, "ClusterNode"]
@@ -267,7 +269,7 @@ class RedisCluster(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterCommand
         ssl: bool = False,
         ssl_ca_certs: Optional[str] = None,
         ssl_ca_data: Optional[str] = None,
-        ssl_cert_reqs: str = "required",
+        ssl_cert_reqs: Union[str, VerifyMode] = "required",
         ssl_certfile: Optional[str] = None,
         ssl_check_hostname: bool = False,
         ssl_keyfile: Optional[str] = None,
@@ -1633,8 +1635,9 @@ class ClusterPipeline(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterComm
                     if isinstance(result, Exception):
                         command = " ".join(map(safe_str, cmd.args))
                         msg = (
-                            f"Command # {cmd.position + 1} ({command}) of pipeline "
-                            f"caused error: {result.args}"
+                            f"Command # {cmd.position + 1} "
+                            f"({truncate_text(command)}) "
+                            f"of pipeline caused error: {result.args}"
                         )
                         result.args = (msg,) + result.args[1:]
                         raise result

redis/asyncio/connection.py

@@ -293,6 +293,9 @@ class AbstractConnection:
 
     async def connect(self):
         """Connects to the Redis server if not already connected"""
+        await self.connect_check_health(check_health=True)
+
+    async def connect_check_health(self, check_health: bool = True):
         if self.is_connected:
             return
         try:
@@ -311,7 +314,7 @@ class AbstractConnection:
         try:
             if not self.redis_connect_func:
                 # Use the default on_connect function
-                await self.on_connect()
+                await self.on_connect_check_health(check_health=check_health)
             else:
                 # Use the passed function redis_connect_func
                 (
@@ -350,6 +353,9 @@ class AbstractConnection:
 
     async def on_connect(self) -> None:
         """Initialize the connection, authenticate and select a database"""
+        await self.on_connect_check_health(check_health=True)
+
+    async def on_connect_check_health(self, check_health: bool = True) -> None:
         self._parser.on_connect(self)
         parser = self._parser
 
@@ -407,7 +413,7 @@ class AbstractConnection:
                 # update cluster exception classes
                 self._parser.EXCEPTION_CLASSES = parser.EXCEPTION_CLASSES
                 self._parser.on_connect(self)
-            await self.send_command("HELLO", self.protocol)
+            await self.send_command("HELLO", self.protocol, check_health=check_health)
             response = await self.read_response()
             # if response.get(b"proto") != self.protocol and response.get(
             #     "proto"
@@ -416,18 +422,35 @@ class AbstractConnection:
 
         # if a client_name is given, set it
         if self.client_name:
-            await self.send_command("CLIENT", "SETNAME", self.client_name)
+            await self.send_command(
+                "CLIENT",
+                "SETNAME",
+                self.client_name,
+                check_health=check_health,
+            )
             if str_if_bytes(await self.read_response()) != "OK":
                 raise ConnectionError("Error setting client name")
 
         # set the library name and version, pipeline for lower startup latency
         if self.lib_name:
-            await self.send_command("CLIENT", "SETINFO", "LIB-NAME", self.lib_name)
+            await self.send_command(
+                "CLIENT",
+                "SETINFO",
+                "LIB-NAME",
+                self.lib_name,
+                check_health=check_health,
+            )
         if self.lib_version:
-            await self.send_command("CLIENT", "SETINFO", "LIB-VER", self.lib_version)
+            await self.send_command(
+                "CLIENT",
+                "SETINFO",
+                "LIB-VER",
+                self.lib_version,
+                check_health=check_health,
+            )
         # if a database is specified, switch to it. Also pipeline this
         if self.db:
-            await self.send_command("SELECT", self.db)
+            await self.send_command("SELECT", self.db, check_health=check_health)
 
         # read responses from pipeline
         for _ in (sent for sent in (self.lib_name, self.lib_version) if sent):
@@ -489,8 +512,8 @@ class AbstractConnection:
         self, command: Union[bytes, str, Iterable[bytes]], check_health: bool = True
     ) -> None:
         if not self.is_connected:
-            await self.connect()
-        elif check_health:
+            await self.connect_check_health(check_health=False)
+        if check_health:
             await self.check_health()
 
         try:
@@ -768,7 +791,7 @@ class SSLConnection(Connection):
         self,
         ssl_keyfile: Optional[str] = None,
         ssl_certfile: Optional[str] = None,
-        ssl_cert_reqs: str = "required",
+        ssl_cert_reqs: Union[str, ssl.VerifyMode] = "required",
         ssl_ca_certs: Optional[str] = None,
         ssl_ca_data: Optional[str] = None,
         ssl_check_hostname: bool = False,
@@ -842,7 +865,7 @@ class RedisSSLContext:
         self,
         keyfile: Optional[str] = None,
         certfile: Optional[str] = None,
-        cert_reqs: Optional[str] = None,
+        cert_reqs: Optional[Union[str, ssl.VerifyMode]] = None,
         ca_certs: Optional[str] = None,
         ca_data: Optional[str] = None,
         check_hostname: bool = False,
@@ -855,7 +878,7 @@ class RedisSSLContext:
         self.keyfile = keyfile
         self.certfile = certfile
         if cert_reqs is None:
-            self.cert_reqs = ssl.CERT_NONE
+            cert_reqs = ssl.CERT_NONE
         elif isinstance(cert_reqs, str):
             CERT_REQS = {  # noqa: N806
                 "none": ssl.CERT_NONE,
@@ -866,7 +889,8 @@ class RedisSSLContext:
                 raise RedisError(
                     f"Invalid SSL Certificate Requirements Flag: {cert_reqs}"
                 )
-            self.cert_reqs = CERT_REQS[cert_reqs]
+            cert_reqs = CERT_REQS[cert_reqs]
+        self.cert_reqs = cert_reqs
         self.ca_certs = ca_certs
         self.ca_data = ca_data
         self.check_hostname = check_hostname

redis/asyncio/sentinel.py

@@ -326,6 +326,8 @@ class Sentinel(AsyncSentinelCommands):
     ):
         """
         Returns a redis client instance for the ``service_name`` master.
+        Sentinel client will detect failover and reconnect Redis clients
+        automatically.
 
         A :py:class:`~redis.sentinel.SentinelConnectionPool` class is
         used to retrieve the master's address before establishing a new

redis/client.py

@@ -61,6 +61,7 @@ from redis.utils import (
     get_lib_version,
     safe_str,
     str_if_bytes,
+    truncate_text,
 )
 
 if TYPE_CHECKING:
@@ -210,7 +211,7 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
         ssl: bool = False,
         ssl_keyfile: Optional[str] = None,
         ssl_certfile: Optional[str] = None,
-        ssl_cert_reqs: str = "required",
+        ssl_cert_reqs: Union[str, "ssl.VerifyMode"] = "required",
         ssl_ca_certs: Optional[str] = None,
         ssl_ca_path: Optional[str] = None,
         ssl_ca_data: Optional[str] = None,
@@ -1524,7 +1525,8 @@ class Pipeline(Redis):
     def annotate_exception(self, exception, number, command):
         cmd = " ".join(map(safe_str, command))
         msg = (
-            f"Command # {number} ({cmd}) of pipeline caused error: {exception.args[0]}"
+            f"Command # {number} ({truncate_text(cmd)}) of pipeline "
+            f"caused error: {exception.args[0]}"
         )
         exception.args = (msg,) + exception.args[1:]
 

redis/cluster.py

@@ -47,6 +47,7 @@ from redis.utils import (
     merge_result,
     safe_str,
     str_if_bytes,
+    truncate_text,
 )
 
 
@@ -2125,7 +2126,8 @@ class ClusterPipeline(RedisCluster):
         """
         cmd = " ".join(map(safe_str, command))
         msg = (
-            f"Command # {number} ({cmd}) of pipeline caused error: {exception.args[0]}"
+            f"Command # {number} ({truncate_text(cmd)}) of pipeline "
+            f"caused error: {exception.args[0]}"
         )
         exception.args = (msg,) + exception.args[1:]
 

redis/commands/core.py

@@ -6556,7 +6556,7 @@ class FunctionCommands:
         This is a read-only variant of the FCALL command that cannot
         execute commands that modify data.
 
-        For more information see https://redis.io/commands/fcal_ro
+        For more information see https://redis.io/commands/fcall_ro
         """
         return self._fcall("FCALL_RO", function, numkeys, *keys_and_args)
 

redis/commands/redismodules.py

@@ -72,6 +72,14 @@ class RedisModuleCommands:
         tdigest = TDigestBloom(client=self)
         return tdigest
 
+    def vset(self):
+        """Access the VectorSet commands namespace."""
+
+        from .vectorset import VectorSet
+
+        vset = VectorSet(client=self)
+        return vset
+
 
 class AsyncRedisModuleCommands(RedisModuleCommands):
     def ft(self, index_name="idx"):

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)

redis/commands/vectorset/commands.py

@@ -0,0 +1,367 @@
+import json
+from enum import Enum
+from typing import Awaitable, Dict, List, Optional, Union
+
+from redis.client import NEVER_DECODE
+from redis.commands.helpers import get_protocol_version
+from redis.exceptions import DataError
+from redis.typing import CommandsProtocol, EncodableT, KeyT, Number
+
+VADD_CMD = "VADD"
+VSIM_CMD = "VSIM"
+VREM_CMD = "VREM"
+VDIM_CMD = "VDIM"
+VCARD_CMD = "VCARD"
+VEMB_CMD = "VEMB"
+VLINKS_CMD = "VLINKS"
+VINFO_CMD = "VINFO"
+VSETATTR_CMD = "VSETATTR"
+VGETATTR_CMD = "VGETATTR"
+VRANDMEMBER_CMD = "VRANDMEMBER"
+
+
+class QuantizationOptions(Enum):
+    """Quantization options for the VADD command."""
+
+    NOQUANT = "NOQUANT"
+    BIN = "BIN"
+    Q8 = "Q8"
+
+
+class CallbacksOptions(Enum):
+    """Options that can be set for the commands callbacks"""
+
+    RAW = "RAW"
+    WITHSCORES = "WITHSCORES"
+    ALLOW_DECODING = "ALLOW_DECODING"
+    RESP3 = "RESP3"
+
+
+class VectorSetCommands(CommandsProtocol):
+    """Redis VectorSet commands"""
+
+    def vadd(
+        self,
+        key: KeyT,
+        vector: Union[List[float], bytes],
+        element: str,
+        reduce_dim: Optional[int] = None,
+        cas: Optional[bool] = False,
+        quantization: Optional[QuantizationOptions] = None,
+        ef: Optional[Number] = None,
+        attributes: Optional[Union[dict, str]] = None,
+        numlinks: Optional[int] = None,
+    ) -> Union[Awaitable[int], int]:
+        """
+        Add vector ``vector`` for element ``element`` to a vector set ``key``.
+
+        ``reduce_dim`` sets the dimensions to reduce the vector to.
+                If not provided, the vector is not reduced.
+
+        ``cas`` is a boolean flag that indicates whether to use CAS (check-and-set style)
+                when adding the vector. If not provided, CAS is not used.
+
+        ``quantization`` sets the quantization type to use.
+                If not provided, int8 quantization is used.
+                The options are:
+                - NOQUANT: No quantization
+                - BIN: Binary quantization
+                - Q8: Signed 8-bit quantization
+
+        ``ef`` sets the exploration factor to use.
+                If not provided, the default exploration factor is used.
+
+        ``attributes`` is a dictionary or json string that contains the attributes to set for the vector.
+                If not provided, no attributes are set.
+
+        ``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
+        """
+        if not vector or not element:
+            raise DataError("Both vector and element must be provided")
+
+        pieces = []
+        if reduce_dim:
+            pieces.extend(["REDUCE", reduce_dim])
+
+        values_pieces = []
+        if isinstance(vector, bytes):
+            values_pieces.extend(["FP32", vector])
+        else:
+            values_pieces.extend(["VALUES", len(vector)])
+            values_pieces.extend(vector)
+        pieces.extend(values_pieces)
+
+        pieces.append(element)
+
+        if cas:
+            pieces.append("CAS")
+
+        if quantization:
+            pieces.append(quantization.value)
+
+        if ef:
+            pieces.extend(["EF", ef])
+
+        if attributes:
+            if isinstance(attributes, dict):
+                # transform attributes to json string
+                attributes_json = json.dumps(attributes)
+            else:
+                attributes_json = attributes
+            pieces.extend(["SETATTR", attributes_json])
+
+        if numlinks:
+            pieces.extend(["M", numlinks])
+
+        return self.execute_command(VADD_CMD, key, *pieces)
+
+    def vsim(
+        self,
+        key: KeyT,
+        input: Union[List[float], bytes, str],
+        with_scores: Optional[bool] = False,
+        count: Optional[int] = None,
+        ef: Optional[Number] = None,
+        filter: Optional[str] = None,
+        filter_ef: Optional[str] = None,
+        truth: Optional[bool] = False,
+        no_thread: Optional[bool] = False,
+    ) -> Union[
+        Awaitable[Optional[List[Union[List[EncodableT], Dict[EncodableT, Number]]]]],
+        Optional[List[Union[List[EncodableT], Dict[EncodableT, Number]]]],
+    ]:
+        """
+        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.
+
+        ``count`` sets the number of results to return.
+
+        ``ef`` sets the exploration factor.
+
+        ``filter`` sets 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.
+
+        ``no_thread`` when enabled forces the command to execute the search
+                on the data structure in the main thread.
+
+        For more information see https://redis.io/commands/vsim
+        """
+
+        if not input:
+            raise DataError("'input' should be provided")
+
+        pieces = []
+        options = {}
+
+        if isinstance(input, bytes):
+            pieces.extend(["FP32", input])
+        elif isinstance(input, list):
+            pieces.extend(["VALUES", len(input)])
+            pieces.extend(input)
+        else:
+            pieces.extend(["ELE", input])
+
+        if with_scores:
+            pieces.append("WITHSCORES")
+            options[CallbacksOptions.WITHSCORES.value] = True
+
+        if count:
+            pieces.extend(["COUNT", count])
+
+        if ef:
+            pieces.extend(["EF", ef])
+
+        if filter:
+            pieces.extend(["FILTER", filter])
+
+        if filter_ef:
+            pieces.extend(["FILTER-EF", filter_ef])
+
+        if truth:
+            pieces.append("TRUTH")
+
+        if no_thread:
+            pieces.append("NOTHREAD")
+
+        return self.execute_command(VSIM_CMD, key, *pieces, **options)
+
+    def vdim(self, key: KeyT) -> Union[Awaitable[int], int]:
+        """
+        Get the dimension of a vector set.
+
+        In the case of vectors that were populated using the `REDUCE`
+        option, for random projection, the vector set will report the size of
+        the projected (reduced) dimension.
+
+        Raises `redis.exceptions.ResponseError` if the vector set doesn't exist.
+
+        For more information see https://redis.io/commands/vdim
+        """
+        return self.execute_command(VDIM_CMD, key)
+
+    def vcard(self, key: KeyT) -> Union[Awaitable[int], int]:
+        """
+        Get the cardinality(the number of elements) of a vector set with key ``key``.
+
+        Raises `redis.exceptions.ResponseError` if the vector set doesn't exist.
+
+        For more information see https://redis.io/commands/vcard
+        """
+        return self.execute_command(VCARD_CMD, key)
+
+    def vrem(self, key: KeyT, element: str) -> Union[Awaitable[int], int]:
+        """
+        Remove an element from a vector set.
+
+        For more information see https://redis.io/commands/vrem
+        """
+        return self.execute_command(VREM_CMD, key, element)
+
+    def vemb(
+        self, key: KeyT, element: str, raw: Optional[bool] = False
+    ) -> Union[
+        Awaitable[Optional[Union[List[EncodableT], Dict[str, EncodableT]]]],
+        Optional[Union[List[EncodableT], Dict[str, EncodableT]]],
+    ]:
+        """
+        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.
+
+
+        For more information see https://redis.io/commands/vembed
+        """
+        options = {}
+        pieces = []
+        pieces.extend([key, element])
+
+        if get_protocol_version(self.client) in ["3", 3]:
+            options[CallbacksOptions.RESP3.value] = True
+
+        if raw:
+            pieces.append("RAW")
+
+            options[NEVER_DECODE] = True
+            if (
+                hasattr(self.client, "connection_pool")
+                and self.client.connection_pool.connection_kwargs["decode_responses"]
+            ) or (
+                hasattr(self.client, "nodes_manager")
+                and self.client.nodes_manager.connection_kwargs["decode_responses"]
+            ):
+                # allow decoding in the postprocessing callback
+                # if the user set decode_responses=True
+                # in the connection pool
+                options[CallbacksOptions.ALLOW_DECODING.value] = True
+
+            options[CallbacksOptions.RAW.value] = True
+
+        return self.execute_command(VEMB_CMD, *pieces, **options)
+
+    def vlinks(
+        self, key: KeyT, element: str, with_scores: Optional[bool] = False
+    ) -> Union[
+        Awaitable[
+            Optional[
+                List[Union[List[Union[str, bytes]], Dict[Union[str, bytes], Number]]]
+            ]
+        ],
+        Optional[List[Union[List[Union[str, bytes]], Dict[Union[str, bytes], Number]]]],
+    ]:
+        """
+        Returns the neighbors for each level the element ``element`` exists in the vector set ``key``.
+
+        The result is a list of lists, where each list contains the neighbors for one level.
+        If the element does not exist, or if the vector set does not exist, None is returned.
+
+        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
+        """
+        options = {}
+        pieces = []
+        pieces.extend([key, element])
+
+        if with_scores:
+            pieces.append("WITHSCORES")
+            options[CallbacksOptions.WITHSCORES.value] = True
+
+        return self.execute_command(VLINKS_CMD, *pieces, **options)
+
+    def vinfo(self, key: KeyT) -> Union[Awaitable[dict], dict]:
+        """
+        Get information about a vector set.
+
+        For more information see https://redis.io/commands/vinfo
+        """
+        return self.execute_command(VINFO_CMD, key)
+
+    def vsetattr(
+        self, key: KeyT, element: str, attributes: Optional[Union[dict, str]] = None
+    ) -> Union[Awaitable[int], int]:
+        """
+        Associate or remove JSON attributes ``attributes`` of element ``element``
+        for vector set ``key``.
+
+        For more information see https://redis.io/commands/vsetattr
+        """
+        if attributes is None:
+            attributes_json = "{}"
+        elif isinstance(attributes, dict):
+            # transform attributes to json string
+            attributes_json = json.dumps(attributes)
+        else:
+            attributes_json = attributes
+
+        return self.execute_command(VSETATTR_CMD, key, element, attributes_json)
+
+    def vgetattr(
+        self, key: KeyT, element: str
+    ) -> Union[Optional[Awaitable[dict]], Optional[dict]]:
+        """
+        Retrieve the JSON attributes of an element ``elemet`` 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
+        """
+        return self.execute_command(VGETATTR_CMD, key, element)
+
+    def vrandmember(
+        self, key: KeyT, count: Optional[int] = None
+    ) -> Union[
+        Awaitable[Optional[Union[List[str], str]]], Optional[Union[List[str], str]]
+    ]:
+        """
+        Returns random elements from a vector set ``key``.
+
+        ``count`` is the number of elements to return.
+                If ``count`` is not provided, a single element is returned as a single string.
+                If ``count`` is positive(smaller than the number of elements
+                            in the vector set), the command returns a list with up to ``count``
+                            distinct elements from the vector set
+                If ``count`` is negative, the command returns a list with ``count`` random elements,
+                            potentially with duplicates.
+                If ``count`` is greater than the number of elements in the vector set,
+                            only the entire set is returned as a list.
+
+        If the vector set does not exist, ``None`` is returned.
+
+        For more information see https://redis.io/commands/vrandmember
+        """
+        pieces = []
+        pieces.append(key)
+        if count is not None:
+            pieces.append(count)
+        return self.execute_command(VRANDMEMBER_CMD, *pieces)

redis/commands/vectorset/utils.py

@@ -0,0 +1,94 @@
+from redis._parsers.helpers import pairs_to_dict
+from redis.commands.vectorset.commands import CallbacksOptions
+
+
+def parse_vemb_result(response, **options):
+    """
+    Handle VEMB result since the command can returning different result
+    structures depending on input options and on quantization type of the vector set.
+
+    Parsing VEMB result into:
+    - List[Union[bytes, Union[int, float]]]
+    - Dict[str, Union[bytes, str, float]]
+    """
+    if response is None:
+        return response
+
+    if options.get(CallbacksOptions.RAW.value):
+        result = {}
+        result["quantization"] = (
+            response[0].decode("utf-8")
+            if options.get(CallbacksOptions.ALLOW_DECODING.value)
+            else response[0]
+        )
+        result["raw"] = response[1]
+        result["l2"] = float(response[2])
+        if len(response) > 3:
+            result["range"] = float(response[3])
+        return result
+    else:
+        if options.get(CallbacksOptions.RESP3.value):
+            return response
+
+        result = []
+        for i in range(len(response)):
+            try:
+                result.append(int(response[i]))
+            except ValueError:
+                # if the value is not an integer, it should be a float
+                result.append(float(response[i]))
+
+        return result
+
+
+def parse_vlinks_result(response, **options):
+    """
+    Handle VLINKS result since the command can be returning different result
+    structures depending on input options.
+    Parsing VLINKS result into:
+    - List[List[str]]
+    - List[Dict[str, Number]]
+    """
+    if response is None:
+        return response
+
+    if options.get(CallbacksOptions.WITHSCORES.value):
+        result = []
+        # Redis will return a list of list of strings.
+        # This list have to be transformed to list of dicts
+        for level_item in response:
+            level_data_dict = {}
+            for key, value in pairs_to_dict(level_item).items():
+                value = float(value)
+                level_data_dict[key] = value
+            result.append(level_data_dict)
+        return result
+    else:
+        # return the list of elements for each level
+        # list of lists
+        return response
+
+
+def parse_vsim_result(response, **options):
+    """
+    Handle VSIM result since the command can be returning different result
+    structures depending on input options.
+    Parsing VSIM result into:
+    - List[List[str]]
+    - List[Dict[str, Number]]
+    """
+    if response is None:
+        return response
+
+    if options.get(CallbacksOptions.WITHSCORES.value):
+        # Redis will return a list of list of pairs.
+        # This list have to be transformed to dict
+        result_dict = {}
+        for key, value in pairs_to_dict(response).items():
+            value = float(value)
+            result_dict[key] = value
+        return result_dict
+    else:
+        # return the list of elements for each level
+        # list of lists
+        return response

redis/connection.py

@@ -376,6 +376,9 @@ class AbstractConnection(ConnectionInterface):
 
     def connect(self):
         "Connects to the Redis server if not already connected"
+        self.connect_check_health(check_health=True)
+
+    def connect_check_health(self, check_health: bool = True):
         if self._sock:
             return
         try:
@@ -391,7 +394,7 @@ class AbstractConnection(ConnectionInterface):
         try:
             if self.redis_connect_func is None:
                 # Use the default on_connect function
-                self.on_connect()
+                self.on_connect_check_health(check_health=check_health)
             else:
                 # Use the passed function redis_connect_func
                 self.redis_connect_func(self)
@@ -421,6 +424,9 @@ class AbstractConnection(ConnectionInterface):
         return format_error_message(self._host_error(), exception)
 
     def on_connect(self):
+        self.on_connect_check_health(check_health=True)
+
+    def on_connect_check_health(self, check_health: bool = True):
         "Initialize the connection, authenticate and select a database"
         self._parser.on_connect(self)
         parser = self._parser
@@ -479,7 +485,7 @@ class AbstractConnection(ConnectionInterface):
                 # update cluster exception classes
                 self._parser.EXCEPTION_CLASSES = parser.EXCEPTION_CLASSES
                 self._parser.on_connect(self)
-            self.send_command("HELLO", self.protocol)
+            self.send_command("HELLO", self.protocol, check_health=check_health)
             self.handshake_metadata = self.read_response()
             if (
                 self.handshake_metadata.get(b"proto") != self.protocol
@@ -489,28 +495,45 @@ class AbstractConnection(ConnectionInterface):
 
         # if a client_name is given, set it
         if self.client_name:
-            self.send_command("CLIENT", "SETNAME", self.client_name)
+            self.send_command(
+                "CLIENT",
+                "SETNAME",
+                self.client_name,
+                check_health=check_health,
+            )
             if str_if_bytes(self.read_response()) != "OK":
                 raise ConnectionError("Error setting client name")
 
         try:
             # set the library name and version
             if self.lib_name:
-                self.send_command("CLIENT", "SETINFO", "LIB-NAME", self.lib_name)
+                self.send_command(
+                    "CLIENT",
+                    "SETINFO",
+                    "LIB-NAME",
+                    self.lib_name,
+                    check_health=check_health,
+                )
                 self.read_response()
         except ResponseError:
             pass
 
         try:
             if self.lib_version:
-                self.send_command("CLIENT", "SETINFO", "LIB-VER", self.lib_version)
+                self.send_command(
+                    "CLIENT",
+                    "SETINFO",
+                    "LIB-VER",
+                    self.lib_version,
+                    check_health=check_health,
+                )
                 self.read_response()
         except ResponseError:
             pass
 
         # if a database is specified, switch to it
         if self.db:
-            self.send_command("SELECT", self.db)
+            self.send_command("SELECT", self.db, check_health=check_health)
             if str_if_bytes(self.read_response()) != "OK":
                 raise ConnectionError("Invalid Database")
 
@@ -552,7 +575,7 @@ class AbstractConnection(ConnectionInterface):
     def send_packed_command(self, command, check_health=True):
         """Send an already packed command to the Redis server"""
         if not self._sock:
-            self.connect()
+            self.connect_check_health(check_health=False)
         # guard against health check recursion
         if check_health:
             self.check_health()
@@ -764,6 +787,10 @@ class Connection(AbstractConnection):
             except OSError as _:
                 err = _
                 if sock is not None:
+                    try:
+                        sock.shutdown(socket.SHUT_RDWR)  # ensure a clean close
+                    except OSError:
+                        pass
                     sock.close()
 
         if err is not None:
@@ -1017,7 +1044,7 @@ class SSLConnection(Connection):
         Args:
             ssl_keyfile: Path to an ssl private key. Defaults to None.
             ssl_certfile: Path to an ssl certificate. Defaults to None.
-            ssl_cert_reqs: The string value for the SSLContext.verify_mode (none, optional, required). Defaults to "required".
+            ssl_cert_reqs: The string value for the SSLContext.verify_mode (none, optional, required), or an ssl.VerifyMode. Defaults to "required".
             ssl_ca_certs: The path to a file of concatenated CA certificates in PEM format. Defaults to None.
             ssl_ca_data: Either an ASCII string of one or more PEM-encoded certificates or a bytes-like object of DER-encoded certificates.
             ssl_check_hostname: If set, match the hostname during the SSL handshake. Defaults to False.
@@ -1179,6 +1206,10 @@ class UnixDomainSocketConnection(AbstractConnection):
             sock.connect(self.path)
         except OSError:
             # Prevent ResourceWarnings for unclosed sockets.
+            try:
+                sock.shutdown(socket.SHUT_RDWR)  # ensure a clean close
+            except OSError:
+                pass
             sock.close()
             raise
         sock.settimeout(self.socket_timeout)

redis/sentinel.py

@@ -349,6 +349,8 @@ class Sentinel(SentinelCommands):
     ):
         """
         Returns a redis client instance for the ``service_name`` master.
+        Sentinel client will detect failover and reconnect Redis clients
+        automatically.
 
         A :py:class:`~redis.sentinel.SentinelConnectionPool` class is
         used to retrieve the master's address before establishing a new

redis/utils.py

@@ -1,5 +1,6 @@
 import datetime
 import logging
+import textwrap
 from contextlib import contextmanager
 from functools import wraps
 from typing import Any, Dict, List, Mapping, Optional, Union
@@ -298,3 +299,9 @@ def extract_expire_flags(
         exp_options.extend(["PXAT", pxat])
 
     return exp_options
+
+
+def truncate_text(txt, max_length=100):
+    return textwrap.shorten(
+        text=txt, width=max_length, placeholder="...", break_long_words=True
+    )

{redis-6.0.0b1.dist-info → redis-6.0.0b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redis
-Version: 6.0.0b1
+Version: 6.0.0b2
 Summary: Python client for Redis database and key-value store
 Project-URL: Changes, https://github.com/redis/redis-py/releases
 Project-URL: Code, https://github.com/redis/redis-py

{redis-6.0.0b1.dist-info → redis-6.0.0b2.dist-info}/RECORD

@@ -1,9 +1,9 @@
-redis/__init__.py,sha256=6Q6GUD5kP-_gx4CNPPxvNEXkk9JopqQmfzDW3S4hpyA,1824
+redis/__init__.py,sha256=HqUOIkvNCUIXIazHsZTzgQFUuEF8ThizLYnusJ69ubs,1824
 redis/backoff.py,sha256=d22h74LEatJiFd_5o8HvFW3biFBotYOFZHddHt45ydc,3663
 redis/cache.py,sha256=68rJDNogvNwgdgBel6zSX9QziL11qsKIMhmvQvHvznM,9549
-redis/client.py,sha256=sFmv_c0vWpZiepzTPSbpao7aO4A-Wu0bX9bq7lAKiXA,62201
-redis/cluster.py,sha256=m7ucCyLYd7J3ke5vxfCy60KCogrE2D_QTVBnwFwuga8,98748
-redis/connection.py,sha256=lv9eC3jXSBTUwCqrrFbcQtiyz8rj3c9V4lmAPpc5Zhk,65508
+redis/client.py,sha256=36anNE36mK76rerheyoLmGiiRW91KcXkoLEnc-2oKB4,62276
+redis/cluster.py,sha256=ABMagl5AEHbCzlesI9AdzPFnIc-Ihb_DhPskyn5UG_I,98798
+redis/connection.py,sha256=Nx8n88ATiViym85Jlgkh2ETkShs303Wmwa8OP5KKYlI,66599
 redis/crc.py,sha256=Z3kXFtkY2LdgefnQMud1xr4vG5UYvA9LCMqNMX1ywu4,729
 redis/credentials.py,sha256=GOnO3-LSW34efHaIrUbS742Mw8l70mRzF6UrKiKZsMY,1828
 redis/event.py,sha256=urOK241IdgmCQ3fq7GqXRstZ2vcXRV14bBBMdN3latk,12129
@@ -12,9 +12,9 @@ redis/lock.py,sha256=GrvPSxaOqKo7iAL2oi5ZUEPsOkxAXHVE_Tp1ejgO2fY,12760
 redis/ocsp.py,sha256=teYSmKnCtk6B3jJLdNYbZN4OE0mxgspt2zUPbkIQzio,11452
 redis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 redis/retry.py,sha256=JiIDxeD890vgi_me8pwypO1LixwhU0Fv3A5NEay8SAY,2206
-redis/sentinel.py,sha256=mDIC_TKbkgRBP0JrLyBs0NkVi6-aWkBIMuqqMWgKFbk,14661
+redis/sentinel.py,sha256=DBphu6uNp6ZCSaVDSVC8nFhSxG93a12DnzgGWpyeh64,14757
 redis/typing.py,sha256=k7F_3Vtsexeb7mUl6txlwrY1veGDLEhtcHe9FwIJOOo,2149
-redis/utils.py,sha256=i7fltyT2JDVk6zqBZFeYlOcl3tXzJNq8kcDZZ8aXesE,8098
+redis/utils.py,sha256=XD4ySRo9JzLIMMpQY_q9MsxUIdEPee1d7rAq7xhmSwM,8268
 redis/_parsers/__init__.py,sha256=qkfgV2X9iyvQAvbLdSelwgz0dCk9SGAosCvuZC9-qDc,550
 redis/_parsers/base.py,sha256=WtCbM2CaOgHk7uxwWXA2KXDlZqfYA1EJrVX_NvdOZNk,7801
 redis/_parsers/commands.py,sha256=pmR4hl4u93UvCmeDgePHFc6pWDr4slrKEvCsdMmtj_M,11052
@@ -25,12 +25,12 @@ redis/_parsers/resp2.py,sha256=f22kH-_ZP2iNtOn6xOe65MSy_fJpu8OEn1u_hgeeojI,4813
 redis/_parsers/resp3.py,sha256=jHtL1LYJegJ_LiNTsjzIvS-kZyNR58jZ_YV4cRfwuN0,11127
 redis/_parsers/socket.py,sha256=CKD8QW_wFSNlIZzxlbNduaGpiv0I8wBcsGuAIojDfJg,5403
 redis/asyncio/__init__.py,sha256=uoDD8XYVi0Kj6mcufYwLDUTQXmBRx7a0bhKF9stZr7I,1489
-redis/asyncio/client.py,sha256=-U9sPfD2TD5jaW_fKOlcVzPKzYLshOnocRrFv74dRw8,61525
-redis/asyncio/cluster.py,sha256=Kb6xptqeiSpal6PH3KItJpfyFLjrZJ0Y3BoClDQ4kCc,66868
-redis/asyncio/connection.py,sha256=UI6CQX1TQz8yW5yqa-iv96tHn7fkuOOs13sdLglsr3Y,48061
+redis/asyncio/client.py,sha256=DHeSpWCjdMjhmq-d9-STRCIhKzjRNI4ISnwfczPs1ws,61651
+redis/asyncio/cluster.py,sha256=Nd6yG23Alv2kXz7Ffv4Fyp989b2l4zRJeJKD9xaMRIA,66987
+redis/asyncio/connection.py,sha256=6GFT5CJvTRTIAzYd6SxvLs6QtLcYUZhkQazwWUOjQvg,48875
 redis/asyncio/lock.py,sha256=GxgV6EsyKpMjh74KtaOPxh4fNPuwApz6Th46qhvrAws,12801
 redis/asyncio/retry.py,sha256=SnPPOlo5gcyIFtkC4DY7HFvmDgUaILsJ3DeHioogdB8,2219
-redis/asyncio/sentinel.py,sha256=HS5UbVlvrGuOcvQoFBHDXvf2YkYjUnKEhkxS_RG-oRk,14540
+redis/asyncio/sentinel.py,sha256=H7N_hvdATojwY06aH1AawFV-05AImqtOSAq0xKElbbk,14636
 redis/asyncio/utils.py,sha256=31xFzXczDgSRyf6hSjiwue1eDQ_XlP_OJdp5dKxW_aE,718
 redis/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 redis/auth/err.py,sha256=WYkbuDIzwp1S-eAvsya6QMlO6g9QIXbzMITOsTWX0xk,694
@@ -39,9 +39,9 @@ redis/auth/token.py,sha256=qYwAgxFW3S93QDUqp1BTsj7Pj9ZohnixGeOX0s7AsjY,3317
 redis/auth/token_manager.py,sha256=ShBsYXiBZBJBOMB_Y-pXfLwEOAmc9s1okaCECinNZ7g,12018
 redis/commands/__init__.py,sha256=cTUH-MGvaLYS0WuoytyqtN1wniw2A1KbkUXcpvOSY3I,576
 redis/commands/cluster.py,sha256=vdWdpl4mP51oqfYBZHg5CUXt6jPaNp7aCLHyTieDrt8,31248
-redis/commands/core.py,sha256=Ca_OhsXzLov3NTaSjIJvRGxzYmePKbdRxowrEbdh91w,238477
+redis/commands/core.py,sha256=dw1iVparHVoWBivdRNuEQXHNwP7_8cTJ-yj1uFZeDC4,238478
 redis/commands/helpers.py,sha256=f1BDIVgfjyE8xTyTjcVH_vffaNTSd6r1ScN_CcJFbmk,2950
-redis/commands/redismodules.py,sha256=y9gxuqY7PmUjpeKLzjQFcN_gZ2IVs36jxq7sSnvG9Nc,1966
+redis/commands/redismodules.py,sha256=H3lHeyWO-KrOmNn0dilebQyiHRCflED4tgXuswWpSGs,2143
 redis/commands/sentinel.py,sha256=hRcIQ9x9nEkdcCsJzo6Ves6vk-3tsfQqfJTT_v3oLY0,4110
 redis/commands/bf/__init__.py,sha256=qk4DA9KsMiP4WYqYeP1T5ScBwctsVtlLyMhrYIyq1Zc,8019
 redis/commands/bf/commands.py,sha256=xeKt8E7G8HB-l922J0DLg07CEIZTVNGx_2Lfyw1gIck,21283
@@ -69,7 +69,10 @@ redis/commands/timeseries/__init__.py,sha256=gkz6wshEzzQQryBOnrAqqQzttS-AHfXmuN_
 redis/commands/timeseries/commands.py,sha256=8Z2BEyP23qTYCJR_e9zdG11yWmIDwGBMO2PJNLtK2BA,47147
 redis/commands/timeseries/info.py,sha256=meZYdu7IV9KaUWMKZs9qW4vo3Q9MwhdY-EBtKQzls5o,3223
 redis/commands/timeseries/utils.py,sha256=NLwSOS5Dz9N8dYQSzEyBIvrItOWwfQ0xgDj8un6x3dU,1319
-redis-6.0.0b1.dist-info/METADATA,sha256=RRAjsLblR6FuHuafiPdggI22QVT943Bq439D5zAARhk,10510
-redis-6.0.0b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-redis-6.0.0b1.dist-info/licenses/LICENSE,sha256=pXslClvwPXr-VbdAYzE_Ktt7ANVGwKsUmok5gzP-PMg,1074
-redis-6.0.0b1.dist-info/RECORD,,
+redis/commands/vectorset/__init__.py,sha256=_fM0UdYjuzs8YWIUjQGH9QX5FwI0So8_D-5ALWWrWFc,1322
+redis/commands/vectorset/commands.py,sha256=7CvQNFvkXuG3XPhHJ82y_oBYJwewRFz84aEi3OCH4Rw,12495
+redis/commands/vectorset/utils.py,sha256=N-x0URyg76XC39CNfBym6FkFCVgm5NthzWKBnc2H0Xc,2981
+redis-6.0.0b2.dist-info/METADATA,sha256=-hyuUYoQOMznsT5hBjAPVD60AIAwWL6nCiJp1yWBgmE,10510
+redis-6.0.0b2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+redis-6.0.0b2.dist-info/licenses/LICENSE,sha256=pXslClvwPXr-VbdAYzE_Ktt7ANVGwKsUmok5gzP-PMg,1074
+redis-6.0.0b2.dist-info/RECORD,,