basedpyright 1.25.0 → 1.26.0

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

@@ -1,265 +0,0 @@
-from _typeshed import Incomplete, Unused
-from collections.abc import Callable, Iterable, Sequence
-from threading import Lock
-from types import TracebackType
-from typing import Any, ClassVar, Literal, NoReturn, Protocol
-from typing_extensions import Self
-
-from redis.client import CaseInsensitiveDict, PubSub, Redis, _ParseResponseOptions
-from redis.commands import CommandsParser, RedisClusterCommands
-from redis.commands.core import _StrType
-from redis.connection import BaseParser, Connection, ConnectionPool, Encoder, _ConnectionPoolOptions, _Encodable
-from redis.exceptions import MovedError, RedisError
-from redis.retry import Retry
-from redis.typing import EncodableT
-
-def get_node_name(host: str, port: str | int) -> str: ...
-def get_connection(redis_node: Redis[Any], *args, **options: _ConnectionPoolOptions) -> Connection: ...
-def parse_scan_result(command: Unused, res, **options): ...
-def parse_pubsub_numsub(command: Unused, res, **options: Unused): ...
-def parse_cluster_slots(resp, **options) -> dict[tuple[int, int], dict[str, Any]]: ...
-def parse_cluster_myshardid(resp: bytes, **options: Unused) -> str: ...
-
-PRIMARY: str
-REPLICA: str
-SLOT_ID: str
-REDIS_ALLOWED_KEYS: tuple[str, ...]
-KWARGS_DISABLED_KEYS: tuple[str, ...]
-PIPELINE_BLOCKED_COMMANDS: tuple[str, ...]
-
-def cleanup_kwargs(**kwargs: Any) -> dict[str, Any]: ...
-
-# It uses `DefaultParser` in real life, but it is a dynamic base class.
-class ClusterParser(BaseParser): ...
-
-class AbstractRedisCluster:
-    RedisClusterRequestTTL: ClassVar[int]
-    PRIMARIES: ClassVar[str]
-    REPLICAS: ClassVar[str]
-    ALL_NODES: ClassVar[str]
-    RANDOM: ClassVar[str]
-    DEFAULT_NODE: ClassVar[str]
-    NODE_FLAGS: ClassVar[set[str]]
-    COMMAND_FLAGS: ClassVar[dict[str, str]]
-    CLUSTER_COMMANDS_RESPONSE_CALLBACKS: ClassVar[dict[str, Any]]
-    RESULT_CALLBACKS: ClassVar[dict[str, Callable[[Incomplete, Incomplete], Incomplete]]]
-    ERRORS_ALLOW_RETRY: ClassVar[tuple[type[RedisError], ...]]
-
-class RedisCluster(AbstractRedisCluster, RedisClusterCommands[_StrType]):
-    user_on_connect_func: Callable[[Connection], object] | None
-    encoder: Encoder
-    cluster_error_retry_attempts: int
-    command_flags: dict[str, str]
-    node_flags: set[str]
-    read_from_replicas: bool
-    reinitialize_counter: int
-    reinitialize_steps: int
-    nodes_manager: NodesManager
-    cluster_response_callbacks: CaseInsensitiveDict[str, Callable[..., Incomplete]]
-    result_callbacks: CaseInsensitiveDict[str, Callable[[Incomplete, Incomplete], Incomplete]]
-    commands_parser: CommandsParser
-    def __init__(  # TODO: make @overloads, either `url` or `host:port` can be passed
-        self,
-        host: str | None = None,
-        port: int | None = 6379,
-        startup_nodes: list[ClusterNode] | None = None,
-        cluster_error_retry_attempts: int = 3,
-        retry: Retry | None = None,
-        require_full_coverage: bool = False,
-        reinitialize_steps: int = 5,
-        read_from_replicas: bool = False,
-        dynamic_startup_nodes: bool = True,
-        url: str | None = None,
-        address_remap: Callable[[str, int], tuple[str, int]] | None = None,
-        **kwargs,
-    ) -> None: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(
-        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-    ) -> None: ...
-    def __del__(self) -> None: ...
-    def disconnect_connection_pools(self) -> None: ...
-    @classmethod
-    def from_url(cls, url: str, **kwargs) -> Self: ...
-    def on_connect(self, connection: Connection) -> None: ...
-    def get_redis_connection(self, node: ClusterNode) -> Redis[Any]: ...
-    def get_node(
-        self, host: str | None = None, port: str | int | None = None, node_name: str | None = None
-    ) -> ClusterNode | None: ...
-    def get_primaries(self) -> list[ClusterNode]: ...
-    def get_replicas(self) -> list[ClusterNode]: ...
-    def get_random_node(self) -> ClusterNode: ...
-    def get_nodes(self) -> list[ClusterNode]: ...
-    def get_node_from_key(self, key: _Encodable, replica: bool = False) -> ClusterNode | None: ...
-    def get_default_node(self) -> ClusterNode | None: ...
-    def set_default_node(self, node: ClusterNode | None) -> bool: ...
-    def monitor(self, target_node: Incomplete | None = None): ...
-    def pubsub(
-        self, node: Incomplete | None = None, host: Incomplete | None = None, port: Incomplete | None = None, **kwargs
-    ): ...
-    def pipeline(self, transaction: Incomplete | None = None, shard_hint: Incomplete | None = None): ...
-    def lock(
-        self,
-        name: str,
-        timeout: float | None = None,
-        sleep: float = 0.1,
-        blocking: bool = True,
-        blocking_timeout: float | None = None,
-        lock_class: type[Incomplete] | None = None,
-        thread_local: bool = True,
-    ): ...
-    def keyslot(self, key: _Encodable) -> int: ...
-    def determine_slot(self, *args): ...
-    def get_encoder(self) -> Encoder: ...
-    def get_connection_kwargs(self) -> dict[str, Any]: ...
-    def execute_command(self, *args, **kwargs): ...
-    def close(self) -> None: ...
-
-class ClusterNode:
-    host: str
-    port: int
-    name: str
-    server_type: str | None
-    redis_connection: Redis[Incomplete] | None
-    def __init__(
-        self, host: str, port: int, server_type: str | None = None, redis_connection: Redis[Incomplete] | None = None
-    ) -> None: ...
-    def __eq__(self, obj: object) -> bool: ...
-    def __del__(self) -> None: ...
-
-class LoadBalancer:
-    primary_to_idx: dict[str, int]
-    start_index: int
-    def __init__(self, start_index: int = 0) -> None: ...
-    def get_server_index(self, primary: str, list_size: int) -> int: ...
-    def reset(self) -> None: ...
-
-class NodesManager:
-    nodes_cache: dict[str, ClusterNode]
-    slots_cache: dict[str, list[ClusterNode]]
-    startup_nodes: dict[str, ClusterNode]
-    default_node: ClusterNode | None
-    from_url: bool
-    connection_pool_class: type[ConnectionPool]
-    connection_kwargs: dict[str, Incomplete]  # TODO: could be a TypedDict
-    read_load_balancer: LoadBalancer
-    address_remap: Callable[[str, int], tuple[str, int]] | None
-    def __init__(
-        self,
-        startup_nodes: Iterable[ClusterNode],
-        from_url: bool = False,
-        require_full_coverage: bool = False,
-        lock: Lock | None = None,
-        dynamic_startup_nodes: bool = True,
-        connection_pool_class: type[ConnectionPool] = ...,
-        address_remap: Callable[[str, int], tuple[str, int]] | None = None,
-        **kwargs,  # TODO: same type as connection_kwargs
-    ) -> None: ...
-    def get_node(
-        self, host: str | None = None, port: int | str | None = None, node_name: str | None = None
-    ) -> ClusterNode | None: ...
-    def update_moved_exception(self, exception: MovedError) -> None: ...
-    def get_node_from_slot(self, slot: str, read_from_replicas: bool = False, server_type: str | None = None) -> ClusterNode: ...
-    def get_nodes_by_server_type(self, server_type: str) -> list[ClusterNode]: ...
-    def populate_startup_nodes(self, nodes: Iterable[ClusterNode]) -> None: ...
-    def check_slots_coverage(self, slots_cache: dict[str, list[ClusterNode]]) -> bool: ...
-    def create_redis_connections(self, nodes: Iterable[ClusterNode]) -> None: ...
-    def create_redis_node(self, host: str, port: int | str, **kwargs: Any) -> Redis[Incomplete]: ...
-    def initialize(self) -> None: ...
-    def close(self) -> None: ...
-    def reset(self) -> None: ...
-    def remap_host_port(self, host: str, port: int) -> tuple[str, int]: ...
-
-class ClusterPubSub(PubSub):
-    node: ClusterNode | None
-    cluster: RedisCluster[Any]
-    def __init__(
-        self,
-        redis_cluster: RedisCluster[Any],
-        node: ClusterNode | None = None,
-        host: str | None = None,
-        port: int | None = None,
-        **kwargs,
-    ) -> None: ...
-    def set_pubsub_node(
-        self, cluster: RedisCluster[Any], node: ClusterNode | None = None, host: str | None = None, port: int | None = None
-    ) -> None: ...
-    def get_pubsub_node(self) -> ClusterNode | None: ...
-    def execute_command(self, *args, **kwargs) -> None: ...
-    def get_redis_connection(self) -> Redis[Any] | None: ...
-
-class ClusterPipeline(RedisCluster[_StrType]):
-    command_stack: list[Incomplete]
-    nodes_manager: Incomplete
-    refresh_table_asap: bool
-    result_callbacks: Incomplete
-    startup_nodes: Incomplete
-    read_from_replicas: bool
-    command_flags: Incomplete
-    cluster_response_callbacks: Incomplete
-    cluster_error_retry_attempts: int
-    reinitialize_counter: int
-    reinitialize_steps: int
-    encoder: Encoder
-    commands_parser: Incomplete
-    def __init__(
-        self,
-        nodes_manager,
-        commands_parser,
-        result_callbacks: Incomplete | None = None,
-        cluster_response_callbacks: Incomplete | None = None,
-        startup_nodes: Incomplete | None = None,
-        read_from_replicas: bool = False,
-        cluster_error_retry_attempts: int = 3,
-        reinitialize_steps: int = 5,
-        lock: Lock | None = None,
-        **kwargs,
-    ) -> None: ...
-    def __len__(self) -> int: ...
-    def __bool__(self) -> Literal[True]: ...
-    def execute_command(self, *args, **kwargs): ...
-    def pipeline_execute_command(self, *args, **options): ...
-    def raise_first_error(self, stack) -> None: ...
-    def annotate_exception(self, exception, number, command) -> None: ...
-    def execute(self, raise_on_error: bool = True): ...
-    scripts: set[Any]  # is only set in `reset()`
-    watching: bool  # is only set in `reset()`
-    explicit_transaction: bool  # is only set in `reset()`
-    def reset(self) -> None: ...
-    def send_cluster_commands(self, stack, raise_on_error: bool = True, allow_redirections: bool = True): ...
-    def eval(self) -> None: ...
-    def multi(self) -> None: ...
-    def immediate_execute_command(self, *args, **options) -> None: ...
-    def load_scripts(self) -> None: ...
-    def watch(self, *names) -> None: ...
-    def unwatch(self) -> None: ...
-    def script_load_for_pipeline(self, *args, **kwargs) -> None: ...
-    def delete(self, *names): ...
-
-def block_pipeline_command(name: str) -> Callable[..., NoReturn]: ...
-
-class PipelineCommand:
-    args: Sequence[EncodableT]
-    options: _ParseResponseOptions
-    position: int | None
-    result: Any | Exception | None
-    node: Incomplete | None
-    asking: bool
-    def __init__(
-        self, args: Sequence[EncodableT], options: _ParseResponseOptions | None = None, position: int | None = None
-    ) -> None: ...
-
-class _ParseResponseCallback(Protocol):
-    def __call__(self, connection: Connection, command: EncodableT, /, **kwargs) -> Any: ...
-
-class NodeCommands:
-    parse_response: _ParseResponseCallback
-    connection_pool: ConnectionPool
-    connection: Connection
-    commands: list[PipelineCommand]
-    def __init__(
-        self, parse_response: _ParseResponseCallback, connection_pool: ConnectionPool, connection: Connection
-    ) -> None: ...
-    def append(self, c: PipelineCommand) -> None: ...
-    def write(self) -> None: ...
-    def read(self) -> None: ...

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

