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

coredis/commands/_validators.py

@@ -8,7 +8,6 @@ from coredis.config import Config
 from coredis.exceptions import CommandSyntaxError
 from coredis.typing import (
     Callable,
-    Coroutine,
     Iterable,
     ParamSpec,
     TypeVar,
@@ -18,6 +17,14 @@ R = TypeVar("R")
 P = ParamSpec("P")
 
 
+class RequiredParameterError(CommandSyntaxError):
+    def __init__(self, arguments: set[str], details: str | None):
+        message = (
+            f"One of [{','.join(arguments)}] must be provided.{' ' + details if details else ''}"
+        )
+        super().__init__(arguments, message)
+
+
 class MutuallyExclusiveParametersError(CommandSyntaxError):
     def __init__(self, arguments: set[str], details: str | None):
         message = (
@@ -45,18 +52,20 @@ class MutuallyInclusiveParametersMissing(CommandSyntaxError):
 
 
 def mutually_exclusive_parameters(
-    *exclusive_params: str | Iterable[str], details: str | None = None
-) -> Callable[[Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]]:
+    *exclusive_params: str | Iterable[str],
+    details: str | None = None,
+    required: bool = False,
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
     primary = {k for k in exclusive_params if isinstance(k, str)}
     secondary = [k for k in set(exclusive_params) - primary]
 
     def wrapper(
-        func: Callable[P, Coroutine[Any, Any, R]],
-    ) -> Callable[P, Coroutine[Any, Any, R]]:
+        func: Callable[P, R],
+    ) -> Callable[P, R]:
         sig = inspect.signature(func)
 
         @functools.wraps(func)
-        async def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
+        def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
             if not Config.optimized:
                 call_args = sig.bind_partial(*args, **kwargs)
                 params = {
@@ -77,8 +86,10 @@ def mutually_exclusive_parameters(
 
                 if len(params) > 1:
                     raise MutuallyExclusiveParametersError(params, details)
+                if len(params) == 0 and required:
+                    raise RequiredParameterError(primary, details)
 
-            return await func(*args, **kwargs)
+            return func(*args, **kwargs)
 
         return wrapped if not Config.optimized else func
 
@@ -89,17 +100,17 @@ def mutually_inclusive_parameters(
     *inclusive_params: str,
     leaders: Iterable[str] | None = None,
     details: str | None = None,
-) -> Callable[[Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]]:
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
     _leaders = set(leaders or [])
     _inclusive_params = set(inclusive_params)
 
     def wrapper(
-        func: Callable[P, Coroutine[Any, Any, R]],
-    ) -> Callable[P, Coroutine[Any, Any, R]]:
+        func: Callable[P, R],
+    ) -> Callable[P, R]:
         sig = inspect.signature(func)
 
         @functools.wraps(func)
-        async def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
+        def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
             if not Config.optimized:
                 call_args = sig.bind_partial(*args, **kwargs)
                 params = {
@@ -111,7 +122,7 @@ def mutually_inclusive_parameters(
                     raise MutuallyInclusiveParametersMissing(_inclusive_params, _leaders, details)
                 elif not _leaders and params and len(params) != len(_inclusive_params):
                     raise MutuallyInclusiveParametersMissing(_inclusive_params, _leaders, details)
-            return await func(*args, **kwargs)
+            return func(*args, **kwargs)
 
         return wrapped if not Config.optimized else func
 
@@ -120,29 +131,28 @@ def mutually_inclusive_parameters(
 
 def ensure_iterable_valid(
     argument: str,
-) -> Callable[[Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]]:
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def iterable_valid(value: Any) -> bool:
         return isinstance(value, Iterable) and not isinstance(value, (str, bytes))
 
     def wrapper(
-        func: Callable[P, Coroutine[Any, Any, R]],
-    ) -> Callable[P, Coroutine[Any, Any, R]]:
+        func: Callable[P, R],
+    ) -> Callable[P, R]:
         sig = inspect.signature(func)
         expected_type = sig.parameters[argument].annotation
 
         @functools.wraps(func)
-        async def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
+        def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
             if Config.optimized:
-                return await func(*args, **kwargs)
+                return func(*args, **kwargs)
             bound = sig.bind_partial(*args, **kwargs)
             value = bound.arguments.get(argument)
             if not iterable_valid(value):
                 raise TypeError(
-                    f"{func.__name__} parameter {argument}={value!r} "
-                    f"violates expected iterable of type {expected_type}"
+                    f"{func.__name__} parameter {argument}={value!r} violates expected iterable of type {expected_type}"
                 )
 
-            return await func(*args, **kwargs)
+            return func(*args, **kwargs)
 
         return wrapped if not Config.optimized else func
 

coredis/commands/_wrappers.py

@@ -1,39 +1,25 @@
 from __future__ import annotations
 
-import contextlib
 import dataclasses
 import functools
-import random
 import textwrap
 import warnings
-from typing import TYPE_CHECKING, Any, cast
 
 from packaging import version
 
-from coredis.cache import AbstractCache, SupportsSampling
 from coredis.commands._utils import check_version, redis_command_link
 from coredis.commands.constants import CommandFlag, CommandGroup, CommandName, NodeFlag
-from coredis.globals import COMMAND_FLAGS, READONLY_COMMANDS
+from coredis.commands.request import CommandRequest
+from coredis.globals import CACHEABLE_COMMANDS, COMMAND_FLAGS, READONLY_COMMANDS
 from coredis.response._callbacks import ClusterMultiNodeCallback
 from coredis.typing import (
-    AsyncIterator,
     Callable,
-    Coroutine,
     NamedTuple,
     P,
     R,
-    ResponseType,
     add_runtime_checks,
 )
 
-if TYPE_CHECKING:
-    pass
-
-
-@dataclasses.dataclass
-class CacheConfig:
-    key_func: Callable[..., bytes]
-
 
 class RedirectUsage(NamedTuple):
     reason: str
@@ -48,7 +34,6 @@ class CommandDetails:
     version_deprecated: version.Version | None
     _arguments: dict[str, dict[str, str]] | None
     cluster: ClusterCommandConfig
-    cache_config: CacheConfig | None
     flags: set[CommandFlag]
     redirect_usage: RedirectUsage | None
     arguments: dict[str, version.Version] = dataclasses.field(
@@ -76,75 +61,13 @@ class ClusterCommandConfig:
             NodeFlag.ALL,
             NodeFlag.PRIMARIES,
             NodeFlag.REPLICAS,
+            NodeFlag.SLOT_ID,
         ]
 
 
-@dataclasses.dataclass
-class CommandCache:
-    command: bytes
-    cache_config: CacheConfig | None
-
-    @contextlib.asynccontextmanager
-    async def __call__(
-        self,
-        func: Callable[P, Coroutine[Any, Any, R]],
-        *args: P.args,
-        **kwargs: P.kwargs,
-    ) -> AsyncIterator[R]:
-        from coredis.modules.base import ModuleGroup
-
-        client = args[0]
-        if isinstance(args[0], ModuleGroup):
-            client = args[0].client
-
-        cache = getattr(client, "cache")
-        noreply = getattr(client, "noreply")
-        if not (self.cache_config and cache) or noreply:
-            yield await func(*args, **kwargs)
-        else:
-            assert isinstance(cache, AbstractCache)
-            if not cache.healthy:
-                yield await func(*args, **kwargs)
-            else:
-                key = self.cache_config.key_func(*args[1:], **kwargs)
-                try:
-                    cached = cast(
-                        R,
-                        cache.get(
-                            self.command,
-                            key,
-                            *args[1:],  # type: ignore
-                            *kwargs.items(),  # type: ignore
-                        ),
-                    )
-                    if isinstance(cache, SupportsSampling) and not random.random() * 100.0 < min(
-                        100.0, cache.confidence
-                    ):
-                        actual = await func(*args, **kwargs)
-                        cache.feedback(
-                            self.command,
-                            key,
-                            *args[1:],  # type: ignore
-                            *kwargs.items(),  # type: ignore
-                            match=(actual == cached),
-                        )
-                        yield actual
-                    else:
-                        yield cached
-                except KeyError:
-                    response = await func(*args, **kwargs)
-                    cache.put(
-                        self.command,
-                        key,
-                        *args[1:],  # type: ignore
-                        *kwargs.items(),  # type: ignore
-                        value=cast(ResponseType, response),
-                    )
-                    yield response
-
-
 def redis_command(
     command_name: CommandName,
+    *,
     group: CommandGroup | None = None,
     version_introduced: str | None = None,
     version_deprecated: str | None = None,
@@ -153,15 +76,17 @@ def redis_command(
     arguments: dict[str, dict[str, str]] | None = None,
     flags: set[CommandFlag] | None = None,
     cluster: ClusterCommandConfig = ClusterCommandConfig(),
-    cache_config: CacheConfig | None = None,
-) -> Callable[[Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]]:
+    cacheable: bool | None = None,
+) -> Callable[[Callable[P, CommandRequest[R]]], Callable[P, CommandRequest[R]]]:
     readonly = False
     if flags and CommandFlag.READONLY in flags:
         READONLY_COMMANDS.add(command_name)
         readonly = True
 
-    if not readonly and cache_config:  # noqa
+    if not readonly and cacheable:  # noqa
         raise RuntimeError(f"Can't decorate non readonly command {command_name} with cache config")
+    if cacheable:
+        CACHEABLE_COMMANDS.add(command_name)
 
     COMMAND_FLAGS[command_name] = flags or set()
 
@@ -172,39 +97,34 @@ def redis_command(
         version.Version(version_deprecated) if version_deprecated else None,
         arguments,
         cluster or ClusterCommandConfig(),
-        cache_config,
         flags or set(),
         redirect_usage,
     )
 
     def wrapper(
-        func: Callable[P, Coroutine[Any, Any, R]],
-    ) -> Callable[P, Coroutine[Any, Any, R]]:
-        command_cache = CommandCache(command_name, cache_config)
+        func: Callable[P, CommandRequest[R]],
+    ) -> Callable[P, CommandRequest[R]]:
         runtime_checkable = add_runtime_checks(func)
 
         @functools.wraps(func)
-        async def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
-            from coredis.client import Redis, RedisCluster
+        def wrapped(*args: P.args, **kwargs: P.kwargs) -> CommandRequest[R]:
+            from coredis import Redis, RedisCluster
 
-            client = args[0]
-            is_regular_client = isinstance(client, (Redis, RedisCluster))
-            runtime_checking = not getattr(client, "noreply", None) and is_regular_client
+            is_regular_client = isinstance(args[0], (Redis, RedisCluster))
             if redirect_usage and is_regular_client:
                 if redirect_usage.warn:
                     warnings.warn(redirect_usage.reason, UserWarning, stacklevel=2)
                 else:
                     raise NotImplementedError(redirect_usage.reason)
-            callable = runtime_checkable if runtime_checking else func
-            await check_version(
-                client,  # type: ignore
+            runtime_checking = not getattr(args[0], "noreply", None) and is_regular_client
+            check_version(
+                args[0],  # type: ignore
                 func.__name__,
                 command_details,
                 deprecation_reason,
                 kwargs,
             )
-            async with command_cache(callable, *args, **kwargs) as response:
-                return response
+            return (func if not runtime_checking else runtime_checkable)(*args, **kwargs)
 
         wrapped.__doc__ = textwrap.dedent(wrapped.__doc__ or "")
         if group:
@@ -236,7 +156,7 @@ Compatibility:
                 wrapped.__doc__ += f"""
 - :paramref:`{argument}`: New in :redis-version:`{min_version}`
 """
-        if cache_config:
+        if cacheable:
             wrapped.__doc__ += """
 .. hint:: Supports client side caching
 """

coredis/commands/bitfield.py

@@ -4,7 +4,9 @@ import enum
 
 from coredis._protocols import AbstractExecutor
 from coredis.commands.constants import CommandName
+from coredis.commands.request import CommandRequest
 from coredis.exceptions import ReadOnlyError
+from coredis.response._callbacks import NoopCallback
 from coredis.tokens import PrefixToken, PureToken
 from coredis.typing import (
     AnyStr,
@@ -96,7 +98,13 @@ class BitFieldOperation(Generic[AnyStr]):
 
         return self
 
-    async def exc(self) -> ResponseType:
+    def exc(self) -> CommandRequest[ResponseType]:
         """execute commands in command stack"""
 
-        return await self.redis.execute_command(self._command, *self._command_stack, decode=False)
+        return CommandRequest(
+            self.redis,
+            self._command,
+            *self._command_stack,
+            callback=NoopCallback(),
+            execution_parameters={"decode": False},
+        )

coredis/commands/constants.py

@@ -351,6 +351,9 @@ class CommandName(CaseAndEncodingInsensitiveEnum):
     HPEXPIRETIME = b"HPEXPIRETIME"  # Since redis: 7.4.0
     HPTTL = b"HPTTL"  # Since redis: 7.4.0
     HTTL = b"HTTL"  # Since redis: 7.4.0
+    HGETDEL = b"HGETDEL"  # Since redis: 8.0.0
+    HGETEX = b"HGETEX"  # Since redis: 8.0.0
+    HSETEX = b"HSETEX"  # Since redis: 8.0.0
     HMSET = b"HMSET"  # Deprecated in redis: 4.0.0
 
     #: Commands for hyperloglog
@@ -420,6 +423,19 @@ class CommandName(CaseAndEncodingInsensitiveEnum):
     XAUTOCLAIM = b"XAUTOCLAIM"  # Since redis: 6.2.0
     XGROUP_CREATECONSUMER = b"XGROUP CREATECONSUMER"  # Since redis: 6.2.0
 
+    #: Commands for vector_set
+    VADD = b"VADD"  # Since redis: 8.0.0
+    VREM = b"VREM"  # Since redis: 8.0.0
+    VSIM = b"VSIM"  # Since redis: 8.0.0
+    VDIM = b"VDIM"  # Since redis: 8.0.0
+    VCARD = b"VCARD"  # Since redis: 8.0.0
+    VEMB = b"VEMB"  # Since redis: 8.0.0
+    VLINKS = b"VLINKS"  # Since redis: 8.0.0
+    VINFO = b"VINFO"  # Since redis: 8.0.0
+    VSETATTR = b"VSETATTR"  # Since redis: 8.0.0
+    VGETATTR = b"VGETATTR"  # Since redis: 8.0.0
+    VRANDMEMBER = b"VRANDMEMBER"  # Since redis: 8.0.0
+
     #: Commands for json
     JSON_DEL = b"JSON.DEL"  # Since RedisJSON: 1.0.0
     JSON_FORGET = b"JSON.FORGET"  # Since RedisJSON: 1.0.0
@@ -549,9 +565,6 @@ class CommandName(CaseAndEncodingInsensitiveEnum):
     FT_ALIASUPDATE = b"FT.ALIASUPDATE"  # Since search: 1.0.0
     FT_ALIASDEL = b"FT.ALIASDEL"  # Since search: 1.0.0
     FT_TAGVALS = b"FT.TAGVALS"  # Since search: 1.0.0
-    FT_CONFIG_SET = b"FT.CONFIG SET"  # Since search: 1.0.0
-    FT_CONFIG_GET = b"FT.CONFIG GET"  # Since search: 1.0.0
-    FT_CONFIG_HELP = b"FT.CONFIG HELP"  # Since search: 1.0.0
     FT_SEARCH = b"FT.SEARCH"  # Since search: 1.0.0
     FT_AGGREGATE = b"FT.AGGREGATE"  # Since search: 1.1.0
     FT_CURSOR_READ = b"FT.CURSOR READ"  # Since search: 1.1.0
@@ -565,6 +578,9 @@ class CommandName(CaseAndEncodingInsensitiveEnum):
     FT_DROPINDEX = b"FT.DROPINDEX"  # Since search: 2.0.0
     FT__LIST = b"FT._LIST"  # Since search: 2.0.0
     FT_PROFILE = b"FT.PROFILE"  # Since search: 2.2.0
+    FT_CONFIG_SET = b"FT.CONFIG SET"  # Deprecated in search: 8.0.0
+    FT_CONFIG_GET = b"FT.CONFIG GET"  # Deprecated in search: 8.0.0
+    FT_CONFIG_HELP = b"FT.CONFIG HELP"  # Deprecated in search: 8.0.0
 
     #: Commands for suggestion
     FT_SUGADD = b"FT.SUGADD"  # Since search: 1.0.0
@@ -624,6 +640,7 @@ class CommandGroup(enum.Enum):
     TIMESERIES = "timeseries"
     TOPK = "topk"
     TRANSACTIONS = "transactions"
+    VECTOR_SET = "vector_set"
 
 
 class NodeFlag(enum.Enum):