basedpyright 1.25.0 → 1.26.0

package/dist/typeshed-fallback/stubs/redis/redis/commands/timeseries/commands.pyi

@@ -1,160 +0,0 @@
-from typing import Literal
-from typing_extensions import TypeAlias
-
-_Key: TypeAlias = bytes | str | memoryview
-
-ADD_CMD: Literal["TS.ADD"]
-ALTER_CMD: Literal["TS.ALTER"]
-CREATERULE_CMD: Literal["TS.CREATERULE"]
-CREATE_CMD: Literal["TS.CREATE"]
-DECRBY_CMD: Literal["TS.DECRBY"]
-DELETERULE_CMD: Literal["TS.DELETERULE"]
-DEL_CMD: Literal["TS.DEL"]
-GET_CMD: Literal["TS.GET"]
-INCRBY_CMD: Literal["TS.INCRBY"]
-INFO_CMD: Literal["TS.INFO"]
-MADD_CMD: Literal["TS.MADD"]
-MGET_CMD: Literal["TS.MGET"]
-MRANGE_CMD: Literal["TS.MRANGE"]
-MREVRANGE_CMD: Literal["TS.MREVRANGE"]
-QUERYINDEX_CMD: Literal["TS.QUERYINDEX"]
-RANGE_CMD: Literal["TS.RANGE"]
-REVRANGE_CMD: Literal["TS.REVRANGE"]
-
-class TimeSeriesCommands:
-    def create(
-        self,
-        key: _Key,
-        retention_msecs: int | None = None,
-        uncompressed: bool | None = False,
-        labels: dict[str, str] | None = None,
-        chunk_size: int | None = None,
-        duplicate_policy: str | None = None,
-    ): ...
-    def alter(
-        self,
-        key: _Key,
-        retention_msecs: int | None = None,
-        labels: dict[str, str] | None = None,
-        chunk_size: int | None = None,
-        duplicate_policy: str | None = None,
-    ): ...
-    def add(
-        self,
-        key: _Key,
-        timestamp: int | str,
-        value: float,
-        retention_msecs: int | None = None,
-        uncompressed: bool | None = False,
-        labels: dict[str, str] | None = None,
-        chunk_size: int | None = None,
-        duplicate_policy: str | None = None,
-    ): ...
-    def madd(self, ktv_tuples): ...
-    def incrby(
-        self,
-        key: _Key,
-        value: float,
-        timestamp: int | str | None = None,
-        retention_msecs: int | None = None,
-        uncompressed: bool | None = False,
-        labels: dict[str, str] | None = None,
-        chunk_size: int | None = None,
-    ): ...
-    def decrby(
-        self,
-        key: _Key,
-        value: float,
-        timestamp: int | str | None = None,
-        retention_msecs: int | None = None,
-        uncompressed: bool | None = False,
-        labels: dict[str, str] | None = None,
-        chunk_size: int | None = None,
-    ): ...
-    def delete(self, key, from_time, to_time): ...
-    def createrule(
-        self, source_key: _Key, dest_key: _Key, aggregation_type: str, bucket_size_msec: int, align_timestamp: int | None = None
-    ): ...
-    def deleterule(self, source_key, dest_key): ...
-    def range(
-        self,
-        key: _Key,
-        from_time: int | str,
-        to_time: int | str,
-        count: int | None = None,
-        aggregation_type: str | None = None,
-        bucket_size_msec: int | None = 0,
-        filter_by_ts: list[int] | None = None,
-        filter_by_min_value: int | None = None,
-        filter_by_max_value: int | None = None,
-        align: int | str | None = None,
-        latest: bool | None = False,
-        bucket_timestamp: str | None = None,
-        empty: bool | None = False,
-    ): ...
-    def revrange(
-        self,
-        key: _Key,
-        from_time: int | str,
-        to_time: int | str,
-        count: int | None = None,
-        aggregation_type: str | None = None,
-        bucket_size_msec: int | None = 0,
-        filter_by_ts: list[int] | None = None,
-        filter_by_min_value: int | None = None,
-        filter_by_max_value: int | None = None,
-        align: int | str | None = None,
-        latest: bool | None = False,
-        bucket_timestamp: str | None = None,
-        empty: bool | None = False,
-    ): ...
-    def mrange(
-        self,
-        from_time: int | str,
-        to_time: int | str,
-        filters: list[str],
-        count: int | None = None,
-        aggregation_type: str | None = None,
-        bucket_size_msec: int | None = 0,
-        with_labels: bool | None = False,
-        filter_by_ts: list[int] | None = None,
-        filter_by_min_value: int | None = None,
-        filter_by_max_value: int | None = None,
-        groupby: str | None = None,
-        reduce: str | None = None,
-        select_labels: list[str] | None = None,
-        align: int | str | None = None,
-        latest: bool | None = False,
-        bucket_timestamp: str | None = None,
-        empty: bool | None = False,
-    ): ...
-    def mrevrange(
-        self,
-        from_time: int | str,
-        to_time: int | str,
-        filters: list[str],
-        count: int | None = None,
-        aggregation_type: str | None = None,
-        bucket_size_msec: int | None = 0,
-        with_labels: bool | None = False,
-        filter_by_ts: list[int] | None = None,
-        filter_by_min_value: int | None = None,
-        filter_by_max_value: int | None = None,
-        groupby: str | None = None,
-        reduce: str | None = None,
-        select_labels: list[str] | None = None,
-        align: int | str | None = None,
-        latest: bool | None = False,
-        bucket_timestamp: str | None = None,
-        empty: bool | None = False,
-    ): ...
-    def get(self, key: _Key, latest: bool | None = False): ...
-    def mget(
-        self,
-        filters: list[str],
-        with_labels: bool | None = False,
-        select_labels: list[str] | None = None,
-        latest: bool | None = False,
-    ): ...
-    def info(self, key): ...
-    def queryindex(self, filters): ...