@@ -1,17 +0,0 @@
-from .cluster import RedisClusterCommands as RedisClusterCommands
-from .core import AsyncCoreCommands as AsyncCoreCommands, CoreCommands as CoreCommands
-from .helpers import list_or_args as list_or_args
-from .parser import CommandsParser as CommandsParser
-from .redismodules import RedisModuleCommands as RedisModuleCommands
-from .sentinel import AsyncSentinelCommands as AsyncSentinelCommands, SentinelCommands as SentinelCommands
-
-__all__ = [
-    "RedisClusterCommands",
-    "CommandsParser",
-    "AsyncCoreCommands",
-    "CoreCommands",
-    "list_or_args",
-    "RedisModuleCommands",
-    "AsyncSentinelCommands",
-    "SentinelCommands",
-]

package/dist/typeshed-fallback/stubs/redis/redis/commands/bf/__init__.pyi

@@ -1,58 +0,0 @@
-from typing import Any
-
-from .commands import *
-from .info import BFInfo as BFInfo, CFInfo as CFInfo, CMSInfo as CMSInfo, TDigestInfo as TDigestInfo, TopKInfo as TopKInfo
-
-class AbstractBloom:
-    @staticmethod
-    def append_items(params, items) -> None: ...
-    @staticmethod
-    def append_error(params, error) -> None: ...
-    @staticmethod
-    def append_capacity(params, capacity) -> None: ...
-    @staticmethod
-    def append_expansion(params, expansion) -> None: ...
-    @staticmethod
-    def append_no_scale(params, noScale) -> None: ...
-    @staticmethod
-    def append_weights(params, weights) -> None: ...
-    @staticmethod
-    def append_no_create(params, noCreate) -> None: ...
-    @staticmethod
-    def append_items_and_increments(params, items, increments) -> None: ...
-    @staticmethod
-    def append_values_and_weights(params, items, weights) -> None: ...
-    @staticmethod
-    def append_max_iterations(params, max_iterations) -> None: ...
-    @staticmethod
-    def append_bucket_size(params, bucket_size) -> None: ...
-
-class CMSBloom(CMSCommands, AbstractBloom):
-    client: Any
-    commandmixin: Any
-    execute_command: Any
-    def __init__(self, client, **kwargs) -> None: ...
-
-class TOPKBloom(TOPKCommands, AbstractBloom):
-    client: Any
-    commandmixin: Any
-    execute_command: Any
-    def __init__(self, client, **kwargs) -> None: ...
-
-class CFBloom(CFCommands, AbstractBloom):
-    client: Any
-    commandmixin: Any
-    execute_command: Any
-    def __init__(self, client, **kwargs) -> None: ...
-
-class TDigestBloom(TDigestCommands, AbstractBloom):
-    client: Any
-    commandmixin: Any
-    execute_command: Any
-    def __init__(self, client, **kwargs) -> None: ...
-
-class BFBloom(BFCommands, AbstractBloom):
-    client: Any
-    commandmixin: Any
-    execute_command: Any
-    def __init__(self, client, **kwargs) -> None: ...

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

