coredis 4.23.1__py3-none-any.whl → 5.0.0__py3-none-any.whl

coredis/pipeline.py

@@ -5,21 +5,22 @@ import functools
 import inspect
 import sys
 import textwrap
+import warnings
 from abc import ABCMeta
 from concurrent.futures import CancelledError
-from dataclasses import dataclass, field
-from itertools import chain
 from types import TracebackType
 from typing import Any, cast
 
-from wrapt import ObjectProxy  # type: ignore
+from deprecated.sphinx import deprecated
 
-from coredis._utils import b, hash_slot
-from coredis.client import Client, Redis, RedisCluster
+from coredis._utils import b, hash_slot, nativestr
+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
+from coredis.connection import BaseConnection, ClusterConnection, CommandInvocation, Connection
 from coredis.exceptions import (
     AskError,
     ClusterCrossSlotError,
@@ -48,16 +49,23 @@ from coredis.response._callbacks import (
 from coredis.retry import ConstantRetryPolicy, retryable
 from coredis.typing import (
     AnyStr,
+    Awaitable,
     Callable,
-    Coroutine,
-    Generic,
+    ExecutionParameters,
+    Generator,
     Iterable,
     KeyT,
     Parameters,
     ParamSpec,
+    RedisCommand,
+    RedisCommandP,
+    RedisValueT,
     ResponseType,
+    Self,
     StringT,
+    T_co,
     TypeVar,
+    Unpack,
     ValueT,
 )
 
@@ -75,45 +83,140 @@ UNWATCH_COMMANDS = {CommandName.DISCARD, CommandName.EXEC, CommandName.UNWATCH}
 
 
 def wrap_pipeline_method(
-    kls: PipelineMeta, func: Callable[P, Coroutine[Any, Any, R]]
-) -> Callable[P, Coroutine[Any, Any, R]]:
+    kls: PipelineMeta, func: Callable[P, Awaitable[R]]
+) -> Callable[P, Awaitable[R]]:
     @functools.wraps(func)
-    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-        return await func(*args, **kwargs)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> Awaitable[R]:
+        return func(*args, **kwargs)
 
-    wrapper.__annotations__ = wrapper.__annotations__.copy()
-    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
-and returns the instance of :class:`{kls.__name__}` itself.
+.. 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.
 
-To fetch the return values call :meth:`{kls.__name__}.execute` to process the pipeline
-and retrieve responses for the commands executed in the pipeline.
+  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__}
 """
     return wrapper
 
 
-@dataclass
-class PipelineCommand:
-    command: bytes
-    args: tuple[ValueT, ...]
-    callback: Callable[..., Any] = NoopCallback()  # type: ignore
-    options: dict[str, ValueT | None] = field(default_factory=dict)
-    request: asyncio.Future[ResponseType] | None = None
+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]
+
+    def __init__(
+        self,
+        client: Pipeline[Any] | ClusterPipeline[Any],
+        name: bytes,
+        *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,
+        )
+        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,
+        )
 
+    async def __backward_compatibility_return(self) -> Pipeline[Any] | ClusterPipeline[Any]:
+        """
+        For backward compatibility: returns the pipeline instance when awaited before execute().
+        """
+        return self.client
 
-@dataclass
-class ClusterPipelineCommand(PipelineCommand):
-    position: int = 0
-    result: Any | None = None  # type: ignore
-    asking: bool = False
+    def __await__(self) -> Generator[None, None, CommandResponseT]:
+        if hasattr(self, "response"):
+            return self.response.__await__()
+        elif self.parent:
+
+            async def _transformed() -> CommandResponseT:
+                if (r := await self.parent) == self.client:  # type: ignore
+                    return r  # type: ignore
+                else:
+                    return self.callback(r)
+
+            return _transformed().__await__()
+        else:
+            warnings.warn(
+                """
+Awaiting a pipeline command response before calling `execute()` on the pipeline instance 
+has no effect and returns the pipeline instance itself for backward compatibility.
+
+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],
+        name: bytes,
+        *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,
+            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],
@@ -121,45 +224,56 @@ class NodeCommands:
         in_transaction: bool = False,
         timeout: float | None = None,
     ):
-        self.client = client
+        self.client: RedisCluster[Any] = client
         self.connection = connection
-        self.commands: list[ClusterPipelineCommand] = []
+        self.commands: list[ClusterPipelineCommandRequest[Any]] = []
         self.in_transaction = in_transaction
         self.timeout = timeout
+        self.multi_cmd: asyncio.Future[ResponseType] | None = None
+        self.exec_cmd: asyncio.Future[ResponseType] | None = None
 
-    def extend(self, c: list[ClusterPipelineCommand]) -> None:
+    def extend(self, c: list[ClusterPipelineCommandRequest[Any]]) -> None:
         self.commands.extend(c)
 
-    def append(self, c: ClusterPipelineCommand) -> None:
+    def append(self, c: ClusterPipelineCommandRequest[Any]) -> None:
         self.commands.append(c)
 
     async def write(self) -> None:
         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(
+                    CommandName.MULTI, timeout=self.timeout
+                )
             requests = await connection.create_requests(
                 [
                     CommandInvocation(
-                        cmd.command,
-                        cmd.args,
-                        (bool(cmd.options.get("decode")) if cmd.options.get("decode") else None),
+                        cmd.name,
+                        cmd.arguments,
+                        (
+                            bool(cmd.execution_parameters.get("decode"))
+                            if cmd.execution_parameters.get("decode")
+                            else None
+                        ),
                         None,
                     )
                     for cmd in commands
                 ],
                 timeout=self.timeout,
             )