package/dist/typeshed-fallback/stubs/redis/redis/commands/timeseries/info.pyi

@@ -1,18 +0,0 @@
-from _typeshed import Incomplete
-from typing import Any
-
-class TSInfo:
-    rules: list[Any]
-    labels: list[Any]
-    sourceKey: Incomplete | None
-    chunk_count: Incomplete | None
-    memory_usage: Incomplete | None
-    total_samples: Incomplete | None
-    retention_msecs: Incomplete | None
-    last_time_stamp: Incomplete | None
-    first_time_stamp: Incomplete | None
-
-    max_samples_per_chunk: Incomplete | None
-    chunk_size: Incomplete | None
-    duplicate_policy: Incomplete | None
-    def __init__(self, args) -> None: ...

package/dist/typeshed-fallback/stubs/redis/redis/commands/timeseries/utils.pyi

@@ -1,5 +0,0 @@
-def list_to_dict(aList): ...
-def parse_range(response): ...
-def parse_m_range(response): ...
-def parse_get(response): ...
-def parse_m_get(response): ...

package/dist/typeshed-fallback/stubs/redis/redis/connection.pyi

@@ -1,289 +0,0 @@
-from _typeshed import Incomplete, Unused
-from abc import abstractmethod
-from collections.abc import Callable, Iterable, Mapping
-from queue import Queue
-from socket import socket
-from typing import Any, ClassVar
-from typing_extensions import Self, TypeAlias
-
-from .credentials import CredentialProvider
-from .retry import Retry
-
-ssl_available: bool
-SYM_STAR: bytes
-SYM_DOLLAR: bytes
-SYM_CRLF: bytes
-SYM_EMPTY: bytes
-SERVER_CLOSED_CONNECTION_ERROR: str
-NONBLOCKING_EXCEPTIONS: tuple[type[Exception], ...]
-NONBLOCKING_EXCEPTION_ERROR_NUMBERS: dict[type[Exception], int]
-SENTINEL: object
-MODULE_LOAD_ERROR: str
-NO_SUCH_MODULE_ERROR: str
-MODULE_UNLOAD_NOT_POSSIBLE_ERROR: str
-MODULE_EXPORTS_DATA_TYPES_ERROR: str
-FALSE_STRINGS: tuple[str, ...]
-URL_QUERY_ARGUMENT_PARSERS: dict[str, Callable[[Any], Any]]
-
-# Options as passed to Pool.get_connection().
-_ConnectionPoolOptions: TypeAlias = Any
-_ConnectFunc: TypeAlias = Callable[[Connection], object]
-
-class BaseParser:
-    EXCEPTION_CLASSES: ClassVar[dict[str, type[Exception] | dict[str, type[Exception]]]]
-    @classmethod
-    def parse_error(cls, response: str) -> Exception: ...
-
-class SocketBuffer:
-    socket_read_size: int
-    bytes_written: int
-    bytes_read: int
-    socket_timeout: float | None
-    def __init__(self, socket: socket, socket_read_size: int, socket_timeout: float | None) -> None: ...
-    def unread_bytes(self) -> int: ...
-    def can_read(self, timeout: float | None) -> bool: ...
-    def read(self, length: int) -> bytes: ...
-    def readline(self) -> bytes: ...
-    def get_pos(self) -> int: ...
-    def rewind(self, pos: int) -> None: ...
-    def purge(self) -> None: ...
-    def close(self) -> None: ...
-
-class PythonParser(BaseParser):
-    encoding: str
-    socket_read_size: int
-    encoder: Encoder | None
-    def __init__(self, socket_read_size: int) -> None: ...
-    def __del__(self) -> None: ...
-    def on_connect(self, connection: Connection) -> None: ...
-    def on_disconnect(self) -> None: ...
-    def can_read(self, timeout: float | None) -> bool: ...
-    def read_response(self, disable_decoding: bool = False) -> Any: ...  # `str | bytes` or `list[str | bytes]`
-
-class HiredisParser(BaseParser):
-    socket_read_size: int
-    def __init__(self, socket_read_size: int) -> None: ...
-    def __del__(self) -> None: ...
-    def on_connect(self, connection: Connection, **kwargs) -> None: ...
-    def on_disconnect(self) -> None: ...
-    def can_read(self, timeout: float | None) -> bool: ...
-    def read_from_socket(self, timeout: float | None = ..., raise_on_timeout: bool = True) -> bool: ...
-    def read_response(self, disable_decoding: bool = False) -> Any: ...  # `str | bytes` or `list[str | bytes]`
-
-DefaultParser: type[BaseParser]  # Hiredis or PythonParser
-
-_Encodable: TypeAlias = str | bytes | memoryview | bool | float
-
-class Encoder:
-    encoding: str
-    encoding_errors: str
-    decode_responses: bool
-    def __init__(self, encoding: str, encoding_errors: str, decode_responses: bool) -> None: ...
-    def encode(self, value: _Encodable) -> bytes: ...
-    def decode(self, value: str | bytes | memoryview, force: bool = False) -> str: ...
-
-class AbstractConnection:
-    pid: int
-    db: int
-    client_name: str | None
-    credential_provider: CredentialProvider | None
-    password: str | None
-    username: str | None
-    socket_timeout: float | None
-    socket_connect_timeout: float | None
-    retry_on_timeout: bool
-    retry_on_error: list[type[Exception]]
-    retry: Retry
-    health_check_interval: int
-    next_health_check: int
-    redis_connect_func: _ConnectFunc | None
-    encoder: Encoder
-
-    def __init__(
-        self,
-        db: int = 0,
-        password: str | None = None,
-        socket_timeout: float | None = None,
-        socket_connect_timeout: float | None = None,
-        retry_on_timeout: bool = False,
-        retry_on_error: list[type[Exception]] = ...,
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        parser_class: type[BaseParser] = ...,
-        socket_read_size: int = 65536,
-        health_check_interval: int = 0,
-        client_name: str | None = None,
-        username: str | None = None,
-        retry: Retry | None = None,
-        redis_connect_func: _ConnectFunc | None = None,
-        credential_provider: CredentialProvider | None = None,
-        command_packer: Incomplete | None = None,
-    ) -> None: ...
-    @abstractmethod
-    def repr_pieces(self) -> list[tuple[str, Any]]: ...
-    def register_connect_callback(self, callback: _ConnectFunc) -> None: ...
-    def clear_connect_callbacks(self) -> None: ...
-    def set_parser(self, parser_class: type[BaseParser]) -> None: ...
-    def connect(self) -> None: ...
-    def on_connect(self) -> None: ...
-    def disconnect(self, *args: Unused) -> None: ...  # 'args' added in redis 4.1.2
-    def check_health(self) -> None: ...
-    def send_packed_command(self, command: str | Iterable[str], check_health: bool = True) -> None: ...
-    def send_command(self, *args, **kwargs) -> None: ...
-    def can_read(self, timeout: float | None = 0) -> bool: ...
-    def read_response(
-        self, disable_decoding: bool = False, *, disconnect_on_error: bool = True
-    ) -> Any: ...  # `str | bytes` or `list[str | bytes]`
-    def pack_command(self, *args) -> list[bytes]: ...
-    def pack_commands(self, commands: Iterable[Iterable[Incomplete]]) -> list[bytes]: ...
-
-class Connection(AbstractConnection):
-    host: str
-    port: int
-    socket_keepalive: bool
-    socket_keepalive_options: Mapping[str, int | str]
-    socket_type: int
-    def __init__(
-        self,
-        host: str = "localhost",
-        port: int = 6379,
-        socket_keepalive: bool = False,
-        socket_keepalive_options: Mapping[str, int | str] | None = None,
-        socket_type: int = 0,
-        *,
-        db: int = 0,
-        password: str | None = None,
-        socket_timeout: float | None = None,
-        socket_connect_timeout: float | None = None,
-        retry_on_timeout: bool = False,
-        retry_on_error: list[type[Exception]] = ...,
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        parser_class: type[BaseParser] = ...,
-        socket_read_size: int = 65536,
-        health_check_interval: int = 0,
-        client_name: str | None = None,
-        username: str | None = None,
-        retry: Retry | None = None,
-        redis_connect_func: _ConnectFunc | None = None,
-        credential_provider: CredentialProvider | None = None,
-        command_packer: Incomplete | None = None,
-    ) -> None: ...
-    def repr_pieces(self) -> list[tuple[str, Any]]: ...
-
-class SSLConnection(Connection):
-    keyfile: Any
-    certfile: Any
-    cert_reqs: Any
-    ca_certs: Any
-    ca_path: Incomplete | None
-    check_hostname: bool
-    certificate_password: Incomplete | None
-    ssl_validate_ocsp: bool
-    ssl_validate_ocsp_stapled: bool  # added in 4.1.1
-    ssl_ocsp_context: Incomplete | None  # added in 4.1.1
-    ssl_ocsp_expected_cert: Incomplete | None  # added in 4.1.1
-    def __init__(
-        self,
-        ssl_keyfile=None,
-        ssl_certfile=None,
-        ssl_cert_reqs="required",
-        ssl_ca_certs=None,
-        ssl_ca_data: Incomplete | None = None,
-        ssl_check_hostname: bool = False,
-        ssl_ca_path: Incomplete | None = None,
-        ssl_password: Incomplete | None = None,
-        ssl_validate_ocsp: bool = False,
-        ssl_validate_ocsp_stapled: bool = False,  # added in 4.1.1
-        ssl_ocsp_context: Incomplete | None = None,  # added in 4.1.1
-        ssl_ocsp_expected_cert: Incomplete | None = None,  # added in 4.1.1
-        *,
-        host: str = "localhost",
-        port: int = 6379,
-        socket_timeout: float | None = None,
-        socket_connect_timeout: float | None = None,
-        socket_keepalive: bool = False,
-        socket_keepalive_options: Mapping[str, int | str] | None = None,
-        socket_type: int = 0,
-        db: int = 0,
-        password: str | None = None,
-        retry_on_timeout: bool = False,
-        retry_on_error: list[type[Exception]] = ...,
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        parser_class: type[BaseParser] = ...,
-        socket_read_size: int = 65536,
-        health_check_interval: int = 0,
-        client_name: str | None = None,
-        username: str | None = None,
-        retry: Retry | None = None,
-        redis_connect_func: _ConnectFunc | None = None,
-        credential_provider: CredentialProvider | None = None,
-        command_packer: Incomplete | None = None,
-    ) -> None: ...
-
-class UnixDomainSocketConnection(AbstractConnection):
-    path: str
-    def __init__(
-        self,
-        path: str = "",
-        *,
-        db: int = 0,
-        password: str | None = None,
-        socket_timeout: float | None = None,
-        socket_connect_timeout: float | None = None,
-        retry_on_timeout: bool = False,
-        retry_on_error: list[type[Exception]] = ...,
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        parser_class: type[BaseParser] = ...,
-        socket_read_size: int = 65536,
-        health_check_interval: int = 0,
-        client_name: str | None = None,
-        username: str | None = None,
-        retry: Retry | None = None,
-        redis_connect_func: _ConnectFunc | None = None,
-        credential_provider: CredentialProvider | None = None,
-        command_packer: Incomplete | None = None,
-    ) -> None: ...
-    def repr_pieces(self) -> list[tuple[str, Any]]: ...
-
-# TODO: make generic on `connection_class`
-class ConnectionPool:
-    connection_class: type[Connection]
-    connection_kwargs: dict[str, Any]
-    max_connections: int
-    pid: int
-    @classmethod
-    def from_url(cls, url: str, *, db: int = ..., decode_components: bool = ..., **kwargs) -> Self: ...
-    def __init__(
-        self, connection_class: type[AbstractConnection] = ..., max_connections: int | None = None, **connection_kwargs
-    ) -> None: ...
-    def reset(self) -> None: ...
-    def get_connection(self, command_name: Unused, *keys, **options: _ConnectionPoolOptions) -> Connection: ...
-    def make_connection(self) -> Connection: ...
-    def release(self, connection: Connection) -> None: ...
-    def disconnect(self, inuse_connections: bool = True) -> None: ...
-    def get_encoder(self) -> Encoder: ...
-    def owns_connection(self, connection: Connection) -> bool: ...
-
-class BlockingConnectionPool(ConnectionPool):
-    queue_class: type[Queue[Any]]
-    timeout: float
-    pool: Queue[Connection | None]  # might not be defined
-    def __init__(
-        self,
-        max_connections: int = 50,
-        timeout: float = 20,
-        connection_class: type[Connection] = ...,
-        queue_class: type[Queue[Any]] = ...,
-        **connection_kwargs,
-    ) -> None: ...
-    def disconnect(self) -> None: ...  # type: ignore[override]
-
-def to_bool(value: object) -> bool: ...
-def parse_url(url: str) -> dict[str, Any]: ...