@@ -1,112 +0,0 @@
-from _typeshed import Incomplete
-
-BF_RESERVE: str
-BF_ADD: str
-BF_MADD: str
-BF_INSERT: str
-BF_EXISTS: str
-BF_MEXISTS: str
-BF_SCANDUMP: str
-BF_LOADCHUNK: str
-BF_INFO: str
-CF_RESERVE: str
-CF_ADD: str
-CF_ADDNX: str
-CF_INSERT: str
-CF_INSERTNX: str
-CF_EXISTS: str
-CF_DEL: str
-CF_COUNT: str
-CF_SCANDUMP: str
-CF_LOADCHUNK: str
-CF_INFO: str
-CMS_INITBYDIM: str
-CMS_INITBYPROB: str
-CMS_INCRBY: str
-CMS_QUERY: str
-CMS_MERGE: str
-CMS_INFO: str
-TOPK_RESERVE: str
-TOPK_ADD: str
-TOPK_INCRBY: str
-TOPK_QUERY: str
-TOPK_COUNT: str
-TOPK_LIST: str
-TOPK_INFO: str
-TDIGEST_CREATE: str
-TDIGEST_RESET: str
-TDIGEST_ADD: str
-TDIGEST_MERGE: str
-TDIGEST_CDF: str
-TDIGEST_QUANTILE: str
-TDIGEST_MIN: str
-TDIGEST_MAX: str
-TDIGEST_INFO: str
-
-class BFCommands:
-    def create(self, key, errorRate, capacity, expansion: Incomplete | None = None, noScale: Incomplete | None = None): ...
-    def add(self, key, item): ...
-    def madd(self, key, *items): ...
-    def insert(
-        self,
-        key,
-        items,
-        capacity: Incomplete | None = None,
-        error: Incomplete | None = None,
-        noCreate: Incomplete | None = None,
-        expansion: Incomplete | None = None,
-        noScale: Incomplete | None = None,
-    ): ...
-    def exists(self, key, item): ...
-    def mexists(self, key, *items): ...
-    def scandump(self, key, iter): ...
-    def loadchunk(self, key, iter, data): ...
-    def info(self, key): ...
-
-class CFCommands:
-    def create(
-        self,
-        key,
-        capacity,
-        expansion: Incomplete | None = None,
-        bucket_size: Incomplete | None = None,
-        max_iterations: Incomplete | None = None,
-    ): ...
-    def add(self, key, item): ...
-    def addnx(self, key, item): ...
-    def insert(self, key, items, capacity: Incomplete | None = None, nocreate: Incomplete | None = None): ...
-    def insertnx(self, key, items, capacity: Incomplete | None = None, nocreate: Incomplete | None = None): ...
-    def exists(self, key, item): ...
-    def delete(self, key, item): ...
-    def count(self, key, item): ...
-    def scandump(self, key, iter): ...
-    def loadchunk(self, key, iter, data): ...
-    def info(self, key): ...
-
-class TOPKCommands:
-    def reserve(self, key, k, width, depth, decay): ...
-    def add(self, key, *items): ...
-    def incrby(self, key, items, increments): ...
-    def query(self, key, *items): ...
-    def count(self, key, *items): ...
-    def list(self, key, withcount: bool = False): ...
-    def info(self, key): ...
-
-class TDigestCommands:
-    def create(self, key, compression: int = 100): ...
-    def reset(self, key): ...
-    def add(self, key, values): ...
-    def merge(self, destination_key, num_keys, *keys, compression: int | None = None, override: bool = False): ...
-    def min(self, key): ...
-    def max(self, key): ...
-    def quantile(self, key, quantile, *quantiles): ...
-    def cdf(self, key, value, *values): ...
-    def info(self, key): ...
-
-class CMSCommands:
-    def initbydim(self, key, width, depth): ...
-    def initbyprob(self, key, error, probability): ...
-    def incrby(self, key, items, increments): ...
-    def query(self, key, *items): ...
-    def merge(self, destKey, numKeys, srcKeys, weights=[]): ...
-    def info(self, key): ...

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

