redis 6.2.0__tar.gz → 6.4.0__tar.gz

{redis-6.2.0 → redis-6.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redis
-Version: 6.2.0
+Version: 6.4.0
 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
@@ -43,7 +43,7 @@ Description-Content-Type: text/markdown
 The Python interface to the Redis key-value store.
 
 [![CI](https://github.com/redis/redis-py/workflows/CI/badge.svg?branch=master)](https://github.com/redis/redis-py/actions?query=workflow%3ACI+branch%3Amaster)
-[![docs](https://readthedocs.org/projects/redis/badge/?version=stable&style=flat)](https://redis-py.readthedocs.io/en/stable/)
+[![docs](https://readthedocs.org/projects/redis/badge/?version=stable&style=flat)](https://redis.readthedocs.io/en/stable/)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 [![pypi](https://badge.fury.io/py/redis.svg)](https://pypi.org/project/redis/)
 [![pre-release](https://img.shields.io/github/v/release/redis/redis-py?include_prereleases&label=latest-prerelease)](https://github.com/redis/redis-py/releases)
@@ -81,7 +81,7 @@ Start a redis via docker (for Redis versions < 8.0):
 
 ``` bash
 docker run -p 6379:6379 -it redis/redis-stack:latest
-
+```
 To install redis-py, simply:
 
 ``` bash
@@ -249,4 +249,4 @@ Special thanks to:
     system.
 -   Paul Hubbard for initial packaging support.
 
-[![Redis](./docs/_static/logo-redis.svg)](https://redis.io)
+[![Redis](./docs/_static/logo-redis.svg)](https://redis.io)

{redis-6.2.0 → redis-6.4.0}/README.md

@@ -3,7 +3,7 @@
 The Python interface to the Redis key-value store.
 
 [![CI](https://github.com/redis/redis-py/workflows/CI/badge.svg?branch=master)](https://github.com/redis/redis-py/actions?query=workflow%3ACI+branch%3Amaster)
-[![docs](https://readthedocs.org/projects/redis/badge/?version=stable&style=flat)](https://redis-py.readthedocs.io/en/stable/)
+[![docs](https://readthedocs.org/projects/redis/badge/?version=stable&style=flat)](https://redis.readthedocs.io/en/stable/)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 [![pypi](https://badge.fury.io/py/redis.svg)](https://pypi.org/project/redis/)
 [![pre-release](https://img.shields.io/github/v/release/redis/redis-py?include_prereleases&label=latest-prerelease)](https://github.com/redis/redis-py/releases)
@@ -41,7 +41,7 @@ Start a redis via docker (for Redis versions < 8.0):
 
 ``` bash
 docker run -p 6379:6379 -it redis/redis-stack:latest
-
+```
 To install redis-py, simply:
 
 ``` bash
@@ -209,4 +209,4 @@ Special thanks to:
     system.
 -   Paul Hubbard for initial packaging support.
 
-[![Redis](./docs/_static/logo-redis.svg)](https://redis.io)
+[![Redis](./docs/_static/logo-redis.svg)](https://redis.io)

{redis-6.2.0 → redis-6.4.0}/redis/__init__.py

@@ -20,6 +20,7 @@ from redis.exceptions import (
     DataError,
     InvalidPipelineStack,
     InvalidResponse,
+    MaxConnectionsError,
     OutOfMemoryError,
     PubSubError,
     ReadOnlyError,
@@ -45,8 +46,7 @@ def int_or_str(value):
         return value
 
 
-# This version is used when building the package for publishing
-__version__ = "6.2.0"
+__version__ = "6.4.0"
 VERSION = tuple(map(int_or_str, __version__.split(".")))
 
 
@@ -66,6 +66,7 @@ __all__ = [
     "default_backoff",
     "InvalidPipelineStack",
     "InvalidResponse",
+    "MaxConnectionsError",
     "OutOfMemoryError",
     "PubSubError",
     "ReadOnlyError",

{redis-6.2.0 → redis-6.4.0}/redis/_parsers/helpers.py

@@ -676,7 +676,8 @@ def parse_client_info(value):
         "omem",
         "tot-mem",
     }:
-        client_info[int_key] = int(client_info[int_key])
+        if int_key in client_info:
+            client_info[int_key] = int(client_info[int_key])
     return client_info
 
 

{redis-6.2.0 → redis-6.4.0}/redis/asyncio/cluster.py

@@ -814,7 +814,13 @@ class RedisCluster(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterCommand
                     moved = False
 
                 return await target_node.execute_command(*args, **kwargs)
-            except (BusyLoadingError, MaxConnectionsError):
+            except BusyLoadingError:
+                raise
+            except MaxConnectionsError:
+                # MaxConnectionsError indicates client-side resource exhaustion
+                # (too many connections in the pool), not a node failure.
+                # Don't treat this as a node failure - just re-raise the error
+                # without reinitializing the cluster.
                 raise
             except (ConnectionError, TimeoutError):
                 # Connection retries are being handled in the node's
@@ -1581,15 +1587,6 @@ class ClusterPipeline(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterComm
     def __await__(self) -> Generator[Any, None, "ClusterPipeline"]:
         return self.initialize().__await__()
 
-    def __enter__(self) -> "ClusterPipeline":
-        # TODO: Remove this method before 7.0.0
-        self._execution_strategy._command_queue = []
-        return self
-
-    def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None:
-        # TODO: Remove this method before 7.0.0
-        self._execution_strategy._command_queue = []
-
     def __bool__(self) -> bool:
         "Pipeline instances should  always evaluate to True on Python 3+"
         return True
@@ -2350,10 +2347,11 @@ class TransactionStrategy(AbstractStrategy):
         # watching something
         if self._transaction_connection:
             try:
-                # call this manually since our unwatch or
-                # immediate_execute_command methods can call reset()
-                await self._transaction_connection.send_command("UNWATCH")
-                await self._transaction_connection.read_response()
+                if self._watching:
+                    # call this manually since our unwatch or
+                    # immediate_execute_command methods can call reset()
+                    await self._transaction_connection.send_command("UNWATCH")
+                    await self._transaction_connection.read_response()
                 # we can safely return the connection to the pool here since we're
                 # sure we're no longer WATCHing anything
                 self._transaction_node.release(self._transaction_connection)

{redis-6.2.0 → redis-6.4.0}/redis/asyncio/connection.py

@@ -295,13 +295,18 @@ class AbstractConnection:
         """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):
+    async def connect_check_health(
+        self, check_health: bool = True, retry_socket_connect: bool = True
+    ):
         if self.is_connected:
             return
         try:
-            await self.retry.call_with_retry(
-                lambda: self._connect(), lambda error: self.disconnect()
-            )
+            if retry_socket_connect:
+                await self.retry.call_with_retry(
+                    lambda: self._connect(), lambda error: self.disconnect()
+                )
+            else:
+                await self._connect()
         except asyncio.CancelledError:
             raise  # in 3.7 and earlier, this is an Exception, not BaseException
         except (socket.timeout, asyncio.TimeoutError):
@@ -1037,6 +1042,7 @@ class ConnectionPool:
     By default, TCP connections are created unless ``connection_class``
     is specified. Use :py:class:`~redis.UnixDomainSocketConnection` for
     unix sockets.
+    :py:class:`~redis.SSLConnection` can be used for SSL enabled connections.
 
     Any additional keyword arguments are passed to the constructor of
     ``connection_class``.
@@ -1112,9 +1118,11 @@ class ConnectionPool:
             self._event_dispatcher = EventDispatcher()
 
     def __repr__(self):
+        conn_kwargs = ",".join([f"{k}={v}" for k, v in self.connection_kwargs.items()])
         return (
             f"<{self.__class__.__module__}.{self.__class__.__name__}"
-            f"({self.connection_class(**self.connection_kwargs)!r})>"
+            f"(<{self.connection_class.__module__}.{self.connection_class.__name__}"
+            f"({conn_kwargs})>)>"
         )
 
     def reset(self):

{redis-6.2.0 → redis-6.4.0}/redis/asyncio/retry.py

@@ -2,18 +2,16 @@ from asyncio import sleep
 from typing import TYPE_CHECKING, Any, Awaitable, Callable, Tuple, Type, TypeVar
 
 from redis.exceptions import ConnectionError, RedisError, TimeoutError
-
-if TYPE_CHECKING:
-    from redis.backoff import AbstractBackoff
-
+from redis.retry import AbstractRetry
 
 T = TypeVar("T")
 
+if TYPE_CHECKING:
+    from redis.backoff import AbstractBackoff
 
-class Retry:
-    """Retry a specific number of times after a failure"""
 
-    __slots__ = "_backoff", "_retries", "_supported_errors"
+class Retry(AbstractRetry[RedisError]):
+    __hash__ = AbstractRetry.__hash__
 
     def __init__(
         self,
@@ -24,36 +22,17 @@ class Retry:
             TimeoutError,
         ),
     ):
-        """
-        Initialize a `Retry` object with a `Backoff` object
-        that retries a maximum of `retries` times.
-        `retries` can be negative to retry forever.
-        You can specify the types of supported errors which trigger
-        a retry with the `supported_errors` parameter.
-        """
-        self._backoff = backoff
-        self._retries = retries
-        self._supported_errors = supported_errors
+        super().__init__(backoff, retries, supported_errors)
 
-    def update_supported_errors(self, specified_errors: list):
-        """
-        Updates the supported errors with the specified error types
-        """
-        self._supported_errors = tuple(
-            set(self._supported_errors + tuple(specified_errors))
-        )
-
-    def get_retries(self) -> int:
-        """
-        Get the number of retries.
-        """
-        return self._retries
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Retry):
+            return NotImplemented
 
-    def update_retries(self, value: int) -> None:
-        """
-        Set the number of retries.
-        """
-        self._retries = value
+        return (
+            self._backoff == other._backoff
+            and self._retries == other._retries
+            and set(self._supported_errors) == set(other._supported_errors)
+        )
 
     async def call_with_retry(
         self, do: Callable[[], Awaitable[T]], fail: Callable[[RedisError], Any]

{redis-6.2.0 → redis-6.4.0}/redis/asyncio/sentinel.py

@@ -11,8 +11,12 @@ from redis.asyncio.connection import (
     SSLConnection,
 )
 from redis.commands import AsyncSentinelCommands
-from redis.exceptions import ConnectionError, ReadOnlyError, ResponseError, TimeoutError
-from redis.utils import str_if_bytes
+from redis.exceptions import (
+    ConnectionError,
+    ReadOnlyError,
+    ResponseError,
+    TimeoutError,
+)
 
 
 class MasterNotFoundError(ConnectionError):
@@ -37,11 +41,10 @@ class SentinelManagedConnection(Connection):
 
     async def connect_to(self, address):
         self.host, self.port = address
-        await super().connect()
-        if self.connection_pool.check_connection:
-            await self.send_command("PING")
-            if str_if_bytes(await self.read_response()) != "PONG":
-                raise ConnectionError("PING failed")
+        await self.connect_check_health(
+            check_health=self.connection_pool.check_connection,
+            retry_socket_connect=False,
+        )
 
     async def _connect_retry(self):
         if self._reader:
@@ -223,19 +226,31 @@ class Sentinel(AsyncSentinelCommands):
         once - If set to True, then execute the resulting command on a single
                node at random, rather than across the entire sentinel cluster.
         """
-        once = bool(kwargs.get("once", False))
-        if "once" in kwargs.keys():
-            kwargs.pop("once")
+        once = bool(kwargs.pop("once", False))
+
+        # Check if command is supposed to return the original
+        # responses instead of boolean value.
+        return_responses = bool(kwargs.pop("return_responses", False))
 
         if once:
-            await random.choice(self.sentinels).execute_command(*args, **kwargs)
-        else:
-            tasks = [
-                asyncio.Task(sentinel.execute_command(*args, **kwargs))
-                for sentinel in self.sentinels
-            ]
-            await asyncio.gather(*tasks)
-        return True
+            response = await random.choice(self.sentinels).execute_command(
+                *args, **kwargs
+            )
+            if return_responses:
+                return [response]
+            else:
+                return True if response else False
+
+        tasks = [
+            asyncio.Task(sentinel.execute_command(*args, **kwargs))
+            for sentinel in self.sentinels
+        ]
+        responses = await asyncio.gather(*tasks)
+
+        if return_responses:
+            return responses
+
+        return all(responses)
 
     def __repr__(self):
         sentinel_addresses = []

{redis-6.2.0 → redis-6.4.0}/redis/backoff.py

@@ -170,7 +170,7 @@ class ExponentialWithJitterBackoff(AbstractBackoff):
         return hash((self._base, self._cap))
 
     def __eq__(self, other) -> bool:
-        if not isinstance(other, EqualJitterBackoff):
+        if not isinstance(other, ExponentialWithJitterBackoff):
             return NotImplemented
 
         return self._base == other._base and self._cap == other._cap

{redis-6.2.0 → redis-6.4.0}/redis/client.py

@@ -368,9 +368,7 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
         ]:
             raise RedisError("Client caching is only supported with RESP version 3")
 
-        # TODO: To avoid breaking changes during the bug fix, we have to keep non-reentrant lock.
-        # TODO: Remove this before next major version (7.0.0)
-        self.single_connection_lock = threading.Lock()
+        self.single_connection_lock = threading.RLock()
         self.connection = None
         self._single_connection_client = single_connection_client
         if self._single_connection_client:
@@ -450,7 +448,7 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
 
     def transaction(
         self, func: Callable[["Pipeline"], None], *watches, **kwargs
-    ) -> None:
+    ) -> Union[List[Any], Any, None]:
         """
         Convenience method for executing the callable `func` as a transaction
         while watching all keys specified in `watches`. The 'func' callable
@@ -776,9 +774,7 @@ class PubSub:
         else:
             self._event_dispatcher = event_dispatcher
 
-        # TODO: To avoid breaking changes during the bug fix, we have to keep non-reentrant lock.
-        # TODO: Remove this before next major version (7.0.0)
-        self._lock = threading.Lock()
+        self._lock = threading.RLock()
         if self.encoder is None:
             self.encoder = self.connection_pool.get_encoder()
         self.health_check_response_b = self.encoder.encode(self.HEALTH_CHECK_MESSAGE)

{redis-6.2.0 → redis-6.4.0}/redis/cluster.py

@@ -39,6 +39,7 @@ from redis.exceptions import (
     DataError,
     ExecAbortError,
     InvalidPipelineStack,
+    MaxConnectionsError,
     MovedError,
     RedisClusterException,
     RedisError,
@@ -856,7 +857,6 @@ class RedisCluster(AbstractRedisCluster, RedisClusterCommands):
             startup_nodes=self.nodes_manager.startup_nodes,
             result_callbacks=self.result_callbacks,
             cluster_response_callbacks=self.cluster_response_callbacks,
-            cluster_error_retry_attempts=self.retry.get_retries(),
             read_from_replicas=self.read_from_replicas,
             load_balancing_strategy=self.load_balancing_strategy,
             reinitialize_steps=self.reinitialize_steps,
@@ -1236,6 +1236,12 @@ class RedisCluster(AbstractRedisCluster, RedisClusterCommands):
                 return response
             except AuthenticationError:
                 raise
+            except MaxConnectionsError:
+                # MaxConnectionsError indicates client-side resource exhaustion
+                # (too many connections in the pool), not a node failure.
+                # Don't treat this as a node failure - just re-raise the error
+                # without reinitializing the cluster.
+                raise
             except (ConnectionError, TimeoutError) as e:
                 # ConnectionError can also be raised if we couldn't get a
                 # connection from the pool before timing out, so check that
@@ -3290,10 +3296,11 @@ class TransactionStrategy(AbstractStrategy):
         # watching something
         if self._transaction_connection:
             try:
-                # call this manually since our unwatch or
-                # immediate_execute_command methods can call reset()
-                self._transaction_connection.send_command("UNWATCH")
-                self._transaction_connection.read_response()
+                if self._watching:
+                    # call this manually since our unwatch or
+                    # immediate_execute_command methods can call reset()
+                    self._transaction_connection.send_command("UNWATCH")
+                    self._transaction_connection.read_response()
                 # we can safely return the connection to the pool here since we're
                 # sure we're no longer WATCHing anything
                 node = self._nodes_manager.find_connection_owner(

{redis-6.2.0 → redis-6.4.0}/redis/commands/core.py

@@ -3290,7 +3290,7 @@ class SetCommands(CommandsProtocol):
     see: https://redis.io/topics/data-types#sets
     """
 
-    def sadd(self, name: str, *values: FieldT) -> Union[Awaitable[int], int]:
+    def sadd(self, name: KeyT, *values: FieldT) -> Union[Awaitable[int], int]:
         """
         Add ``value(s)`` to set ``name``
 
@@ -3298,7 +3298,7 @@ class SetCommands(CommandsProtocol):
         """
         return self.execute_command("SADD", name, *values)
 
-    def scard(self, name: str) -> Union[Awaitable[int], int]:
+    def scard(self, name: KeyT) -> Union[Awaitable[int], int]:
         """
         Return the number of elements in set ``name``
 
@@ -3337,7 +3337,7 @@ class SetCommands(CommandsProtocol):
         return self.execute_command("SINTER", *args, keys=args)
 
     def sintercard(
-        self, numkeys: int, keys: List[str], limit: int = 0
+        self, numkeys: int, keys: List[KeyT], limit: int = 0
     ) -> Union[Awaitable[int], int]:
         """
         Return the cardinality of the intersect of multiple sets specified by ``keys``.
@@ -3352,7 +3352,7 @@ class SetCommands(CommandsProtocol):
         return self.execute_command("SINTERCARD", *args, keys=keys)
 
     def sinterstore(
-        self, dest: str, keys: List, *args: List
+        self, dest: KeyT, keys: List, *args: List
     ) -> Union[Awaitable[int], int]:
         """
         Store the intersection of sets specified by ``keys`` into a new
@@ -3364,7 +3364,7 @@ class SetCommands(CommandsProtocol):
         return self.execute_command("SINTERSTORE", dest, *args)
 
     def sismember(
-        self, name: str, value: str
+        self, name: KeyT, value: str
     ) -> Union[Awaitable[Union[Literal[0], Literal[1]]], Union[Literal[0], Literal[1]]]:
         """
         Return whether ``value`` is a member of set ``name``:
@@ -3375,7 +3375,7 @@ class SetCommands(CommandsProtocol):
         """
         return self.execute_command("SISMEMBER", name, value, keys=[name])
 
-    def smembers(self, name: str) -> Union[Awaitable[Set], Set]:
+    def smembers(self, name: KeyT) -> Union[Awaitable[Set], Set]:
         """
         Return all members of the set ``name``
 
@@ -3384,7 +3384,7 @@ class SetCommands(CommandsProtocol):
         return self.execute_command("SMEMBERS", name, keys=[name])
 
     def smismember(
-        self, name: str, values: List, *args: List
+        self, name: KeyT, values: List, *args: List
     ) -> Union[
         Awaitable[List[Union[Literal[0], Literal[1]]]],
         List[Union[Literal[0], Literal[1]]],
@@ -3400,7 +3400,7 @@ class SetCommands(CommandsProtocol):
         args = list_or_args(values, args)
         return self.execute_command("SMISMEMBER", name, *args, keys=[name])
 
-    def smove(self, src: str, dst: str, value: str) -> Union[Awaitable[bool], bool]:
+    def smove(self, src: KeyT, dst: KeyT, value: str) -> Union[Awaitable[bool], bool]:
         """
         Move ``value`` from set ``src`` to set ``dst`` atomically
 
@@ -3408,7 +3408,7 @@ class SetCommands(CommandsProtocol):
         """
         return self.execute_command("SMOVE", src, dst, value)
 
-    def spop(self, name: str, count: Optional[int] = None) -> Union[str, List, None]:
+    def spop(self, name: KeyT, count: Optional[int] = None) -> Union[str, List, None]:
         """
         Remove and return a random member of set ``name``
 
@@ -3418,7 +3418,7 @@ class SetCommands(CommandsProtocol):
         return self.execute_command("SPOP", name, *args)
 
     def srandmember(
-        self, name: str, number: Optional[int] = None
+        self, name: KeyT, number: Optional[int] = None
     ) -> Union[str, List, None]:
         """
         If ``number`` is None, returns a random member of set ``name``.
@@ -3432,7 +3432,7 @@ class SetCommands(CommandsProtocol):
         args = (number is not None) and [number] or []
         return self.execute_command("SRANDMEMBER", name, *args)
 
-    def srem(self, name: str, *values: FieldT) -> Union[Awaitable[int], int]:
+    def srem(self, name: KeyT, *values: FieldT) -> Union[Awaitable[int], int]:
         """
         Remove ``values`` from set ``name``
 
@@ -3450,7 +3450,7 @@ class SetCommands(CommandsProtocol):
         return self.execute_command("SUNION", *args, keys=args)
 
     def sunionstore(
-        self, dest: str, keys: List, *args: List
+        self, dest: KeyT, keys: List, *args: List
     ) -> Union[Awaitable[int], int]:
         """
         Store the union of sets specified by ``keys`` into a new
@@ -3484,6 +3484,28 @@ class StreamCommands(CommandsProtocol):
         """
         return self.execute_command("XACK", name, groupname, *ids)
 
+    def xackdel(
+        self,
+        name: KeyT,
+        groupname: GroupT,
+        *ids: StreamIdT,
+        ref_policy: Literal["KEEPREF", "DELREF", "ACKED"] = "KEEPREF",
+    ) -> ResponseT:
+        """
+        Combines the functionality of XACK and XDEL. Acknowledges the specified
+        message IDs in the given consumer group and simultaneously attempts to
+        delete the corresponding entries from the stream.
+        """
+        if not ids:
+            raise DataError("XACKDEL requires at least one message ID")
+
+        if ref_policy not in {"KEEPREF", "DELREF", "ACKED"}:
+            raise DataError("XACKDEL ref_policy must be one of: KEEPREF, DELREF, ACKED")
+
+        pieces = [name, groupname, ref_policy, "IDS", len(ids)]
+        pieces.extend(ids)
+        return self.execute_command("XACKDEL", *pieces)
+
     def xadd(
         self,
         name: KeyT,
@@ -3494,6 +3516,7 @@ class StreamCommands(CommandsProtocol):
         nomkstream: bool = False,
         minid: Union[StreamIdT, None] = None,
         limit: Optional[int] = None,
+        ref_policy: Optional[Literal["KEEPREF", "DELREF", "ACKED"]] = None,
     ) -> ResponseT:
         """
         Add to a stream.
@@ -3507,6 +3530,10 @@ class StreamCommands(CommandsProtocol):
         minid: the minimum id in the stream to query.
         Can't be specified with maxlen.
         limit: specifies the maximum number of entries to retrieve
+        ref_policy: optional reference policy for consumer groups when trimming:
+            - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
+            - DELREF: When trimming, removes all references from consumer groups' PEL
+            - ACKED: When trimming, only removes entries acknowledged by all consumer groups
 
         For more information see https://redis.io/commands/xadd
         """
@@ -3514,6 +3541,9 @@ class StreamCommands(CommandsProtocol):
         if maxlen is not None and minid is not None:
             raise DataError("Only one of ```maxlen``` or ```minid``` may be specified")
 
+        if ref_policy is not None and ref_policy not in {"KEEPREF", "DELREF", "ACKED"}:
+            raise DataError("XADD ref_policy must be one of: KEEPREF, DELREF, ACKED")
+
         if maxlen is not None:
             if not isinstance(maxlen, int) or maxlen < 0:
                 raise DataError("XADD maxlen must be non-negative integer")
@@ -3530,6 +3560,8 @@ class StreamCommands(CommandsProtocol):
             pieces.extend([b"LIMIT", limit])
         if nomkstream:
             pieces.append(b"NOMKSTREAM")
+        if ref_policy is not None:
+            pieces.append(ref_policy)
         pieces.append(id)
         if not isinstance(fields, dict) or len(fields) == 0:
             raise DataError("XADD fields must be a non-empty dict")
@@ -3683,6 +3715,26 @@ class StreamCommands(CommandsProtocol):
         """
         return self.execute_command("XDEL", name, *ids)
 
+    def xdelex(
+        self,
+        name: KeyT,
+        *ids: StreamIdT,
+        ref_policy: Literal["KEEPREF", "DELREF", "ACKED"] = "KEEPREF",
+    ) -> ResponseT:
+        """
+        Extended version of XDEL that provides more control over how message entries
+        are deleted concerning consumer groups.
+        """
+        if not ids:
+            raise DataError("XDELEX requires at least one message ID")
+
+        if ref_policy not in {"KEEPREF", "DELREF", "ACKED"}:
+            raise DataError("XDELEX ref_policy must be one of: KEEPREF, DELREF, ACKED")
+
+        pieces = [name, ref_policy, "IDS", len(ids)]
+        pieces.extend(ids)
+        return self.execute_command("XDELEX", *pieces)
+
     def xgroup_create(
         self,
         name: KeyT,
@@ -4034,6 +4086,7 @@ class StreamCommands(CommandsProtocol):
         approximate: bool = True,
         minid: Union[StreamIdT, None] = None,
         limit: Optional[int] = None,
+        ref_policy: Optional[Literal["KEEPREF", "DELREF", "ACKED"]] = None,
     ) -> ResponseT:
         """
         Trims old messages from a stream.
@@ -4044,6 +4097,10 @@ class StreamCommands(CommandsProtocol):
         minid: the minimum id in the stream to query
         Can't be specified with maxlen.
         limit: specifies the maximum number of entries to retrieve
+        ref_policy: optional reference policy for consumer groups:
+            - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
+            - DELREF: Trims entries and removes all references from consumer groups' PEL
+            - ACKED: Only trims entries that were read and acknowledged by all consumer groups
 
         For more information see https://redis.io/commands/xtrim
         """
@@ -4054,6 +4111,9 @@ class StreamCommands(CommandsProtocol):
         if maxlen is None and minid is None:
             raise DataError("One of ``maxlen`` or ``minid`` must be specified")
 
+        if ref_policy is not None and ref_policy not in {"KEEPREF", "DELREF", "ACKED"}:
+            raise DataError("XTRIM ref_policy must be one of: KEEPREF, DELREF, ACKED")
+
         if maxlen is not None:
             pieces.append(b"MAXLEN")
         if minid is not None:
@@ -4067,6 +4127,8 @@ class StreamCommands(CommandsProtocol):
         if limit is not None:
             pieces.append(b"LIMIT")
             pieces.append(limit)
+        if ref_policy is not None:
+            pieces.append(ref_policy)
 
         return self.execute_command("XTRIM", name, *pieces)
 

redis-6.4.0/redis/commands/json/_util.py

@@ -0,0 +1,5 @@
+from typing import List, Mapping, Union
+
+JsonType = Union[
+    str, int, float, bool, None, Mapping[str, "JsonType"], List["JsonType"]
+]