coredis 5.0.0rc1__tar.gz → 5.0.0rc2__tar.gz

{coredis-5.0.0rc1 → coredis-5.0.0rc2}/HISTORY.rst

@@ -3,6 +3,14 @@
 Changelog
 =========
 
+v5.0.0rc2
+---------
+Release Date: 2025-07-10
+
+* Bug Fix
+
+  * Fix duplicate command error in using ``transform`` with pipeline
+
 v5.0.0rc1
 ---------
 Release Date: 2025-07-07
@@ -1963,3 +1971,4 @@ v1.0.1
 
 
 
+

{coredis-5.0.0rc1/coredis.egg-info → coredis-5.0.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coredis
-Version: 5.0.0rc1
+Version: 5.0.0rc2
 Summary: Python async client for Redis key-value store
 Home-page: https://github.com/alisaifee/coredis
 Author: Ali-Akber Saifee
@@ -80,9 +80,6 @@ coredis is an async redis client with support for redis server, cluster & sentin
   and the [API Documentation](https://coredis.readthedocs.io/en/latest/api/index.html)
   for more details.
 
-> **Warning**
-> The command API does NOT mirror the official python [redis client](https://github.com/redis/redis-py). For details about the high level differences refer to [Divergence from aredis & redis-py](https://coredis.readthedocs.io/en/latest/history.html#divergence-from-aredis-redis-py)
-
 ______________________________________________________________________
 
 <!-- TOC depthFrom:2 depthTo:6 withLinks:1 updateOnSave:1 orderedList:0 -->

{coredis-5.0.0rc1 → coredis-5.0.0rc2}/README.md

@@ -27,9 +27,6 @@ coredis is an async redis client with support for redis server, cluster & sentin
   and the [API Documentation](https://coredis.readthedocs.io/en/latest/api/index.html)
   for more details.
 
-> **Warning**
-> The command API does NOT mirror the official python [redis client](https://github.com/redis/redis-py). For details about the high level differences refer to [Divergence from aredis & redis-py](https://coredis.readthedocs.io/en/latest/history.html#divergence-from-aredis-redis-py)
-
 ______________________________________________________________________
 
 <!-- TOC depthFrom:2 depthTo:6 withLinks:1 updateOnSave:1 orderedList:0 -->

{coredis-5.0.0rc1 → coredis-5.0.0rc2}/coredis/_protocols.py

@@ -49,21 +49,21 @@ class AbstractExecutor(Protocol):
 
 @runtime_checkable
 class SupportsScript(Protocol[T_co]):  # noqa
-    async def evalsha(
+    def evalsha(
         self,
         sha1: StringT,
         keys: Parameters[KeyT] | None = ...,
         args: Parameters[RedisValueT] | None = ...,
-    ) -> ResponseType: ...
+    ) -> CommandRequest[ResponseType]: ...
 
-    async def evalsha_ro(
+    def evalsha_ro(
         self,
         sha1: StringT,
         keys: Parameters[KeyT] | None = ...,
         args: Parameters[RedisValueT] | None = ...,
-    ) -> ResponseType: ...
+    ) -> CommandRequest[ResponseType]: ...
 
-    async def script_load(self, script: StringT) -> T_co: ...
+    def script_load(self, script: StringT) -> CommandRequest[T_co]: ...
 
 
 @runtime_checkable

{coredis-5.0.0rc1 → coredis-5.0.0rc2}/coredis/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-07-07T11:41:52-0700",
+ "date": "2025-07-10T16:37:52-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "e2034feabddbed8c1a549ccc53976ca41d724a00",
- "version": "5.0.0rc1"
+ "full-revisionid": "500ec3f7c2c644928da3459bf3242872e672728c",
+ "version": "5.0.0rc2"
 }
 '''  # END VERSION_JSON
 

{coredis-5.0.0rc1 → coredis-5.0.0rc2}/coredis/commands/script.py

@@ -10,7 +10,9 @@ from deprecated.sphinx import versionadded
 
 from coredis._protocols import SupportsScript
 from coredis._utils import b
+from coredis.commands import CommandRequest
 from coredis.exceptions import NoScriptError
+from coredis.retry import ConstantRetryPolicy, retryable
 from coredis.typing import (
     AnyStr,
     Awaitable,
@@ -72,16 +74,16 @@ class Script(Generic[AnyStr]):
         self.sha = hashlib.sha1(b(script)).hexdigest()  # type: ignore
         self.readonly = readonly
 
-    async def __call__(
+    def __call__(
         self,
         keys: Parameters[KeyT] | None = None,
         args: Parameters[RedisValueT] | None = None,
         client: SupportsScript[AnyStr] | None = None,
         readonly: bool | None = None,
-    ) -> ResponseType:
+    ) -> CommandRequest[ResponseType]:
         """
         Executes the script registered in :paramref:`Script.script` using
-        :meth:`coredis.Redis.evalsha`. Additionally if the script was not yet
+        :meth:`coredis.Redis.evalsha`. Additionally, if the script was not yet
         registered on the instance, it will automatically do that as well
         and cache the sha at :data:`Script.sha`
 
@@ -103,20 +105,21 @@ class Script(Generic[AnyStr]):
         if readonly is None:
             readonly = self.readonly
 
+        method = client.evalsha_ro if readonly else client.evalsha
+
         # make sure the Redis server knows about the script
         if isinstance(client, Pipeline):
             # make sure this script is good to go on pipeline
             cast(Pipeline[AnyStr], client).scripts.add(self)
-
-        method = client.evalsha_ro if readonly else client.evalsha
-        try:
-            return await method(self.sha, keys=keys, args=args)
-        except NoScriptError:
-            # Maybe the client is pointed to a different server than the client
-            # that created this instance?
-            # Overwrite the sha just in case there was a discrepancy.
-            self.sha = await client.script_load(self.script)
-            return await method(self.sha, keys=keys, args=args)
+            return method(self.sha, keys=keys, args=args)
+        else:
+            return cast(
+                CommandRequest[ResponseType],
+                retryable(
+                    ConstantRetryPolicy((NoScriptError,), 1, 0),
+                    failure_hook=lambda _: client.script_load(self.script),
+                )(method)(self.sha, keys=keys, args=args),
+            )
 
     async def execute(
         self,

{coredis-5.0.0rc1 → coredis-5.0.0rc2}/coredis/pipeline.py

@@ -18,6 +18,7 @@ from coredis.client import Client, RedisCluster
 from coredis.commands import CommandRequest, CommandResponseT
 from coredis.commands._key_spec import KeySpec
 from coredis.commands.constants import CommandName, NodeFlag
+from coredis.commands.request import TransformedResponse
 from coredis.commands.script import Script
 from coredis.connection import BaseConnection, ClusterConnection, CommandInvocation, Connection
 from coredis.exceptions import (
@@ -92,12 +93,12 @@ def wrap_pipeline_method(
     wrapper.__annotations__["return"] = kls
     wrapper.__doc__ = textwrap.dedent(wrapper.__doc__ or "")
     wrapper.__doc__ = f"""
-Pipeline variant of :meth:`coredis.Redis.{func.__name__}` that does not execute
-immediately and instead pushes the command into a stack for batch send.
+.. note:: Pipeline variant of :meth:`coredis.Redis.{func.__name__}` that does not execute
+  immediately and instead pushes the command into a stack for batch send.
 
-The return value can be retrieved either as part of the tuple returned by
-:meth:`~{kls.__name__}.execute` or by awaiting the :class:`~coredis.commands.CommandRequest`
-instance after calling :meth:`~{kls.__name__}.execute`
+  The return value can be retrieved either as part of the tuple returned by
+  :meth:`~{kls.__name__}.execute` or by awaiting the :class:`~coredis.commands.CommandRequest`
+  instance after calling :meth:`~{kls.__name__}.execute`
 
 {wrapper.__doc__}
 """
@@ -105,6 +106,11 @@ instance after calling :meth:`~{kls.__name__}.execute`
 
 
 class PipelineCommandRequest(CommandRequest[CommandResponseT]):
+    """
+    Command request used within a pipeline. Handles immediate execution for WATCH or
+    watched commands outside explicit transactions, otherwise queues the command.
+    """
+
     client: Pipeline[Any] | ClusterPipeline[Any]
     queued_response: Awaitable[bytes | str]
 
@@ -115,23 +121,59 @@ class PipelineCommandRequest(CommandRequest[CommandResponseT]):
         *arguments: ValueT,
         callback: Callable[..., CommandResponseT],
         execution_parameters: ExecutionParameters | None = None,
+        parent: CommandRequest[Any] | None = None,
     ) -> None:
         super().__init__(
-            client, name, *arguments, callback=callback, execution_parameters=execution_parameters
+            client,
+            name,
+            *arguments,
+            callback=callback,
+            execution_parameters=execution_parameters,
+        )
+        if not parent:
+            if (client.watching or name == CommandName.WATCH) and not client.explicit_transaction:
+                self.response = client.immediate_execute_command(
+                    self, callback=callback, **self.execution_parameters
+                )
+            else:
+                client.pipeline_execute_command(self)  # type: ignore[arg-type]
+        self.parent = parent
+
+    def transform(
+        self, transformer: type[TransformedResponse]
+    ) -> CommandRequest[TransformedResponse]:
+        transform_func = functools.partial(
+            self.type_adapter.deserialize,
+            return_type=transformer,
+        )
+        return cast(type[PipelineCommandRequest[TransformedResponse]], self.__class__)(
+            self.client,
+            self.name,
+            *self.arguments,
+            callback=lambda resp, **k: transform_func(resp),
+            execution_parameters=self.execution_parameters,
+            parent=self,
         )
-        if (client.watching or name == CommandName.WATCH) and not client.explicit_transaction:
-            self.response = client.immediate_execute_command(
-                self, callback=callback, **self.execution_parameters
-            )
-        else:
-            client.pipeline_execute_command(self)  # type: ignore[arg-type]
 
     async def __backward_compatibility_return(self) -> Pipeline[Any] | ClusterPipeline[Any]:
+        """
+        For backward compatibility: returns the pipeline instance when awaited before execute().
+        """
         return self.client
 
     def __await__(self) -> Generator[None, None, CommandResponseT]:
         if hasattr(self, "response"):
             return self.response.__await__()
+        elif self.parent:
+            parent = self.parent
+
+            async def _transformed() -> CommandResponseT:
+                if hasattr(parent, "response"):
+                    return self.callback(await parent.response)
+                else:
+                    return await parent  # type: ignore[no-any-return]
+
+            return _transformed().__await__()
         else:
             warnings.warn(
                 """
@@ -140,12 +182,17 @@ has no effect and returns the pipeline instance itself for backward compatibilit
 
 To add commands to a pipeline simply call the methods synchronously. The awaitable response
 can be awaited after calling `execute()` to retrieve a statically typed response if required.                  
-                """
+                """,
+                stacklevel=2,
             )
             return self.__backward_compatibility_return().__await__()  # type: ignore[return-value]
 
 
 class ClusterPipelineCommandRequest(PipelineCommandRequest[CommandResponseT]):
+    """
+    Command request for cluster pipelines, tracks position and result for cluster routing.
+    """
+
     def __init__(
         self,
         client: ClusterPipeline[Any],
@@ -153,16 +200,26 @@ class ClusterPipelineCommandRequest(PipelineCommandRequest[CommandResponseT]):
         *arguments: ValueT,
         callback: Callable[..., CommandResponseT],
         execution_parameters: ExecutionParameters | None = None,
+        parent: CommandRequest[Any] | None = None,
     ) -> None:
         self.position: int = 0
         self.result: Any | None = None
         self.asking: bool = False
         super().__init__(
-            client, name, *arguments, callback=callback, execution_parameters=execution_parameters
+            client,
+            name,
+            *arguments,
+            callback=callback,
+            execution_parameters=execution_parameters,
+            parent=parent,
         )
 
 
 class NodeCommands:
+    """
+    Helper for grouping and executing commands on a single cluster node, handling transactions if needed.
+    """
+
     def __init__(
         self,
         client: RedisCluster[AnyStr],
@@ -188,14 +245,11 @@ class NodeCommands:
         connection = self.connection
         commands = self.commands
 
-        # We are going to clobber the commands with the write, so go ahead
-        # and ensure that nothing is sitting there from a previous run.
-
+        # Reset results for all commands before writing.
         for c in commands:
             c.result = None
 
-        # build up all commands into a single request to increase network perf
-        # send all the commands and catch connection and timeout errors.
+        # Batch all commands into a single request for efficiency.
         try:
             if self.in_transaction:
                 self.multi_cmd = await connection.create_request(
@@ -307,20 +361,16 @@ class ClusterPipelineMeta(PipelineMeta):
 
 
 class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
-    """Pipeline for the Redis class"""
-
     """
-    Pipelines provide a way to transmit multiple commands to the Redis server
-    in one transmission.  This is convenient for batch processing, such as
-    saving all the values in a list to Redis.
+    Pipeline for batching multiple commands to a Redis server.
+    Supports transactions and command stacking.
 
     All commands executed within a pipeline are wrapped with MULTI and EXEC
-    calls. This guarantees all commands executed in the pipeline will be
-    executed atomically.
+    calls when :paramref:`transaction` is ``True``.
 
     Any command raising an exception does *not* halt the execution of
     subsequent commands in the pipeline. Instead, the exception is caught
-    and its instance is placed into the response list returned by await pipeline.execute()
+    and its instance is placed into the response list returned by :meth:`execute`
     """
 
     command_stack: list[PipelineCommandRequest[Any]]
@@ -340,7 +390,7 @@ class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
         self.watching = False
         self.watches: Parameters[KeyT] | None = watches or None
         self.command_stack = []
-        self.cache = None  # not implemented.
+        self.cache = None
         self.explicit_transaction = False
         self.scripts: set[Script[AnyStr]] = set()
         self.timeout = timeout
@@ -385,30 +435,21 @@ class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
 
     async def clear(self) -> None:
         """
-        Empties the pipeline and resets / returns the connection
-        back to the pool
+        Clear the pipeline, reset state, and release the connection back to the pool.
         """
         self.command_stack.clear()
         self.scripts = set()
-        # make sure to reset the connection state in the event that we were
-        # watching something
-
+        # Reset connection state if we were watching something.
         if self.watching and self.connection:
             try:
-                # call this manually since our unwatch or
-                # immediate_execute_command methods can call clear()
                 request = await self.connection.create_request(CommandName.UNWATCH, decode=False)
                 await request
             except ConnectionError:
-                # disconnect will also remove any previous WATCHes
                 self.connection.disconnect()
-        # clean up the other instance attributes
+        # Reset pipeline state and release connection if needed.
         self.watching = False
         self.watches = []
         self.explicit_transaction = False
-        # we can safely return the connection to the pool here since we're
-        # sure we're no longer WATCHing anything
-
         if self.connection:
             self.connection_pool.release(self.connection)
             self.connection = None
@@ -422,19 +463,14 @@ class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
     )
     def reset(self) -> CommandRequest[None]:
         """
-        Empties the pipeline and resets / returns the connection
-        back to the pool
-
-        :meta private:
+        Deprecated. Use :meth:`clear` instead.
         """
         return self.clear()  # type: ignore
 
     def multi(self) -> None:
         """
-        Starts a transactional block of the pipeline after WATCH commands
-        are issued. End the transactional block with `execute`.
+        Start a transactional block after WATCH commands. End with `execute()`.
         """
-
         if self.explicit_transaction:
             raise RedisError("Cannot issue nested calls to MULTI")
 
@@ -504,17 +540,7 @@ class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
         command: PipelineCommandRequest[R],
     ) -> None:
         """
-        Stages a command to be executed next execute() invocation
-
-        Returns the current Pipeline object back so commands can be
-        chained together, such as:
-
-        pipe = pipe.set('foo', 'bar').incr('baz').decr('bang')
-
-        At some other point, you can then run: pipe.execute(),
-        which will execute all commands queued in the pipe.
-
-        :meta private:
+        Queue a command for execution on the next `execute()` call.
         """
         self.command_stack.append(command)
 
@@ -704,7 +730,9 @@ class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
                     )
 
     async def execute(self, raise_on_error: bool = True) -> tuple[Any, ...]:
-        """Executes all the commands in the current pipeline"""
+        """
+        Execute all queued commands in the pipeline. Returns a tuple of results.
+        """
         stack = self.command_stack
 
         if not stack:
@@ -748,9 +776,8 @@ class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
 
     def watch(self, *keys: KeyT) -> CommandRequest[bool]:
         """
-        Watches the values at ``keys`` for change. Commands issues after this call
-        will be executed immediately and should be awaited. To switch back to
-        pipeline buffering mode, call :meth:`multi`.
+        Watch the given keys for changes. Switches to immediate execution mode
+        until :meth:`multi` is called.
         """
         if self.explicit_transaction:
             raise RedisError("Cannot issue a WATCH after a MULTI")
@@ -759,13 +786,21 @@ class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
 
     def unwatch(self) -> CommandRequest[bool]:
         """
-        Removes watches from any previously specified keys and returns the pipeline
-        to buffered mode.
+        Remove all key watches and return to buffered mode.
         """
         return self.create_request(CommandName.UNWATCH, callback=SimpleStringCallback())
 
 
 class ClusterPipeline(Client[AnyStr], metaclass=ClusterPipelineMeta):
+    """
+    Pipeline for batching commands to a Redis Cluster.
+    Handles routing, transactions, and error management across nodes.
+
+    .. warning:: Unlike :class:`Pipeline`, :paramref:`transaction` is ``False`` by
+       default as there is limited support for transactions in redis cluster
+       (only keys in the same slot can be part of a transaction).
+    """
+
     client: RedisCluster[AnyStr]
     connection_pool: ClusterConnectionPool
     command_stack: list[ClusterPipelineCommandRequest[Any]]
@@ -791,7 +826,7 @@ class ClusterPipeline(Client[AnyStr], metaclass=ClusterPipelineMeta):
         self.watches: Parameters[KeyT] | None = watches or None
         self.watching = False
         self.explicit_transaction = False
-        self.cache = None  # not implemented.
+        self.cache = None
         self.timeout = timeout
         self.type_adapter = client.type_adapter
 
@@ -811,9 +846,8 @@ class ClusterPipeline(Client[AnyStr], metaclass=ClusterPipelineMeta):
 
     def watch(self, *keys: KeyT) -> CommandRequest[bool]:
         """
-        Watches the values at ``keys`` for change. Commands issues after this call
-        will be executed immediately and should be awaited. To switch back to
-        pipeline buffering mode, call :meth:`multi`.
+        Watch the given keys for changes. Switches to immediate execution mode
+        until :meth:`multi` is called.
         """
         if self.explicit_transaction:
             raise RedisError("Cannot issue a WATCH after a MULTI")
@@ -822,8 +856,7 @@ class ClusterPipeline(Client[AnyStr], metaclass=ClusterPipelineMeta):
 
     async def unwatch(self) -> bool:
         """
-        Removes watches from any previously specified keys and returns the pipeline
-        to buffered mode.
+        Remove all key watches and return to buffered mode.
         """
         if self._watched_connection:
             try:
@@ -898,7 +931,9 @@ class ClusterPipeline(Client[AnyStr], metaclass=ClusterPipelineMeta):
             exception.args = (msg,) + exception.args[1:]
 
     async def execute(self, raise_on_error: bool = True) -> tuple[object, ...]:
-        """Executes all the commands in the current pipeline"""
+        """
+        Execute all queued commands in the cluster pipeline. Returns a tuple of results.
+        """
         await self.connection_pool.initialize()
 
         if not self.command_stack:
@@ -915,8 +950,7 @@ class ClusterPipeline(Client[AnyStr], metaclass=ClusterPipelineMeta):
 
     async def clear(self) -> None:
         """
-        Empties the pipeline and resets / returns the connection
-        back to the pool
+        Clear the pipeline, reset state, and release any held connections.
         """
         self.command_stack = []
 
@@ -981,9 +1015,7 @@ class ClusterPipeline(Client[AnyStr], metaclass=ClusterPipelineMeta):
             if self.explicit_transaction:
                 request = await conn.create_request(CommandName.DISCARD)
                 await request
-        # If at least one watched key is modified before the EXEC command,
-        # the whole transaction aborts,
-        # and EXEC returns a Null reply to notify that the transaction failed.
+        # If at least one watched key is modified before EXEC, the transaction aborts and EXEC returns null.
 
         if node_commands.exec_cmd and await node_commands.exec_cmd is None:
             raise WatchError
@@ -1006,104 +1038,57 @@ class ClusterPipeline(Client[AnyStr], metaclass=ClusterPipelineMeta):
         self, raise_on_error: bool = True, allow_redirections: bool = True
     ) -> tuple[object, ...]:
         """
-        Sends a bunch of cluster commands to the redis cluster.
-
-        `allow_redirections` If the pipeline should follow `ASK` & `MOVED` responses
-        automatically. If set to false it will raise RedisClusterException.
+        Execute all queued commands in the cluster pipeline, handling redirections
+        and retries as needed.
 
         :meta private:
         """
-        # the first time sending the commands we send all of the commands that were queued up.
-        # if we have to run through it again, we only retry the commands that failed.
+        # On first send, queue all commands. On retry, only failed ones.
         attempt = sorted(self.command_stack, key=lambda x: x.position)
 
-        protocol_version: int = 3
-        # build a list of node objects based on node names we need to
+        # Group commands by node for efficient network usage.
         nodes: dict[str, NodeCommands] = {}
-        # as we move through each command that still needs to be processed,
-        # we figure out the slot number that command maps to, then from the slot determine the node.
         for c in attempt:
-            # refer to our internal node -> slot table that tells us where a given
-            # command should route to.
             slot = self._determine_slot(c.name, *c.arguments)
             node = self.connection_pool.get_node_by_slot(slot)
-
             if node.name not in nodes:
                 nodes[node.name] = NodeCommands(
                     self.client,
                     await self.connection_pool.get_connection_by_node(node),
                     timeout=self.timeout,
                 )
-
             nodes[node.name].append(c)
 
-        # send the commands in sequence.
-        # we  write to all the open sockets for each node first, before reading anything
-        # this allows us to flush all the requests out across the network essentially in parallel
-        # so that we can read them all in parallel as they come back.
-        # we dont' multiplex on the sockets as they come available, but that shouldn't make
-        # too much difference.
+        # Write to all nodes, then read from all nodes in sequence.
         node_commands = nodes.values()
-
         for n in node_commands:
             await n.write()
-
         for n in node_commands:
             await n.read()
 
-        # release all of the redis connections we allocated earlier back into the connection pool.
-        # we used to do this step as part of a try/finally block, but it is really dangerous to
-        # release connections back into the pool if for some reason the socket has data still left
-        # in it from a previous operation. The write and read operations already have try/catch
-        # around them for all known types of errors including connection and socket level errors.
-        # So if we hit an exception, something really bad happened and putting any of
-        # these connections back into the pool is a very bad idea.
-        # the socket might have unread buffer still sitting in it, and then the
-        # next time we read from it we pass the buffered result back from a previous
-        # command and every single request after to that connection will always get
-        # a mismatched result. (not just theoretical, I saw this happen on production x.x).
+        # Release all connections back to the pool only if safe (no unread buffer).
+        # If an error occurred, do not release to avoid buffer mismatches.
         for n in nodes.values():
             protocol_version = n.connection.protocol_version
             self.connection_pool.release(n.connection)
-        # if the response isn't an exception it is a valid response from the node
-        # we're all done with that command, YAY!
-        # if we have more commands to attempt, we've run into problems.
-        # collect all the commands we are allowed to retry.
-        # (MOVED, ASK, or connection errors or timeout errors)
+
+        # Retry MOVED/ASK/connection errors one by one if allowed.
         attempt = sorted(
             (c for c in attempt if isinstance(c.result, ERRORS_ALLOW_RETRY)),
             key=lambda x: x.position,
         )
 
         if attempt and allow_redirections:
-            # RETRY MAGIC HAPPENS HERE!
-            # send these remaing comamnds one at a time using `execute_command`
-            # in the main client. This keeps our retry logic in one place mostly,
-            # and allows us to be more confident in correctness of behavior.
-            # at this point any speed gains from pipelining have been lost
-            # anyway, so we might as well make the best attempt to get the correct
-            # behavior.
-            #
-            # The client command will handle retries for each individual command
-            # sequentially as we pass each one into `execute_command`. Any exceptions
-            # that bubble out should only appear once all retries have been exhausted.
-            #
-            # If a lot of commands have failed, we'll be setting the
-            # flag to rebuild the slots table from scratch. So MOVED errors should
-            # correct .commandsthemselves fairly quickly.
             await self.connection_pool.nodes.increment_reinitialize_counter(len(attempt))
-
             for c in attempt:
                 try:
-                    # send each command individually like we do in the main client.
                     c.result = await self.client.execute_command(
                         RedisCommand(c.name, c.arguments), **c.execution_parameters
                     )
                 except RedisError as e:
                     c.result = e
 
-        # turn the response back into a simple flat array that corresponds
-        # to the sequence of commands issued in the stack in pipeline.execute()
+        # Flatten results to match the original command order.
         response = []
         for c in sorted(self.command_stack, key=lambda x: x.position):
             r = c.result
@@ -1121,8 +1106,9 @@ class ClusterPipeline(Client[AnyStr], metaclass=ClusterPipelineMeta):
     def _determine_slot(
         self, command: bytes, *args: ValueT, **options: Unpack[ExecutionParameters]
     ) -> int:
-        """Figure out what slot based on command and args"""
-
+        """
+        Determine the hash slot for the given command and arguments.
+        """
         keys: tuple[RedisValueT, ...] = cast(
             tuple[RedisValueT, ...], options.get("keys")
         ) or KeySpec.extract_keys(command, *args)  # type: ignore
@@ -1138,13 +1124,15 @@ class ClusterPipeline(Client[AnyStr], metaclass=ClusterPipelineMeta):
         return slots.pop()
 
     def _fail_on_redirect(self, allow_redirections: bool) -> None:
+        """
+        Raise if redirections are not allowed in the pipeline.
+        """
         if not allow_redirections:
             raise RedisClusterException("ASK & MOVED redirection not allowed in this pipeline")
 
     def multi(self) -> None:
         """
-        Starts a transactional block of the pipeline after WATCH commands
-        are issued. End the transactional block with `execute`.
+        Start a transactional block after WATCH commands. End with `execute()`.
         """
         if self.explicit_transaction:
             raise RedisError("Cannot issue nested calls to MULTI")

{coredis-5.0.0rc1 → coredis-5.0.0rc2}/coredis/retry.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 from functools import wraps
 from typing import Any
 
-from coredis.typing import Callable, Coroutine, P, R
+from coredis.typing import Awaitable, Callable, P, R
 
 logger = logging.getLogger(__name__)
 
@@ -31,10 +31,10 @@ class RetryPolicy(ABC):
 
     async def call_with_retries(
         self,
-        func: Callable[..., Coroutine[Any, Any, R]],
-        before_hook: Callable[..., Coroutine[Any, Any, Any]] | None = None,
-        failure_hook: Callable[..., Coroutine[Any, Any, None]]
-        | dict[type[BaseException], Callable[..., Coroutine[Any, Any, None]]]
+        func: Callable[..., Awaitable[R]],
+        before_hook: Callable[..., Awaitable[Any]] | None = None,
+        failure_hook: Callable[..., Awaitable[Any]]
+        | dict[type[BaseException], Callable[..., Awaitable[None]]]
         | None = None,
     ) -> R:
         """
@@ -159,12 +159,11 @@ class CompositeRetryPolicy(RetryPolicy):
 
     async def call_with_retries(
         self,
-        func: Callable[..., Coroutine[Any, Any, R]],
-        before_hook: Callable[..., Coroutine[Any, Any, Any]] | None = None,
+        func: Callable[..., Awaitable[R]],
+        before_hook: Callable[..., Awaitable[Any]] | None = None,
         failure_hook: None
         | (
-            Callable[..., Coroutine[Any, Any, None]]
-            | dict[type[BaseException], Callable[..., Coroutine[Any, Any, None]]]
+            Callable[..., Awaitable[Any]] | dict[type[BaseException], Callable[..., Awaitable[Any]]]
         ) = None,
     ) -> R:
         """
@@ -214,15 +213,15 @@ class CompositeRetryPolicy(RetryPolicy):
 
 def retryable(
     policy: RetryPolicy,
-    failure_hook: Callable[..., Coroutine[Any, Any, None]] | None = None,
-) -> Callable[[Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]]:
+    failure_hook: Callable[..., Awaitable[Any]] | None = None,
+) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]:
     """
     Decorator to be used to apply a retry policy to a coroutine
     """
 
     def inner(
-        func: Callable[P, Coroutine[Any, Any, R]],
-    ) -> Callable[P, Coroutine[Any, Any, R]]:
+        func: Callable[P, Awaitable[R]],
+    ) -> Callable[P, Awaitable[R]]:
         @wraps(func)
         async def _inner(*args: P.args, **kwargs: P.kwargs) -> R:
             return await policy.call_with_retries(

{coredis-5.0.0rc1 → coredis-5.0.0rc2}/coredis/typing.py

@@ -53,8 +53,6 @@ from typing_extensions import (
 
 from coredis.config import Config
 
-_runtime_checks = False
-
 RUNTIME_TYPECHECKS = Config.runtime_checks and not TYPE_CHECKING
 
 P = ParamSpec("P")
@@ -63,7 +61,7 @@ R = TypeVar("R")
 
 
 def safe_beartype(func: Callable[P, R]) -> Callable[P, R]:
-    return beartype(func) if RUNTIME_TYPECHECKS else func
+    return beartype(func)
 
 
 def add_runtime_checks(func: Callable[P, R]) -> Callable[P, R]:

{coredis-5.0.0rc1 → coredis-5.0.0rc2/coredis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coredis
-Version: 5.0.0rc1
+Version: 5.0.0rc2
 Summary: Python async client for Redis key-value store
 Home-page: https://github.com/alisaifee/coredis
 Author: Ali-Akber Saifee
@@ -80,9 +80,6 @@ coredis is an async redis client with support for redis server, cluster & sentin
   and the [API Documentation](https://coredis.readthedocs.io/en/latest/api/index.html)
   for more details.
 
-> **Warning**
-> The command API does NOT mirror the official python [redis client](https://github.com/redis/redis-py). For details about the high level differences refer to [Divergence from aredis & redis-py](https://coredis.readthedocs.io/en/latest/history.html#divergence-from-aredis-redis-py)
-
 ______________________________________________________________________
 
 <!-- TOC depthFrom:2 depthTo:6 withLinks:1 updateOnSave:1 orderedList:0 -->