package/dist/typeshed-fallback/stubs/redis/redis/crc.pyi

@@ -1,5 +0,0 @@
-from redis.typing import EncodedT
-
-REDIS_CLUSTER_HASH_SLOTS: int
-
-def key_slot(key: EncodedT, bucket: int = 16384) -> int: ...

package/dist/typeshed-fallback/stubs/redis/redis/credentials.pyi

@@ -1,11 +0,0 @@
-from abc import abstractmethod
-
-class CredentialProvider:
-    @abstractmethod
-    def get_credentials(self) -> tuple[str] | tuple[str, str]: ...
-
-class UsernamePasswordCredentialProvider(CredentialProvider):
-    username: str
-    password: str
-    def __init__(self, username: str | None = None, password: str | None = None) -> None: ...
-    def get_credentials(self) -> tuple[str] | tuple[str, str]: ...

package/dist/typeshed-fallback/stubs/redis/redis/exceptions.pyi

@@ -1,42 +0,0 @@
-class RedisError(Exception): ...
-class AuthenticationError(RedisError): ...
-class ConnectionError(RedisError): ...
-class TimeoutError(RedisError): ...
-class AuthorizationError(ConnectionError): ...
-class BusyLoadingError(ConnectionError): ...
-class InvalidResponse(RedisError): ...
-class ResponseError(RedisError): ...
-class DataError(RedisError): ...
-class PubSubError(RedisError): ...
-class WatchError(RedisError): ...
-class NoScriptError(ResponseError): ...
-class ExecAbortError(ResponseError): ...
-class ReadOnlyError(ResponseError): ...
-class NoPermissionError(ResponseError): ...
-class ModuleError(ResponseError): ...
-class LockError(RedisError, ValueError): ...
-class LockNotOwnedError(LockError): ...
-class ChildDeadlockedError(Exception): ...
-class AuthenticationWrongNumberOfArgsError(ResponseError): ...
-class RedisClusterException(Exception): ...
-class ClusterError(RedisError): ...
-
-class ClusterDownError(ClusterError, ResponseError):
-    args: tuple[str]
-    message: str
-    def __init__(self, resp: str) -> None: ...
-
-class AskError(ResponseError):
-    args: tuple[str]
-    message: str
-    slot_id: int
-    node_addr: tuple[str, int]
-    host: str
-    port: int
-    def __init__(self, resp: str) -> None: ...
-
-class TryAgainError(ResponseError): ...
-class ClusterCrossSlotError(ResponseError): ...
-class MovedError(AskError): ...
-class MasterDownError(ClusterDownError): ...
-class SlotNotCoveredError(RedisClusterException): ...