+            if self.in_transaction:
+                self.exec_cmd = await connection.create_request(
+                    CommandName.EXEC, timeout=self.timeout
+                )
             for i, cmd in enumerate(commands):
-                cmd.request = requests[i]
+                cmd.response = requests[i]
         except (ConnectionError, TimeoutError) as e:
             for c in commands:
                 c.result = e
@@ -167,51 +281,50 @@ class NodeCommands:
     async def read(self) -> None:
         connection = self.connection
         success = True
-
+        multi_result = None
+        if self.multi_cmd:
+            multi_result = await self.multi_cmd
+            success = multi_result in {b"OK", "OK"}
         for c in self.commands:
             if c.result is None:
                 try:
-                    c.result = await c.request if c.request else None
+                    c.result = await c.response if c.response else None
                 except ExecAbortError:
                     raise
                 except (ConnectionError, TimeoutError, RedisError) as e:
                     success = False
                     c.result = e
-
-        if self.in_transaction:
-            transaction_result = []
+        if self.in_transaction and self.exec_cmd:
             if success:
-                for c in self.commands:
-                    if c.command == CommandName.EXEC:
-                        if c.result:
-                            transaction_result = cast(list[ResponseType], c.result)
-                        else:
-                            raise WatchError("Watched variable changed.")
+                res = await self.exec_cmd
+                if res:
+                    transaction_result = cast(list[ResponseType], res)
+                else:
+                    raise WatchError("Watched variable changed.")
                 for idx, c in enumerate(
                     [
                         _c
                         for _c in sorted(self.commands, key=lambda x: x.position)
-                        if _c.command not in {CommandName.MULTI, CommandName.EXEC}
+                        if _c.name not in {CommandName.MULTI, CommandName.EXEC}
                     ]
                 ):
                     if isinstance(c.callback, AsyncPreProcessingCallback):
-                        await c.callback.pre_process(
-                            self.client, transaction_result[idx], **c.options
-                        )
+                        await c.callback.pre_process(self.client, transaction_result[idx])
                     c.result = c.callback(
                         transaction_result[idx],
                         version=connection.protocol_version,
-                        **c.options,
                     )
-            elif isinstance(self.commands[0].result, BaseException):
-                raise self.commands[0].result
+            elif isinstance(multi_result, BaseException):
+                raise multi_result
 
 
 class PipelineMeta(ABCMeta):
     RESULT_CALLBACKS: dict[str, Callable[..., Any]]
     NODES_FLAGS: dict[str, NodeFlag]
 
-    def __new__(cls, name: str, bases: tuple[type, ...], namespace: dict[str, object]):
+    def __new__(
+        cls, name: str, bases: tuple[type, ...], namespace: dict[str, object]
+    ) -> PipelineMeta:
         kls = super().__new__(cls, name, bases, namespace)
 
         for name, method in PipelineMeta.get_methods(kls).items():
@@ -226,7 +339,9 @@ class PipelineMeta(ABCMeta):
 
 
 class ClusterPipelineMeta(PipelineMeta):
-    def __new__(cls, name: str, bases: tuple[type, ...], namespace: dict[str, object]):
+    def __new__(
+        cls, name: str, bases: tuple[type, ...], namespace: dict[str, object]
+    ) -> PipelineMeta:
         kls = super().__new__(cls, name, bases, namespace)
         for name, method in ClusterPipelineMeta.get_methods(kls).items():
             cmd = getattr(method, "__coredis_command", None)
@@ -242,28 +357,20 @@ class ClusterPipelineMeta(PipelineMeta):
         return kls
 
 
-class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
-    """Pipeline for the Redis class"""
-
+class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
     """
-    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 execute().
-    Code iterating over the response list should be able to deal with an
-    instance of an exception as a potential value. In general, these will be
-    ResponseError exceptions, such as those raised when issuing a command
-    on a key of a different datatype.
+    and its instance is placed into the response list returned by :meth:`execute`
     """
 
-    command_stack: list[PipelineCommand]
+    command_stack: list[PipelineCommandRequest[Any]]
     connection_pool: ConnectionPool
 
     def __init__(
@@ -273,20 +380,21 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
         watches: Parameters[KeyT] | None = None,
         timeout: float | None = None,
     ) -> None:
-        self.client = client
+        self.client: Client[AnyStr] = client
         self.connection_pool = client.connection_pool
-        self.connection = None
+        self.connection: Connection | None = None
         self._transaction = transaction
         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
+        self.type_adapter = client.type_adapter
 
-    async def __aenter__(self) -> PipelineImpl[AnyStr]:
-        return self
+    async def __aenter__(self) -> Pipeline[AnyStr]:
+        return await self.get_instance()
 
     async def __aexit__(
         self,
@@ -294,7 +402,10 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
         exc_value: BaseException | None,
         traceback: TracebackType | None,
     ) -> None:
-        await self.reset_pipeline()
+        await self.clear()
+
+    def __await__(self) -> Generator[Any, Any, Pipeline[AnyStr]]:
+        return self.get_instance().__await__()
 
     def __len__(self) -> int:
         return len(self.command_stack)
