coredis 5.5.0__cp313-cp313-macosx_11_0_arm64.whl

coredis/constants.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from coredis._utils import b
+from coredis.typing import Final
+
+SYM_STAR: Final[bytes] = b("*")
+SYM_DOLLAR: Final[bytes] = b("$")
+SYM_CRLF: Final[bytes] = b("\r\n")
+SYM_LF: Final[bytes] = b("\n")
+SYM_EMPTY: Final[bytes] = b("")
+
+
+class RESPDataType:
+    """
+    Markers used by redis server to signal
+    the type of data being sent.
+
+    See:
+
+    - `RESP protocol spec <https://redis.io/docs/reference/protocol-spec/>`__
+    - `RESP3 specification <https://github.com/antirez/RESP3/blob/master/spec.md>`__
+    """
+
+    NONE: Final[int] = ord(b"_")
+    SIMPLE_STRING: Final[int] = ord(b"+")
+    BULK_STRING: Final[int] = ord(b"$")
+    VERBATIM: Final[int] = ord(b"=")
+    BOOLEAN: Final[int] = ord(b"#")
+    INT: Final[int] = ord(b":")
+    DOUBLE: Final[int] = ord(b",")
+    BIGNUMBER: Final[int] = ord(b"(")
+    ARRAY: Final[int] = ord(b"*")
+    PUSH: Final[int] = ord(b">")
+    MAP: Final[int] = ord(b"%")
+    SET: Final[int] = ord(b"~")
+    ERROR: Final[int] = ord(b"-")
+    ATTRIBUTE: Final[int] = ord(b"|")

coredis/credentials.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from coredis.typing import NamedTuple
+
+
+class UserPass(NamedTuple):
+    """
+    Username/password tuple.
+    """
+
+    #: Username
+    username: str
+    #: Password
+    password: str
+
+
+class AbstractCredentialProvider(ABC):
+    """
+    Abstract credential provider
+    """
+
+    @abstractmethod
+    async def get_credentials(self) -> UserPass:
+        """
+        Returns an instance of :class:`coredis.credentials.UserPass` for
+        establishing a connection to the redis server.
+        """
+        pass
+
+
+class UserPassCredentialProvider(AbstractCredentialProvider):
+    """
+    Credential provider that just returns a
+    :paramref:`UserPassCredentialProvider.password`
+    and/or :paramref:`UserPassCredentialProvider.username`.
+    """
+
+    def __init__(self, username: str | None = None, password: str | None = None) -> None:
+        self.username = username or ""
+        self.password = password or ""
+
+    async def get_credentials(self) -> UserPass:
+        return UserPass(self.username or "default", self.password)

