coredis 5.5.0__cp313-cp313-macosx_11_0_arm64.whl

coredis/__init__.py

@@ -0,0 +1,42 @@
+"""
+coredis
+-------
+
+coredis is an async redis client with support for redis server,
+cluster & sentinel.
+"""
+
+from __future__ import annotations
+
+from coredis._version import __version__
+from coredis.client import Redis, RedisCluster
+from coredis.config import Config
+from coredis.connection import (
+    BaseConnection,
+    ClusterConnection,
+    Connection,
+    UnixDomainSocketConnection,
+)
+from coredis.pool import (
+    BlockingClusterConnectionPool,
+    BlockingConnectionPool,
+    ClusterConnectionPool,
+    ConnectionPool,
+)
+from coredis.tokens import PureToken
+
+__all__ = [
+    "Config",
+    "Redis",
+    "RedisCluster",
+    "BaseConnection",
+    "Connection",
+    "UnixDomainSocketConnection",
+    "ClusterConnection",
+    "BlockingConnectionPool",
+    "ConnectionPool",
+    "BlockingClusterConnectionPool",
+    "ClusterConnectionPool",
+    "PureToken",
+    "__version__",
+]

coredis/_enum.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import enum
+
+from coredis.typing import StringT
+
+
+@enum.unique
+class CaseAndEncodingInsensitiveEnum(bytes, enum.Enum):
+    __decoded: set[StringT]
+
+    @property
+    def variants(self) -> set[StringT]:
+        if not hasattr(self, "__decoded"):
+            decoded = str(self)
+            self.__decoded = {
+                self.value.lower(),  # type: ignore
+                self.value,  # type: ignore
+                decoded.lower(),
+                decoded.upper(),
+            }
+        return self.__decoded
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Since redis tokens are case insensitive allow mixed case
+        Additionally allow strings to be passed in instead of
+        bytes.
+        """
+
+        if other:
+            if isinstance(other, self.__class__):
+                return bool(self.value == other.value)
+            else:
+                return other in self.variants
+        return False
+
+    def __str__(self) -> str:
+        return self.decode("latin-1")
+
+    def __hash__(self) -> int:
+        return hash(self.value)

coredis/_json.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from types import ModuleType
+
+json: ModuleType
+try:
+    import orjson as json  # type: ignore
+except ImportError:
+    import json
+
+__all__ = ["json"]

coredis/_packer.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from coredis.constants import SYM_CRLF, SYM_DOLLAR, SYM_EMPTY, SYM_STAR
+from coredis.typing import RedisValueT
+
+
+class Packer:
+    def __init__(self, encoding: str):
+        self.encoding = encoding
+
+    def encode(self, value: RedisValueT) -> bytes:
+        """Returns a bytestring representation of the value"""
+        if isinstance(value, str):
+            return value.encode(self.encoding)
+        elif isinstance(value, int):
+            return b"%d" % value
+        elif isinstance(value, float):
+            return b"%.15g" % value
+        return value
+
+    def pack_command(self, command: bytes, *args: RedisValueT) -> list[bytes]:
+        "Pack a series of arguments into the Redis protocol"
+        output: list[bytes] = []
+        # the client might have included 1 or more literal arguments in
+        # the command name, e.g., 'CONFIG GET'. The Redis server expects these
+        # arguments to be sent separately, so split the first argument
+        # manually. All of these arguements get wrapped in the Token class
+        # to prevent them from being encoded.
+        cleaned_args = args
+        if b" " in command:
+            cleaned_args = tuple(s for s in command.split()) + cleaned_args
+        else:
+            cleaned_args = (command,) + cleaned_args
+
+        buff = SYM_EMPTY.join((SYM_STAR, b"%d" % len(cleaned_args), SYM_CRLF))
+
+        for arg in cleaned_args:
+            if not isinstance(arg, bytes):
+                arg = self.encode(arg)
+            # to avoid large string mallocs, chunk the command into the
+            # output list if we're sending large values
+
+            if len(buff) > 6000 or len(arg) > 6000:
+                buff = SYM_EMPTY.join((buff, SYM_DOLLAR, b"%d" % len(arg), SYM_CRLF))
+                output.append(buff)
+                output.append(arg)
+                buff = SYM_CRLF
+            else:
+                buff = SYM_EMPTY.join((buff, SYM_DOLLAR, b"%d" % len(arg), SYM_CRLF, arg, SYM_CRLF))
+        output.append(buff)
+        return output
+
+    def pack_commands(self, commands: list[tuple[RedisValueT, ...]]) -> list[bytes]:
+        output: list[bytes] = []
+        command_arguments: list[bytes] = []
+        buffer_length = 0
+
+        for cmd in commands:
+            for chunk in self.pack_command(self.encode(cmd[0]), *cmd[1:]):
+                command_arguments.append(chunk)
+                buffer_length += len(chunk)
+
+            if buffer_length > 6000:
+                output.append(SYM_EMPTY.join(command_arguments))
+                buffer_length = 0
+                command_arguments = []
+
+        if command_arguments:
+            output.append(SYM_EMPTY.join(command_arguments))
+
+        return output

coredis/_protocols.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import asyncio
+
+from typing_extensions import runtime_checkable
+
+from coredis.response._callbacks import NoopCallback
+from coredis.typing import (
+    TYPE_CHECKING,
+    Awaitable,
+    Callable,
+    ExecutionParameters,
+    Protocol,
+    R,
+    RedisCommandP,
+    ResponseType,
+    TypeVar,
+    Unpack,
+    ValueT,
+)
+
+T_co = TypeVar("T_co", covariant=True)
+
+
+if TYPE_CHECKING:
+    from coredis.commands import CommandRequest
+
+
+class AbstractExecutor(Protocol):
+    def execute_command(
+        self,
+        command: RedisCommandP,
+        callback: Callable[..., R] = NoopCallback(),
+        **options: Unpack[ExecutionParameters],
+    ) -> Awaitable[R]: ...
+
+    def create_request(
+        self,
+        name: bytes,
+        *arguments: ValueT,
+        callback: Callable[..., R],
+        execution_parameters: ExecutionParameters | None = None,
+    ) -> CommandRequest[R]: ...
+
+
+@runtime_checkable
+class ConnectionP(Protocol):
+    decode_responses: bool
+    encoding: str
+    push_messages: asyncio.Queue[ResponseType]

coredis/_py_311_typing.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from collections.abc import Hashable
+from typing import Any, TypeAlias
+
+from .typing import MutableSet, RedisError, ResponsePrimitive
+
+#: Represents the total structure of any response for any redis command.
+ResponseType: TypeAlias = (
+    ResponsePrimitive
+    | list[Any]
+    | MutableSet[Hashable]
+    | dict[
+        Hashable,
+        Any,
+    ]
+    | RedisError
+)
+#: Type alias for valid python types that can be represented as json
+JsonType: TypeAlias = str | int | float | bool | dict[str, Any] | list[Any] | None

coredis/_py_312_typing.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from collections.abc import Hashable
+
+from .typing import MutableSet, RedisError, ResponsePrimitive
+
+#: Type alias for valid python types that can be represented as json
+type JsonType = str | int | float | bool | dict[str, JsonType] | list[JsonType] | None
+
+#: Represents the total structure of any response for any redis command.
+type ResponseType = (
+    ResponsePrimitive
+    | RedisError
+    | list[ResponseType]
+    | MutableSet[Hashable]
+    | dict[Hashable, ResponseType]
+)

coredis/_sidecar.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import asyncio
+import time
+import weakref
+from typing import TYPE_CHECKING, Any
+
+from coredis.connection import BaseConnection, Connection
+from coredis.exceptions import ConnectionError
+from coredis.typing import ResponseType, TypeVar
+
+if TYPE_CHECKING:
+    import coredis.client
+
+SidecarT = TypeVar("SidecarT", bound="Sidecar")
+
+
+class Sidecar:
+    """
+    A sidecar to a redis client that reserves a single connection
+    and moves any responses from the socket to a FIFO queue
+    """
+
+    def __init__(
+        self, push_message_types: set[bytes], health_check_interval_seconds: int = 5
+    ) -> None:
+        self._client: weakref.ReferenceType[coredis.client.Client[Any]] | None = None
+        self.messages: asyncio.Queue[ResponseType] = asyncio.Queue()
+        self.connection: Connection | None = None
+        self.client_id: int | None = None
+        self.read_task: asyncio.Task[None] | None = None
+        self.push_message_types = push_message_types
+        self.health_check_interval = health_check_interval_seconds
+        self.health_check_task: asyncio.Task[None] | None = None
+        self.last_checkin: float = 0
+
+    @property
+    def client(self) -> coredis.client.Client[Any] | None:
+        if self._client:
+            return self._client()
+        return None  # noqa
+
+    async def start(self: SidecarT, client: coredis.client.Client[Any]) -> SidecarT:
+        self._client = weakref.ref(client, lambda *_: self.stop())
+        if not self.connection and self.client:
+            self.connection = await self.client.connection_pool.get_connection()
+            self.connection.register_connect_callback(self.on_reconnect)
+            await self.connection.connect()
+            if self.connection.tracking_client_id:  # noqa
+                await self.connection.update_tracking_client(False)
+        if not self.read_task or self.read_task.done():
+            self.read_task = asyncio.create_task(self.__read_loop())
+        if not self.health_check_task or self.health_check_task.done():
+            self.health_check_task = asyncio.create_task(self.__health_check())
+        return self
+
+    def process_message(self, message: ResponseType) -> tuple[ResponseType, ...]:
+        return (message,)  # noqa
+
+    def stop(self) -> None:
+        try:
+            asyncio.get_running_loop()
+            if self.read_task and not self.read_task.done():
+                self.read_task.cancel()
+            if self.health_check_task and not self.health_check_task.done():
+                self.health_check_task.cancel()
+        except RuntimeError:
+            pass
+        if self.connection:
+            self.connection.disconnect()
+            if self.client and self.connection:  # noqa
+                self.client.connection_pool.release(self.connection)
+            self.connection = None
+            self.client_id = None
+
+    def __del__(self) -> None:
+        self.stop()
+
+    async def on_reconnect(self, connection: BaseConnection) -> None:
+        self.client_id = connection.client_id
+        self.last_checkin = time.monotonic()
+
+    async def __health_check(self) -> None:
+        while True:
+            try:
+                if self.connection:
+                    await self.connection.send_command(b"PING")
+                await asyncio.sleep(self.health_check_interval)
+            except asyncio.CancelledError:
+                break
+
+    async def __read_loop(self) -> None:
+        while self.connection:
+            try:
+                response = await self.connection.fetch_push_message(
+                    decode=False, push_message_types=self.push_message_types
+                )
+                self.last_checkin = time.monotonic()
+                if response == b"PONG" or b"pong" in response:  # type: ignore
+                    continue
+                for m in self.process_message(response):
+                    self.messages.put_nowait(m)
+            except asyncio.CancelledError:
+                break
+            except ConnectionError:
+                if self.client and self.connection:
+                    self.client.connection_pool.release(self.connection)
+                self.connection = None
+
+                if self.client:
+                    asyncio.get_running_loop().call_soon(
+                        asyncio.create_task, self.start(self.client)
+                    )
+                    break