@@ -302,38 +413,61 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
     def __bool__(self) -> bool:
         return True
 
-    async def reset_pipeline(self) -> None:
-        self.command_stack.clear()
-        self.scripts: set[Script[AnyStr]] = set()
-        # make sure to reset the connection state in the event that we were
-        # watching something
+    async def get_instance(self) -> Pipeline[AnyStr]:
+        return self
 
+    def create_request(
+        self,
+        name: bytes,
+        *arguments: ValueT,
+        callback: Callable[..., T_co],
+        execution_parameters: ExecutionParameters | None = None,
+    ) -> CommandRequest[T_co]:
+        """
+        :meta private:
+        """
+        return PipelineCommandRequest(
+            self, name, *arguments, callback=callback, execution_parameters=execution_parameters
+        )
+
+    async def clear(self) -> None:
+        """
+        Clear the pipeline, reset state, and release the connection back to the pool.
+        """
+        self.command_stack.clear()
+        self.scripts = set()
+        # 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 reset_pipeline()
                 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
 
-    def multi(self) -> None:
+    #: :meta private:
+    reset_pipeline = clear
+
+    @deprecated(
+        "The reset method in pipelines clashes with the redis ``RESET`` command. Use :meth:`clear` instead",
+        "5.0.0",
+    )
+    def reset(self) -> CommandRequest[None]:
         """
-        Starts a transactional block of the pipeline after WATCH commands
-        are issued. End the transactional block with `execute`.
+        Deprecated. Use :meth:`clear` instead.
         """
+        return self.clear()  # type: ignore
 
+    def multi(self) -> None:
+        """
+        Start a transactional block after WATCH commands. End with `execute()`.
+        """
         if self.explicit_transaction:
             raise RedisError("Cannot issue nested calls to MULTI")
 
@@ -341,27 +475,20 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
             raise RedisError("Commands without an initial WATCH have already been issued")
         self.explicit_transaction = True
 
-    async def execute_command(
+    def execute_command(
         self,
-        command: bytes,
-        *args: ValueT,
-        callback: Callable[..., Any] = NoopCallback(),  # type: ignore
-        **options: ValueT | None,
-    ) -> PipelineImpl[AnyStr]:  # type: ignore
-        if (self.watching or command == CommandName.WATCH) and not self.explicit_transaction:
-            return await self.immediate_execute_command(
-                command, *args, callback=callback, **options
-            )  # type: ignore
-
-        return self.pipeline_execute_command(command, *args, callback=callback, **options)
+        command: RedisCommandP,
+        callback: Callable[..., R] = NoopCallback(),
+        **options: Unpack[ExecutionParameters],
+    ) -> Awaitable[R]:
+        raise NotImplementedError
 
     async def immediate_execute_command(
         self,
-        command: bytes,
-        *args: ValueT,
-        callback: Callable[..., Any] = NoopCallback(),  # type: ignore
-        **kwargs: ValueT | None,
-    ) -> Any:  # type: ignore
+        command: RedisCommandP,
+        callback: Callable[..., R] = NoopCallback(),
+        **kwargs: Unpack[ExecutionParameters],
+    ) -> R:
         """
         Executes a command immediately, but don't auto-retry on a
         ConnectionError if we're already WATCHing a variable. Used when
@@ -372,17 +499,16 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
         """
         conn = self.connection
         # if this is the first call, we need a connection
-
         if not conn:
             conn = await self.connection_pool.get_connection()
             self.connection = conn
         try:
-            request = await conn.create_request(command, *args, decode=kwargs.get("decode"))
-
+            request = await conn.create_request(
+                command.name, *command.arguments, decode=kwargs.get("decode")
+            )
             return callback(
                 await request,
                 version=conn.protocol_version,
-                **kwargs,
             )
         except (ConnectionError, TimeoutError):
             conn.disconnect()
@@ -390,85 +516,59 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
             # if we're not already watching, we can safely retry the command
             try:
                 if not self.watching:
-                    request = await conn.create_request(command, *args, decode=kwargs.get("decode"))
-                    return callback(await request, version=conn.protocol_version, **kwargs)
+                    request = await conn.create_request(
+                        command.name, *command.arguments, decode=kwargs.get("decode")
+                    )
+                    return callback(await request, version=conn.protocol_version)
+                raise
             except ConnectionError:
                 # the retry failed so cleanup.
                 conn.disconnect()
-                await self.reset_pipeline()
+                await self.clear()
                 raise
         finally:
-            if command in UNWATCH_COMMANDS:
+            if command.name in UNWATCH_COMMANDS:
                 self.watching = False