@@ -1,43 +0,0 @@
-from typing import Any
-
-class BFInfo:
-    capacity: Any
-    size: Any
-    filterNum: Any
-    insertedNum: Any
-    expansionRate: Any
-    def __init__(self, args) -> None: ...
-
-class CFInfo:
-    size: Any
-    bucketNum: Any
-    filterNum: Any
-    insertedNum: Any
-    deletedNum: Any
-    bucketSize: Any
-    expansionRate: Any
-    maxIteration: Any
-    def __init__(self, args) -> None: ...
-
-class CMSInfo:
-    width: Any
-    depth: Any
-    count: Any
-    def __init__(self, args) -> None: ...
-
-class TopKInfo:
-    k: Any
-    width: Any
-    depth: Any
-    decay: Any
-    def __init__(self, args) -> None: ...
-
-class TDigestInfo:
-    compression: Any
-    capacity: Any
-    mergedNodes: Any
-    unmergedNodes: Any
-    mergedWeight: Any
-    unmergedWeight: Any
-    totalCompressions: Any
-    def __init__(self, args) -> None: ...

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

@@ -1,60 +0,0 @@
-from _typeshed import Incomplete
-from typing import NoReturn
-
-from .core import ACLCommands, DataAccessCommands, ManagementCommands, PubSubCommands, _StrType
-
-class ClusterMultiKeyCommands:
-    def mget_nonatomic(self, keys, *args): ...
-    def mset_nonatomic(self, mapping): ...
-    def exists(self, *keys): ...
-    def delete(self, *keys): ...
-    def touch(self, *keys): ...
-    def unlink(self, *keys): ...
-
-class ClusterManagementCommands(ManagementCommands):
-    def slaveof(self, *args, **kwargs) -> None: ...
-    def replicaof(self, *args, **kwargs) -> None: ...
-    def swapdb(self, *args, **kwargs) -> None: ...
-
-class ClusterDataAccessCommands(DataAccessCommands[_StrType]):
-    def stralgo(
-        self,
-        algo,
-        value1,
-        value2,
-        specific_argument: str = "strings",
-        len: bool = False,
-        idx: bool = False,
-        minmatchlen: Incomplete | None = None,
-        withmatchlen: bool = False,
-        **kwargs,
-    ): ...
-
-class RedisClusterCommands(
-    ClusterMultiKeyCommands, ClusterManagementCommands, ACLCommands[_StrType], PubSubCommands, ClusterDataAccessCommands[_StrType]
-):
-    def cluster_addslots(self, target_node, *slots): ...
-    def cluster_countkeysinslot(self, slot_id): ...
-    def cluster_count_failure_report(self, node_id): ...
-    def cluster_delslots(self, *slots): ...
-    def cluster_failover(self, target_node, option: Incomplete | None = None): ...
-    def cluster_info(self, target_nodes: Incomplete | None = None): ...
-    def cluster_keyslot(self, key): ...
-    def cluster_meet(self, host, port, target_nodes: Incomplete | None = None): ...
-    def cluster_nodes(self): ...
-    def cluster_replicate(self, target_nodes, node_id): ...
-    def cluster_reset(self, soft: bool = True, target_nodes: Incomplete | None = None): ...
-    def cluster_save_config(self, target_nodes: Incomplete | None = None): ...
-    def cluster_get_keys_in_slot(self, slot, num_keys): ...
-    def cluster_set_config_epoch(self, epoch, target_nodes: Incomplete | None = None): ...
-    def cluster_setslot(self, target_node, node_id, slot_id, state): ...
-    def cluster_setslot_stable(self, slot_id): ...
-    def cluster_replicas(self, node_id, target_nodes: Incomplete | None = None): ...
-    def cluster_slots(self, target_nodes: Incomplete | None = None): ...
-    def cluster_myshardid(self, target_nodes: Incomplete | None = None): ...
-    def cluster_links(self, target_node): ...
-    def cluster_flushslots(self, target_nodes: Incomplete | None = None) -> NoReturn: ...
-    def cluster_bumpepoch(self, target_nodes: Incomplete | None = None) -> NoReturn: ...
-    read_from_replicas: bool
-    def readonly(self, target_nodes: Incomplete | None = None): ...
-    def readwrite(self, target_nodes: Incomplete | None = None): ...