basedpyright 1.25.0 → 1.26.0

package/dist/typeshed-fallback/stubs/redis/redis/asyncio/cluster.pyi

@@ -1,229 +0,0 @@
-from _typeshed import Incomplete
-from collections.abc import Awaitable, Callable, Mapping
-from types import TracebackType
-from typing import Any, Generic, TypeVar
-from typing_extensions import Self
-
-from redis.asyncio.client import ResponseCallbackT
-from redis.asyncio.connection import AbstractConnection, BaseParser, Connection, Encoder
-from redis.asyncio.parser import CommandsParser
-from redis.client import AbstractRedis
-from redis.cluster import AbstractRedisCluster, LoadBalancer
-
-# TODO: add  AsyncRedisClusterCommands stubs
-# from redis.commands import AsyncRedisClusterCommands
-from redis.commands.core import _StrType
-from redis.credentials import CredentialProvider
-from redis.exceptions import ResponseError
-from redis.retry import Retry
-from redis.typing import AnyKeyT, EncodableT, KeyT
-
-TargetNodesT = TypeVar("TargetNodesT", str, ClusterNode, list[ClusterNode], dict[Any, ClusterNode])  # noqa: Y001
-
-# It uses `DefaultParser` in real life, but it is a dynamic base class.
-class ClusterParser(BaseParser):
-    def on_disconnect(self) -> None: ...
-    def on_connect(self, connection: AbstractConnection) -> None: ...
-    async def can_read_destructive(self) -> bool: ...
-    async def read_response(self, disable_decoding: bool = False) -> EncodableT | ResponseError | list[EncodableT] | None: ...
-
-class RedisCluster(AbstractRedis, AbstractRedisCluster, Generic[_StrType]):  # TODO: AsyncRedisClusterCommands
-    @classmethod
-    def from_url(
-        cls,
-        url: str,
-        *,
-        host: str | None = None,
-        port: str | int = 6379,
-        # Cluster related kwargs
-        startup_nodes: list[ClusterNode] | None = None,
-        require_full_coverage: bool = True,
-        read_from_replicas: bool = False,
-        reinitialize_steps: int = 5,
-        cluster_error_retry_attempts: int = 3,
-        connection_error_retry_attempts: int = 3,
-        max_connections: int = 2147483648,
-        # Client related kwargs
-        db: str | int = 0,
-        path: str | None = None,
-        credential_provider: CredentialProvider | None = None,
-        username: str | None = None,
-        password: str | None = None,
-        client_name: str | None = None,
-        # Encoding related kwargs
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        # Connection related kwargs
-        health_check_interval: float = 0,
-        socket_connect_timeout: float | None = None,
-        socket_keepalive: bool = False,
-        socket_keepalive_options: Mapping[int, int | bytes] | None = None,
-        socket_timeout: float | None = None,
-        retry: Retry | None = None,
-        retry_on_error: list[Exception] | None = None,
-        # SSL related kwargs
-        ssl: bool = False,
-        ssl_ca_certs: str | None = None,
-        ssl_ca_data: str | None = None,
-        ssl_cert_reqs: str = "required",
-        ssl_certfile: str | None = None,
-        ssl_check_hostname: bool = False,
-        ssl_keyfile: str | None = None,
-        address_remap: Callable[[str, int], tuple[str, int]] | None = None,
-    ) -> Self: ...
-
-    retry: Retry | None
-    connection_kwargs: dict[str, Any]
-    nodes_manager: NodesManager
-    encoder: Encoder
-    read_from_replicas: bool
-    reinitialize_steps: int
-    cluster_error_retry_attempts: int
-    reinitialize_counter: int
-    commands_parser: CommandsParser
-    node_flags: set[str]
-    command_flags: dict[str, str]
-    response_callbacks: Incomplete
-    result_callbacks: dict[str, Callable[[Incomplete, Incomplete], Incomplete]]
-
-    def __init__(
-        self,
-        host: str | None = None,
-        port: str | int = 6379,
-        # Cluster related kwargs
-        startup_nodes: list[ClusterNode] | None = None,
-        require_full_coverage: bool = True,
-        read_from_replicas: bool = False,
-        reinitialize_steps: int = 5,
-        cluster_error_retry_attempts: int = 3,
-        connection_error_retry_attempts: int = 3,
-        max_connections: int = 2147483648,
-        # Client related kwargs
-        db: str | int = 0,
-        path: str | None = None,
-        credential_provider: CredentialProvider | None = None,
-        username: str | None = None,
-        password: str | None = None,
-        client_name: str | None = None,
-        # Encoding related kwargs
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        # Connection related kwargs
-        health_check_interval: float = 0,
-        socket_connect_timeout: float | None = None,
-        socket_keepalive: bool = False,
-        socket_keepalive_options: Mapping[int, int | bytes] | None = None,
-        socket_timeout: float | None = None,
-        retry: Retry | None = None,
-        retry_on_error: list[Exception] | None = None,
-        # SSL related kwargs
-        ssl: bool = False,
-        ssl_ca_certs: str | None = None,
-        ssl_ca_data: str | None = None,
-        ssl_cert_reqs: str = "required",
-        ssl_certfile: str | None = None,
-        ssl_check_hostname: bool = False,
-        ssl_keyfile: str | None = None,
-        address_remap: Callable[[str, int], tuple[str, int]] | None = None,
-    ) -> None: ...
-    async def initialize(self) -> Self: ...
-    async def close(self) -> None: ...
-    async def __aenter__(self) -> Self: ...
-    async def __aexit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
-    ) -> None: ...
-    def __await__(self) -> Awaitable[Self]: ...
-    def __del__(self) -> None: ...
-    async def on_connect(self, connection: Connection) -> None: ...
-    def get_nodes(self) -> list[ClusterNode]: ...
-    def get_primaries(self) -> list[ClusterNode]: ...
-    def get_replicas(self) -> list[ClusterNode]: ...
-    def get_random_node(self) -> ClusterNode: ...
-    def get_default_node(self) -> ClusterNode: ...
-    def set_default_node(self, node: ClusterNode) -> None: ...
-    def get_node(self, host: str | None = None, port: int | None = None, node_name: str | None = None) -> ClusterNode | None: ...
-    def get_node_from_key(self, key: str, replica: bool = False) -> ClusterNode | None: ...
-    def keyslot(self, key: EncodableT) -> int: ...
-    def get_encoder(self) -> Encoder: ...
-    def get_connection_kwargs(self) -> dict[str, Any | None]: ...
-    def set_response_callback(self, command: str, callback: ResponseCallbackT) -> None: ...
-    async def execute_command(self, *args: EncodableT, **kwargs: Any) -> Any: ...
-    def pipeline(self, transaction: Any | None = None, shard_hint: Any | None = None) -> ClusterPipeline[_StrType]: ...
-
-class ClusterNode:
-    host: str
-    port: str | int
-    name: str
-    server_type: str | None
-    max_connections: int
-    connection_class: type[Connection]
-    connection_kwargs: dict[str, Any]
-    response_callbacks: dict[Incomplete, Incomplete]
-    def __init__(
-        self,
-        host: str,
-        port: str | int,
-        server_type: str | None = None,
-        *,
-        max_connections: int = 2147483648,
-        connection_class: type[Connection] = ...,
-        **connection_kwargs: Any,
-    ) -> None: ...
-    def __eq__(self, obj: object) -> bool: ...
-    def __del__(self) -> None: ...
-    async def disconnect(self) -> None: ...
-    def acquire_connection(self) -> Connection: ...
-    async def parse_response(self, connection: Connection, command: str, **kwargs: Any) -> Any: ...
-    async def execute_command(self, *args: Any, **kwargs: Any) -> Any: ...
-    async def execute_pipeline(self, commands: list[PipelineCommand]) -> bool: ...
-
-class NodesManager:
-    startup_nodes: dict[str, ClusterNode]
-    require_full_coverage: bool
-    connection_kwargs: dict[str, Any]
-    default_node: ClusterNode | None
-    nodes_cache: dict[str, ClusterNode]
-    slots_cache: dict[int, list[ClusterNode]]
-    read_load_balancer: LoadBalancer
-    address_remap: Callable[[str, int], tuple[str, int]] | None
-    def __init__(
-        self,
-        startup_nodes: list[ClusterNode],
-        require_full_coverage: bool,
-        connection_kwargs: dict[str, Any],
-        address_remap: Callable[[str, int], tuple[str, int]] | None = None,
-    ) -> None: ...
-    def get_node(self, host: str | None = None, port: int | None = None, node_name: str | None = None) -> ClusterNode | None: ...
-    def set_nodes(self, old: dict[str, ClusterNode], new: dict[str, ClusterNode], remove_old: bool = False) -> None: ...
-    def get_node_from_slot(self, slot: int, read_from_replicas: bool = False) -> ClusterNode: ...
-    def get_nodes_by_server_type(self, server_type: str) -> list[ClusterNode]: ...
-    async def initialize(self) -> None: ...
-    async def close(self, attr: str = "nodes_cache") -> None: ...
-    def remap_host_port(self, host: str, port: int) -> tuple[str, int]: ...
-
-class ClusterPipeline(AbstractRedis, AbstractRedisCluster, Generic[_StrType]):  # TODO: AsyncRedisClusterCommands
-    def __init__(self, client: RedisCluster[_StrType]) -> None: ...
-    async def initialize(self) -> Self: ...
-    async def __aenter__(self) -> Self: ...
-    async def __aexit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
-    ) -> None: ...
-    def __await__(self) -> Awaitable[Self]: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
-    ) -> None: ...
-    def __bool__(self) -> bool: ...
-    def __len__(self) -> int: ...
-    def execute_command(self, *args: KeyT | EncodableT, **kwargs: Any) -> Self: ...
-    async def execute(self, raise_on_error: bool = True, allow_redirections: bool = True) -> list[Any]: ...
-    def mset_nonatomic(self, mapping: Mapping[AnyKeyT, EncodableT]) -> Self: ...
-
-class PipelineCommand:
-    args: Any
-    kwargs: Any
-    position: int
-    result: Exception | None | Any
-    def __init__(self, position: int, *args: Any, **kwargs: Any) -> None: ...

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