-            elif command == CommandName.WATCH:
+            elif command.name == CommandName.WATCH:
                 self.watching = True
 
     def pipeline_execute_command(
         self,
-        command: bytes,
-        *args: ValueT,
-        callback: Callable[..., Any],
-        **options: ValueT | None,
-    ) -> PipelineImpl[AnyStr]:
+        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.
+        Queue a command for execution on the next `execute()` call.
 
         :meta private:
         """
-        self.command_stack.append(
-            PipelineCommand(command=command, args=args, options=options, callback=callback)
-        )
-
-        return self
+        self.command_stack.append(command)
 
     async def _execute_transaction(
         self,
         connection: BaseConnection,
-        commands: list[PipelineCommand],
+        commands: list[PipelineCommandRequest[Any]],
         raise_on_error: bool,
     ) -> tuple[Any, ...]:
-        cmds = list(
-            chain(
-                [
-                    PipelineCommand(
-                        command=CommandName.MULTI,
-                        args=(),
-                    )
-                ],
-                commands,
-                [
-                    PipelineCommand(
-                        command=CommandName.EXEC,
-                        args=(),
-                    )
-                ],
-            )
-        )
-        if self.watches:
-            await self.watch(*self.watches)
-
+        multi_cmd = await connection.create_request(CommandName.MULTI, timeout=self.timeout)
         requests = await connection.create_requests(
             [
                 CommandInvocation(
-                    cmd.command,
-                    cmd.args,
-                    (bool(cmd.options.get("decode")) if cmd.options.get("decode") else None),
+                    cmd.name,
+                    cmd.arguments,
+                    (
+                        bool(cmd.execution_parameters.get("decode"))
+                        if cmd.execution_parameters.get("decode")
+                        else None
+                    ),
                     None,
                 )
-                for cmd in cmds
+                for cmd in commands
             ],
             timeout=self.timeout,
         )
-        for i, cmd in enumerate(cmds):
-            cmd.request = requests[i]
+        exec_cmd = await connection.create_request(CommandName.EXEC, timeout=self.timeout)
+        for i, cmd in enumerate(commands):
+            cmd.queued_response = cast(Awaitable[StringT], requests[i])
 
         errors: list[tuple[int, RedisError | None]] = []
         multi_failed = False
@@ -478,30 +578,32 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
         # so that we read all the additional command messages from
         # the socket
         try:
-            await cmds[0].request if cmds[0].request else None
+            await multi_cmd
         except RedisError:
             multi_failed = True
             errors.append((0, cast(RedisError, sys.exc_info()[1])))
 
         # and all the other commands
-        for i, cmd in enumerate(cmds[1:-1]):
+        for i, cmd in enumerate(commands):
             try:
-                if cmd.request:
-                    assert (await cmd.request) in {b"QUEUED", "QUEUED"}
+                if cmd.queued_response:
+                    assert (await cmd.queued_response) in {b"QUEUED", "QUEUED"}
             except RedisError:
                 ex = cast(RedisError, sys.exc_info()[1])
-                self.annotate_exception(ex, i + 1, cmd.command, cmd.args)
+                self.annotate_exception(ex, i + 1, cmd.name, cmd.arguments)
                 errors.append((i, ex))
 
         response: list[ResponseType]
         try:
             response = cast(
                 list[ResponseType],
-                await cmds[-1].request if cmds[-1].request else None,
+                await exec_cmd if exec_cmd else None,
             )
         except (ExecAbortError, ResponseError):
             if self.explicit_transaction and not multi_failed:
-                await self.immediate_execute_command(CommandName.DISCARD, callback=BoolCallback())
+                await self.immediate_execute_command(
+                    RedisCommand(name=CommandName.DISCARD, arguments=()), callback=BoolCallback()
+                )
 
             if errors and errors[0][1]:
                 raise errors[0][1]
@@ -529,24 +631,30 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
         for r, cmd in zip(response, commands):
             if not isinstance(r, Exception):
                 if isinstance(cmd.callback, AsyncPreProcessingCallback):
-                    await cmd.callback.pre_process(self.client, r, **cmd.options)
-                r = cmd.callback(r, version=connection.protocol_version, **cmd.options)
+                    await cmd.callback.pre_process(self.client, r)
+                r = cmd.callback(r, version=connection.protocol_version, **cmd.execution_parameters)
+                cmd.response = asyncio.get_running_loop().create_future()
+                cmd.response.set_result(r)
             data.append(r)
         return tuple(data)
 
     async def _execute_pipeline(
         self,
         connection: BaseConnection,
-        commands: list[PipelineCommand],
+        commands: list[PipelineCommandRequest[Any]],
         raise_on_error: bool,
     ) -> tuple[Any, ...]:
         # build up all commands into a single request to increase network perf
         requests = await connection.create_requests(
             [
                 CommandInvocation(
-                    cmd.command,
-                    cmd.args,
-                    (bool(cmd.options.get("decode")) if cmd.options.get("decode") else None),
+                    cmd.name,
+                    cmd.arguments,
+                    (
+                        bool(cmd.execution_parameters.get("decode"))
+                        if cmd.execution_parameters.get("decode")
+                        else None
+                    ),
                     None,
                 )
                 for cmd in commands
@@ -554,35 +662,38 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
             timeout=self.timeout,
         )
         for i, cmd in enumerate(commands):
-            cmd.request = requests[i]
+            cmd.response = requests[i]
 
         response: list[Any] = []
-
         for cmd in commands:
             try:
-                res = await cmd.request if cmd.request else None
+                res = await cmd.response if cmd.response else None
                 if isinstance(cmd.callback, AsyncPreProcessingCallback):
-                    await cmd.callback.pre_process(self.client, res, **cmd.options)
-                response.append(
-                    cmd.callback(
-                        res,
-                        version=connection.protocol_version,
-                        **cmd.options,
-                    )
+                    await cmd.callback.pre_process(self.client, res, **cmd.execution_parameters)
+                resp = cmd.callback(
+                    res,
+                    version=connection.protocol_version,
+                    **cmd.execution_parameters,
                 )
-            except ResponseError:
+                cmd.response = asyncio.get_event_loop().create_future()
+                cmd.response.set_result(resp)
+                response.append(resp)
+            except ResponseError as re:
+                cmd.response = asyncio.get_event_loop().create_future()
+                cmd.response.set_exception(re)
                 response.append(sys.exc_info()[1])
-
         if raise_on_error:
             self.raise_first_error(commands, response)
 
         return tuple(response)
 
-    def raise_first_error(self, commands: list[PipelineCommand], response: ResponseType) -> None:
+    def raise_first_error(
+        self, commands: list[PipelineCommandRequest[Any]], response: ResponseType
+    ) -> None:
         assert isinstance(response, list)
         for i, r in enumerate(response):
             if isinstance(r, RedisError):
-                self.annotate_exception(r, i + 1, commands[i].command, commands[i].args)
+                self.annotate_exception(r, i + 1, commands[i].name, commands[i].arguments)
                 raise r
 
     def annotate_exception(
@@ -590,7 +701,7 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
         exception: RedisError | None,
         number: int,
         command: bytes,
-        args: Iterable[ValueT],
+        args: Iterable[RedisValueT],
     ) -> None:
         if exception:
             cmd = command.decode("latin-1")
@@ -598,26 +709,29 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
             msg = f"Command # {number} ({cmd} {args}) of pipeline caused error: {str(exception.args[0])}"
             exception.args = (msg,) + exception.args[1:]
 
-    async def load_scripts(self):
+    async def load_scripts(self) -> None:
         # make sure all scripts that are about to be run on this pipeline exist
         scripts = list(self.scripts)
         immediate = self.immediate_execute_command
         shas = [s.sha for s in scripts]
         # we can't use the normal script_* methods because they would just
         # get buffered in the pipeline.
-        exists = await immediate(CommandName.SCRIPT_EXISTS, *shas, callback=BoolsCallback())
+        exists = await immediate(
+            RedisCommand(CommandName.SCRIPT_EXISTS, tuple(shas)), callback=BoolsCallback()
+        )
 
         if not all(exists):
             for s, exist in zip(scripts, exists):
                 if not exist:
                     s.sha = await immediate(
-                        CommandName.SCRIPT_LOAD,
-                        s.script,
+                        RedisCommand(CommandName.SCRIPT_LOAD, (s.script,)),
                         callback=AnyStrCallback[AnyStr](),
                     )
 
     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:
@@ -635,7 +749,7 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
 
         if not conn:
             conn = await self.connection_pool.get_connection()
-            # assign to self.connection so reset_pipeline() releases the connection
+            # assign to self.connection so clear() releases the connection
             # back to the pool after we're done
             self.connection = conn
 
@@ -657,36 +771,38 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
 
             return await exec(conn, stack, raise_on_error)
         finally:
-            await self.reset_pipeline()
+            await self.clear()
 
-    async def watch(self, *keys: KeyT) -> bool:
+    def watch(self, *keys: KeyT) -> CommandRequest[bool]:
         """