package/dist/typeshed-fallback/stubs/redis/redis/lock.pyi

@@ -1,56 +0,0 @@
-from _typeshed import Incomplete
-from types import TracebackType
-from typing import Any, ClassVar, Protocol
-from typing_extensions import Self
-
-from redis.client import Redis
-
-class _Local(Protocol):
-    token: str | bytes | None
-
-class Lock:
-    LUA_EXTEND_SCRIPT: ClassVar[str]
-    LUA_REACQUIRE_SCRIPT: ClassVar[str]
-    LUA_RELEASE_SCRIPT: ClassVar[str]
-    lua_extend: ClassVar[Incomplete | None]
-    lua_reacquire: ClassVar[Incomplete | None]
-    lua_release: ClassVar[Incomplete | None]
-    redis: Redis[Any]
-    name: str
-    timeout: float | None
-    sleep: float
-    blocking: bool
-    blocking_timeout: float | None
-    thread_local: bool
-    local: _Local
-    def __init__(
-        self,
-        redis: Redis[Any],
-        name: str,
-        timeout: float | None = None,
-        sleep: float = 0.1,
-        blocking: bool = True,
-        blocking_timeout: float | None = None,
-        thread_local: bool = True,
-    ) -> None: ...
-    def register_scripts(self) -> None: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
-    ) -> bool | None: ...
-    def acquire(
-        self,
-        sleep: float | None = None,
-        blocking: bool | None = None,
-        blocking_timeout: float | None = None,
-        token: str | bytes | None = None,
-    ) -> bool: ...
-    def do_acquire(self, token: str | bytes) -> bool: ...
-    def locked(self) -> bool: ...
-    def owned(self) -> bool: ...
-    def release(self) -> None: ...
-    def do_release(self, expected_token: str | bytes) -> None: ...
-    def extend(self, additional_time: float, replace_ttl: bool = False) -> bool: ...
-    def do_extend(self, additional_time: float, replace_ttl: bool) -> bool: ...
-    def reacquire(self) -> bool: ...
-    def do_reacquire(self) -> bool: ...

