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

coredis/pipeline.py

@@ -5,21 +5,21 @@ 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.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 +48,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,42 +82,84 @@ 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.
+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]):
+    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,
+    ) -> None:
+        super().__init__(
+            client, name, *arguments, callback=callback, execution_parameters=execution_parameters
+        )
+        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]:
+        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__()
+        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.                  
+                """
+            )
+            return self.__backward_compatibility_return().__await__()  # type: ignore[return-value]
+
+
+class ClusterPipelineCommandRequest(PipelineCommandRequest[CommandResponseT]):
+    def __init__(
+        self,
+        client: ClusterPipeline[Any],
+        name: bytes,
+        *arguments: ValueT,
+        callback: Callable[..., CommandResponseT],
+        execution_parameters: ExecutionParameters | 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
+        )
 
 
 class NodeCommands:
@@ -121,16 +170,18 @@ 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:
@@ -146,20 +197,32 @@ class NodeCommands:
         # build up all commands into a single request to increase network perf
         # send all the commands and catch connection and timeout errors.
         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 +230,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 +288,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,7 +306,7 @@ class ClusterPipelineMeta(PipelineMeta):
         return kls
 
 
-class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
+class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
     """Pipeline for the Redis class"""
 
     """
@@ -256,14 +320,10 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
 
     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 await pipeline.execute()
     """
 
-    command_stack: list[PipelineCommand]
+    command_stack: list[PipelineCommandRequest[Any]]
     connection_pool: ConnectionPool
 
     def __init__(
@@ -273,9 +333,9 @@ 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
@@ -284,9 +344,10 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
         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 +355,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,16 +366,37 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
     def __bool__(self) -> bool:
         return True
 
-    async def reset_pipeline(self) -> None:
+    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:
+        """
+        Empties the pipeline and resets / returns the connection
+        back to the pool
+        """
         self.command_stack.clear()
-        self.scripts: set[Script[AnyStr]] = set()
+        self.scripts = set()
         # make sure to reset the connection state in the event that 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()
+                # immediate_execute_command methods can call clear()
                 request = await self.connection.create_request(CommandName.UNWATCH, decode=False)
                 await request
             except ConnectionError:
@@ -328,6 +413,22 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
             self.connection_pool.release(self.connection)
             self.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
+
     def multi(self) -> None:
         """
         Starts a transactional block of the pipeline after WATCH commands
@@ -341,27 +442,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 +466,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,26 +483,26 @@ 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
 
@@ -423,52 +516,34 @@ class PipelineImpl(Client[AnyStr], metaclass=PipelineMeta):
 
         :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 +553,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 +606,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 +637,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 +676,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,21 +684,22 @@ 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](),
                     )
 
@@ -635,7 +722,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 +744,31 @@ 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``
+        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`.
         """
-
         if self.explicit_transaction:
             raise RedisError("Cannot issue a WATCH after a MULTI")
 
-        return await self.immediate_execute_command(
-            CommandName.WATCH, *keys, callback=SimpleStringCallback()
-        )
-
-    async def unwatch(self) -> bool:
-        """Unwatches all previously specified keys"""
+        return self.create_request(CommandName.WATCH, *keys, callback=SimpleStringCallback())
 
-        return (
-            await self.immediate_execute_command(
-                CommandName.UNWATCH, callback=SimpleStringCallback()
-            )
-            if self.watching
-            else True
-        )
+    def unwatch(self) -> CommandRequest[bool]:
+        """
+        Removes watches from any previously specified keys and returns the pipeline
+        to buffered mode.
+        """
+        return self.create_request(CommandName.UNWATCH, callback=SimpleStringCallback())
 
 
-class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
+class ClusterPipeline(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] = {}
@@ -711,16 +793,38 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
         self.explicit_transaction = False
         self.cache = None  # not implemented.
         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]:
+        """
+        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`.
+        """
         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:
+        """
+        Removes watches from any previously specified keys and returns the pipeline
+        to buffered mode.
+        """
         if self._watched_connection:
             try:
                 return await self._unwatch(self._watched_connection)
@@ -732,20 +836,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 +859,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 +889,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 +898,7 @@ class ClusterPipelineImpl(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"""
         await self.connection_pool.initialize()
 
         if not self.command_stack:
@@ -822,10 +911,13 @@ 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:
+        """
+        Empties the pipeline and resets / returns the connection
+        back to the pool
+        """
         self.command_stack = []
 
         self.scripts: set[Script[AnyStr]] = set()
@@ -837,32 +929,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()
@@ -876,7 +985,7 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
         # the whole transaction aborts,
         # and EXEC returns a Null reply to notify that the transaction failed.
 
-        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 +998,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))
@@ -901,6 +1010,8 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
 
         `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.
@@ -914,7 +1025,7 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
         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:
@@ -985,7 +1096,9 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
             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
 
@@ -996,8 +1109,8 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
             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 +1118,18 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
 
         return tuple(response)
 
-    def _determine_slot(self, command: bytes, *args: ValueT, **options: ValueT) -> int:
+    def _determine_slot(
+        self, command: bytes, *args: ValueT, **options: Unpack[ExecutionParameters]
+    ) -> 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)
+        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}
 
@@ -1027,6 +1142,10 @@ class ClusterPipelineImpl(Client[AnyStr], metaclass=ClusterPipelineMeta):
             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`.
+        """
         if self.explicit_transaction:
             raise RedisError("Cannot issue nested calls to MULTI")
 
@@ -1036,14 +1155,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 +1175,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 +1231,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"