@@ -1,363 +0,0 @@
-import asyncio
-import enum
-import ssl
-from _typeshed import Unused
-from abc import abstractmethod
-from collections.abc import Callable, Iterable, Mapping
-from types import MappingProxyType
-from typing import Any, Final, Generic, Literal, Protocol, TypedDict, TypeVar, overload
-from typing_extensions import Self, TypeAlias
-
-from redis.asyncio.retry import Retry
-from redis.credentials import CredentialProvider
-from redis.exceptions import AuthenticationError, RedisError, ResponseError
-from redis.typing import EncodableT, EncodedT
-
-_SSLVerifyMode: TypeAlias = Literal["none", "optional", "required"]
-
-SYM_STAR: Final[bytes]
-SYM_DOLLAR: Final[bytes]
-SYM_CRLF: Final[bytes]
-SYM_LF: Final[bytes]
-SYM_EMPTY: Final[bytes]
-
-SERVER_CLOSED_CONNECTION_ERROR: Final[str]
-
-class _Sentinel(enum.Enum):
-    sentinel = object()
-
-SENTINEL: Final[object]
-MODULE_LOAD_ERROR: Final[str]
-NO_SUCH_MODULE_ERROR: Final[str]
-MODULE_UNLOAD_NOT_POSSIBLE_ERROR: Final[str]
-MODULE_EXPORTS_DATA_TYPES_ERROR: Final[str]
-NO_AUTH_SET_ERROR: Final[dict[str, type[AuthenticationError]]]
-
-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: EncodableT) -> EncodedT: ...
-    def decode(self, value: EncodableT, force: bool = False) -> EncodableT: ...
-
-ExceptionMappingT: TypeAlias = Mapping[str, type[Exception] | Mapping[str, type[Exception]]]
-
-class BaseParser:
-    EXCEPTION_CLASSES: ExceptionMappingT
-    def __init__(self, socket_read_size: int) -> None: ...
-    @classmethod
-    def parse_error(cls, response: str) -> ResponseError: ...
-    @abstractmethod
-    def on_disconnect(self) -> None: ...
-    @abstractmethod
-    def on_connect(self, connection: AbstractConnection) -> None: ...
-    @abstractmethod
-    async def can_read_destructive(self) -> bool: ...
-    @abstractmethod
-    async def read_response(self, disable_decoding: bool = False) -> EncodableT | ResponseError | list[EncodableT] | None: ...
-
-class PythonParser(BaseParser):
-    encoder: Encoder | None
-    def __init__(self, socket_read_size: int) -> None: ...
-    def on_connect(self, connection: AbstractConnection) -> None: ...
-    def on_disconnect(self) -> None: ...
-    async def can_read_destructive(self) -> bool: ...
-    async def read_response(self, disable_decoding: bool = False) -> EncodableT | ResponseError | None: ...
-
-class HiredisParser(BaseParser):
-    def __init__(self, socket_read_size: int) -> None: ...
-    def on_connect(self, connection: AbstractConnection) -> None: ...
-    def on_disconnect(self) -> None: ...
-    async def can_read_destructive(self) -> bool: ...
-    async def read_from_socket(self) -> Literal[True]: ...
-    async def read_response(self, disable_decoding: bool = False) -> EncodableT | list[EncodableT]: ...
-
-DefaultParser: type[PythonParser | HiredisParser]
-
-class ConnectCallbackProtocol(Protocol):
-    def __call__(self, connection: Connection): ...
-
-class AsyncConnectCallbackProtocol(Protocol):
-    async def __call__(self, connection: Connection): ...
-
-ConnectCallbackT: TypeAlias = ConnectCallbackProtocol | AsyncConnectCallbackProtocol
-
-class AbstractConnection:
-    pid: int
-    db: str | 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: float
-    next_health_check: float
-    encoder: Encoder
-    redis_connect_func: ConnectCallbackT | None
-
-    def __init__(
-        self,
-        *,
-        db: str | 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[RedisError]] | _Sentinel = ...,
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        parser_class: type[BaseParser] = ...,
-        socket_read_size: int = 65536,
-        health_check_interval: float = 0,
-        client_name: str | None = None,
-        username: str | None = None,
-        retry: Retry | None = None,
-        redis_connect_func: ConnectCallbackT | None = None,
-        encoder_class: type[Encoder] = ...,
-        credential_provider: CredentialProvider | None = None,
-    ) -> None: ...
-    @abstractmethod
-    def repr_pieces(self) -> list[tuple[str, Any]]: ...
-    @property
-    def is_connected(self) -> bool: ...
-    def register_connect_callback(self, callback: ConnectCallbackT) -> None: ...
-    def clear_connect_callbacks(self) -> None: ...
-    def set_parser(self, parser_class: type[BaseParser]) -> None: ...
-    async def connect(self) -> None: ...
-    async def on_connect(self) -> None: ...
-    async def disconnect(self, nowait: bool = False) -> None: ...
-    async def check_health(self) -> None: ...
-    async def send_packed_command(self, command: bytes | str | Iterable[bytes], check_health: bool = True) -> None: ...
-    async def send_command(self, *args: Any, **kwargs: Any) -> None: ...
-    async def can_read_destructive(self) -> bool: ...
-    async def read_response(
-        self, disable_decoding: bool = False, timeout: float | None = None, *, disconnect_on_error: bool = True
-    ) -> EncodableT | list[EncodableT] | None: ...
-    def pack_command(self, *args: EncodableT) -> list[bytes]: ...
-    def pack_commands(self, commands: Iterable[Iterable[EncodableT]]) -> list[bytes]: ...
-
-class Connection(AbstractConnection):
-    host: str
-    port: int
-    socket_keepalive: bool
-    socket_keepalive_options: Mapping[int, int | bytes] | None
-    socket_type: int
-
-    def __init__(
-        self,
-        *,
-        host: str = "localhost",
-        port: str | int = 6379,
-        socket_keepalive: bool = False,
-        socket_keepalive_options: Mapping[int, int | bytes] | None = None,
-        socket_type: int = 0,
-        # **kwargs forwarded to AbstractConnection.
-        db: str | 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[RedisError]] | _Sentinel = ...,
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        parser_class: type[BaseParser] = ...,
-        socket_read_size: int = 65536,
-        health_check_interval: float = 0,
-        client_name: str | None = None,
-        username: str | None = None,
-        retry: Retry | None = None,
-        redis_connect_func: ConnectCallbackT | None = None,
-        encoder_class: type[Encoder] = ...,
-        credential_provider: CredentialProvider | None = None,
-    ) -> None: ...
-    def repr_pieces(self) -> list[tuple[str, Any]]: ...
-
-class SSLConnection(Connection):
-    ssl_context: RedisSSLContext
-    def __init__(
-        self,
-        ssl_keyfile: str | None = None,
-        ssl_certfile: str | None = None,
-        ssl_cert_reqs: _SSLVerifyMode = "required",
-        ssl_ca_certs: str | None = None,
-        ssl_ca_data: str | None = None,
-        ssl_check_hostname: bool = False,
-        *,
-        # **kwargs forwarded to Connection.
-        host: str = "localhost",
-        port: str | int = 6379,
-        socket_keepalive: bool = False,
-        socket_keepalive_options: Mapping[int, int | bytes] | None = None,
-        socket_type: int = 0,
-        db: str | 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[RedisError]] | _Sentinel = ...,
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        parser_class: type[BaseParser] = ...,
-        socket_read_size: int = 65536,
-        health_check_interval: float = 0,
-        client_name: str | None = None,
-        username: str | None = None,
-        retry: Retry | None = None,
-        redis_connect_func: ConnectCallbackT | None = None,
-        encoder_class: type[Encoder] = ...,
-        credential_provider: CredentialProvider | None = None,
-    ) -> None: ...
-    @property
-    def keyfile(self) -> str | None: ...
-    @property
-    def certfile(self) -> str | None: ...
-    @property
-    def cert_reqs(self) -> ssl.VerifyMode: ...
-    @property
-    def ca_certs(self) -> str | None: ...
-    @property
-    def ca_data(self) -> str | None: ...
-    @property
-    def check_hostname(self) -> bool: ...
-
-class RedisSSLContext:
-    keyfile: str | None
-    certfile: str | None
-    cert_reqs: ssl.VerifyMode
-    ca_certs: str | None
-    ca_data: str | None
-    check_hostname: bool
-    context: ssl.SSLContext | None
-    def __init__(
-        self,
-        keyfile: str | None = None,
-        certfile: str | None = None,
-        cert_reqs: _SSLVerifyMode | None = None,
-        ca_certs: str | None = None,
-        ca_data: str | None = None,
-        check_hostname: bool = False,
-    ) -> None: ...
-    def get(self) -> ssl.SSLContext: ...
-
-class UnixDomainSocketConnection(Connection):
-    path: str
-    def __init__(
-        self,
-        *,
-        path: str = "",
-        # **kwargs forwarded to AbstractConnection.
-        db: str | 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[RedisError]] | _Sentinel = ...,
-        encoding: str = "utf-8",
-        encoding_errors: str = "strict",
-        decode_responses: bool = False,
-        parser_class: type[BaseParser] = ...,
-        socket_read_size: int = 65536,
-        health_check_interval: float = 0,
-        client_name: str | None = None,
-        username: str | None = None,
-        retry: Retry | None = None,
-        redis_connect_func: ConnectCallbackT | None = None,
-        encoder_class: type[Encoder] = ...,
-        credential_provider: CredentialProvider | None = None,
-    ) -> None: ...
-    def repr_pieces(self) -> list[tuple[str, Any]]: ...
-
-FALSE_STRINGS: Final[tuple[str, ...]]
-
-def to_bool(value: object) -> bool | None: ...
-
-URL_QUERY_ARGUMENT_PARSERS: MappingProxyType[str, Callable[[str], Any]]
-
-class ConnectKwargs(TypedDict):
-    username: str
-    password: str
-    connection_class: type[AbstractConnection]
-    host: str
-    port: int
-    db: int
-    path: str
-
-def parse_url(url: str) -> ConnectKwargs: ...
-
-_ConnectionT = TypeVar("_ConnectionT", bound=AbstractConnection)
-
-class ConnectionPool(Generic[_ConnectionT]):
-    # kwargs accepts all arguments from the connection class chosen for
-    # the given URL, except those encoded in the URL itself.
-    @classmethod
-    def from_url(cls, url: str, **kwargs: Any) -> Self: ...
-
-    connection_class: type[_ConnectionT]
-    connection_kwargs: Mapping[str, Any]
-    max_connections: int
-    encoder_class: type[Encoder]
-    pid: int
-
-    @overload
-    def __init__(
-        self: ConnectionPool[_ConnectionT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
-        connection_class: type[_ConnectionT],
-        max_connections: int | None = None,
-        # **kwargs are passed to the constructed connection instances.
-        **connection_kwargs: Any,
-    ) -> None: ...
-    @overload
-    def __init__(self: ConnectionPool[Connection], *, max_connections: int | None = None, **connection_kwargs) -> None: ...
-    def reset(self) -> None: ...
-    async def get_connection(self, command_name: Unused, *keys: Unused, **options: Unused) -> _ConnectionT: ...
-    def get_encoder(self) -> Encoder: ...
-    def make_connection(self) -> _ConnectionT: ...
-    async def release(self, connection: AbstractConnection) -> None: ...
-    def owns_connection(self, connection: AbstractConnection) -> bool: ...
-    async def disconnect(self, inuse_connections: bool = True) -> None: ...
-    def set_retry(self, retry: Retry) -> None: ...
-
-class BlockingConnectionPool(ConnectionPool[_ConnectionT]):
-    queue_class: type[asyncio.Queue[_ConnectionT | None]]
-    timeout: int | None
-    pool: asyncio.Queue[_ConnectionT | None]
-
-    @overload
-    def __init__(
-        self: BlockingConnectionPool[_ConnectionT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
-        max_connections: int,
-        timeout: int | None,
-        connection_class: type[_ConnectionT],
-        queue_class: type[asyncio.Queue[_ConnectionT | None]] = ...,
-        # **kwargs are passed to the constructed connection instances.
-        **connection_kwargs: Any,
-    ) -> None: ...
-    @overload
-    def __init__(
-        self: BlockingConnectionPool[_ConnectionT],  # pyright: ignore[reportInvalidTypeVarUse]  #11780
-        max_connections: int = 50,
-        timeout: int | None = 20,
-        *,
-        connection_class: type[_ConnectionT],
-        queue_class: type[asyncio.Queue[_ConnectionT | None]] = ...,
-        # **kwargs are passed to the constructed connection instances.
-        **connection_kwargs: Any,
-    ) -> None: ...
-    @overload
-    def __init__(
-        self: BlockingConnectionPool[Connection],
-        max_connections: int = 50,
-        timeout: int | None = 20,
-        *,
-        queue_class: type[asyncio.Queue[Connection | None]] = ...,
-        # **kwargs are passed to the constructed connection instances.
-        **connection_kwargs: Any,
-    ) -> None: ...

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

@@ -1,51 +0,0 @@
-import threading
-from collections.abc import Awaitable
-from types import SimpleNamespace, TracebackType
-from typing import Any, ClassVar
-from typing_extensions import Self
-
-from redis.asyncio import Redis
-from redis.commands.core import AsyncScript
-
-class Lock:
-    lua_release: ClassVar[AsyncScript | None]
-    lua_extend: ClassVar[AsyncScript | None]
-    lua_reacquire: ClassVar[AsyncScript | None]
-    LUA_RELEASE_SCRIPT: ClassVar[str]
-    LUA_EXTEND_SCRIPT: ClassVar[str]
-    LUA_REACQUIRE_SCRIPT: ClassVar[str]
-    redis: Redis[Any]
-    name: str | bytes | memoryview
-    timeout: float | None
-    sleep: float
-    blocking: bool
-    blocking_timeout: float | None
-    thread_local: bool
-    local: threading.local | SimpleNamespace
-    def __init__(
-        self,
-        redis: Redis[Any],
-        name: str | bytes | memoryview,
-        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: ...
-    async def __aenter__(self) -> Self: ...
-    async def __aexit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
-    ) -> None: ...
-    async def acquire(
-        self, blocking: bool | None = None, blocking_timeout: float | None = None, token: str | bytes | None = None
-    ) -> bool: ...
-    async def do_acquire(self, token: str | bytes) -> bool: ...
-    async def locked(self) -> bool: ...
-    async def owned(self) -> bool: ...
-    def release(self) -> Awaitable[None]: ...
-    async def do_release(self, expected_token: bytes) -> None: ...
-    def extend(self, additional_time: float, replace_ttl: bool = False) -> Awaitable[bool]: ...
-    async def do_extend(self, additional_time: float, replace_ttl: bool) -> bool: ...
-    def reacquire(self) -> Awaitable[bool]: ...
-    async def do_reacquire(self) -> bool: ...

package/dist/typeshed-fallback/stubs/redis/redis/asyncio/parser.pyi

@@ -1,9 +0,0 @@
-from _typeshed import Incomplete
-from typing import Any
-
-# TODO: define and use:
-# from redis.asyncio.cluster import ClusterNode
-
-class CommandsParser:
-    async def initialize(self, node: Incomplete | None = None) -> None: ...  # TODO: ClusterNode
-    async def get_keys(self, *args: Any) -> tuple[str, ...] | None: ...

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

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