package/dist/typeshed-fallback/stubs/redis/redis/ocsp.pyi

@@ -1,21 +0,0 @@
-from _typeshed import Incomplete
-from ssl import SSLObject, SSLSocket
-from typing import Literal
-
-from cryptography.x509.base import Certificate
-from OpenSSL.SSL import Connection
-
-def ocsp_staple_verifier(con: Connection, ocsp_bytes: bytes, expected: bytes | None = None) -> Literal[True]: ...
-
-class OCSPVerifier:
-    SOCK: SSLObject | SSLSocket
-    HOST: str
-    PORT: int
-    CA_CERTS: str | None
-    def __init__(self, sock: SSLObject | SSLSocket, host: str, port: int, ca_certs: str | None = None) -> None: ...
-    # cryptography.x509.general_name.GeneralName.value is typed as Any
-    def components_from_socket(self) -> tuple[Certificate, Incomplete | None, Incomplete]: ...
-    def components_from_direct_connection(self) -> tuple[Certificate, Incomplete | None, Incomplete]: ...
-    def build_certificate_url(self, server: str, cert: Certificate, issuer_cert: Certificate) -> str: ...
-    def check_certificate(self, server: str, cert: Certificate, issuer_url: str | bytes) -> Literal[True]: ...
-    def is_valid(self) -> Literal[True]: ...