coredis/exceptions.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+
+import re
+
+from coredis.typing import RedisValueT
+
+
+class RedisError(Exception):
+    """
+    Base exception from which all other exceptions in coredis
+    derive from.
+    """
+
+
+class CommandSyntaxError(RedisError):
+    """
+    Raised when a redis command is called with an invalid syntax
+    """
+
+    def __init__(self, arguments: set[str], message: str) -> None:
+        self.arguments: set[str] = arguments
+        super().__init__(message)
+
+
+class CommandNotSupportedError(RedisError):
+    """
+    Raised when the target server doesn't support a command due to
+    version mismatch
+    """
+
+    def __init__(self, cmd: str, current_version: str) -> None:
+        super().__init__(f"{cmd} is not supported on server version {current_version}")
+
+
+class ModuleCommandNotSupportedError(CommandNotSupportedError):
+    """
+    Raised when the target server doesn't support a module command due to
+    version mismatch of the module
+    """
+
+    def __init__(self, cmd: str, module: str, current_version: str) -> None:
+        RedisError.__init__(
+            self,
+            (
+                f"{cmd} is not supported on {module} version {current_version}"
+                if current_version
+                else f"{cmd} is not supported since Module: {module} is not available"
+            ),
+        )
+
+
+class ConnectionError(RedisError):
+    pass
+
+
+class ProtocolError(ConnectionError):
+    """
+    Raised on errors related to ser/deser protocol parsing
+    """
+
+
+class TimeoutError(RedisError):
+    pass
+
+
+class BusyLoadingError(ConnectionError):
+    pass
+
+
+class InvalidResponse(RedisError):
+    pass
+
+
+class ResponseError(RedisError):
+    pass
+
+
+class DataError(RedisError):
+    pass
+
+
+class NoKeyError(RedisError):
+    """
+    Raised when a key provided in the command is missing
+    """
+
+
+class ReplicationError(RedisError):
+    """
+    Raised when the replication requirements were not met
+    """
+
+    def __init__(self, command: bytes, replicas: int, timeout: int):
+        super().__init__(
+            f"Command {str(command)} did not replicate to {replicas} replicas within {timeout} ms."
+        )
+
+
+class PersistenceError(RedisError):
+    """
+    Raised when the persistence requirements were not met
+    """
+
+    def __init__(self, command: bytes, local: int, replicas: int, timeout: int):
+        super().__init__(
+            f"Command {str(command)} did not sync to the aof of {local} hosts and/or {replicas} "
+            f"replicas within {timeout} ms."
+        )
+
+
+class NotBusyError(ResponseError):
+    """
+    Raised when script kill or function kill have nothing to terminate
+    """
+
+
+class UnblockedError(ResponseError):
+    """
+    Raised if a blocked client is unblocked forcefully
+    """
+
+
+class WrongTypeError(ResponseError):
+    """
+    Raised when an operation is performed on a key
+    containing a datatype that doesn't support the operation
+    """
+
+
+class PubSubError(RedisError):
+    pass
+
+
+class WatchError(RedisError):
+    pass
+
+
+class NoScriptError(ResponseError):
+    pass
+
+
+class ExecAbortError(ResponseError):
+    pass
+
+
+class ReadOnlyError(ResponseError):
+    pass
+
+
+class LockError(RedisError, ValueError):
+    """Errors acquiring or releasing a lock"""
+
+    # NOTE: For backwards compatability, this class derives from ValueError.
+    # This was originally chosen to behave like threading.Lock.
+
+
+class LockAcquisitionError(LockError):
+    """Errors acquiring a lock"""
+
+
+class LockReleaseError(LockError):
+    """Errors releasing a lock"""
+
+
+class LockExtensionError(LockError):
+    """Errors extending a lock"""
+
+
+class RedisClusterException(Exception):
+    """Base exception for the RedisCluster client"""
+
+
+class ClusterError(RedisError):
+    """
+    Cluster errors occurred multiple times, resulting in an exhaustion of the
+    command execution ``TTL``
+    """
+
+
+class ClusterCrossSlotError(ResponseError):
+    """Raised when keys in request don't hash to the same slot"""
+
+    def __init__(
+        self,
+        message: str | None = None,
+        command: bytes | 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
+        self.keys = keys
+
+
+class ClusterRoutingError(RedisClusterException):
+    """Raised when keys in request can't be routed to destination nodes"""
+
+
+class ClusterDownError(ClusterError, ResponseError):
+    """
+    Error indicated ``CLUSTERDOWN`` error received from cluster.
+
+    By default Redis Cluster nodes stop accepting queries if they detect there
+    is at least a hash slot uncovered (no available node is serving it).
+    This way if the cluster is partially down (for example a range of hash
+    slots are no longer covered) the entire cluster eventually becomes
+    unavailable. It automatically returns available as soon as all the slots
+    are covered again.
+    """
+
+    def __init__(self, resp: str) -> None:
+        self.args = (resp,)
+        self.message = resp
+
+
+class ClusterTransactionError(ClusterError):
+    def __init__(self, msg: str) -> None:
+        self.msg = msg
+
+
+class ClusterResponseError(ClusterError):
+    """
+    Raised when application logic to combine multi node
+    cluster responses has errors.
+    """
+
+
+class AskError(ResponseError):
+    """
+    Error indicated ``ASK`` error received from cluster.
+
+    When a slot is set as ``MIGRATING``, the node will accept all queries that
+    pertain to this hash slot, but only if the key in question exists,
+    otherwise the query is forwarded using a -ASK redirection to the node that
+    is target of the migration.
+
+    src node: ``MIGRATING`` to dst node
+        get > ``ASK`` error
+        ask dst node > ``ASKING`` command
+    dst node: ``IMPORTING`` from src node
+        asking command only affects next command
+        any op will be allowed after asking command
+    """
+
+    def __init__(self, resp: str) -> None:
+        self.args = (resp,)
+        self.message = resp
+        slot_id, new_node = resp.split(" ")
+        host, port = new_node.rsplit(":", 1)
+        self.slot_id = int(slot_id)
+        self.node_addr = self.host, self.port = host, int(port)
+
+
+class TryAgainError(ResponseError):
+    """
+    Error indicated ``TRYAGAIN`` error received from cluster.
+    Operations on keys that don't exist or are - during resharding - split
+    between the source and destination nodes, will generate a -``TRYAGAIN`` error.
+    """
+
+
+class MovedError(AskError):
+    """
+    Error indicated ``MOVED`` error received from cluster.
+    A request sent to a node that doesn't serve this key will be replayed with
+    a ``MOVED`` error that points to the correct node.
+    """
+
+
+class AuthenticationError(ResponseError):
+    """
+    Base class for authentication errors
+    """
+
+
+class AuthenticationFailureError(AuthenticationError):
+    """
+    Raised when authentication parameters were provided
+    but were invalid
+    """
+
+
+class AuthenticationRequiredError(AuthenticationError):
+    """
+    Raised when authentication parameters are required
+    but not provided
+    """
+
+
+class AuthorizationError(ResponseError):
+    """
+    Base class for authorization errors
+    """
+
+
+class FunctionError(RedisError):
+    """
+    Raised for errors relating to redis functions
+    """
+
+
+class SentinelError(RedisError):
+    pass
+
+
+class PrimaryNotFoundError(SentinelError):
+    """
+    Raised when a primary cannot be located in a
+    sentinel managed redis
+    """
+
+
+class ReplicaNotFoundError(SentinelError):
+    """
+    Raised when a replica cannot be located in a
+    sentinel managed redis
+    """
+
+
+class UnknownCommandError(ResponseError):
+    """
+    Raised when the server returns an error response relating
+    to an unknown command.
+    """
+
+    ERROR_REGEX = re.compile("unknown command (.*?)")
+    #: Name of command requested
+    command: str
+
+    def __init__(self, message: str) -> None:
+        command_match = self.ERROR_REGEX.findall(message)
+
+        if command_match:
+            self.command = command_match.pop()
+        super().__init__(message)
+
+
+class StreamConsumerError(RedisError):
+    """
+    Base exception for stream consumer related errors
+    """
+
+
+class StreamConsumerGroupError(StreamConsumerError):
+    """
+    Base exception for consumer group related errors
+    """
+
+
+class StreamDuplicateConsumerGroupError(StreamConsumerGroupError):
+    """
+    Raised when and attempt to create a stream consumer
+    group fails because it already exists
+    """
+
+
+class StreamConsumerInitializationError(StreamConsumerError):
+    """
+    Raised when a stream consumer could not be initialized
+    based on the configuration provided
+    """

coredis/experimental/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

coredis/globals.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING
+
+from coredis.commands.constants import CommandFlag
+
+if TYPE_CHECKING:
+    from coredis.modules.base import ModuleGroupRegistry, ModuleRegistry
+
+#: Populated by the @redis_command wrapper
+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()
+
+#: Populated by ModuleRegistry
+MODULES: dict[str, ModuleRegistry] = {}

coredis/modules/__init__.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from deprecated.sphinx import deprecated, versionadded
+
+from coredis.commands import CommandMixin
+from coredis.typing import AnyStr
+
+from .autocomplete import Autocomplete
+from .filters import (
+    BloomFilter,
+    CountMinSketch,
+    CuckooFilter,
+    RedisBloom,
+    TDigest,
+    TopK,
+)
+from .graph import Graph
+from .json import Json, RedisJSON
+from .search import RediSearch, Search
+from .timeseries import RedisTimeSeries, TimeSeries
+
+
+class ModuleMixin(CommandMixin[AnyStr]):
+    @property
+    @versionadded(version="4.12.0")
+    def json(self) -> Json[AnyStr]:
+        """
+        Property to access :class:`~coredis.modules.Json` commands.
+        """
+        return Json(self)
+
+    @property
+    @versionadded(version="4.12.0")
+    def bf(self) -> BloomFilter[AnyStr]:
+        """
+        Property to access :class:`~coredis.modules.BloomFilter` commands.
+        """
+        return BloomFilter(self)
+
+    @property
+    @versionadded(version="4.12.0")
+    def cf(self) -> CuckooFilter[AnyStr]:
+        """
+        Property to access :class:`~coredis.modules.CuckooFilter` commands.
+        """
+        return CuckooFilter(self)
+
+    @property
+    @versionadded(version="4.12.0")
+    def cms(self) -> CountMinSketch[AnyStr]:
+        """
+        Property to access :class:`~coredis.modules.CountMinSketch` commands.
+        """
+        return CountMinSketch(self)
+
+    @property
+    @versionadded(version="4.12.0")
+    def tdigest(self) -> TDigest[AnyStr]:
+        """
+        Property to access :class:`~coredis.modules.TDigest` commands.
+        """
+        return TDigest(self)
+
+    @property
+    @versionadded(version="4.12.0")
+    def topk(self) -> TopK[AnyStr]:
+        """
+        Property to access :class:`~coredis.modules.TopK` commands.
+        """
+        return TopK(self)
+
+    @property
+    @versionadded(version="4.12.0")
+    def timeseries(self) -> TimeSeries[AnyStr]:
+        """
+        Property to access :class:`~coredis.modules.TimeSeries` commands.
+        """
+        return TimeSeries(self)
+
+    @property
+    @versionadded(version="4.12.0")
+    def search(self) -> Search[AnyStr]:
+        """
+        Property to access :class:`~coredis.modules.Search` commands.
+        """
+        return Search(self)
+
+    @property
+    @versionadded(version="4.12.0")
+    def autocomplete(self) -> Autocomplete[AnyStr]:
+        """
+        Property to access :class:`~coredis.modules.Autocomplete` commands.
+        """
+        return Autocomplete(self)
+
+    @property
+    @versionadded(version="4.12.0")
+    @deprecated(
+        "RedisGraph has been discontinued and support for it's commands will be removed in 6.0",
+        version="5.2.1",
+    )
+    def graph(self) -> Graph[AnyStr]:
+        """
+        Property to access :class:`~coredis.modules.Graph` commands.
+        """
+        return Graph(self)
+
+
+__all__ = [
+    "RediSearch",
+    "RedisBloom",
+    "RedisJSON",
+    "RedisTimeSeries",
+    "Json",
+    "BloomFilter",
+    "CuckooFilter",
+    "CountMinSketch",
+    "TopK",
+    "TDigest",
+    "TimeSeries",
+]