-        Watches the values at keys ``keys``
+        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")
 
-        return await self.immediate_execute_command(
-            CommandName.WATCH, *keys, callback=SimpleStringCallback()
-        )
+        return self.create_request(CommandName.WATCH, *keys, callback=SimpleStringCallback())
 
-    async def unwatch(self) -> bool:
-        """Unwatches all previously specified keys"""
+    def unwatch(self) -> CommandRequest[bool]:
+        """
+        Remove all key watches and return to buffered mode.
+        """
+        return self.create_request(CommandName.UNWATCH, callback=SimpleStringCallback())
 
-        return (
-            await self.immediate_execute_command(
-                CommandName.UNWATCH, callback=SimpleStringCallback()
-            )
-            if self.watching
-            else True
-        )
 
+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).
+    """
 
-class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
     client: RedisCluster[AnyStr]
     connection_pool: ClusterConnectionPool
-    command_stack: list[ClusterPipelineCommand]
+    command_stack: list[ClusterPipelineCommandRequest[Any]]
 
     RESULT_CALLBACKS: dict[str, Callable[..., Any]] = {}
     NODES_FLAGS: dict[str, NodeFlag] = {}
@@ -709,18 +825,38 @@ class ClusterPipelineImpl(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
 
-    async def watch(self, *keys: KeyT) -> bool:
+    def create_request(
+        self,
+        name: bytes,
+        *arguments: ValueT,
+        callback: Callable[..., T_co],
+        execution_parameters: ExecutionParameters | None = None,
+    ) -> CommandRequest[T_co]:
+        """
+        :meta private:
+        """
+        return ClusterPipelineCommandRequest(
+            self, name, *arguments, callback=callback, execution_parameters=execution_parameters
+        )
+
+    def watch(self, *keys: KeyT) -> CommandRequest[bool]:
+        """
+        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")
 
-        return await self.immediate_execute_command(
-            CommandName.WATCH, *keys, callback=SimpleStringCallback()
-        )
+        return self.create_request(CommandName.WATCH, *keys, callback=SimpleStringCallback())
 
     async def unwatch(self) -> bool:
+        """
+        Remove all key watches and return to buffered mode.
+        """
         if self._watched_connection:
             try:
                 return await self._unwatch(self._watched_connection)
@@ -732,20 +868,21 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
                     self._watched_connection = None
         return True
 
