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

coredis/commands/sentinel.py

@@ -15,45 +15,49 @@ from coredis.response._callbacks.sentinel import (
 )
 from coredis.typing import (
     AnyStr,
+    RedisValueT,
     ResponseType,
     StringT,
-    ValueT,
 )
 
 from . import CommandMixin
 from ._wrappers import redis_command
 from .constants import CommandName
+from .request import CommandRequest
 
 
 class SentinelCommands(CommandMixin[AnyStr]):
     @redis_command(
         CommandName.SENTINEL_CKQUORUM,
     )
-    async def sentinel_ckquorum(self, service_name: StringT) -> bool:
-        return await self.execute_command(
+    def sentinel_ckquorum(self, service_name: StringT) -> CommandRequest[bool]:
+        return CommandRequest(
+            self,
             CommandName.SENTINEL_CKQUORUM,
             service_name,
             callback=SimpleStringCallback(prefix_match=True),
         )
 
     @redis_command(CommandName.SENTINEL_CONFIG_GET, version_introduced="6.2.0")
-    async def sentinel_config_get(self, name: ValueT) -> dict[AnyStr, AnyStr]:
+    def sentinel_config_get(self, name: RedisValueT) -> CommandRequest[dict[AnyStr, AnyStr]]:
         """
         Get the current value of a global Sentinel configuration parameter.
         The specified name may be a wildcard, similar to :meth:`config_get`
         """
-        return await self.execute_command(
+        return CommandRequest(
+            self,
             CommandName.SENTINEL_CONFIG_GET,
             name,
             callback=DictCallback[AnyStr, AnyStr](),
         )
 
     @redis_command(CommandName.SENTINEL_CONFIG_SET, version_introduced="6.2")
-    async def sentinel_config_set(self, name: ValueT, value: ValueT) -> bool:
+    def sentinel_config_set(self, name: RedisValueT, value: RedisValueT) -> CommandRequest[bool]:
         """
         Set the value of a global Sentinel configuration parameter
         """
-        return await self.execute_command(
+        return CommandRequest(
+            self,
             CommandName.SENTINEL_CONFIG_SET,
             name,
             value,
@@ -63,14 +67,15 @@ class SentinelCommands(CommandMixin[AnyStr]):
     @redis_command(
         CommandName.SENTINEL_GET_MASTER_ADDR_BY_NAME,
     )
-    async def sentinel_get_master_addr_by_name(
+    def sentinel_get_master_addr_by_name(
         self, service_name: StringT
-    ) -> tuple[str, int] | None:
+    ) -> CommandRequest[tuple[str, int] | None]:
         """
         Returns a (host, port) pair for the given :paramref:`service_name`
         """
 
-        return await self.execute_command(
+        return CommandRequest(
+            self,
             CommandName.SENTINEL_GET_MASTER_ADDR_BY_NAME,
             service_name,
             callback=GetPrimaryCallback(),
@@ -79,32 +84,33 @@ class SentinelCommands(CommandMixin[AnyStr]):
     @redis_command(
         CommandName.SENTINEL_FAILOVER,
     )
-    async def sentinel_failover(self, service_name: StringT) -> bool:
+    def sentinel_failover(self, service_name: StringT) -> CommandRequest[bool]:
         """
         Force a failover as if the master was not reachable, and without asking
         for agreement to other Sentinels
         """
-        return await self.execute_command(
-            CommandName.SENTINEL_FAILOVER, service_name, callback=SimpleStringCallback()
+        return CommandRequest(
+            self, CommandName.SENTINEL_FAILOVER, service_name, callback=SimpleStringCallback()
         )
 
     @redis_command(CommandName.SENTINEL_FLUSHCONFIG)
-    async def sentinel_flushconfig(self) -> bool:
+    def sentinel_flushconfig(self) -> CommandRequest[bool]:
         """
         Force Sentinel to rewrite its configuration on disk, including the current Sentinel state.
         """
-        return await self.execute_command(
-            CommandName.SENTINEL_FLUSHCONFIG, callback=SimpleStringCallback()
+        return CommandRequest(
+            self, CommandName.SENTINEL_FLUSHCONFIG, callback=SimpleStringCallback()
         )
 
     @redis_command(CommandName.SENTINEL_INFO_CACHE)
-    async def sentinel_infocache(
+    def sentinel_infocache(
         self, *nodenames: StringT
-    ) -> dict[AnyStr, dict[int, dict[str, ResponseType]]]:
+    ) -> CommandRequest[dict[AnyStr, dict[int, dict[str, ResponseType]]]]:
         """
         Return cached INFO output from masters and replicas.
         """
-        return await self.execute_command(
+        return CommandRequest(
+            self,
             CommandName.SENTINEL_INFO_CACHE,
             *nodenames,
             callback=SentinelInfoCallback[AnyStr](),
@@ -113,30 +119,31 @@ class SentinelCommands(CommandMixin[AnyStr]):
     @redis_command(
         CommandName.SENTINEL_MASTER,
     )
-    async def sentinel_master(self, service_name: StringT) -> dict[str, int | bool | str]:
+    def sentinel_master(self, service_name: StringT) -> CommandRequest[dict[str, int | bool | str]]:
         """Returns a dictionary containing the specified masters state."""
 
-        return await self.execute_command(
-            CommandName.SENTINEL_MASTER, service_name, callback=PrimaryCallback()
+        return CommandRequest(
+            self, CommandName.SENTINEL_MASTER, service_name, callback=PrimaryCallback()
         )
 
     @redis_command(
         CommandName.SENTINEL_MASTERS,
     )
-    async def sentinel_masters(self) -> dict[str, dict[str, int | bool | str]]:
+    def sentinel_masters(self) -> CommandRequest[dict[str, dict[str, int | bool | str]]]:
         """Returns a list of dictionaries containing each master's state."""
 
-        return await self.execute_command(
-            CommandName.SENTINEL_MASTERS, callback=PrimariesCallback()
-        )
+        return CommandRequest(self, CommandName.SENTINEL_MASTERS, callback=PrimariesCallback())
 
     @redis_command(
         CommandName.SENTINEL_MONITOR,
     )
-    async def sentinel_monitor(self, name: ValueT, ip: ValueT, port: int, quorum: int) -> bool:
+    def sentinel_monitor(
+        self, name: RedisValueT, ip: RedisValueT, port: int, quorum: int
+    ) -> CommandRequest[bool]:
         """Adds a new master to Sentinel to be monitored"""
 
-        return await self.execute_command(
+        return CommandRequest(
+            self,
             CommandName.SENTINEL_MONITOR,
             name,
             ip,
@@ -146,32 +153,31 @@ class SentinelCommands(CommandMixin[AnyStr]):
         )
 
     @redis_command(CommandName.SENTINEL_MYID, version_introduced="6.2.0")
-    async def sentinel_myid(self) -> AnyStr:
+    def sentinel_myid(self) -> CommandRequest[AnyStr]:
         """Return the ID of the Sentinel instance"""
 
-        return await self.execute_command(
-            CommandName.SENTINEL_MYID, callback=AnyStrCallback[AnyStr]()
-        )
+        return CommandRequest(self, CommandName.SENTINEL_MYID, callback=AnyStrCallback[AnyStr]())
 
     @redis_command(
         CommandName.SENTINEL_REMOVE,
     )
-    async def sentinel_remove(self, name: ValueT) -> bool:
+    def sentinel_remove(self, name: RedisValueT) -> CommandRequest[bool]:
         """Removes a master from Sentinel's monitoring"""
 
-        return await self.execute_command(
-            CommandName.SENTINEL_REMOVE, name, callback=SimpleStringCallback()
+        return CommandRequest(
+            self, CommandName.SENTINEL_REMOVE, name, callback=SimpleStringCallback()
         )
 
     @redis_command(
         CommandName.SENTINEL_SENTINELS,
     )
-    async def sentinel_sentinels(
+    def sentinel_sentinels(
         self, service_name: StringT
-    ) -> tuple[dict[str, int | bool | str], ...]:
+    ) -> CommandRequest[tuple[dict[str, int | bool | str], ...]]:
         """Returns a list of sentinels for :paramref:`service_name`"""
 
-        return await self.execute_command(
+        return CommandRequest(
+            self,
             CommandName.SENTINEL_SENTINELS,
             service_name,
             callback=SentinelsStateCallback(),
@@ -180,10 +186,13 @@ class SentinelCommands(CommandMixin[AnyStr]):
     @redis_command(
         CommandName.SENTINEL_SET,
     )
-    async def sentinel_set(self, name: ValueT, option: ValueT, value: ValueT) -> bool:
+    def sentinel_set(
+        self, name: RedisValueT, option: RedisValueT, value: RedisValueT
+    ) -> CommandRequest[bool]:
         """Sets Sentinel monitoring parameters for a given master"""
 
-        return await self.execute_command(
+        return CommandRequest(
+            self,
             CommandName.SENTINEL_SET,
             name,
             option,
@@ -194,31 +203,32 @@ class SentinelCommands(CommandMixin[AnyStr]):
     @redis_command(
         CommandName.SENTINEL_SLAVES,
     )
-    async def sentinel_slaves(
+    def sentinel_slaves(
         self, service_name: StringT
-    ) -> tuple[dict[str, int | bool | str], ...]:
+    ) -> CommandRequest[tuple[dict[str, int | bool | str], ...]]:
         """Returns a list of slaves for paramref:`service_name`"""
 
-        return await self.execute_command(
-            CommandName.SENTINEL_SLAVES, service_name, callback=SentinelsStateCallback()
+        return CommandRequest(
+            self, CommandName.SENTINEL_SLAVES, service_name, callback=SentinelsStateCallback()
         )
 
     @redis_command(
         CommandName.SENTINEL_REPLICAS,
     )
-    async def sentinel_replicas(
+    def sentinel_replicas(
         self, service_name: StringT
-    ) -> tuple[dict[str, int | bool | str], ...]:
+    ) -> CommandRequest[tuple[dict[str, int | bool | str], ...]]:
         """Returns a list of replicas for :paramref:`service_name`"""
 
-        return await self.execute_command(
+        return CommandRequest(
+            self,
             CommandName.SENTINEL_REPLICAS,
             service_name,
             callback=SentinelsStateCallback(),
         )
 
     @redis_command(CommandName.SENTINEL_RESET)
-    async def sentinel_reset(self, pattern: StringT) -> int:
+    def sentinel_reset(self, pattern: StringT) -> CommandRequest[int]:
         """
         Reset all the masters with matching name.
         The pattern argument is a glob-style pattern.
@@ -226,7 +236,8 @@ class SentinelCommands(CommandMixin[AnyStr]):
         failover in progress), and removes every replica and sentinel already
         discovered and associated with the master.
         """
-        return await self.execute_command(
+        return CommandRequest(
+            self,
             CommandName.SENTINEL_RESET,
             pattern,
             callback=IntCallback(),

coredis/connection.py

@@ -12,6 +12,7 @@ import time
 import warnings
 import weakref
 from collections import defaultdict, deque
+from contextlib import suppress
 from typing import TYPE_CHECKING, Any, cast
 
 import async_timeout
@@ -38,9 +39,9 @@ from coredis.typing import (
     Callable,
     ClassVar,
     Literal,
+    RedisValueT,
     ResponseType,
     TypeVar,
-    ValueT,
 )
 
 R = TypeVar("R")
@@ -78,7 +79,7 @@ class Request:
 @dataclasses.dataclass
 class CommandInvocation:
     command: bytes
-    args: tuple[ValueT, ...]
+    args: tuple[RedisValueT, ...]
     decode: bool | None
     encoding: str | None
 
@@ -383,7 +384,7 @@ class BaseConnection(asyncio.BaseProtocol):
         relay any tracking notifications to.
         """
         try:
-            params: list[ValueT] = (
+            params: list[RedisValueT] = (
                 [b"ON", b"REDIRECT", client_id] if (enabled and client_id is not None) else [b"OFF"]
             )
 
@@ -440,12 +441,12 @@ class BaseConnection(asyncio.BaseProtocol):
             )
             assert isinstance(hello_resp, (list, dict))
             if self.protocol_version == 3:
-                resp3 = cast(dict[bytes, ValueT], hello_resp)
+                resp3 = cast(dict[bytes, RedisValueT], hello_resp)
                 assert resp3[b"proto"] == 3
                 self.server_version = nativestr(resp3[b"version"])
                 self.client_id = int(resp3[b"id"])
             else:
-                resp = cast(list[ValueT], hello_resp)
+                resp = cast(list[RedisValueT], hello_resp)
                 self.server_version = nativestr(resp[3])
                 self.client_id = int(resp[7])
             if self.server_version >= "7.2":
@@ -512,7 +513,7 @@ class BaseConnection(asyncio.BaseProtocol):
 
     async def fetch_push_message(
         self,
-        decode: ValueT | None = None,
+        decode: RedisValueT | None = None,
         push_message_types: set[bytes] | None = None,
         block: bool | None = False,
     ) -> ResponseType:
@@ -578,7 +579,7 @@ class BaseConnection(asyncio.BaseProtocol):
     async def send_command(
         self,
         command: bytes,
-        *args: ValueT,
+        *args: RedisValueT,
     ) -> None:
         """
         Send a command to the redis server
@@ -594,9 +595,9 @@ class BaseConnection(asyncio.BaseProtocol):
     async def create_request(
         self,
         command: bytes,
-        *args: ValueT,
+        *args: RedisValueT,
         noreply: bool | None = None,
-        decode: ValueT | None = None,
+        decode: RedisValueT | None = None,
         encoding: str | None = None,
         raise_exceptions: bool = True,
         timeout: float | None = None,
@@ -690,17 +691,15 @@ class BaseConnection(asyncio.BaseProtocol):
         self.noreply_set = False
         self._parser.on_disconnect()
         if self._transport:
-            try:
+            with suppress(RuntimeError):
                 self._transport.close()
-            # Raised if event loop is already closed.
-            except RuntimeError:  # noqa
-                pass
 
         disconnect_exc = self._last_error or ConnectionError("connection lost")
         while self._read_waiters:
             waiter = self._read_waiters.pop()
             if not waiter.done():
-                waiter.cancel()
+                with suppress(RuntimeError):
+                    waiter.cancel()
         while True:
             try:
                 request = self._requests.popleft()
@@ -818,7 +817,7 @@ class UnixDomainSocketConnection(BaseConnection):
         *,
         client_name: str | None = None,
         protocol_version: Literal[2, 3] = 3,
-        **_: ValueT,
+        **_: RedisValueT,
     ) -> None:
         super().__init__(
             stream_timeout,

coredis/exceptions.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 
-from coredis.typing import ValueT
+from coredis.typing import RedisValueT
 
 
 class RedisError(Exception):
@@ -184,7 +184,7 @@ class ClusterCrossSlotError(ResponseError):
         self,
         message: str | None = None,
         command: bytes | None = None,
-        keys: tuple[ValueT, ...] | None = None,
+        keys: tuple[RedisValueT, ...] | None = None,
     ) -> None:
         super().__init__(message or "Keys in request don't hash to the same slot")
         self.command = command

coredis/experimental/__init__.py

@@ -1,5 +1 @@
 from __future__ import annotations
-
-from coredis.client.keydb import KeyDB, KeyDBCluster
-
-__all__ = ["KeyDB", "KeyDBCluster"]

coredis/globals.py

@@ -13,6 +13,9 @@ READONLY_COMMANDS: set[bytes] = set()
 #: Populated by the @redis_command wrapper
 COMMAND_FLAGS: dict[bytes, set[CommandFlag]] = defaultdict(set)
 
+#: Populated by the @redis_command wrapper
+CACHEABLE_COMMANDS: set[bytes] = set()
+
 #: Populated by ModuleGroupRegistry
 MODULE_GROUPS: set[ModuleGroupRegistry] = set()
 

coredis/modules/autocomplete.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from deprecated.sphinx import versionadded
 
-from ..commands._wrappers import CacheConfig
 from ..commands.constants import CommandFlag, CommandGroup, CommandName
+from ..commands.request import CommandRequest
 from ..response._callbacks import BoolCallback, IntCallback
 from ..tokens import PrefixToken, PureToken
 from ..typing import AnyStr, CommandArgList, KeyT, StringT
@@ -24,14 +24,14 @@ class Autocomplete(ModuleGroup[AnyStr]):
         version_introduced="1.0.0",
         group=COMMAND_GROUP,
     )
-    async def sugadd(
+    def sugadd(
         self,
         key: KeyT,
         string: StringT,
         score: int | float,
         increment_score: bool | None = None,
         payload: StringT | None = None,
-    ) -> int:
+    ) -> CommandRequest[int]:
         """
         Adds a suggestion string to an auto-complete suggestion dictionary
 
@@ -43,14 +43,14 @@ class Autocomplete(ModuleGroup[AnyStr]):
         :param payload: Saves an extra payload with the suggestion, that can be
          fetched when calling :meth:`sugget` by using :paramref:`sugget.withpayloads`
         """
-        pieces: CommandArgList = [key, string, score]
+        command_arguments: CommandArgList = [key, string, score]
         if increment_score:
-            pieces.append(PureToken.INCREMENT)
+            command_arguments.append(PureToken.INCREMENT)
         if payload:
-            pieces.extend([PrefixToken.PAYLOAD, payload])
+            command_arguments.extend([PrefixToken.PAYLOAD, payload])
 
-        return await self.execute_module_command(
-            CommandName.FT_SUGADD, *pieces, callback=IntCallback()
+        return self.client.create_request(
+            CommandName.FT_SUGADD, *command_arguments, callback=IntCallback()
         )
 
     @module_command(
@@ -58,10 +58,10 @@ class Autocomplete(ModuleGroup[AnyStr]):
         module=MODULE,
         version_introduced="1.0.0",
         group=COMMAND_GROUP,
-        cache_config=CacheConfig(lambda *a, **_: a[0]),
+        cacheable=True,
         flags={CommandFlag.READONLY},
     )
-    async def sugget(
+    def sugget(
         self,
         key: KeyT,
         prefix: StringT,
@@ -70,7 +70,7 @@ class Autocomplete(ModuleGroup[AnyStr]):
         withscores: bool | None = None,
         withpayloads: bool | None = None,
         max_suggestions: int | None = None,
-    ) -> tuple[AutocompleteSuggestion[AnyStr], ...] | tuple[()]:
+    ) -> CommandRequest[tuple[AutocompleteSuggestion[AnyStr], ...] | tuple[()]]:
         """
         Gets completion suggestions for a prefix
 
@@ -82,23 +82,21 @@ class Autocomplete(ModuleGroup[AnyStr]):
         :param withpayloads: If True, returns optional payloads saved along with the suggestions.
         :param max_suggestions: Limits the results to a maximum of ``max_suggestions``
         """
-        pieces: CommandArgList = [key, prefix]
+        command_arguments: CommandArgList = [key, prefix]
         if fuzzy:
-            pieces.append(PureToken.FUZZY)
+            command_arguments.append(PureToken.FUZZY)
         if withscores:
-            pieces.append(PureToken.WITHSCORES)
+            command_arguments.append(PureToken.WITHSCORES)
         if withpayloads:
-            pieces.append(PureToken.WITHPAYLOADS)
+            command_arguments.append(PureToken.WITHPAYLOADS)
         if max_suggestions is not None:
-            pieces.append(PureToken.MAX)
-            pieces.append(max_suggestions)
+            command_arguments.append(PureToken.MAX)
+            command_arguments.append(max_suggestions)
 
-        return await self.execute_module_command(
+        return self.client.create_request(
             CommandName.FT_SUGGET,
-            *pieces,
-            callback=AutocompleteCallback[AnyStr](),
-            withscores=withscores,
-            withpayloads=withpayloads,
+            *command_arguments,
+            callback=AutocompleteCallback[AnyStr](withscores=withscores, withpayloads=withpayloads),
         )
 
     @module_command(
@@ -107,7 +105,7 @@ class Autocomplete(ModuleGroup[AnyStr]):
         version_introduced="1.0.0",
         group=COMMAND_GROUP,
     )
-    async def sugdel(self, key: KeyT, string: StringT) -> bool:
+    def sugdel(self, key: KeyT, string: StringT) -> CommandRequest[bool]:
         """
         Deletes a string from a suggestion index
 
@@ -115,10 +113,10 @@ class Autocomplete(ModuleGroup[AnyStr]):
         :param string: The suggestion string to index.
 
         """
-        pieces: CommandArgList = [key, string]
+        command_arguments: CommandArgList = [key, string]
 
-        return await self.execute_module_command(
-            CommandName.FT_SUGDEL, *pieces, callback=BoolCallback()
+        return self.client.create_request(
+            CommandName.FT_SUGDEL, *command_arguments, callback=BoolCallback()
         )
 
     @module_command(
@@ -127,14 +125,14 @@ class Autocomplete(ModuleGroup[AnyStr]):
         version_introduced="1.0.0",
         group=COMMAND_GROUP,
     )
-    async def suglen(self, key: KeyT) -> int:
+    def suglen(self, key: KeyT) -> CommandRequest[int]:
         """
         Gets the size of an auto-complete suggestion dictionary
 
         :param key: The key of the suggestion dictionary.
         """
-        pieces: CommandArgList = [key]
+        command_arguments: CommandArgList = [key]
 
-        return await self.execute_module_command(
-            CommandName.FT_SUGLEN, *pieces, callback=IntCallback()
+        return self.client.create_request(
+            CommandName.FT_SUGLEN, *command_arguments, callback=IntCallback()
         )

coredis/modules/base.py

@@ -12,24 +12,20 @@ from coredis.config import Config
 from .._protocols import AbstractExecutor
 from ..commands._utils import redis_command_link
 from ..commands._wrappers import (
-    CacheConfig,
     ClusterCommandConfig,
-    CommandCache,
     CommandDetails,
 )
 from ..commands.constants import CommandFlag, CommandGroup, CommandName
+from ..commands.request import CommandRequest
 from ..exceptions import CommandSyntaxError, ModuleCommandNotSupportedError
-from ..globals import COMMAND_FLAGS, MODULE_GROUPS, MODULES, READONLY_COMMANDS
-from ..response._callbacks import NoopCallback
+from ..globals import CACHEABLE_COMMANDS, COMMAND_FLAGS, MODULE_GROUPS, MODULES, READONLY_COMMANDS
 from ..typing import (
     AnyStr,
     Callable,
     ClassVar,
-    Coroutine,
     Generic,
     P,
     R,
-    ValueT,
     add_runtime_checks,
 )
 
@@ -37,7 +33,7 @@ if TYPE_CHECKING:
     import coredis.client
 
 
-async def ensure_compatibility(
+def ensure_compatibility(
     client: coredis.client.Client[Any],
     module: str,
     command_details: CommandDetails,
@@ -47,11 +43,12 @@ async def ensure_compatibility(
         Config.optimized
         or not command_details.version_introduced
         or not getattr(client, "verify_version", False)
+        or not getattr(client, "server_version", None)
         or getattr(client, "noreply", False)
     ):
         return
     if command_details.version_introduced:
-        module_version = await client.get_server_module_version(module)
+        module_version = client.get_server_module_version(module)
         if module_version and command_details.version_introduced <= module_version:
             if command_details.arguments and set(command_details.arguments.keys()).intersection(
                 kwargs.keys()
@@ -79,11 +76,11 @@ def module_command(
     group: CommandGroup,
     flags: set[CommandFlag] | None = None,
     cluster: ClusterCommandConfig = ClusterCommandConfig(),
-    cache_config: CacheConfig | None = None,
+    cacheable: bool | None = None,
     version_introduced: str | None = None,
     version_deprecated: str | None = None,
     arguments: dict[str, dict[str, str]] | None = None,
-) -> Callable[[Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]]:
+) -> Callable[[Callable[P, CommandRequest[R]]], Callable[P, CommandRequest[R]]]:
     command_details = CommandDetails(
         command_name,
         group,
@@ -91,22 +88,22 @@ def module_command(
         version.Version(version_deprecated) if version_deprecated else None,
         arguments,
         cluster or ClusterCommandConfig(),
-        cache_config,
         flags or set(),
         None,
     )
 
     def wrapper(
-        func: Callable[P, Coroutine[Any, Any, R]],
-    ) -> Callable[P, Coroutine[Any, Any, R]]:
+        func: Callable[P, CommandRequest[R]],
+    ) -> Callable[P, CommandRequest[R]]:
         runtime_checkable = add_runtime_checks(func)
-        command_cache = CommandCache(command_name, cache_config)
         if flags and CommandFlag.READONLY in flags:
             READONLY_COMMANDS.add(command_name)
+        if cacheable:
+            CACHEABLE_COMMANDS.add(command_name)
         COMMAND_FLAGS[command_name] = flags or set()
 
         @functools.wraps(func)
-        async def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
+        def wrapped(*args: P.args, **kwargs: P.kwargs) -> CommandRequest[R]:
             from coredis.client import Redis, RedisCluster
 
             mg = cast(ModuleGroup[bytes], args[0])
@@ -114,9 +111,8 @@ def module_command(
             is_regular_client = isinstance(client, (Redis, RedisCluster))
             runtime_checking = not getattr(client, "noreply", None) and is_regular_client
             callable = runtime_checkable if runtime_checking else func
-            await ensure_compatibility(client, module.NAME, command_details, kwargs)
-            async with command_cache(callable, *args, **kwargs) as response:
-                return response
+            ensure_compatibility(client, module.NAME, command_details, kwargs)
+            return callable(*args, **kwargs)
 
         wrapped.__doc__ = textwrap.dedent(wrapped.__doc__ or "")
         if group:
@@ -147,7 +143,7 @@ Compatibility:
                     wrapped.__doc__ += f"""
 - :paramref:`{argument}`: New in {module.FULL_NAME} version `{min_version}`
                     """
-        if cache_config:
+        if cacheable:
             wrapped.__doc__ += """
 .. hint:: Supports client side caching
 """
@@ -264,15 +260,3 @@ class ModuleGroup(Generic[AnyStr], metaclass=ModuleGroupRegistry):
 
     def __init__(self, client: AbstractExecutor):
         self.client = client
-
-    async def execute_module_command(
-        self,
-        command: bytes,
-        *args: ValueT,
-        callback: Callable[..., R] = NoopCallback(),
-        **options: ValueT | None,
-    ) -> R:
-        return cast(
-            R,
-            await self.client.execute_command(command, *args, callback=callback, **options),
-        )