package/dist/typeshed-fallback/stubs/redis/redis/retry.pyi

@@ -1,11 +0,0 @@
-from collections.abc import Callable, Iterable
-from typing import TypeVar
-
-from redis.backoff import AbstractBackoff
-
-_T = TypeVar("_T")
-
-class Retry:
-    def __init__(self, backoff: AbstractBackoff, retries: int, supported_errors: tuple[type[Exception], ...] = ...) -> None: ...
-    def update_supported_errors(self, specified_errors: Iterable[type[Exception]]) -> None: ...
-    def call_with_retry(self, do: Callable[[], _T], fail: Callable[[Exception], object]) -> _T: ...

package/dist/typeshed-fallback/stubs/redis/redis/sentinel.pyi

@@ -1,62 +0,0 @@
-from collections.abc import Iterable, Iterator
-from typing import Any, Literal, TypeVar, overload
-from typing_extensions import TypeAlias
-
-from redis.client import Redis
-from redis.commands.sentinel import SentinelCommands
-from redis.connection import Connection, ConnectionPool, SSLConnection
-from redis.exceptions import ConnectionError
-
-_RedisT = TypeVar("_RedisT", bound=Redis[Any])
-_AddressAndPort: TypeAlias = tuple[str, int]
-_SentinelState: TypeAlias = dict[str, Any]  # TODO: this can be a TypedDict
-
-class MasterNotFoundError(ConnectionError): ...
-class SlaveNotFoundError(ConnectionError): ...
-
-class SentinelManagedConnection(Connection):
-    connection_pool: SentinelConnectionPool
-    def __init__(self, *, connection_pool: SentinelConnectionPool, **kwargs) -> None: ...
-    def connect_to(self, address: _AddressAndPort) -> None: ...
-    def connect(self) -> None: ...
-    # The result can be either `str | bytes` or `list[str | bytes]`
-    def read_response(self, disable_decoding: bool = False, *, disconnect_on_error: bool = False) -> Any: ...
-
-class SentinelManagedSSLConnection(SentinelManagedConnection, SSLConnection): ...
-
-class SentinelConnectionPool(ConnectionPool):
-    is_master: bool
-    check_connection: bool
-    service_name: str
-    sentinel_manager: Sentinel
-    def __init__(self, service_name: str, sentinel_manager: Sentinel, **kwargs) -> None: ...
-    def reset(self) -> None: ...
-    def owns_connection(self, connection: Connection) -> bool: ...
-    def get_master_address(self) -> _AddressAndPort: ...
-    def rotate_slaves(self) -> Iterator[_AddressAndPort]: ...
-
-class Sentinel(SentinelCommands):
-    sentinel_kwargs: dict[str, Any]
-    sentinels: list[Redis[Any]]
-    min_other_sentinels: int
-    connection_kwargs: dict[str, Any]
-    def __init__(
-        self,
-        sentinels: Iterable[_AddressAndPort],
-        min_other_sentinels: int = 0,
-        sentinel_kwargs: dict[str, Any] | None = None,
-        **connection_kwargs,
-    ) -> None: ...
-    def check_master_state(self, state: _SentinelState, service_name: str) -> bool: ...
-    def discover_master(self, service_name: str) -> _AddressAndPort: ...
-    def filter_slaves(self, slaves: Iterable[_SentinelState]) -> list[_AddressAndPort]: ...
-    def discover_slaves(self, service_name: str) -> list[_AddressAndPort]: ...
-    @overload
-    def master_for(self, service_name: str, *, connection_pool_class=..., **kwargs) -> Redis[Any]: ...
-    @overload
-    def master_for(self, service_name: str, redis_class: type[_RedisT], connection_pool_class=..., **kwargs) -> _RedisT: ...
-    @overload
-    def slave_for(self, service_name: str, *, connection_pool_class=..., **kwargs) -> Redis[Any]: ...
-    @overload
-    def slave_for(self, service_name: str, redis_class: type[_RedisT], connection_pool_class=..., **kwargs) -> _RedisT: ...
-    def execute_command(self, *args, **kwargs) -> Literal[True]: ...