-    def __repr__(self):
-        return f"{type(self).__name__}"
-
-    def __del__(self):
+    def __del__(self) -> None:
         if self._watched_connection:
             self.connection_pool.release(self._watched_connection)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.command_stack)
 
     def __bool__(self) -> bool:
         return True
 
-    async def __aenter__(self) -> ClusterPipelineImpl[AnyStr]:
+    def __await__(self) -> Generator[None, None, Self]:
+        yield
+        return self
+
+    async def __aenter__(self) -> ClusterPipeline[AnyStr]:
         return self
 
     async def __aexit__(
@@ -754,46 +891,29 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
         exc_value: BaseException | None,
         traceback: TracebackType | None,
     ) -> None:
-        await self.reset_pipeline()
+        await self.clear()
 
-    async def execute_command(
+    def execute_command(
         self,
-        command: bytes,
-        *args: ValueT,
-        callback: Callable[..., Any] = NoopCallback(),  # type: ignore
-        **options: ValueT | None,
-    ) -> ClusterPipelineImpl[AnyStr]:  # type: ignore
-        if (self.watching or command == CommandName.WATCH) and not self.explicit_transaction:
-            return await self.immediate_execute_command(
-                command, *args, callback=callback, **options
-            )  # type: ignore
-        return self.pipeline_execute_command(command, *args, callback=callback, **options)
+        command: RedisCommandP,
+        callback: Callable[..., R] = NoopCallback(),
+        **options: Unpack[ExecutionParameters],
+    ) -> Awaitable[R]:
+        raise NotImplementedError
 
     def pipeline_execute_command(
         self,
-        command: bytes,
-        *args: ValueT,
-        callback: Callable[..., Any],
-        **options: ValueT | None,
-    ) -> ClusterPipelineImpl[AnyStr]:
-        self.command_stack.append(
-            ClusterPipelineCommand(
-                command=command,
-                args=args,
-                options=options,
-                callback=callback,
-                position=len(self.command_stack),
-            )
-        )
-
-        return self
+        command: ClusterPipelineCommandRequest[Any],
+    ) -> None:
+        command.position = len(self.command_stack)
+        self.command_stack.append(command)
 
     def raise_first_error(self) -> None:
         for c in self.command_stack:
             r = c.result
 
             if isinstance(r, RedisError):
-                self.annotate_exception(r, c.position + 1, c.command, c.args)
+                self.annotate_exception(r, c.position + 1, c.name, c.arguments)
                 raise r
 
     def annotate_exception(
@@ -801,7 +921,7 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
         exception: RedisError | None,
         number: int,
         command: bytes,
-        args: Iterable[ValueT],
+        args: Iterable[RedisValueT],
     ) -> None:
         if exception:
             cmd = command.decode("latin-1")
@@ -810,6 +930,9 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
             exception.args = (msg,) + exception.args[1:]
 
     async def execute(self, raise_on_error: bool = True) -> tuple[object, ...]:
+        """
+        Execute all queued commands in the cluster pipeline. Returns a tuple of results.
+        """
         await self.connection_pool.initialize()
 
         if not self.command_stack:
@@ -822,10 +945,12 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
         try:
             return await execute(raise_on_error)
         finally:
-            await self.reset_pipeline()
+            await self.clear()
 
-    async def reset_pipeline(self):
-        """Empties pipeline"""
+    async def clear(self) -> None:
+        """
+        Clear the pipeline, reset state, and release any held connections.
+        """
         self.command_stack = []
 
         self.scripts: set[Script[AnyStr]] = set()
@@ -837,32 +962,49 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
             self.connection_pool.release(self._watched_connection)
             self._watched_connection = None
 
+    #: :meta private:
+    reset_pipeline = clear
+
+    @deprecated(
+        "The reset method in pipelines clashes with the redis ``RESET`` command. Use :meth:`clear` instead",
+        "5.0.0",
+    )
+    def reset(self) -> CommandRequest[None]:
+        """
+        Empties the pipeline and resets / returns the connection
+        back to the pool
+
+        :meta private:
+        """
+        return self.clear()  # type: ignore
+
     @retryable(policy=ConstantRetryPolicy((ClusterDownError,), 3, 0.1))
     async def send_cluster_transaction(self, raise_on_error: bool = True) -> tuple[object, ...]:
+        """
+        :meta private:
+        """
         attempt = sorted(self.command_stack, key=lambda x: x.position)
         slots: set[int] = set()
         for c in attempt:
-            slot = self._determine_slot(c.command, *c.args, **c.options)
+            slot = self._determine_slot(c.name, *c.arguments, **c.execution_parameters)
             if slot:
                 slots.add(slot)
 
             if len(slots) > 1:
-                raise ClusterTransactionError("Multiple nodes involved in transaction")
+                raise ClusterTransactionError("Multiple slots involved in transaction")
         if not slots:
             raise ClusterTransactionError("No slots found for transaction")
         node = self.connection_pool.get_node_by_slot(slots.pop())
 
         if self._watched_node and node.name != self._watched_node.name:
-            raise ClusterTransactionError("Multiple nodes involved in transaction")
+            raise ClusterTransactionError("Multiple slots involved in transaction")
 
         conn = self._watched_connection or await self.connection_pool.get_connection_by_node(node)
 
         if self.watches:
             await self._watch(node, conn, self.watches)
         node_commands = NodeCommands(self.client, conn, in_transaction=True, timeout=self.timeout)
-        node_commands.append(ClusterPipelineCommand(CommandName.MULTI, ()))
         node_commands.extend(attempt)
