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

coredis/commands/function.py

@@ -9,6 +9,7 @@ from typing import Any, ClassVar, cast
 from deprecated.sphinx import versionadded
 
 from coredis._utils import EncodingInsensitiveDict, nativestr
+from coredis.commands.request import CommandRequest
 from coredis.exceptions import FunctionError
 from coredis.typing import (
     TYPE_CHECKING,
@@ -18,6 +19,7 @@ from coredis.typing import (
     Generator,
     Generic,
     KeyT,
+    MutableMapping,
     P,
     Parameters,
     R,
@@ -90,7 +92,7 @@ class Library(Generic[AnyStr]):
         return c
 
     @property
-    def functions(self) -> dict[str, Function[AnyStr]]:
+    def functions(self) -> MutableMapping[str, Function[AnyStr]]:
         """
         mapping of function names to :class:`~coredis.commands.function.Function`
         instances that can be directly called.
@@ -107,11 +109,17 @@ class Library(Generic[AnyStr]):
         return False
 
     async def initialize(self: LibraryT, replace: bool = False) -> LibraryT:
+        from coredis.pipeline import ClusterPipeline, Pipeline
+
         self._functions.clear()
-        library = (await self.client.function_list(self.name)).get(self.name)
+        if isinstance(self.client, (Pipeline, ClusterPipeline)):
+            redis_client = self.client.client
+        else:
+            redis_client = self.client
+        library = (await redis_client.function_list(self.name)).get(self.name)
         if (not library and self.code) or (replace or self.replace):
-            await self.client.function_load(self.code, replace=replace or self.replace)
-            library = (await self.client.function_list(self.name)).get(self.name)
+            await redis_client.function_load(self.code, replace=replace or self.replace)
+            library = (await redis_client.function_list(self.name)).get(self.name)
 
         if not library:
             raise FunctionError(f"No library found for {self.name}")
@@ -142,7 +150,7 @@ class Library(Generic[AnyStr]):
         ),
         runtime_checks: bool = False,
         readonly: bool | None = None,
-    ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]:
+    ) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, CommandRequest[R]]]:
         """
         Decorator for wrapping methods of subclasses of :class:`Library`
         as entry points to the functions contained in the library. This allows
@@ -165,7 +173,7 @@ class Library(Generic[AnyStr]):
 
             import coredis
             from coredis.commands import Library
-            from coredis.typing import KeyT, ValueT
+            from coredis.typing import KeyT, RedisValueT
             from typing import List
 
             class MyAwesomeLibrary(Library):
@@ -213,22 +221,24 @@ class Library(Generic[AnyStr]):
                 \"\"\"
 
                 @Library.wraps("echo")
-                async def echo(self, value: ValueT) -> ValueT: ...
+                def echo(self, value: ValueT) -> CommandRequest[RedisValueT]: ...
 
-                @Library.wraps("ping")
-                async def ping(self) -> str: ...
+                @Library.wraps("ping"print(c)
+                )
+                def ping(self) -> CommandRequest[str]: ...
 
                 @Library.wraps("get")
-                async def get(self, key: KeyT) -> ValueT: ...
+                def get(self, key: KeyT) -> CommandRequest[ValueT]: ...
 
                 @Library.wraps("hmmget")
-                async def hmmget(self, *keys: KeyT, **fields_with_values: ValueT): ...
+                def hmmget(self, *keys: KeyT, **fields_with_values: RedisValueT):
                 \"\"\"
                 Return values of ``fields_with_values`` on a first come first serve
                 basis from the hashes at ``keys``. Since ``fields_with_values`` is a mapping
                 the keys are mapped to hash fields and the values are used
                 as defaults if they are not found in any of the hashes at ``keys``
                 \"\"\"
+                ...
 
             client = coredis.Redis()
             lib = await MyAwesomeLibrary(client, replace=True)
@@ -264,7 +274,7 @@ class Library(Generic[AnyStr]):
         :return: A function that has a signature mirroring the decorated function.
         """
 
-        def wrapper(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+        def wrapper(func: Callable[P, Awaitable[R]]) -> Callable[P, CommandRequest[R]]:
             sig = inspect.signature(func)
             first_arg: str = list(sig.parameters.keys())[0]
             runtime_check_wrapper = add_runtime_checks if not runtime_checks else safe_beartype
@@ -318,16 +328,13 @@ class Library(Generic[AnyStr]):
 
             @runtime_check_wrapper
             @functools.wraps(func)
-            async def _inner(*args: P.args, **kwargs: P.kwargs) -> R:
+            def _inner(*args: P.args, **kwargs: P.kwargs) -> CommandRequest[R]:
                 instance, keys, arguments = split_args(*args, **kwargs)
-                func = instance.functions[function_name]
-                if not func:
+                if (func := instance.functions.get(function_name, None)) is None:
                     raise AttributeError(
                         f"Library {instance.name} has no registered function {function_name}"
                     )
-                # TODO: atleast lie with a cast.
-                #  mypy doesn't like the cast
-                return await func(keys, arguments, readonly=readonly)  # type: ignore
+                return cast(CommandRequest[R], func(keys, arguments, readonly=readonly))
 
             return _inner
 
@@ -373,14 +380,14 @@ class Function(Generic[AnyStr]):
     def __await__(self) -> Generator[Any, None, Function[AnyStr]]:
         return self.initialize().__await__()
 
-    async def __call__(
+    def __call__(
         self,
         keys: Parameters[KeyT] | None = None,
         args: Parameters[ValueT] | None = None,
         *,
         client: coredis.client.Client[AnyStr] | None = None,
         readonly: bool | None = None,
-    ) -> ResponseType:
+    ) -> CommandRequest[ResponseType]:
         """
         Wrapper to call :meth:`~coredis.Redis.fcall` with the
         function named :paramref:`Function.name` registered under
@@ -396,6 +403,6 @@ class Function(Generic[AnyStr]):
             readonly = self.readonly
 
         if readonly:
-            return await client.fcall_ro(self.name, keys or [], args or [])
+            return client.fcall_ro(self.name, keys or [], args or [])
         else:
-            return await client.fcall(self.name, keys or [], args or [])
+            return client.fcall(self.name, keys or [], args or [])

coredis/commands/monitor.py

@@ -1,9 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import threading
-from asyncio import AbstractEventLoop
-from concurrent.futures import Future
 from types import TracebackType
 from typing import TYPE_CHECKING, Any
 
@@ -113,44 +110,6 @@ class Monitor(Generic[AnyStr]):
         """
         return await self.aclose()
 
-    @deprecated(
-        """
-        Running the monitor in a thread is no longer necessary
-        since the constructor for :class:`Monitor` will accept a callback
-        to be triggered when a command is received by the monitor and this will
-        automatically happen in a background async task that is started as soon 
-        as :class:`Monitor` is initialized.
-        
-        To achieve identical results simply await an instance of :class:`Monitor`
-        instantiated with :paramref:`Monitor.response_handler` and call :meth:`aclose` 
-        when done.
-        
-        
-        .. code:: python
-        
-            monitor = await client.monitor(response_handler=my_handler)
-            # when done
-            await pubsub.aclose() 
-        """,
-        version="4.21.0",
-    )
-    def run_in_thread(
-        self,
-        response_handler: Callable[[MonitorResult], None],
-        loop: AbstractEventLoop | None = None,
-    ) -> MonitorThread:
-        """
-        Runs the monitor in a :class:`MonitorThread` and invokes :paramref:`response_handler`
-        for every command received.
-
-        To stop the processing call :meth:`MonitorThread.stop` on the instance
-        returned by this method.
-
-        """
-        monitor_thread = MonitorThread(self, loop or asyncio.get_event_loop(), response_handler)
-        monitor_thread.start()
-        return monitor_thread
-
     async def __connect(self) -> None:
         if self.connection is None:
             self.connection = await self.client.connection_pool.get_connection()
@@ -206,33 +165,3 @@ class Monitor(Generic[AnyStr]):
             except ConnectionError:
                 break
         self.__reset()
-
-
-class MonitorThread(threading.Thread):
-    """
-    Thread to be used to run monitor
-    """
-
-    def __init__(
-        self,
-        monitor: Monitor[Any],
-        loop: asyncio.events.AbstractEventLoop,
-        response_handler: Callable[[MonitorResult], None],
-    ):
-        self._monitor = monitor
-        self._loop = loop
-        self._response_handler = response_handler
-        self._future: Future[None] | None = None
-        super().__init__()
-
-    def run(self) -> None:
-        self._future = asyncio.run_coroutine_threadsafe(self._run(), self._loop)
-
-    async def _run(self) -> None:
-        async with self._monitor:
-            async for command in self._monitor:
-                self._response_handler(command)
-
-    def stop(self) -> None:
-        if self._future:
-            self._future.cancel()

coredis/commands/pubsub.py

@@ -2,16 +2,14 @@ from __future__ import annotations
 
 import asyncio
 import inspect
-import threading
 from asyncio import CancelledError
-from concurrent.futures import Future
-from contextlib import aclosing, suppress
+from contextlib import suppress
 from functools import partial
 from types import TracebackType
 from typing import TYPE_CHECKING, Any, cast
 
 import async_timeout
-from deprecated.sphinx import deprecated, versionadded
+from deprecated.sphinx import versionadded
 
 from coredis._utils import CaseAndEncodingInsensitiveEnum, b, hash_slot, nativestr
 from coredis.commands.constants import CommandName
@@ -33,12 +31,12 @@ from coredis.typing import (
     Mapping,
     MutableMapping,
     Parameters,
+    RedisValueT,
     ResponsePrimitive,
     ResponseType,
     Self,
     StringT,
     TypeVar,
-    ValueT,
 )
 
 if TYPE_CHECKING:
@@ -216,61 +214,6 @@ class BasePubSub(Generic[AnyStr, PoolT]):
 
         await self.execute_command(CommandName.UNSUBSCRIBE, *channels)
 
-    @deprecated(
-        """
-        Use :meth:`get_message` with :paramref:`get_message.timeout` as `None`
-        or the instance itself as an async iterator to infinitely consume messages
-        
-        .. code:: python
-        
-            pubsub = client.pubsub()
-            
-            # instead of 
-            while True:
-                message = await pubsub.listen()
-                
-            # do 
-            async for message in pubsub:
-                ....
-            # or 
-            while True:
-                message = await pubsub.get_message(timeout=None)
-        
-        If you were using this method to simply pull messages and/or
-        ensure callbacks were being triggered when the message arrives
-        this isn't necessary anymore and simply creating a pubsub instance
-        and registering the handlers is sufficient to ensure the messages
-        are fetched and callbacks are triggered.
-        
-        .. code:: python
-        
-           # instead of
-           pubsub = client.pubsub()
-           await pubsub.subscribe(**{"topic-a": topic_a_handler})
-           while True:
-               await pubsub.listen()
-               
-           # do
-           pubsub = await client.pubsub(
-             channel_handlers={"topic-a": topic_a_handler}
-           )
-           # when done 
-           await pubsub.aclose()
-           
-               
-        """,
-        version="4.21.0",
-    )
-    async def listen(self) -> PubSubMessage | None:
-        """
-        Listens for messages on channels this client has been subscribed to
-        """
-
-        await self.initialize()
-        if self.subscribed:
-            return self._filter_ignored_messages(await self._message_queue.get())
-        return None
-
     async def get_message(
         self,
         ignore_subscribe_messages: bool = False,
@@ -333,7 +276,7 @@ class BasePubSub(Generic[AnyStr, PoolT]):
         return value
 
     async def execute_command(
-        self, command: bytes, *args: ValueT, **options: ValueT
+        self, command: bytes, *args: RedisValueT, **options: RedisValueT
     ) -> ResponseType | None:
         """
         Executes a publish/subscribe command
@@ -440,44 +383,6 @@ class BasePubSub(Generic[AnyStr, PoolT]):
 
         return message
 
-    @deprecated(
-        """
-        Registered handlers are called in a background async task automatically 
-        as soon as this pubsub instance is initialized. To achieve identical results 
-        just subscribe to the channels or patterns with the appropriate handlers
-        and call :meth:`aclose` when done.
-        
-        
-        .. code:: python
-        
-            pubsub = client.pubsub()
-            await client.subscribe(topic=topic_handler)
-            await client.psubscribe(topic=pattern_handler)
-            # when done
-            await pubsub.aclose() 
-        """,
-        version="4.21.0",
-    )
-    def run_in_thread(self, poll_timeout: float = 1.0) -> PubSubWorkerThread:
-        """
-        Run the listeners in a thread. For each message received on a
-        subscribed channel or pattern the registered handlers will be invoked.
-
-        To stop listening invoke :meth:`~coredis.commands.pubsub.PubSubWorkerThread.stop`
-        on the returned instance
-        """
-        for channel, handler in self.channels.items():
-            if handler is None:
-                raise PubSubError(f"Channel: {channel!r} has no handler registered")
-
-        for pattern, handler in self.patterns.items():
-            if handler is None:
-                raise PubSubError(f"Pattern: {pattern!r} has no handler registered")
-        thread = PubSubWorkerThread(self, poll_timeout=poll_timeout)
-        thread.start()
-
-        return thread
-
     async def _consumer(self) -> None:
         while self.initialized:
             try:
@@ -509,7 +414,7 @@ class BasePubSub(Generic[AnyStr, PoolT]):
         self,
         connection: BaseConnection,
         command: Callable[..., Awaitable[None]] | Callable[..., Awaitable[ResponseType]],
-        *args: ValueT,
+        *args: RedisValueT,
     ) -> ResponseType | None:
         try:
             return await command(*args)
@@ -653,7 +558,7 @@ class ClusterPubSub(BasePubSub[AnyStr, "coredis.pool.ClusterConnectionPool"]):
     """
 
     async def execute_command(
-        self, command: bytes, *args: ValueT, **options: ValueT
+        self, command: bytes, *args: RedisValueT, **options: RedisValueT
     ) -> ResponseType | None:
         await self.initialize()
         assert self.connection
@@ -807,7 +712,7 @@ class ShardedPubSub(BasePubSub[AnyStr, "coredis.pool.ClusterConnectionPool"]):
         raise NotImplementedError("Sharded PubSub does not support subscription by pattern")
 
     async def execute_command(
-        self, command: bytes, *args: ValueT, **options: ValueT
+        self, command: bytes, *args: RedisValueT, **options: RedisValueT
     ) -> ResponseType | None:
         await self.initialize()
 
@@ -997,43 +902,3 @@ class ShardedPubSub(BasePubSub[AnyStr, "coredis.pool.ClusterConnectionPool"]):
         if self.shard_connections:
             await self.unsubscribe()
         self.close()
-
-
-class PubSubWorkerThread(threading.Thread):
-    def __init__(
-        self,
-        pubsub: BasePubSub[Any, Any],
-        poll_timeout: float = 1.0,
-    ):
-        super().__init__()
-        self._pubsub = pubsub
-        self._poll_timeout = poll_timeout
-        self._running = False
-        self._loop = asyncio.get_running_loop()
-        self._future: Future[None] | None = None
-
-    async def _run(self) -> None:
-        async with aclosing(self._pubsub) as pubsub:
-            try:
-                while pubsub.subscribed:
-                    await pubsub.get_message(
-                        ignore_subscribe_messages=True, timeout=self._poll_timeout
-                    )
-            except CancelledError:
-                self._running = False
-
-    def run(self) -> None:
-        """
-        :meta private:
-        """
-        if self._running:
-            return
-        self._running = True
-        self._future = asyncio.run_coroutine_threadsafe(self._run(), self._loop)
-
-    def stop(self) -> None:
-        """
-        Stop the worker thread from processing any more messages
-        """
-        if self._future:
-            self._future.cancel()

coredis/commands/request.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import functools
+from typing import Any, cast
+
+from coredis._protocols import AbstractExecutor
+from coredis.typing import (
+    Awaitable,
+    Callable,
+    ExecutionParameters,
+    Generator,
+    Serializable,
+    TypeAdapter,
+    TypeVar,
+    ValueT,
+)
+
+#: Covariant type used for generalizing :class:`~coredis.command.CommandRequest`
+CommandResponseT = TypeVar("CommandResponseT", covariant=True)
+
+TransformedResponse = TypeVar("TransformedResponse")
+empty_adapter = TypeAdapter()
+
+
+class CommandRequest(Awaitable[CommandResponseT]):
+    response: Awaitable[CommandResponseT]
+
+    def __init__(
+        self,
+        client: AbstractExecutor,
+        name: bytes,
+        *arguments: ValueT,
+        callback: Callable[..., CommandResponseT],
+        execution_parameters: ExecutionParameters | None = None,
+    ) -> None:
+        """
+        The default command request object which is returned by all
+        methods mirroring redis commands.
+
+        :param client: The instance of the :class:`coredis.Redis` that
+         will be used to call :meth:`~coredis.Redis.execute_command`
+        :param name:  The name of the command
+        :param arguments:  All arguments (in redis format) to be passed to the command
+        :param callback: The callback to be used to transform the RESP response
+        :param execution_parameters:  Any additional parameters to be passed to
+         :meth:`coredis.Redis.execute_command`
+        """
+        self.name = name
+        self.callback = callback
+        self.execution_parameters = execution_parameters or {}
+        self.client: AbstractExecutor = client
+        self.arguments = tuple(
+            self.type_adapter.serialize(k) if isinstance(k, Serializable) else k for k in arguments
+        )
+
+    def run(self) -> Awaitable[CommandResponseT]:
+        if not hasattr(self, "response"):
+            self.response = self.client.execute_command(
+                self, self.callback, **self.execution_parameters
+            )
+
+        return self.response
+
+    def transform(
+        self, transformer: type[TransformedResponse]
+    ) -> CommandRequest[TransformedResponse]:
+        """
+        :param transformer: A type that was registered with the client
+         using :meth:`~coredis.typing.TypeAdapter.register_deserializer`
+         or decorated by :meth:`~coredis.typing.TypeAdapter.deserializer`
+
+        :return: a command request object that when awaited will return the
+         transformed response
+
+         For example when used with a redis command::
+
+           client = coredis.Redis(....)
+           @client.type_adapter.deserializer
+           def _(value: bytes) -> int:
+               return int(value)
+
+           await client.set("fubar", 1)
+           raw: bytes = await client.get("fubar")
+           int_value: int = await client.get("fubar").transform(int)
+        """
+        transform_func = functools.partial(
+            self.type_adapter.deserialize,
+            return_type=transformer,
+        )
+        return cast(type[CommandRequest[TransformedResponse]], self.__class__)(
+            self.client,
+            self.name,
+            *self.arguments,
+            callback=lambda resp, **kwargs: transform_func(self.callback(resp, **kwargs)),
+            execution_parameters=self.execution_parameters,
+        )
+
+    @property
+    def type_adapter(self) -> TypeAdapter:
+        from coredis.client import Client
+
+        if isinstance(self.client, Client):
+            return self.client.type_adapter
+
+        return empty_adapter
+
+    def __await__(self) -> Generator[Any, Any, CommandResponseT]:
+        return self.run().__await__()

coredis/commands/script.py

@@ -8,9 +8,9 @@ from typing import TYPE_CHECKING, Any, cast
 
 from deprecated.sphinx import versionadded
 
-from coredis._protocols import SupportsScript
 from coredis._utils import b
 from coredis.exceptions import NoScriptError
+from coredis.retry import ConstantRetryPolicy, retryable
 from coredis.typing import (
     AnyStr,
     Awaitable,
@@ -20,6 +20,7 @@ from coredis.typing import (
     P,
     Parameters,
     R,
+    RedisValueT,
     ResponseType,
     StringT,
     ValueT,
@@ -51,7 +52,7 @@ class Script(Generic[AnyStr]):
 
     def __init__(
         self,
-        registered_client: SupportsScript[AnyStr] | None = None,
+        registered_client: coredis.client.Client[AnyStr] | None = None,
         script: StringT | None = None,
         readonly: bool = False,
     ):
@@ -64,7 +65,7 @@ class Script(Generic[AnyStr]):
         :param readonly: If ``True`` the script will be called with
          :meth:`coredis.Redis.evalsha_ro` instead of :meth:`coredis.Redis.evalsha`
         """
-        self.registered_client: SupportsScript[AnyStr] | None = registered_client
+        self.registered_client: coredis.client.Client[AnyStr] | None = registered_client
         self.script: StringT
         if not script:
             raise RuntimeError("No script provided")
@@ -72,16 +73,16 @@ class Script(Generic[AnyStr]):
         self.sha = hashlib.sha1(b(script)).hexdigest()  # type: ignore
         self.readonly = readonly
 
-    async def __call__(
+    def __call__(
         self,
         keys: Parameters[KeyT] | None = None,
         args: Parameters[ValueT] | None = None,
-        client: SupportsScript[AnyStr] | None = None,
+        client: coredis.client.Client[AnyStr] | None = None,
         readonly: bool | None = None,
-    ) -> ResponseType:
+    ) -> Awaitable[ResponseType]:
         """
         Executes the script registered in :paramref:`Script.script` using
-        :meth:`coredis.Redis.evalsha`. Additionally if the script was not yet
+        :meth:`coredis.Redis.evalsha`. Additionally, if the script was not yet
         registered on the instance, it will automatically do that as well
         and cache the sha at :data:`Script.sha`
 
@@ -103,26 +104,24 @@ class Script(Generic[AnyStr]):
         if readonly is None:
             readonly = self.readonly
 
+        method = client.evalsha_ro if readonly else client.evalsha
+
         # make sure the Redis server knows about the script
         if isinstance(client, Pipeline):
             # make sure this script is good to go on pipeline
             cast(Pipeline[AnyStr], client).scripts.add(self)
-
-        method = client.evalsha_ro if readonly else client.evalsha
-        try:
-            return cast(ResponseType, await method(self.sha, keys=keys, args=args))
-        except NoScriptError:
-            # Maybe the client is pointed to a different server than the client
-            # that created this instance?
-            # Overwrite the sha just in case there was a discrepancy.
-            self.sha = await client.script_load(self.script)
-            return cast(ResponseType, await method(self.sha, keys=keys, args=args))
+            return method(self.sha, keys=keys, args=args)
+        else:
+            return retryable(
+                ConstantRetryPolicy((NoScriptError,), 1, 0),
+                failure_hook=lambda _: client.script_load(self.script),
+            )(method)(self.sha, keys=keys, args=args)
 
     async def execute(
         self,
         keys: Parameters[KeyT] | None = None,
         args: Parameters[ValueT] | None = None,
-        client: SupportsScript[AnyStr] | None = None,
+        client: coredis.client.Client[AnyStr] | None = None,
         readonly: bool | None = None,
     ) -> ResponseType:
         """
@@ -169,12 +168,12 @@ class Script(Generic[AnyStr]):
         passed to redis as an ``arg``::
 
             import coredis
-            from coredis.typing import KeyT, ValueT
+            from coredis.typing import KeyT, RedisValueT
             from typing import List
 
             client = coredis.Redis()
             @client.register_script("return {KEYS[1], ARGV[1]}").wraps()
-            async def echo_key_value(key: KeyT, value: ValueT) -> List[ValueT]: ...
+            async def echo_key_value(key: KeyT, value: RedisValueT) -> List[RedisValueT]: ...
 
             k, v = await echo_key_value("co", "redis")
             # (b"co", b"redis")
@@ -260,13 +259,13 @@ class Script(Generic[AnyStr]):
                 bound_arguments: inspect.BoundArguments,
             ) -> tuple[
                 Parameters[KeyT],
-                Parameters[ValueT],
+                Parameters[RedisValueT],
                 coredis.client.Client[AnyStr] | None,
             ]:
                 bound_arguments.apply_defaults()
                 arguments = bound_arguments.arguments
                 keys: list[KeyT] = []
-                args: list[ValueT] = []
+                args: list[RedisValueT] = []
                 for name in sig.parameters:
                     if name not in arg_fetch:
                         continue