-        node_commands.append(ClusterPipelineCommand(CommandName.EXEC, ()))
         self.explicit_transaction = True
 
         await node_commands.write()
@@ -872,11 +1014,9 @@ class ClusterPipelineImpl(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.commands[-1].result is None:
+        if node_commands.exec_cmd and await node_commands.exec_cmd is None:
             raise WatchError
         self.connection_pool.release(conn)
 
@@ -889,7 +1029,7 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
         return tuple(
             n.result
             for n in node_commands.commands
-            if n.command not in {CommandName.MULTI, CommandName.EXEC}
+            if n.name not in {CommandName.MULTI, CommandName.EXEC}
         )
 
     @retryable(policy=ConstantRetryPolicy((ClusterDownError,), 3, 0.1))
@@ -897,107 +1037,64 @@ class ClusterPipelineImpl(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.
+        Execute all queued commands in the cluster pipeline, handling redirections
+        and retries as needed.
 
-        `allow_redirections` If the pipeline should follow `ASK` & `MOVED` responses
-        automatically. If set to false it will raise RedisClusterException.
+        :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.command, *c.args)
+            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(c.command, *c.args, **c.options)
+                    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
             if not isinstance(c.result, RedisError):
                 if isinstance(c.callback, AsyncPreProcessingCallback):
-                    await c.callback.pre_process(self.client, c.result, **c.options)
-                r = c.callback(c.result, version=protocol_version, **c.options)
+                    await c.callback.pre_process(self.client, c.result)
+                r = c.callback(c.result, version=protocol_version)
             response.append(r)
 
         if raise_on_error:
@@ -1005,16 +1102,19 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
 
         return tuple(response)
 
-    def _determine_slot(self, command: bytes, *args: ValueT, **options: ValueT) -> int:
-        """Figure out what slot based on command and args"""
-
-        keys: tuple[ValueT, ...] = cast(
-            tuple[ValueT, ...], options.get("keys")
-        ) or KeySpec.extract_keys(command, *args)
+    def _determine_slot(
+        self, command: bytes, *args: ValueT, **options: Unpack[ExecutionParameters]
+    ) -> int:
+        """
+        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
 
         if not keys:
             raise RedisClusterException(
-                f"No way to dispatch {command} to Redis Cluster. Missing key"
+                f"No way to dispatch {nativestr(command)} to Redis Cluster. Missing key"
             )
         slots = {hash_slot(b(key)) for key in keys}
 
@@ -1023,10 +1123,16 @@ class ClusterPipelineImpl(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:
+        """
+        Start a transactional block after WATCH commands. End with `execute()`.
+        """
         if self.explicit_transaction:
             raise RedisError("Cannot issue nested calls to MULTI")
 
@@ -1036,14 +1142,13 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
 
     async def immediate_execute_command(
         self,
-        command: bytes,
-        *args: ValueT,
-        callback: Callable[..., Any] = NoopCallback(),
-        **kwargs: ValueT | None,
-    ) -> Any:
-        slot = self._determine_slot(command, *args)
+        command: RedisCommandP,
+        callback: Callable[..., R] = NoopCallback(),
+        **kwargs: Unpack[ExecutionParameters],
+    ) -> R:
+        slot = self._determine_slot(command.name, *command.arguments)
         node = self.connection_pool.get_node_by_slot(slot)
-        if command == CommandName.WATCH:
+        if command.name == CommandName.WATCH:
             if self._watched_node and node.name != self._watched_node.name:
                 raise ClusterTransactionError(
                     "Cannot issue a watch on a different node in the same transaction"
@@ -1057,40 +1162,44 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
             conn = await self.connection_pool.get_connection_by_node(node)
 
         try:
-            request = await conn.create_request(command, *args, decode=kwargs.get("decode"))
+            request = await conn.create_request(
+                command.name, *command.arguments, decode=kwargs.get("decode")
+            )
 
             return callback(
                 await request,
                 version=conn.protocol_version,
-                **kwargs,
             )
         except (ConnectionError, TimeoutError):
             conn.disconnect()
 
             try:
                 if not self.watching:
-                    request = await conn.create_request(command, *args, decode=kwargs.get("decode"))
-                    return callback(await request, version=conn.protocol_version, **kwargs)
+                    request = await conn.create_request(
+                        command.name, *command.arguments, decode=kwargs.get("decode")
+                    )
+                    return callback(await request, version=conn.protocol_version)
+                else:
+                    raise
             except ConnectionError:
                 # the retry failed so cleanup.
                 conn.disconnect()
-                await self.reset_pipeline()
+                await self.clear()
                 raise
         finally:
-            if command in UNWATCH_COMMANDS:
+            release = True
+            if command.name in UNWATCH_COMMANDS:
                 self.watching = False
-            elif command == CommandName.WATCH:
+            elif command.name == CommandName.WATCH:
                 self.watching = True
-                # don't release the connection if the command was a watch
-                return
-            self.connection_pool.release(conn)
+                release = False
+            if release:
+                self.connection_pool.release(conn)
 
-    def load_scripts(self):
+    def load_scripts(self) -> None:
         raise RedisClusterException("method load_scripts() is not implemented")
 
     async def _watch(self, node: ManagedNode, conn: BaseConnection, keys: Parameters[KeyT]) -> bool:
-        "Watches the values at keys ``keys``"
-
         for key in keys:
             slot = self._determine_slot(CommandName.WATCH, key)
             dist_node = self.connection_pool.get_node_by_slot(slot)
@@ -1109,161 +1218,8 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
 
     async def _unwatch(self, conn: BaseConnection) -> bool:
         """Unwatches all previously specified keys"""
+        if not self.watching:
+            return True
         request = await conn.create_request(CommandName.UNWATCH, decode=False)
-        res = cast(StringT, await request)
-        return res == b"OK" if self.watching else True
-
-
-class Pipeline(ObjectProxy, Generic[AnyStr]):  # type: ignore
-    """
-    Class returned by :meth:`coredis.Redis.pipeline`
-
-    The class exposes the redis command methods available in
-    :class:`~coredis.Redis`, however each of those methods returns
-    the instance itself and the results of the batched commands
-    can be retrieved by calling :meth:`execute`.
-    """
-
-    __wrapped__: PipelineImpl[AnyStr]
-
-    async def __aenter__(self) -> Pipeline[AnyStr]:
-        return cast(Pipeline[AnyStr], await self.__wrapped__.__aenter__())
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        await self.__wrapped__.__aexit__(exc_type, exc_value, traceback)
-
-    @classmethod
-    def proxy(
-        cls,
-        client: Redis[AnyStr],
-        transaction: bool | None = None,
-        watches: Parameters[KeyT] | None = None,
-        timeout: float | None = None,
-    ) -> Pipeline[AnyStr]:
-        return cls(
-            PipelineImpl(
-                client,
-                transaction=transaction,
-                watches=watches,
-                timeout=timeout,
-            )
-        )
-
-    def multi(self) -> None:
-        """
-        Starts a transactional block of the pipeline after WATCH commands
-        are issued. End the transactional block with :meth:`execute`
-        """
-        self.__wrapped__.multi()  # Only here for documentation purposes.
-
-    async def watch(self, *keys: KeyT) -> bool:  # noqa
-        """
-        Watches the values at keys ``keys``
-        """
-        return await self.__wrapped__.watch(*keys)  # Only here for documentation purposes.
-
-    async def unwatch(self) -> bool:  # noqa
-        """
-        Unwatches all previously specified keys
-        """
-        return await self.__wrapped__.unwatch()  # Only here for documentation purposes.
-
-    async def execute(self, raise_on_error: bool = True) -> tuple[object, ...]:
-        """
-        Executes all the commands in the current pipeline
-        and return the results of the individual batched commands
-        """
-
-        # Only here for documentation purposes.
-        return await self.__wrapped__.execute(raise_on_error=raise_on_error)
-
-    async def reset(self) -> None:
-        """
-        Resets the command stack and releases any connections acquired from the
-        pool
-        """
-        await self.__wrapped__.reset_pipeline()
-
-
-class ClusterPipeline(ObjectProxy, Generic[AnyStr]):  # type: ignore
-    """
-    Class returned by :meth:`coredis.RedisCluster.pipeline`
-
-    The class exposes the redis command methods available in
-    :class:`~coredis.Redis`, however each of those methods returns
-    the instance itself and the results of the batched commands
-    can be retrieved by calling :meth:`execute`.
-    """
-
-    __wrapped__: ClusterPipelineImpl[AnyStr]
-
-    async def __aenter__(self) -> ClusterPipeline[AnyStr]:
-        return cast(ClusterPipeline[AnyStr], await self.__wrapped__.__aenter__())
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        await self.__wrapped__.__aexit__(exc_type, exc_value, traceback)
-
-    @classmethod
-    def proxy(
-        cls,
-        client: RedisCluster[AnyStr],
-        transaction: bool | None = False,
-        watches: Parameters[KeyT] | None = None,
-        timeout: float | None = None,
-    ) -> ClusterPipeline[AnyStr]:
-        return cls(
-            ClusterPipelineImpl(
-                client,
-                transaction=transaction,
-                watches=watches,
-                timeout=timeout,
-            )
-        )
-
-    def multi(self) -> None:
-        """
-        Starts a transactional block of the pipeline after WATCH commands
-        are issued. End the transactional block with :meth:`execute`
-        """
-        self.__wrapped__.multi()  # Only here for documentation purposes.
-
-    async def watch(self, *keys: KeyT) -> bool:  # noqa
-        """
-        Watches the values at keys ``keys``
-
-        :raises: :exc:`~coredis.exceptions.ClusterTransactionError`
-         if a watch is issued on a key that resides on a different
-         cluster node than a previous watch.
-        """
-        return await self.__wrapped__.watch(*keys)  # Only here for documentation purposes.
-
-    async def unwatch(self) -> bool:  # noqa
-        """
-        Unwatches all previously specified keys
-        """
-        return await self.__wrapped__.unwatch()  # Only here for documentation purposes.
-
-    async def execute(self, raise_on_error: bool = True) -> tuple[object, ...]:
-        """
-        Executes all the commands in the current pipeline
-        and return the results of the individual batched commands
-        """
-        # Only here for documentation purposes.
-        return await self.__wrapped__.execute(raise_on_error=raise_on_error)
-
-    async def reset(self) -> None:
-        """
-        Resets the command stack and releases any connections acquired from the
-        pool
-        """
-        await self.__wrapped__.reset_pipeline()
+        res = cast(bytes, await request)
+        return res == b"OK"