Full Code of redis/redis-py for AI

gitextract_8s9rmjqg/

├── .agent/
│   └── sync_async_type_hints_overload_guide.md
├── .dockerignore
├── .github/
│   ├── CODEOWNERS
│   ├── ISSUE_TEMPLATE.md
│   ├── PULL_REQUEST_TEMPLATE.md
│   ├── actions/
│   │   └── run-tests/
│   │       └── action.yml
│   ├── dependabot.yml
│   ├── release-drafter-config.yml
│   ├── spellcheck-settings.yml
│   ├── wordlist.txt
│   └── workflows/
│       ├── codeql-analysis.yml
│       ├── docs.yaml
│       ├── hiredis-py-integration.yaml
│       ├── install_and_test.sh
│       ├── integration.yaml
│       ├── pypi-publish.yaml
│       ├── release-drafter.yml
│       ├── spellcheck.yml
│       └── stale-issues.yml
├── .gitignore
├── .mypy.ini
├── .readthedocs.yml
├── CHANGES
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── benchmarks/
│   ├── __init__.py
│   ├── base.py
│   ├── basic_operations.py
│   ├── cluster_async.py
│   ├── cluster_async_pipeline.py
│   ├── command_packer_benchmark.py
│   ├── otel_benchmark.py
│   └── socket_read_size.py
├── codecov.yml
├── dev_requirements.txt
├── docker-compose.yml
├── dockers/
│   └── sentinel.conf
├── docs/
│   ├── Makefile
│   ├── _static/
│   │   └── .keep
│   ├── _templates/
│   │   └── .keep
│   ├── advanced_features.rst
│   ├── backoff.rst
│   ├── clustering.rst
│   ├── commands.rst
│   ├── conf.py
│   ├── connections.rst
│   ├── examples/
│   │   ├── README.md
│   │   ├── asyncio_examples.ipynb
│   │   ├── connection_examples.ipynb
│   │   ├── opentelemetry/
│   │   │   ├── README.md
│   │   │   ├── config/
│   │   │   │   ├── alertmanager.yml
│   │   │   │   ├── otel-collector.yaml
│   │   │   │   └── vector.toml
│   │   │   ├── docker-compose.yml
│   │   │   ├── main.py
│   │   │   ├── requirements.txt
│   │   │   └── uptrace.yml
│   │   ├── opentelemetry_api_examples.ipynb
│   │   ├── pipeline_examples.ipynb
│   │   ├── redis-stream-example.ipynb
│   │   ├── search_json_examples.ipynb
│   │   ├── search_vector_similarity_examples.ipynb
│   │   ├── set_and_get_examples.ipynb
│   │   ├── ssl_connection_examples.ipynb
│   │   └── timeseries_examples.ipynb
│   ├── examples.rst
│   ├── exceptions.rst
│   ├── genindex.rst
│   ├── geographic_failover.rst
│   ├── index.rst
│   ├── lock.rst
│   ├── lua_scripting.rst
│   ├── opentelemetry.rst
│   ├── redismodules.rst
│   ├── requirements.txt
│   ├── resp3_features.rst
│   └── retry.rst
├── doctests/
│   ├── README.md
│   ├── cmds_cnxmgmt.py
│   ├── cmds_generic.py
│   ├── cmds_hash.py
│   ├── cmds_list.py
│   ├── cmds_servermgmt.py
│   ├── cmds_set.py
│   ├── cmds_sorted_set.py
│   ├── cmds_string.py
│   ├── data/
│   │   ├── query_em.json
│   │   └── query_vector.json
│   ├── dt_bitfield.py
│   ├── dt_bitmap.py
│   ├── dt_bloom.py
│   ├── dt_cms.py
│   ├── dt_cuckoo.py
│   ├── dt_geo.py
│   ├── dt_hash.py
│   ├── dt_hll.py
│   ├── dt_json.py
│   ├── dt_list.py
│   ├── dt_set.py
│   ├── dt_ss.py
│   ├── dt_stream.py
│   ├── dt_string.py
│   ├── dt_tdigest.py
│   ├── dt_time_series.py
│   ├── dt_topk.py
│   ├── dt_vec_set.py
│   ├── geo_index.py
│   ├── home_json.py
│   ├── home_prob_dts.py
│   ├── query_agg.py
│   ├── query_combined.py
│   ├── query_em.py
│   ├── query_ft.py
│   ├── query_geo.py
│   ├── query_range.py
│   ├── requirements.txt
│   ├── run_examples.sh
│   ├── search_quickstart.py
│   ├── search_vss.py
│   ├── string_set_get.py
│   └── trans_pipe.py
├── pyproject.toml
├── redis/
│   ├── __init__.py
│   ├── _parsers/
│   │   ├── __init__.py
│   │   ├── base.py
│   │   ├── commands.py
│   │   ├── encoders.py
│   │   ├── helpers.py
│   │   ├── hiredis.py
│   │   ├── resp2.py
│   │   ├── resp3.py
│   │   └── socket.py
│   ├── asyncio/
│   │   ├── __init__.py
│   │   ├── client.py
│   │   ├── cluster.py
│   │   ├── connection.py
│   │   ├── http/
│   │   │   ├── __init__.py
│   │   │   └── http_client.py
│   │   ├── lock.py
│   │   ├── multidb/
│   │   │   ├── __init__.py
│   │   │   ├── client.py
│   │   │   ├── command_executor.py
│   │   │   ├── config.py
│   │   │   ├── database.py
│   │   │   ├── event.py
│   │   │   ├── failover.py
│   │   │   ├── failure_detector.py
│   │   │   └── healthcheck.py
│   │   ├── observability/
│   │   │   ├── __init__.py
│   │   │   └── recorder.py
│   │   ├── retry.py
│   │   ├── sentinel.py
│   │   └── utils.py
│   ├── auth/
│   │   ├── __init__.py
│   │   ├── err.py
│   │   ├── idp.py
│   │   ├── token.py
│   │   └── token_manager.py
│   ├── background.py
│   ├── backoff.py
│   ├── cache.py
│   ├── client.py
│   ├── cluster.py
│   ├── commands/
│   │   ├── __init__.py
│   │   ├── bf/
│   │   │   ├── __init__.py
│   │   │   ├── commands.py
│   │   │   └── info.py
│   │   ├── cluster.py
│   │   ├── core.py
│   │   ├── helpers.py
│   │   ├── json/
│   │   │   ├── __init__.py
│   │   │   ├── _util.py
│   │   │   ├── commands.py
│   │   │   ├── decoders.py
│   │   │   └── path.py
│   │   ├── policies.py
│   │   ├── redismodules.py
│   │   ├── search/
│   │   │   ├── __init__.py
│   │   │   ├── _util.py
│   │   │   ├── aggregation.py
│   │   │   ├── commands.py
│   │   │   ├── dialect.py
│   │   │   ├── document.py
│   │   │   ├── field.py
│   │   │   ├── hybrid_query.py
│   │   │   ├── hybrid_result.py
│   │   │   ├── index_definition.py
│   │   │   ├── profile_information.py
│   │   │   ├── query.py
│   │   │   ├── querystring.py
│   │   │   ├── reducers.py
│   │   │   ├── result.py
│   │   │   └── suggestion.py
│   │   ├── sentinel.py
│   │   ├── timeseries/
│   │   │   ├── __init__.py
│   │   │   ├── commands.py
│   │   │   ├── info.py
│   │   │   └── utils.py
│   │   └── vectorset/
│   │       ├── __init__.py
│   │       ├── commands.py
│   │       └── utils.py
│   ├── connection.py
│   ├── crc.py
│   ├── credentials.py
│   ├── data_structure.py
│   ├── driver_info.py
│   ├── event.py
│   ├── exceptions.py
│   ├── http/
│   │   ├── __init__.py
│   │   └── http_client.py
│   ├── lock.py
│   ├── maint_notifications.py
│   ├── multidb/
│   │   ├── __init__.py
│   │   ├── circuit.py
│   │   ├── client.py
│   │   ├── command_executor.py
│   │   ├── config.py
│   │   ├── database.py
│   │   ├── event.py
│   │   ├── exception.py
│   │   ├── failover.py
│   │   └── failure_detector.py
│   ├── observability/
│   │   ├── __init__.py
│   │   ├── attributes.py
│   │   ├── config.py
│   │   ├── metrics.py
│   │   ├── providers.py
│   │   ├── recorder.py
│   │   └── registry.py
│   ├── ocsp.py
│   ├── py.typed
│   ├── retry.py
│   ├── sentinel.py
│   ├── typing.py
│   └── utils.py
├── specs/
│   ├── commands_overload_inventory.md
│   └── sync_async_deduplication_analysis.md
├── tasks.py
├── tests/
│   ├── __init__.py
│   ├── conftest.py
│   ├── entraid_utils.py
│   ├── helpers.py
│   ├── maint_notifications/
│   │   ├── proxy_server_helpers.py
│   │   ├── test_cluster_maint_notifications_handling.py
│   │   ├── test_maint_notifications.py
│   │   └── test_maint_notifications_handling.py
│   ├── mocks.py
│   ├── ssl_utils.py
│   ├── test_asyncio/
│   │   ├── __init__.py
│   │   ├── compat.py
│   │   ├── conftest.py
│   │   ├── helpers.py
│   │   ├── mocks.py
│   │   ├── test_bloom.py
│   │   ├── test_client.py
│   │   ├── test_cluster.py
│   │   ├── test_cluster_transaction.py
│   │   ├── test_command_parser.py
│   │   ├── test_command_policies.py
│   │   ├── test_commands.py
│   │   ├── test_connect.py
│   │   ├── test_connection.py
│   │   ├── test_connection_pool.py
│   │   ├── test_credentials.py
│   │   ├── test_cwe_404.py
│   │   ├── test_encoding.py
│   │   ├── test_hash.py
│   │   ├── test_json.py
│   │   ├── test_lock.py
│   │   ├── test_monitor.py
│   │   ├── test_multidb/
│   │   │   ├── __init__.py
│   │   │   ├── conftest.py
│   │   │   ├── test_client.py
│   │   │   ├── test_command_executor.py
│   │   │   ├── test_config.py
│   │   │   ├── test_failover.py
│   │   │   ├── test_failure_detector.py
│   │   │   ├── test_healthcheck.py
│   │   │   └── test_pipeline.py
│   │   ├── test_observability/
│   │   │   ├── __init__.py
│   │   │   ├── test_cluster_metrics_error_handling.py
│   │   │   └── test_recorder.py
│   │   ├── test_pipeline.py
│   │   ├── test_pubsub.py
│   │   ├── test_retry.py
│   │   ├── test_scenario/
│   │   │   ├── __init__.py
│   │   │   ├── conftest.py
│   │   │   └── test_active_active.py
│   │   ├── test_scripting.py
│   │   ├── test_search.py
│   │   ├── test_sentinel.py
│   │   ├── test_sentinel_managed_connection.py
│   │   ├── test_ssl.py
│   │   ├── test_timeseries.py
│   │   ├── test_usage_counter.py
│   │   ├── test_utils.py
│   │   ├── test_vsets.py
│   │   └── testdata/
│   │       ├── jsontestdata.py
│   │       ├── titles.csv
│   │       └── will_play_text.csv.bz2
│   ├── test_auth/
│   │   ├── __init__.py
│   │   ├── test_token.py
│   │   └── test_token_manager.py
│   ├── test_background.py
│   ├── test_backoff.py
│   ├── test_bloom.py
│   ├── test_cache.py
│   ├── test_client.py
│   ├── test_cluster.py
│   ├── test_cluster_transaction.py
│   ├── test_command_parser.py
│   ├── test_command_policies.py
│   ├── test_commands.py
│   ├── test_connect.py
│   ├── test_connection.py
│   ├── test_connection_pool.py
│   ├── test_credentials.py
│   ├── test_data_structure.py
│   ├── test_driver_info.py
│   ├── test_encoding.py
│   ├── test_event.py
│   ├── test_function.py
│   ├── test_hash.py
│   ├── test_helpers.py
│   ├── test_http/
│   │   ├── __init__.py
│   │   └── test_http_client.py
│   ├── test_json.py
│   ├── test_lock.py
│   ├── test_max_connections_error.py
│   ├── test_monitor.py
│   ├── test_multidb/
│   │   ├── __init__.py
│   │   ├── conftest.py
│   │   ├── test_circuit.py
│   │   ├── test_client.py
│   │   ├── test_command_executor.py
│   │   ├── test_config.py
│   │   ├── test_failover.py
│   │   ├── test_failure_detector.py
│   │   └── test_pipeline.py
│   ├── test_multiprocessing.py
│   ├── test_observability/
│   │   ├── __init__.py
│   │   ├── test_cluster_metrics_error_handling.py
│   │   ├── test_config.py
│   │   ├── test_metrics_connection_attributes.py
│   │   ├── test_provider.py
│   │   ├── test_public_api.py
│   │   └── test_recorder.py
│   ├── test_parsers/
│   │   ├── test_errors.py
│   │   └── test_helpers.py
│   ├── test_pipeline.py
│   ├── test_pubsub.py
│   ├── test_retry.py
│   ├── test_scenario/
│   │   ├── __init__.py
│   │   ├── conftest.py
│   │   ├── fault_injector_client.py
│   │   ├── maint_notifications_helpers.py
│   │   ├── test_active_active.py
│   │   └── test_maint_notifications.py
│   ├── test_scripting.py
│   ├── test_search.py
│   ├── test_sentinel.py
│   ├── test_sentinel_managed_connection.py
│   ├── test_ssl.py
│   ├── test_timeseries.py
│   ├── test_utils.py
│   ├── test_vsets.py
│   └── testdata/
│       ├── jsontestdata.py
│       ├── titles.csv
│       └── will_play_text.csv.bz2
├── util/
│   └── wait-for-it.sh
└── whitelist.py

SYMBOL INDEX (8361 symbols across 227 files)

FILE: benchmarks/base.py
  class Benchmark (line 9) | class Benchmark:
    method __init__ (line 12) | def __init__(self):
    method get_client (line 15) | def get_client(self, **kwargs):
    method setup (line 25) | def setup(self, **kwargs):
    method run (line 28) | def run(self, **kwargs):
    method run_benchmark (line 31) | def run_benchmark(self):

FILE: benchmarks/basic_operations.py
  function parse_args (line 8) | def parse_args():
  function run (line 30) | def run():
  function timer (line 45) | def timer(func):
  function set_str (line 65) | def set_str(conn, num, pipeline_size, data_size):
  function set_int (line 80) | def set_int(conn, num, pipeline_size, data_size):
  function get_str (line 95) | def get_str(conn, num, pipeline_size, data_size):
  function get_int (line 109) | def get_int(conn, num, pipeline_size, data_size):
  function incr (line 123) | def incr(conn, num, pipeline_size, *args, **kwargs):
  function lpush (line 137) | def lpush(conn, num, pipeline_size, data_size):
  function lrange_300 (line 152) | def lrange_300(conn, num, pipeline_size, data_size):
  function lpop (line 166) | def lpop(conn, num, pipeline_size, data_size):
  function hmset (line 178) | def hmset(conn, num, pipeline_size, data_size):

FILE: benchmarks/cluster_async.py
  function timer (line 12) | def timer(func):
  function set_str (line 24) | async def set_str(client, gather, data):
  function set_int (line 39) | async def set_int(client, gather, data):
  function get_str (line 54) | async def get_str(client, gather):
  function get_int (line 66) | async def get_int(client, gather):
  function hset (line 78) | async def hset(client, gather, data):
  function hget (line 93) | async def hget(client, gather):
  function incr (line 108) | async def incr(client, gather):
  function lpush (line 120) | async def lpush(client, gather, data):
  function lrange_300 (line 135) | async def lrange_300(client, gather):
  function lpop (line 150) | async def lpop(client, gather):
  function warmup (line 162) | async def warmup(client):
  function run (line 169) | async def run(client, gather):
  function main (line 204) | async def main(loop, gather=None):

FILE: benchmarks/cluster_async_pipeline.py
  function timer (line 12) | def timer(func):
  function warmup (line 24) | async def warmup(client):
  function run (line 31) | async def run(client):
  function main (line 52) | async def main(loop):

FILE: benchmarks/command_packer_benchmark.py
  class StringJoiningConnection (line 6) | class StringJoiningConnection(Connection):
    method send_packed_command (line 7) | def send_packed_command(self, command, check_health=True):
    method pack_command (line 24) | def pack_command(self, *args):
  class ListJoiningConnection (line 40) | class ListJoiningConnection(Connection):
    method send_packed_command (line 41) | def send_packed_command(self, command, check_health=True):
    method pack_command (line 60) | def pack_command(self, *args):
  class CommandPackerBenchmark (line 80) | class CommandPackerBenchmark(Benchmark):
    method setup (line 92) | def setup(self, connection_class, value_size):
    method run (line 95) | def run(self, connection_class, value_size):

FILE: benchmarks/otel_benchmark.py
  class BenchmarkResult (line 51) | class BenchmarkResult:
  class LoadGeneratorConfig (line 74) | class LoadGeneratorConfig:
  class ComprehensiveLoadGenerator (line 84) | class ComprehensiveLoadGenerator:
    method __init__ (line 100) | def __init__(self, config: LoadGeneratorConfig, redis_module: Any = No...
    method _get_redis_module (line 135) | def _get_redis_module(self) -> Any:
    method _get_key (line 142) | def _get_key(self) -> str:
    method setup (line 148) | def setup(self) -> None:
    method teardown (line 205) | def teardown(self) -> None:
    method _run_operation (line 236) | def _run_operation(self) -> float:
    method warmup (line 292) | def warmup(self) -> None:
    method _sample_resources (line 304) | def _sample_resources(self) -> None:
    method run (line 319) | def run(self) -> BenchmarkResult:
    method _calculate_results (line 357) | def _calculate_results(self, duration: float) -> BenchmarkResult:
  class AsyncComprehensiveLoadGenerator (line 402) | class AsyncComprehensiveLoadGenerator:
    method __init__ (line 416) | def __init__(self, config: LoadGeneratorConfig, redis_module: Any = No...
    method _get_redis_module (line 448) | def _get_redis_module(self) -> Any:
    method _get_key (line 455) | def _get_key(self) -> str:
    method setup (line 461) | async def setup(self) -> None:
    method teardown (line 503) | async def teardown(self) -> None:
    method _run_operation (line 528) | async def _run_operation(self) -> float:
    method warmup (line 594) | async def warmup(self) -> None:
    method _sample_resources (line 606) | def _sample_resources(self) -> None:
    method run (line 619) | async def run(self) -> BenchmarkResult:
    method _calculate_results (line 657) | def _calculate_results(self, duration: float) -> BenchmarkResult:
  function print_result (line 702) | def print_result(result: BenchmarkResult, iterations: int = 1) -> None:
  function average_results (line 735) | def average_results(results: List[BenchmarkResult]) -> BenchmarkResult:
  function parse_args (line 777) | def parse_args() -> argparse.Namespace:
  function _clear_redis_modules (line 839) | def _clear_redis_modules() -> None:
  function run_baseline_scenario (line 846) | def run_baseline_scenario(tag: str, config: LoadGeneratorConfig) -> Opti...
  function run_baseline_scenario_async (line 902) | async def run_baseline_scenario_async(tag: str, config: LoadGeneratorCon...
  function _get_metric_groups_for_benchmark (line 959) | def _get_metric_groups_for_benchmark(metric_group_names: Optional[List[s...
  function setup_scenario (line 997) | def setup_scenario(
  function run_iteration (line 1104) | def run_iteration(scenario: str, config: LoadGeneratorConfig, descriptio...
  function run_iteration_async (line 1128) | async def run_iteration_async(scenario: str, config: LoadGeneratorConfig...
  function main (line 1153) | def main() -> int:
  function _run_sync_benchmark (line 1215) | def _run_sync_benchmark(args: argparse.Namespace, config: LoadGeneratorC...
  function _run_async_benchmark (line 1244) | async def _run_async_benchmark(args: argparse.Namespace, config: LoadGen...

FILE: benchmarks/socket_read_size.py
  class SocketReadBenchmark (line 6) | class SocketReadBenchmark(Benchmark):
    method setup (line 16) | def setup(self, value_size, read_size, parser):
    method run (line 20) | def run(self, value_size, read_size, parser):

FILE: docs/examples/opentelemetry/main.py
  function main (line 13) | def main():
  function handle_request (line 31) | def handle_request(client):

FILE: doctests/query_combined.py
  function embed_text (line 14) | def embed_text(model, text):

FILE: doctests/search_vss.py
  function create_query_table (line 260) | def create_query_table(query, queries, encoded_queries, extra_params=None):

FILE: doctests/trans_pipe.py
  function watched_sequence (line 80) | def watched_sequence(pipe):

FILE: redis/__init__.py
  function int_or_str (line 43) | def int_or_str(value):

FILE: redis/_parsers/base.py
  class BaseParser (line 73) | class BaseParser(ABC):
    method parse_error (line 110) | def parse_error(cls, response):
    method on_disconnect (line 121) | def on_disconnect(self):
    method on_connect (line 124) | def on_connect(self, connection):
  class _RESPBase (line 128) | class _RESPBase(BaseParser):
    method __init__ (line 131) | def __init__(self, socket_read_size):
    method __del__ (line 137) | def __del__(self):
    method on_connect (line 143) | def on_connect(self, connection):
    method on_disconnect (line 151) | def on_disconnect(self):
    method can_read (line 159) | def can_read(self, timeout):
  class AsyncBaseParser (line 163) | class AsyncBaseParser(BaseParser):
    method __init__ (line 168) | def __init__(self, socket_read_size: int):
    method can_read_destructive (line 172) | async def can_read_destructive(self) -> bool:
    method read_response (line 175) | async def read_response(
  class MaintenanceNotificationsParser (line 181) | class MaintenanceNotificationsParser:
    method parse_oss_maintenance_start_msg (line 185) | def parse_oss_maintenance_start_msg(response):
    method parse_oss_maintenance_completed_msg (line 193) | def parse_oss_maintenance_completed_msg(response):
    method parse_maintenance_start_msg (line 219) | def parse_maintenance_start_msg(response, notification_type):
    method parse_maintenance_completed_msg (line 229) | def parse_maintenance_completed_msg(response, notification_type):
    method parse_moving_msg (line 238) | def parse_moving_msg(response):
  class PushNotificationsParser (line 303) | class PushNotificationsParser(Protocol):
    method handle_pubsub_push_response (line 312) | def handle_pubsub_push_response(self, response):
    method handle_push_response (line 316) | def handle_push_response(self, response, **kwargs):
    method set_pubsub_push_handler (line 379) | def set_pubsub_push_handler(self, pubsub_push_handler_func):
    method set_invalidation_push_handler (line 382) | def set_invalidation_push_handler(self, invalidation_push_handler_func):
    method set_node_moving_push_handler (line 385) | def set_node_moving_push_handler(self, node_moving_push_handler_func):
    method set_maintenance_push_handler (line 388) | def set_maintenance_push_handler(self, maintenance_push_handler_func):
    method set_oss_cluster_maint_push_handler (line 391) | def set_oss_cluster_maint_push_handler(self, oss_cluster_maint_push_ha...
  class AsyncPushNotificationsParser (line 395) | class AsyncPushNotificationsParser(Protocol):
    method handle_pubsub_push_response (line 404) | async def handle_pubsub_push_response(self, response):
    method handle_push_response (line 408) | async def handle_push_response(self, response, **kwargs):
    method set_pubsub_push_handler (line 471) | def set_pubsub_push_handler(self, pubsub_push_handler_func):
    method set_invalidation_push_handler (line 475) | def set_invalidation_push_handler(self, invalidation_push_handler_func):
    method set_node_moving_push_handler (line 479) | def set_node_moving_push_handler(self, node_moving_push_handler_func):
    method set_maintenance_push_handler (line 482) | def set_maintenance_push_handler(self, maintenance_push_handler_func):
    method set_oss_cluster_maint_push_handler (line 485) | def set_oss_cluster_maint_push_handler(self, oss_cluster_maint_push_ha...
  class _AsyncRESPBase (line 489) | class _AsyncRESPBase(AsyncBaseParser):
    method __init__ (line 494) | def __init__(self, socket_read_size: int):
    method _clear (line 501) | def _clear(self):
    method on_connect (line 505) | def on_connect(self, connection):
    method on_disconnect (line 514) | def on_disconnect(self):
    method can_read_destructive (line 518) | async def can_read_destructive(self) -> bool:
    method _read (line 529) | async def _read(self, length: int) -> bytes:
    method _readline (line 549) | async def _readline(self) -> bytes:

FILE: redis/_parsers/commands.py
  class RequestPolicy (line 11) | class RequestPolicy(Enum):
  class ResponsePolicy (line 22) | class ResponsePolicy(Enum):
  class CommandPolicies (line 35) | class CommandPolicies:
    method __init__ (line 36) | def __init__(
  class AbstractCommandsParser (line 48) | class AbstractCommandsParser:
    method _get_pubsub_keys (line 49) | def _get_pubsub_keys(self, *args):
    method parse_subcommand (line 78) | def parse_subcommand(self, command, **options):
  class CommandsParser (line 94) | class CommandsParser(AbstractCommandsParser):
    method __init__ (line 103) | def __init__(self, redis_connection):
    method initialize (line 108) | def initialize(self, r):
    method get_keys (line 121) | def get_keys(self, redis_conn, *args):
    method _get_moveable_keys (line 188) | def _get_moveable_keys(self, redis_conn, *args):
    method _is_keyless_command (line 213) | def _is_keyless_command(
    method get_command_policies (line 255) | def get_command_policies(self) -> PolicyRecords:
  class AsyncCommandsParser (line 398) | class AsyncCommandsParser(AbstractCommandsParser):
    method __init__ (line 416) | def __init__(self) -> None:
    method initialize (line 419) | async def initialize(self, node: Optional["ClusterNode"] = None) -> None:
    method get_keys (line 429) | async def get_keys(self, *args: Any) -> Optional[Tuple[str, ...]]:
    method _get_moveable_keys (line 496) | async def _get_moveable_keys(self, *args: Any) -> Optional[Tuple[str, ...
    method _is_keyless_command (line 510) | async def _is_keyless_command(
    method get_command_policies (line 552) | async def get_command_policies(self) -> Awaitable[PolicyRecords]:

FILE: redis/_parsers/encoders.py
  class Encoder (line 4) | class Encoder:
    method __init__ (line 9) | def __init__(self, encoding, encoding_errors, decode_responses):
    method encode (line 14) | def encode(self, value):
    method decode (line 37) | def decode(self, value, force=False):

FILE: redis/_parsers/helpers.py
  function timestamp_to_datetime (line 6) | def timestamp_to_datetime(response):
  function parse_debug_object (line 17) | def parse_debug_object(response):
  function parse_info (line 35) | def parse_info(response):
  function parse_memory_stats (line 86) | def parse_memory_stats(response, **kwargs):
  function parse_sentinel_state (line 124) | def parse_sentinel_state(item):
  function parse_sentinel_master (line 140) | def parse_sentinel_master(response, **options):
  function parse_sentinel_state_resp3 (line 144) | def parse_sentinel_state_resp3(response, **options):
  function parse_sentinel_masters (line 157) | def parse_sentinel_masters(response, **options):
  function parse_sentinel_masters_resp3 (line 165) | def parse_sentinel_masters_resp3(response, **options):
  function parse_sentinel_slaves_and_sentinels (line 169) | def parse_sentinel_slaves_and_sentinels(response, **options):
  function parse_sentinel_slaves_and_sentinels_resp3 (line 173) | def parse_sentinel_slaves_and_sentinels_resp3(response, **options):
  function parse_sentinel_get_master (line 177) | def parse_sentinel_get_master(response, **options):
  function pairs_to_dict (line 181) | def pairs_to_dict(response, decode_keys=False, decode_string_values=False):
  function pairs_to_dict_typed (line 200) | def pairs_to_dict_typed(response, type_info):
  function zset_score_pairs (line 215) | def zset_score_pairs(response, **options):
  function zset_score_for_rank (line 227) | def zset_score_for_rank(response, **options):
  function zset_score_pairs_resp3 (line 238) | def zset_score_pairs_resp3(response, **options):
  function zset_score_for_rank_resp3 (line 249) | def zset_score_for_rank_resp3(response, **options):
  function sort_return_tuples (line 260) | def sort_return_tuples(response, **options):
  function parse_stream_list (line 271) | def parse_stream_list(response, **options):
  function pairs_to_dict_with_str_keys (line 286) | def pairs_to_dict_with_str_keys(response):
  function parse_list_of_dicts (line 290) | def parse_list_of_dicts(response):
  function parse_xclaim (line 294) | def parse_xclaim(response, **options):
  function parse_xautoclaim (line 300) | def parse_xautoclaim(response, **options):
  function parse_xinfo_stream (line 307) | def parse_xinfo_stream(response, **options):
  function parse_xread (line 338) | def parse_xread(response, **options):
  function parse_xread_resp3 (line 344) | def parse_xread_resp3(response, **options):
  function parse_xpending (line 352) | def parse_xpending(response, **options):
  function parse_xpending_range (line 364) | def parse_xpending_range(response):
  function float_or_none (line 369) | def float_or_none(response):
  function bool_ok (line 375) | def bool_ok(response, **options):
  function parse_zadd (line 379) | def parse_zadd(response, **options):
  function parse_client_list (line 387) | def parse_client_list(response, **options):
  function parse_config_get (line 409) | def parse_config_get(response, **options):
  function parse_scan (line 414) | def parse_scan(response, **options):
  function parse_hscan (line 419) | def parse_hscan(response, **options):
  function parse_zscan (line 429) | def parse_zscan(response, **options):
  function parse_zmscore (line 436) | def parse_zmscore(response, **options):
  function parse_slowlog_get (line 441) | def parse_slowlog_get(response, **options):
  function parse_stralgo (line 470) | def parse_stralgo(response, **options):
  function parse_cluster_info (line 499) | def parse_cluster_info(response, **options):
  function _parse_node_line (line 504) | def _parse_node_line(line):
  function _parse_slots (line 527) | def _parse_slots(slot_ranges):
  function parse_cluster_nodes (line 547) | def parse_cluster_nodes(response, **options):
  function parse_geosearch_generic (line 557) | def parse_geosearch_generic(response, **options):
  function parse_command (line 593) | def parse_command(response, **options):
  function parse_command_resp3 (line 612) | def parse_command_resp3(response, **options):
  function parse_pubsub_numsub (line 633) | def parse_pubsub_numsub(response, **options):
  function parse_client_kill (line 637) | def parse_client_kill(response, **options):
  function parse_acl_getuser (line 643) | def parse_acl_getuser(response, **options):
  function parse_acl_log (line 686) | def parse_acl_log(response, **options):
  function parse_client_info (line 704) | def parse_client_info(value):
  function parse_set_result (line 736) | def parse_set_result(response, **options):
  function string_keys_to_dict (line 750) | def string_keys_to_dict(key_string, callback):

FILE: redis/_parsers/hiredis.py
  class _HiredisReaderArgs (line 34) | class _HiredisReaderArgs(TypedDict, total=False):
  class _HiredisParser (line 41) | class _HiredisParser(BaseParser, PushNotificationsParser):
    method __init__ (line 44) | def __init__(self, socket_read_size):
    method __del__ (line 56) | def __del__(self):
    method handle_pubsub_push_response (line 62) | def handle_pubsub_push_response(self, response):
    method on_connect (line 67) | def on_connect(self, connection, **kwargs):
    method on_disconnect (line 90) | def on_disconnect(self):
    method can_read (line 95) | def can_read(self, timeout):
    method read_from_socket (line 105) | def read_from_socket(self, timeout=SENTINEL, raise_on_timeout=True):
    method read_response (line 135) | def read_response(
  class _AsyncHiredisParser (line 200) | class _AsyncHiredisParser(AsyncBaseParser, AsyncPushNotificationsParser):
    method __init__ (line 205) | def __init__(self, socket_read_size: int):
    method handle_pubsub_push_response (line 214) | async def handle_pubsub_push_response(self, response):
    method on_connect (line 219) | def on_connect(self, connection):
    method on_disconnect (line 243) | def on_disconnect(self):
    method can_read_destructive (line 246) | async def can_read_destructive(self):
    method read_from_socket (line 257) | async def read_from_socket(self):
    method read_response (line 266) | async def read_response(

FILE: redis/_parsers/resp2.py
  class _RESP2Parser (line 9) | class _RESP2Parser(_RESPBase):
    method read_response (line 12) | def read_response(
    method _read_response (line 28) | def _read_response(
  class _AsyncRESP2Parser (line 77) | class _AsyncRESP2Parser(_AsyncRESPBase):
    method read_response (line 80) | async def read_response(self, disable_decoding: bool = False):
    method _read_response (line 93) | async def _read_response(

FILE: redis/_parsers/resp3.py
  class _RESP3Parser (line 15) | class _RESP3Parser(_RESPBase, PushNotificationsParser):
    method __init__ (line 18) | def __init__(self, socket_read_size):
    method handle_pubsub_push_response (line 26) | def handle_pubsub_push_response(self, response):
    method read_response (line 31) | def read_response(
    method _read_response (line 58) | def _read_response(
  class _AsyncRESP3Parser (line 165) | class _AsyncRESP3Parser(_AsyncRESPBase, AsyncPushNotificationsParser):
    method __init__ (line 166) | def __init__(self, socket_read_size):
    method handle_pubsub_push_response (line 171) | async def handle_pubsub_push_response(self, response):
    method read_response (line 176) | async def read_response(
    method _read_response (line 191) | async def _read_response(

FILE: redis/_parsers/socket.py
  class SocketBuffer (line 29) | class SocketBuffer:
    method __init__ (line 30) | def __init__(
    method unread_bytes (line 38) | def unread_bytes(self) -> int:
    method _read_from_socket (line 47) | def _read_from_socket(
    method can_read (line 94) | def can_read(self, timeout: float) -> bool:
    method read (line 99) | def read(self, length: int, timeout: Union[float, object] = SENTINEL) ...
    method readline (line 110) | def readline(self, timeout: Union[float, object] = SENTINEL) -> bytes:
    method get_pos (line 120) | def get_pos(self) -> int:
    method rewind (line 126) | def rewind(self, pos: int) -> None:
    method purge (line 132) | def purge(self) -> None:
    method close (line 151) | def close(self) -> None:

FILE: redis/asyncio/client.py
  class ResponseCallbackProtocol (line 107) | class ResponseCallbackProtocol(Protocol):
    method __call__ (line 108) | def __call__(self, response: Any, **kwargs): ...
  class AsyncResponseCallbackProtocol (line 111) | class AsyncResponseCallbackProtocol(Protocol):
    method __call__ (line 112) | async def __call__(self, response: Any, **kwargs): ...
  class Redis (line 118) | class Redis(
    method from_url (line 139) | def from_url(
    method from_pool (line 208) | def from_pool(
    method __init__ (line 233) | def __init__(
    method __repr__ (line 427) | def __repr__(self):
    method __await__ (line 433) | def __await__(self):
    method initialize (line 436) | async def initialize(self: _RedisT) -> _RedisT:
    method set_response_callback (line 449) | def set_response_callback(self, command: str, callback: ResponseCallba...
    method get_encoder (line 453) | def get_encoder(self):
    method get_connection_kwargs (line 457) | def get_connection_kwargs(self):
    method get_retry (line 461) | def get_retry(self) -> Optional[Retry]:
    method set_retry (line 464) | def set_retry(self, retry: Retry) -> None:
    method load_external_module (line 468) | def load_external_module(self, funcname, func):
    method pipeline (line 491) | def pipeline(
    method transaction (line 505) | async def transaction(
    method lock (line 534) | def lock(
    method pubsub (line 615) | def pubsub(self, **kwargs) -> "PubSub":
    method monitor (line 625) | def monitor(self) -> "Monitor":
    method client (line 628) | def client(self) -> "Redis":
    method __aenter__ (line 633) | async def __aenter__(self: _RedisT) -> _RedisT:
    method _increment_usage (line 648) | async def _increment_usage(self) -> int:
    method _decrement_usage (line 657) | async def _decrement_usage(self) -> int:
    method __aexit__ (line 666) | async def __aexit__(self, exc_type, exc_value, traceback):
    method __del__ (line 680) | def __del__(
    method aclose (line 694) | async def aclose(self, close_connection_pool: Optional[bool] = None) -...
    method close (line 715) | async def close(self, close_connection_pool: Optional[bool] = None) ->...
    method _send_command_parse_response (line 721) | async def _send_command_parse_response(self, conn, command_name, *args...
    method _close_connection (line 728) | async def _close_connection(
    method execute_command (line 763) | async def execute_command(self, *args, **options):
    method parse_response (line 818) | async def parse_response(
  class MonitorCommandInfo (line 850) | class MonitorCommandInfo(TypedDict):
  class Monitor (line 859) | class Monitor:
    method __init__ (line 869) | def __init__(self, connection_pool: ConnectionPool):
    method connect (line 873) | async def connect(self):
    method __aenter__ (line 877) | async def __aenter__(self):
    method __aexit__ (line 886) | async def __aexit__(self, *args):
    method next_command (line 890) | async def next_command(self) -> MonitorCommandInfo:
    method listen (line 926) | async def listen(self) -> AsyncIterator[MonitorCommandInfo]:
  class PubSub (line 932) | class PubSub:
    method __init__ (line 945) | def __init__(
    method __aenter__ (line 986) | async def __aenter__(self):
    method __aexit__ (line 989) | async def __aexit__(self, exc_type, exc_value, traceback):
    method __del__ (line 992) | def __del__(self):
    method aclose (line 996) | async def aclose(self):
    method close (line 1014) | async def close(self) -> None:
    method reset (line 1019) | async def reset(self) -> None:
    method on_connect (line 1023) | async def on_connect(self, connection: Connection):
    method subscribed (line 1062) | def subscribed(self):
    method execute_command (line 1066) | async def execute_command(self, *args: EncodableT):
    method connect (line 1078) | async def connect(self):
    method _reconnect (line 1098) | async def _reconnect(
    method _execute (line 1130) | async def _execute(self, conn, command, *args, **kwargs):
    method parse_response (line 1182) | async def parse_response(self, block: bool = True, timeout: float = 0):
    method check_health (line 1247) | async def check_health(self):
    method _normalize_keys (line 1263) | def _normalize_keys(self, data: _NormalizeKeysT) -> _NormalizeKeysT:
    method psubscribe (line 1273) | async def psubscribe(self, *args: ChannelT, **kwargs: PubSubHandler):
    method punsubscribe (line 1294) | def punsubscribe(self, *args: ChannelT) -> Awaitable:
    method subscribe (line 1309) | async def subscribe(self, *args: ChannelT, **kwargs: Callable):
    method unsubscribe (line 1330) | def unsubscribe(self, *args) -> Awaitable:
    method listen (line 1344) | async def listen(self) -> AsyncIterator:
    method get_message (line 1351) | async def get_message(
    method ping (line 1366) | def ping(self, message=None) -> Awaitable[bool]:
    method handle_message (line 1376) | async def handle_message(self, response, ignore_subscribe_messages=Fal...
    method run (line 1449) | async def run(
  class PubsubWorkerExceptionHandler (line 1500) | class PubsubWorkerExceptionHandler(Protocol):
    method __call__ (line 1501) | def __call__(self, e: BaseException, pubsub: PubSub): ...
  class AsyncPubsubWorkerExceptionHandler (line 1504) | class AsyncPubsubWorkerExceptionHandler(Protocol):
    method __call__ (line 1505) | async def __call__(self, e: BaseException, pubsub: PubSub): ...
  class Pipeline (line 1517) | class Pipeline(Redis):  # lgtm [py/init-calls-subclass]
    method __init__ (line 1539) | def __init__(
    method __aenter__ (line 1556) | async def __aenter__(self: _RedisT) -> _RedisT:
    method __aexit__ (line 1559) | async def __aexit__(self, exc_type, exc_value, traceback):
    method __await__ (line 1562) | def __await__(self):
    method __len__ (line 1567) | def __len__(self):
    method __bool__ (line 1570) | def __bool__(self):
    method _async_self (line 1574) | async def _async_self(self):
    method reset (line 1577) | async def reset(self):
    method aclose (line 1601) | async def aclose(self) -> None:
    method multi (line 1605) | def multi(self):
    method execute_command (line 1618) | def execute_command(
    method _disconnect_reset_raise_on_watching (line 1625) | async def _disconnect_reset_raise_on_watching(
    method immediate_execute_command (line 1667) | async def immediate_execute_command(self, *args, **options):
    method pipeline_execute_command (line 1723) | def pipeline_execute_command(self, *args, **options):
    method _execute_transaction (line 1738) | async def _execute_transaction(  # noqa: C901
    method _execute_pipeline (line 1816) | async def _execute_pipeline(
    method raise_first_error (line 1836) | def raise_first_error(self, commands: CommandStackT, response: Iterabl...
    method annotate_exception (line 1842) | def annotate_exception(
    method parse_response (line 1852) | async def parse_response(
    method load_scripts (line 1862) | async def load_scripts(self):
    method _disconnect_raise_on_watching (line 1875) | async def _disconnect_raise_on_watching(
    method execute (line 1915) | async def execute(self, raise_on_error: bool = True) -> List[Any]:
    method discard (line 1978) | async def discard(self):
    method watch (line 1984) | async def watch(self, *names: KeyT):
    method unwatch (line 1990) | async def unwatch(self):

FILE: redis/asyncio/cluster.py
  class RedisCluster (line 107) | class RedisCluster(AbstractRedis, AbstractRedisCluster, AsyncRedisCluste...
    method from_url (line 210) | def from_url(cls, url: str, **kwargs: Any) -> "RedisCluster":
    method __init__ (line 274) | def __init__(
    method initialize (line 486) | async def initialize(self) -> "RedisCluster":
    method aclose (line 505) | async def aclose(self) -> None:
    method close (line 517) | async def close(self) -> None:
    method __aenter__ (line 521) | async def __aenter__(self) -> "RedisCluster":
    method _increment_usage (line 536) | async def _increment_usage(self) -> int:
    method _decrement_usage (line 545) | async def _decrement_usage(self) -> int:
    method __aexit__ (line 554) | async def __aexit__(self, exc_type, exc_value, traceback):
    method __await__ (line 564) | def __await__(self) -> Generator[Any, None, "RedisCluster"]:
    method __del__ (line 569) | def __del__(
    method on_connect (line 582) | async def on_connect(self, connection: Connection) -> None:
    method get_nodes (line 594) | def get_nodes(self) -> List["ClusterNode"]:
    method get_primaries (line 598) | def get_primaries(self) -> List["ClusterNode"]:
    method get_replicas (line 602) | def get_replicas(self) -> List["ClusterNode"]:
    method get_random_node (line 606) | def get_random_node(self) -> "ClusterNode":
    method get_default_node (line 610) | def get_default_node(self) -> "ClusterNode":
    method set_default_node (line 614) | def set_default_node(self, node: "ClusterNode") -> None:
    method get_node (line 625) | def get_node(
    method get_node_from_key (line 634) | def get_node_from_key(
    method get_random_primary_or_all_nodes (line 662) | def get_random_primary_or_all_nodes(self, command_name):
    method get_random_primary_node (line 671) | def get_random_primary_node(self) -> "ClusterNode":
    method get_nodes_from_slot (line 677) | async def get_nodes_from_slot(self, command: str, *args):
    method get_special_nodes (line 690) | def get_special_nodes(self) -> Optional[list["ClusterNode"]]:
    method keyslot (line 701) | def keyslot(self, key: EncodableT) -> int:
    method get_encoder (line 709) | def get_encoder(self) -> Encoder:
    method get_connection_kwargs (line 713) | def get_connection_kwargs(self) -> Dict[str, Optional[Any]]:
    method set_retry (line 717) | def set_retry(self, retry: Retry) -> None:
    method set_response_callback (line 720) | def set_response_callback(self, command: str, callback: ResponseCallba...
    method _determine_nodes (line 724) | async def _determine_nodes(
    method _determine_slot (line 754) | async def _determine_slot(self, command: str, *args: Any) -> int:
    method _is_node_flag (line 805) | def _is_node_flag(self, target_nodes: Any) -> bool:
    method _parse_target_nodes (line 808) | def _parse_target_nodes(self, target_nodes: Any) -> List["ClusterNode"]:
    method _record_error_metric (line 828) | async def _record_error_metric(
    method _record_command_metric (line 849) | async def _record_command_metric(
    method execute_command (line 874) | async def execute_command(self, *args: EncodableT, **kwargs: Any) -> Any:
    method _execute_command (line 1017) | async def _execute_command(
    method pipeline (line 1203) | def pipeline(
    method lock (line 1218) | def lock(
    method transaction (line 1299) | async def transaction(
  class ClusterNode (line 1324) | class ClusterNode:
    method __init__ (line 1347) | def __init__(
    method __repr__ (line 1378) | def __repr__(self) -> str:
    method __eq__ (line 1384) | def __eq__(self, obj: Any) -> bool:
    method __hash__ (line 1387) | def __hash__(self) -> int:
    method __del__ (line 1392) | def __del__(
    method disconnect (line 1408) | async def disconnect(self) -> None:
    method acquire_connection (line 1420) | def acquire_connection(self) -> Connection:
    method disconnect_if_needed (line 1447) | async def disconnect_if_needed(self, connection: Connection) -> None:
    method release (line 1456) | def release(self, connection: Connection) -> None:
    method update_active_connections_for_reconnect (line 1464) | def update_active_connections_for_reconnect(self) -> None:
    method disconnect_free_connections (line 1475) | async def disconnect_free_connections(self) -> None:
    method parse_response (line 1489) | async def parse_response(
    method execute_command (line 1515) | async def execute_command(self, *args: Any, **kwargs: Any) -> Any:
    method execute_pipeline (line 1532) | async def execute_pipeline(self, commands: List["PipelineCommand"]) ->...
    method re_auth_callback (line 1560) | async def re_auth_callback(self, token: TokenInterface):
    method _mock (line 1579) | async def _mock(self, error: RedisError):
  class NodesManager (line 1588) | class NodesManager:
    method __init__ (line 1605) | def __init__(
    method get_node (line 1633) | def get_node(
    method set_nodes (line 1651) | def set_nodes(
    method move_node_to_end_of_cached_nodes (line 1691) | def move_node_to_end_of_cached_nodes(self, node_name: str) -> None:
    method move_slot (line 1708) | def move_slot(self, e: AskError | MovedError):
    method get_node_from_slot (line 1745) | def get_node_from_slot(
    method get_nodes_by_server_type (line 1769) | def get_nodes_by_server_type(self, server_type: str) -> List["ClusterN...
    method initialize (line 1776) | async def initialize(self) -> None:
    method aclose (line 1926) | async def aclose(self, attr: str = "nodes_cache") -> None:
    method remap_host_port (line 1935) | def remap_host_port(self, host: str, port: int) -> Tuple[str, int]:
  class ClusterPipeline (line 1946) | class ClusterPipeline(AbstractRedis, AbstractRedisCluster, AsyncRedisClu...
    method __init__ (line 1992) | def __init__(
    method nodes_manager (line 2004) | def nodes_manager(self) -> "NodesManager":
    method set_response_callback (line 2008) | def set_response_callback(self, command: str, callback: ResponseCallba...
    method initialize (line 2012) | async def initialize(self) -> "ClusterPipeline":
    method __aenter__ (line 2016) | async def __aenter__(self) -> "ClusterPipeline":
    method __aexit__ (line 2019) | async def __aexit__(self, exc_type: None, exc_value: None, traceback: ...
    method __await__ (line 2022) | def __await__(self) -> Generator[Any, None, "ClusterPipeline"]:
    method __bool__ (line 2025) | def __bool__(self) -> bool:
    method __len__ (line 2029) | def __len__(self) -> int:
    method execute_command (line 2032) | def execute_command(
    method execute (line 2048) | async def execute(
    method _split_command_across_slots (line 2073) | def _split_command_across_slots(
    method reset (line 2081) | async def reset(self):
    method multi (line 2087) | def multi(self):
    method discard (line 2094) | async def discard(self):
    method watch (line 2098) | async def watch(self, *names):
    method unwatch (line 2102) | async def unwatch(self):
    method unlink (line 2106) | async def unlink(self, *names):
    method mset_nonatomic (line 2109) | def mset_nonatomic(
  class PipelineCommand (line 2123) | class PipelineCommand:
    method __init__ (line 2124) | def __init__(self, position: int, *args: Any, **kwargs: Any) -> None:
    method __repr__ (line 2131) | def __repr__(self) -> str:
  class ExecutionStrategy (line 2135) | class ExecutionStrategy(ABC):
    method initialize (line 2137) | async def initialize(self) -> "ClusterPipeline":
    method execute_command (line 2146) | def execute_command(
    method execute (line 2157) | async def execute(
    method mset_nonatomic (line 2171) | def mset_nonatomic(
    method reset (line 2182) | async def reset(self):
    method multi (line 2191) | def multi(self):
    method watch (line 2200) | async def watch(self, *names):
    method unwatch (line 2209) | async def unwatch(self):
    method discard (line 2218) | async def discard(self):
    method unlink (line 2222) | async def unlink(self, *names):
    method __len__ (line 2231) | def __len__(self) -> int:
  class AbstractStrategy (line 2235) | class AbstractStrategy(ExecutionStrategy):
    method __init__ (line 2236) | def __init__(self, pipe: ClusterPipeline) -> None:
    method initialize (line 2240) | async def initialize(self) -> "ClusterPipeline":
    method execute_command (line 2246) | def execute_command(
    method _annotate_exception (line 2254) | def _annotate_exception(self, exception, number, command):
    method mset_nonatomic (line 2266) | def mset_nonatomic(
    method execute (line 2272) | async def execute(
    method reset (line 2278) | async def reset(self):
    method multi (line 2282) | def multi(self):
    method watch (line 2286) | async def watch(self, *names):
    method unwatch (line 2290) | async def unwatch(self):
    method discard (line 2294) | async def discard(self):
    method unlink (line 2298) | async def unlink(self, *names):
    method __len__ (line 2301) | def __len__(self) -> int:
  class PipelineStrategy (line 2305) | class PipelineStrategy(AbstractStrategy):
    method __init__ (line 2306) | def __init__(self, pipe: ClusterPipeline) -> None:
    method mset_nonatomic (line 2309) | def mset_nonatomic(
    method execute (line 2324) | async def execute(
    method _execute (line 2356) | async def _execute(
    method reset (line 2497) | async def reset(self):
    method multi (line 2503) | def multi(self):
    method watch (line 2508) | async def watch(self, *names):
    method unwatch (line 2513) | async def unwatch(self):
    method discard (line 2518) | async def discard(self):
    method unlink (line 2523) | async def unlink(self, *names):
  class TransactionStrategy (line 2532) | class TransactionStrategy(AbstractStrategy):
    method __init__ (line 2544) | def __init__(self, pipe: ClusterPipeline) -> None:
    method _get_client_and_connection_for_transaction (line 2557) | def _get_client_and_connection_for_transaction(
    method execute_command (line 2584) | def execute_command(self, *args: Union[KeyT, EncodableT], **kwargs: An...
    method _execute_command (line 2606) | async def _execute_command(
    method _validate_watch (line 2642) | def _validate_watch(self):
    method _immediate_execute_command (line 2648) | async def _immediate_execute_command(self, *args, **options):
    method _get_connection_and_send_command (line 2655) | async def _get_connection_and_send_command(self, *args, **options):
    method _send_command_parse_response (line 2690) | async def _send_command_parse_response(
    method _reinitialize_on_error (line 2709) | async def _reinitialize_on_error(self, error, failure_count):
    method _raise_first_error (line 2750) | async def _raise_first_error(self, responses, stack, start_time):
    method mset_nonatomic (line 2769) | def mset_nonatomic(
    method execute (line 2774) | async def execute(
    method _execute_transaction_with_retries (line 2783) | async def _execute_transaction_with_retries(
    method _execute_transaction (line 2794) | async def _execute_transaction(
    method reset (line 2913) | async def reset(self):
    method multi (line 2943) | def multi(self):
    method watch (line 2952) | async def watch(self, *names):
    method unwatch (line 2958) | async def unwatch(self):
    method discard (line 2964) | async def discard(self):
    method unlink (line 2967) | async def unlink(self, *names):

FILE: redis/asyncio/connection.py
  class _Sentinel (line 100) | class _Sentinel(enum.Enum):
  class ConnectCallbackProtocol (line 114) | class ConnectCallbackProtocol(Protocol):
    method __call__ (line 115) | def __call__(self, connection: "AbstractConnection"): ...
  class AsyncConnectCallbackProtocol (line 118) | class AsyncConnectCallbackProtocol(Protocol):
    method __call__ (line 119) | async def __call__(self, connection: "AbstractConnection"): ...
  class AbstractConnection (line 125) | class AbstractConnection:
    method __init__ (line 162) | def __init__(
    method __del__ (line 269) | def __del__(self, _warnings: Any = warnings):
    method _close (line 285) | def _close(self):
    method __repr__ (line 293) | def __repr__(self):
    method repr_pieces (line 298) | def repr_pieces(self):
    method is_connected (line 302) | def is_connected(self):
    method register_connect_callback (line 305) | def register_connect_callback(self, callback):
    method deregister_connect_callback (line 317) | def deregister_connect_callback(self, callback):
    method set_parser (line 328) | def set_parser(self, parser_class: Type[BaseParser]) -> None:
    method connect (line 336) | async def connect(self):
    method connect_check_health (line 350) | async def connect_check_health(
    method mark_for_reconnect (line 427) | def mark_for_reconnect(self):
    method should_reconnect (line 430) | def should_reconnect(self):
    method reset_should_reconnect (line 433) | def reset_should_reconnect(self):
    method _connect (line 437) | async def _connect(self):
    method _host_error (line 441) | def _host_error(self) -> str:
    method _error_message (line 444) | def _error_message(self, exception: BaseException) -> str:
    method get_protocol (line 447) | def get_protocol(self):
    method on_connect (line 450) | async def on_connect(self) -> None:
    method on_connect_check_health (line 454) | async def on_connect_check_health(self, check_health: bool = True) -> ...
    method disconnect (line 569) | async def disconnect(
    method _send_ping (line 625) | async def _send_ping(self):
    method _ping_failed (line 631) | async def _ping_failed(self, error, failure_count):
    method check_health (line 637) | async def check_health(self):
    method _send_packed_command (line 647) | async def _send_packed_command(self, command: Iterable[bytes]) -> None:
    method send_packed_command (line 651) | async def send_packed_command(
    method send_command (line 692) | async def send_command(self, *args: Any, **kwargs: Any) -> None:
    method can_read_destructive (line 698) | async def can_read_destructive(self):
    method read_response (line 707) | async def read_response(
    method pack_command (line 765) | def pack_command(self, *args: EncodableT) -> List[bytes]:
    method pack_commands (line 811) | def pack_commands(self, commands: Iterable[Iterable[EncodableT]]) -> L...
    method _socket_is_empty (line 841) | def _socket_is_empty(self):
    method process_invalidation_messages (line 845) | async def process_invalidation_messages(self):
    method set_re_auth_token (line 849) | def set_re_auth_token(self, token: TokenInterface):
    method re_auth (line 852) | async def re_auth(self):
  class Connection (line 863) | class Connection(AbstractConnection):
    method __init__ (line 866) | def __init__(
    method repr_pieces (line 883) | def repr_pieces(self):
    method _connection_arguments (line 889) | def _connection_arguments(self) -> Mapping:
    method _connect (line 892) | async def _connect(self):
    method _host_error (line 916) | def _host_error(self) -> str:
  class SSLConnection (line 920) | class SSLConnection(Connection):
    method __init__ (line 926) | def __init__(
    method _connection_arguments (line 961) | def _connection_arguments(self) -> Mapping:
    method keyfile (line 967) | def keyfile(self):
    method certfile (line 971) | def certfile(self):
    method cert_reqs (line 975) | def cert_reqs(self):
    method include_verify_flags (line 979) | def include_verify_flags(self):
    method exclude_verify_flags (line 983) | def exclude_verify_flags(self):
    method ca_certs (line 987) | def ca_certs(self):
    method ca_data (line 991) | def ca_data(self):
    method check_hostname (line 995) | def check_hostname(self):
    method min_version (line 999) | def min_version(self):
  class RedisSSLContext (line 1003) | class RedisSSLContext:
    method __init__ (line 1020) | def __init__(
    method get (line 1067) | def get(self) -> SSLContext:
  class UnixDomainSocketConnection (line 1096) | class UnixDomainSocketConnection(AbstractConnection):
    method __init__ (line 1099) | def __init__(self, *, path: str = "", **kwargs):
    method repr_pieces (line 1103) | def repr_pieces(self) -> Iterable[Tuple[str, Union[str, int]]]:
    method _connect (line 1109) | async def _connect(self):
    method _host_error (line 1116) | def _host_error(self) -> str:
  function to_bool (line 1123) | def to_bool(value) -> Optional[bool]:
  function parse_ssl_verify_flags (line 1131) | def parse_ssl_verify_flags(value):
  class ConnectKwargs (line 1162) | class ConnectKwargs(TypedDict, total=False):
  function parse_url (line 1172) | def parse_url(url: str) -> ConnectKwargs:
  class ConnectionPool (line 1228) | class ConnectionPool:
    method from_url (line 1244) | def from_url(cls: Type[_CP], url: str, **kwargs) -> _CP:
    method __init__ (line 1290) | def __init__(
    method __repr__ (line 1322) | def __repr__(self):
    method reset (line 1335) | def reset(self):
    method __del__ (line 1366) | def __del__(self) -> None:
    method can_get_connection (line 1397) | def can_get_connection(self) -> bool:
    method get_connection (line 1409) | async def get_connection(self, command_name=None, *keys, **options):
    method get_available_connection (line 1461) | def get_available_connection(self):
    method get_encoder (line 1472) | def get_encoder(self):
    method make_connection (line 1481) | def make_connection(self):
    method ensure_connection (line 1487) | async def ensure_connection(self, connection: AbstractConnection):
    method release (line 1503) | async def release(self, connection: AbstractConnection):
    method disconnect (line 1530) | async def disconnect(self, inuse_connections: bool = True):
    method update_active_connections_for_reconnect (line 1553) | async def update_active_connections_for_reconnect(self):
    method aclose (line 1561) | async def aclose(self) -> None:
    method set_retry (line 1565) | def set_retry(self, retry: "Retry") -> None:
    method re_auth_callback (line 1571) | async def re_auth_callback(self, token: TokenInterface):
    method _mock (line 1586) | async def _mock(self, error: RedisError):
    method get_connection_count (line 1594) | def get_connection_count(self) -> List[tuple[int, dict]]:
  class BlockingConnectionPool (line 1616) | class BlockingConnectionPool(ConnectionPool):
    method __init__ (line 1650) | def __init__(
    method get_connection (line 1671) | async def get_connection(self, command_name=None, *keys, **options):
    method release (line 1713) | async def release(self, connection: AbstractConnection):

FILE: redis/asyncio/http/http_client.py
  class AsyncHTTPClient (line 13) | class AsyncHTTPClient(ABC):
    method get (line 15) | async def get(
    method delete (line 30) | async def delete(
    method post (line 45) | async def post(
    method put (line 62) | async def put(
    method patch (line 79) | async def patch(
    method request (line 96) | async def request(
  class AsyncHTTPClientWrapper (line 112) | class AsyncHTTPClientWrapper(AsyncHTTPClient):
    method __init__ (line 117) | def __init__(self, client: HttpClient, max_workers: int = 10) -> None:
    method get (line 133) | async def get(
    method delete (line 148) | async def delete(
    method post (line 169) | async def post(
    method put (line 194) | async def put(
    method patch (line 219) | async def patch(
    method request (line 244) | async def request(

FILE: redis/asyncio/lock.py
  class Lock (line 17) | class Lock:
    method __init__ (line 82) | def __init__(
    method register_scripts (line 160) | def register_scripts(self):
    method __aenter__ (line 170) | async def __aenter__(self):
    method __aexit__ (line 175) | async def __aexit__(self, exc_type, exc_value, traceback):
    method acquire (line 185) | async def acquire(
    method do_acquire (line 234) | async def do_acquire(self, token: Union[str, bytes]) -> bool:
    method locked (line 244) | async def locked(self) -> bool:
    method owned (line 250) | async def owned(self) -> bool:
    method release (line 266) | async def release(self) -> None:
    method do_release (line 288) | async def do_release(self, expected_token: bytes) -> None:
    method extend (line 296) | def extend(
    method do_extend (line 315) | async def do_extend(self, additional_time, replace_ttl) -> bool:
    method reacquire (line 327) | def reacquire(self) -> Awaitable[bool]:
    method do_reacquire (line 337) | async def do_reacquire(self) -> bool:

FILE: redis/asyncio/multidb/client.py
  class MultiDBClient (line 35) | class MultiDBClient(AsyncRedisModuleCommands, AsyncCoreCommands):
    method __init__ (line 41) | def __init__(self, config: MultiDbConfig):
    method __aenter__ (line 86) | async def __aenter__(self: "MultiDBClient") -> "MultiDBClient":
    method aclose (line 91) | async def aclose(self):
    method __aexit__ (line 107) | async def __aexit__(self, exc_type, exc_value, traceback):
    method initialize (line 110) | async def initialize(self):
    method get_databases (line 146) | def get_databases(self) -> Databases:
    method set_active_database (line 152) | async def set_active_database(self, database: AsyncDatabase) -> None:
    method add_database (line 179) | async def add_database(
    method _change_active_database (line 228) | async def _change_active_database(
    method remove_database (line 239) | async def remove_database(self, database: AsyncDatabase):
    method update_database_weight (line 254) | async def update_database_weight(self, database: AsyncDatabase, weight...
    method add_failure_detector (line 273) | def add_failure_detector(self, failure_detector: AsyncFailureDetector):
    method add_health_check (line 279) | async def add_health_check(self, healthcheck: HealthCheck):
    method execute_command (line 286) | async def execute_command(self, *args, **options):
    method pipeline (line 295) | def pipeline(self):
    method transaction (line 301) | async def transaction(
    method pubsub (line 323) | async def pubsub(self, **kwargs):
    method _check_databases_health (line 334) | async def _check_databases_health(self) -> dict[Database, bool]:
    method _perform_initial_health_check (line 368) | async def _perform_initial_health_check(self):
    method _check_db_health (line 392) | async def _check_db_health(self, database: AsyncDatabase) -> bool:
    method _on_circuit_state_change_callback (line 410) | def _on_circuit_state_change_callback(
  function _half_open_circuit (line 431) | def _half_open_circuit(circuit: CircuitBreaker):
  class Pipeline (line 435) | class Pipeline(AsyncRedisModuleCommands, AsyncCoreCommands):
    method __init__ (line 442) | def __init__(self, client: MultiDBClient):
    method __aenter__ (line 446) | async def __aenter__(self: "Pipeline") -> "Pipeline":
    method __aexit__ (line 449) | async def __aexit__(self, exc_type, exc_value, traceback):
    method __await__ (line 453) | def __await__(self):
    method _async_self (line 456) | async def _async_self(self):
    method __len__ (line 459) | def __len__(self) -> int:
    method __bool__ (line 462) | def __bool__(self) -> bool:
    method reset (line 466) | async def reset(self) -> None:
    method aclose (line 469) | async def aclose(self) -> None:
    method pipeline_execute_command (line 473) | def pipeline_execute_command(self, *args, **options) -> "Pipeline":
    method execute_command (line 488) | def execute_command(self, *args, **kwargs):
    method execute (line 492) | async def execute(self) -> List[Any]:
  class PubSub (line 505) | class PubSub:
    method __init__ (line 510) | def __init__(self, client: MultiDBClient, **kwargs):
    method __aenter__ (line 521) | async def __aenter__(self) -> "PubSub":
    method __aexit__ (line 524) | async def __aexit__(self, exc_type, exc_value, traceback) -> None:
    method aclose (line 527) | async def aclose(self):
    method subscribed (line 531) | def subscribed(self) -> bool:
    method execute_command (line 534) | async def execute_command(self, *args: EncodableT):
    method psubscribe (line 539) | async def psubscribe(self, *args: ChannelT, **kwargs: PubSubHandler):
    method punsubscribe (line 551) | async def punsubscribe(self, *args: ChannelT):
    method subscribe (line 560) | async def subscribe(self, *args: ChannelT, **kwargs: Callable):
    method unsubscribe (line 572) | async def unsubscribe(self, *args):
    method get_message (line 581) | async def get_message(
    method run (line 597) | async def run(

FILE: redis/asyncio/multidb/command_executor.py
  class AsyncCommandExecutor (line 33) | class AsyncCommandExecutor(CommandExecutor):
    method databases (line 36) | def databases(self) -> Databases:
    method failure_detectors (line 42) | def failure_detectors(self) -> List[AsyncFailureDetector]:
    method add_failure_detector (line 47) | def add_failure_detector(self, failure_detector: AsyncFailureDetector)...
    method active_database (line 53) | def active_database(self) -> Optional[AsyncDatabase]:
    method set_active_database (line 58) | async def set_active_database(
    method active_pubsub (line 71) | def active_pubsub(self) -> Optional[PubSub]:
    method active_pubsub (line 77) | def active_pubsub(self, pubsub: PubSub) -> None:
    method failover_strategy_executor (line 83) | def failover_strategy_executor(self) -> FailoverStrategyExecutor:
    method command_retry (line 89) | def command_retry(self) -> Retry:
    method pubsub (line 94) | async def pubsub(self, **kwargs):
    method execute_command (line 99) | async def execute_command(self, *args, **options):
    method execute_pipeline (line 104) | async def execute_pipeline(self, command_stack: tuple):
    method execute_transaction (line 109) | async def execute_transaction(
    method execute_pubsub_method (line 116) | async def execute_pubsub_method(self, method_name: str, *args, **kwargs):
    method execute_pubsub_run (line 121) | async def execute_pubsub_run(self, sleep_time: float, **kwargs) -> Any:
  class DefaultCommandExecutor (line 126) | class DefaultCommandExecutor(BaseCommandExecutor, AsyncCommandExecutor):
    method __init__ (line 127) | def __init__(
    method databases (line 170) | def databases(self) -> Databases:
    method failure_detectors (line 174) | def failure_detectors(self) -> List[AsyncFailureDetector]:
    method add_failure_detector (line 177) | def add_failure_detector(self, failure_detector: AsyncFailureDetector)...
    method active_database (line 181) | def active_database(self) -> Optional[AsyncDatabase]:
    method set_active_database (line 184) | async def set_active_database(
    method active_pubsub (line 206) | def active_pubsub(self) -> Optional[PubSub]:
    method active_pubsub (line 210) | def active_pubsub(self, pubsub: PubSub) -> None:
    method failover_strategy_executor (line 214) | def failover_strategy_executor(self) -> FailoverStrategyExecutor:
    method command_retry (line 218) | def command_retry(self) -> Retry:
    method pubsub (line 221) | def pubsub(self, **kwargs):
    method execute_command (line 229) | async def execute_command(self, *args, **options):
    method execute_pipeline (line 239) | async def execute_pipeline(self, command_stack: tuple):
    method execute_transaction (line 251) | async def execute_transaction(
    method execute_pubsub_method (line 272) | async def execute_pubsub_method(self, method_name: str, *args, **kwargs):
    method execute_pubsub_run (line 285) | async def execute_pubsub_run(
    method _execute_with_failure_detection (line 297) | async def _execute_with_failure_detection(
    method _check_active_database (line 314) | async def _check_active_database(self):
    method _on_command_fail (line 332) | async def _on_command_fail(self, error, *args):
    method _register_command_execution (line 337) | async def _register_command_execution(self, cmd: tuple):
    method _setup_event_dispatcher (line 341) | def _setup_event_dispatcher(self):

FILE: redis/asyncio/multidb/config.py
  class InitialHealthCheck (line 48) | class InitialHealthCheck(Enum):
  function default_event_dispatcher (line 54) | def default_event_dispatcher() -> EventDispatcherInterface:
  class DatabaseConfig (line 59) | class DatabaseConfig:
    method default_circuit_breaker (line 92) | def default_circuit_breaker(self) -> CircuitBreaker:
  class MultiDbConfig (line 98) | class MultiDbConfig:
    method databases (line 166) | def databases(self) -> Databases:
    method default_failure_detectors (line 207) | def default_failure_detectors(self) -> List[AsyncFailureDetector]:
    method default_health_checks (line 218) | def default_health_checks(self) -> List[HealthCheck]:
    method default_failover_strategy (line 227) | def default_failover_strategy(self) -> AsyncFailoverStrategy:

FILE: redis/asyncio/multidb/database.py
  class AsyncDatabase (line 11) | class AsyncDatabase(AbstractDatabase):
    method client (line 16) | def client(self) -> Union[Redis, RedisCluster]:
    method client (line 22) | def client(self, client: Union[Redis, RedisCluster]):
    method circuit (line 28) | def circuit(self) -> CircuitBreaker:
    method circuit (line 34) | def circuit(self, circuit: CircuitBreaker):
  class Database (line 42) | class Database(BaseDatabase, AsyncDatabase):
    method __init__ (line 43) | def __init__(
    method client (line 56) | def client(self) -> Union[Redis, RedisCluster]:
    method client (line 60) | def client(self, client: Union[Redis, RedisCluster]):
    method circuit (line 64) | def circuit(self) -> CircuitBreaker:
    method circuit (line 68) | def circuit(self, circuit: CircuitBreaker):
    method __repr__ (line 71) | def __repr__(self):

FILE: redis/asyncio/multidb/event.py
  class AsyncActiveDatabaseChanged (line 9) | class AsyncActiveDatabaseChanged:
    method __init__ (line 14) | def __init__(
    method old_database (line 27) | def old_database(self) -> AsyncDatabase:
    method new_database (line 31) | def new_database(self) -> AsyncDatabase:
    method command_executor (line 35) | def command_executor(self):
    method kwargs (line 39) | def kwargs(self):
  class ResubscribeOnActiveDatabaseChanged (line 43) | class ResubscribeOnActiveDatabaseChanged(AsyncEventListenerInterface):
    method listen (line 48) | async def listen(self, event: AsyncActiveDatabaseChanged):
  class CloseConnectionOnActiveDatabaseChanged (line 61) | class CloseConnectionOnActiveDatabaseChanged(AsyncEventListenerInterface):
    method listen (line 66) | async def listen(self, event: AsyncActiveDatabaseChanged):
  class RegisterCommandFailure (line 74) | class RegisterCommandFailure(AsyncEventListenerInterface):
    method __init__ (line 79) | def __init__(self, failure_detectors: List[AsyncFailureDetector]):
    method listen (line 82) | async def listen(self, event: AsyncOnCommandsFailEvent) -> None:

FILE: redis/asyncio/multidb/failover.py
  class AsyncFailoverStrategy (line 16) | class AsyncFailoverStrategy(ABC):
    method database (line 18) | async def database(self) -> AsyncDatabase:
    method set_databases (line 23) | def set_databases(self, databases: Databases) -> None:
  class FailoverStrategyExecutor (line 28) | class FailoverStrategyExecutor(ABC):
    method failover_attempts (line 31) | def failover_attempts(self) -> int:
    method failover_delay (line 37) | def failover_delay(self) -> float:
    method strategy (line 43) | def strategy(self) -> AsyncFailoverStrategy:
    method execute (line 48) | async def execute(self) -> AsyncDatabase:
  class WeightBasedFailoverStrategy (line 53) | class WeightBasedFailoverStrategy(AsyncFailoverStrategy):
    method __init__ (line 58) | def __init__(self):
    method database (line 61) | async def database(self) -> AsyncDatabase:
    method set_databases (line 68) | def set_databases(self, databases: Databases) -> None:
  class DefaultFailoverStrategyExecutor (line 72) | class DefaultFailoverStrategyExecutor(FailoverStrategyExecutor):
    method __init__ (line 77) | def __init__(
    method failover_attempts (line 90) | def failover_attempts(self) -> int:
    method failover_delay (line 94) | def failover_delay(self) -> float:
    method strategy (line 98) | def strategy(self) -> AsyncFailoverStrategy:
    method execute (line 101) | async def execute(self) -> AsyncDatabase:
    method _reset (line 123) | def _reset(self) -> None:

FILE: redis/asyncio/multidb/failure_detector.py
  class AsyncFailureDetector (line 6) | class AsyncFailureDetector(ABC):
    method register_failure (line 8) | async def register_failure(self, exception: Exception, cmd: tuple) -> ...
    method register_command_execution (line 13) | async def register_command_execution(self, cmd: tuple) -> None:
    method set_command_executor (line 18) | def set_command_executor(self, command_executor) -> None:
  class FailureDetectorAsyncWrapper (line 23) | class FailureDetectorAsyncWrapper(AsyncFailureDetector):
    method __init__ (line 28) | def __init__(self, failure_detector: FailureDetector) -> None:
    method register_failure (line 31) | async def register_failure(self, exception: Exception, cmd: tuple) -> ...
    method register_command_execution (line 34) | async def register_command_execution(self, cmd: tuple) -> None:
    method set_command_executor (line 37) | def set_command_executor(self, command_executor) -> None:

FILE: redis/asyncio/multidb/healthcheck.py
  function _get_init_params (line 22) | def _get_init_params(cls: Type) -> frozenset:
  function _filter_kwargs (line 37) | def _filter_kwargs(kwargs: dict, cls: Type) -> dict:
  class HealthCheck (line 52) | class HealthCheck(ABC):
    method health_check_probes (line 59) | def health_check_probes(self) -> int:
    method health_check_delay (line 65) | def health_check_delay(self) -> float:
    method health_check_timeout (line 71) | def health_check_timeout(self) -> float:
    method check_health (line 76) | async def check_health(self, database, hc_client: AsyncRedisClientT) -...
  class HealthCheckPolicy (line 91) | class HealthCheckPolicy(ABC):
    method execute (line 97) | async def execute(self, health_checks: List[HealthCheck], database) ->...
    method _execute (line 102) | async def _execute(self, health_check: HealthCheck, database) -> bool:
    method get_client (line 109) | async def get_client(self, database) -> AsyncRedisClientT:
    method close (line 116) | async def close(self) -> None:
  class AbstractHealthCheckPolicy (line 121) | class AbstractHealthCheckPolicy(HealthCheckPolicy):
    method __init__ (line 126) | def __init__(self):
    method execute (line 130) | async def execute(self, health_checks: List[HealthCheck], database) ->...
    method get_client (line 163) | async def get_client(self, database) -> AsyncRedisClientT:
    method close (line 208) | async def close(self) -> None:
    method _execute (line 220) | async def _execute(self, health_check: HealthCheck, database) -> bool:
  class HealthyAllPolicy (line 227) | class HealthyAllPolicy(AbstractHealthCheckPolicy):
    method _execute (line 232) | async def _execute(self, health_check: HealthCheck, database) -> bool:
  class HealthyMajorityPolicy (line 252) | class HealthyMajorityPolicy(AbstractHealthCheckPolicy):
    method _execute (line 262) | async def _execute(self, health_check: HealthCheck, database) -> bool:
  class HealthyAnyPolicy (line 296) | class HealthyAnyPolicy(AbstractHealthCheckPolicy):
    method _execute (line 301) | async def _execute(self, health_check: HealthCheck, database) -> bool:
  class HealthCheckPolicies (line 330) | class HealthCheckPolicies(Enum):
  class AbstractHealthCheck (line 339) | class AbstractHealthCheck(HealthCheck):
    method __init__ (line 340) | def __init__(
    method health_check_probes (line 353) | def health_check_probes(self) -> int:
    method health_check_delay (line 357) | def health_check_delay(self) -> float:
    method health_check_timeout (line 361) | def health_check_timeout(self) -> float:
    method check_health (line 365) | async def check_health(self, database, hc_client: AsyncRedisClientT) -...
  class PingHealthCheck (line 369) | class PingHealthCheck(AbstractHealthCheck):
    method check_health (line 374) | async def check_health(self, database, hc_client: AsyncRedisClientT) -...
  class LagAwareHealthCheck (line 387) | class LagAwareHealthCheck(AbstractHealthCheck):
    method __init__ (line 393) | def __init__(
    method check_health (line 451) | async def check_health(self, database, hc_client: AsyncRedisClientT) -...

FILE: redis/asyncio/observability/recorder.py
  function _get_or_create_collector (line 47) | def _get_or_create_collector() -> Optional[RedisMetricsCollector]:
  function _get_config (line 80) | async def _get_config() -> Optional["OTelConfig"]:
  function record_operation_duration (line 96) | async def record_operation_duration(
  function record_connection_create_time (line 148) | async def record_connection_create_time(
  function record_connection_count (line 172) | async def record_connection_count(
  function init_connection_count (line 204) | async def init_connection_count() -> None:
  function register_pools_connection_count (line 235) | async def register_pools_connection_count(
  function record_connection_timeout (line 264) | async def record_connection_timeout(
  function record_connection_wait_time (line 285) | async def record_connection_wait_time(
  function record_connection_closed (line 309) | async def record_connection_closed(
  function record_connection_relaxed_timeout (line 333) | async def record_connection_relaxed_timeout(
  function record_connection_handoff (line 360) | async def record_connection_handoff(
  function record_error_count (line 381) | async def record_error_count(
  function record_pubsub_message (line 420) | async def record_pubsub_message(
  function record_streaming_lag (line 457) | async def record_streaming_lag(
  function record_streaming_lag_from_response (line 491) | async def record_streaming_lag_from_response(
  function record_maint_notification_count (line 559) | async def record_maint_notification_count(
  function record_geo_failover (line 592) | async def record_geo_failover(
  function reset_collector (line 619) | def reset_collector() -> None:
  function is_enabled (line 627) | async def is_enabled() -> bool:

FILE: redis/asyncio/retry.py
  class Retry (line 23) | class Retry(AbstractRetry[RedisError]):
    method __init__ (line 26) | def __init__(
    method __eq__ (line 37) | def __eq__(self, other: Any) -> bool:
    method call_with_retry (line 47) | async def call_with_retry(

FILE: redis/asyncio/sentinel.py
  class MasterNotFoundError (line 22) | class MasterNotFoundError(ConnectionError):
  class SlaveNotFoundError (line 26) | class SlaveNotFoundError(ConnectionError):
  class SentinelManagedConnection (line 30) | class SentinelManagedConnection(Connection):
    method __init__ (line 31) | def __init__(self, **kwargs):
    method __repr__ (line 35) | def __repr__(self):
    method connect_to (line 42) | async def connect_to(self, address):
    method _connect_retry (line 49) | async def _connect_retry(self):
    method connect (line 62) | async def connect(self):
    method read_response (line 68) | async def read_response(
  class SentinelManagedSSLConnection (line 95) | class SentinelManagedSSLConnection(SentinelManagedConnection, SSLConnect...
  class SentinelConnectionPool (line 99) | class SentinelConnectionPool(ConnectionPool):
    method __init__ (line 107) | def __init__(self, service_name, sentinel_manager, **kwargs):
    method __repr__ (line 125) | def __repr__(self):
    method reset (line 131) | def reset(self):
    method owns_connection (line 136) | def owns_connection(self, connection: Connection):
    method get_master_address (line 142) | async def get_master_address(self):
    method rotate_slaves (line 152) | async def rotate_slaves(self) -> AsyncIterator:
  class Sentinel (line 170) | class Sentinel(AsyncSentinelCommands):
    method __init__ (line 199) | def __init__(
    method execute_command (line 223) | async def execute_command(self, *args, **kwargs):
    method __repr__ (line 255) | def __repr__(self):
    method check_master_state (line 267) | def check_master_state(self, state: dict, service_name: str) -> bool:
    method discover_master (line 275) | async def discover_master(self, service_name: str):
    method filter_slaves (line 310) | def filter_slaves(
    method discover_slaves (line 321) | async def discover_slaves(
    method master_for (line 335) | def master_for(
    method slave_for (line 374) | def slave_for(

FILE: redis/asyncio/utils.py
  function from_url (line 7) | def from_url(url: str, **kwargs: Any) -> "Redis":
  class pipeline (line 19) | class pipeline:  # noqa: N801
    method __init__ (line 20) | def __init__(self, redis_obj: "Redis"):
    method __aenter__ (line 23) | async def __aenter__(self) -> "Pipeline":
    method __aexit__ (line 26) | async def __aexit__(self, exc_type, exc_value, traceback):

FILE: redis/auth/err.py
  class RequestTokenErr (line 4) | class RequestTokenErr(Exception):
    method __init__ (line 9) | def __init__(self, *args):
  class InvalidTokenSchemaErr (line 13) | class InvalidTokenSchemaErr(Exception):
    method __init__ (line 18) | def __init__(self, missing_fields: Iterable[str] = []):
  class TokenRenewalErr (line 25) | class TokenRenewalErr(Exception):
    method __init__ (line 30) | def __init__(self, *args):

FILE: redis/auth/idp.py
  class IdentityProviderInterface (line 10) | class IdentityProviderInterface(ABC):
    method request_token (line 17) | def request_token(self, force_refresh=False) -> TokenInterface:
  class IdentityProviderConfigInterface (line 21) | class IdentityProviderConfigInterface(ABC):
    method get_provider (line 27) | def get_provider(self) -> IdentityProviderInterface:

FILE: redis/auth/token.py
  class TokenInterface (line 7) | class TokenInterface(ABC):
    method is_expired (line 9) | def is_expired(self) -> bool:
    method ttl (line 13) | def ttl(self) -> float:
    method try_get (line 17) | def try_get(self, key: str) -> str:
    method get_value (line 21) | def get_value(self) -> str:
    method get_expires_at_ms (line 25) | def get_expires_at_ms(self) -> float:
    method get_received_at_ms (line 29) | def get_received_at_ms(self) -> float:
  class TokenResponse (line 33) | class TokenResponse:
    method __init__ (line 34) | def __init__(self, token: TokenInterface):
    method get_token (line 37) | def get_token(self) -> TokenInterface:
    method get_ttl_ms (line 40) | def get_ttl_ms(self) -> float:
  class SimpleToken (line 44) | class SimpleToken(TokenInterface):
    method __init__ (line 45) | def __init__(
    method ttl (line 53) | def ttl(self) -> float:
    method is_expired (line 59) | def is_expired(self) -> bool:
    method try_get (line 65) | def try_get(self, key: str) -> str:
    method get_value (line 68) | def get_value(self) -> str:
    method get_expires_at_ms (line 71) | def get_expires_at_ms(self) -> float:
    method get_received_at_ms (line 74) | def get_received_at_ms(self) -> float:
  class JWToken (line 78) | class JWToken(TokenInterface):
    method __init__ (line 81) | def __init__(self, token: str):
    method is_expired (line 96) | def is_expired(self) -> bool:
    method ttl (line 105) | def ttl(self) -> float:
    method try_get (line 114) | def try_get(self, key: str) -> str:
    method get_value (line 117) | def get_value(self) -> str:
    method get_expires_at_ms (line 120) | def get_expires_at_ms(self) -> float:
    method get_received_at_ms (line 123) | def get_received_at_ms(self) -> float:
    method _validate_token (line 126) | def _validate_token(self):

FILE: redis/auth/token_manager.py
  class CredentialsListener (line 15) | class CredentialsListener:
    method __init__ (line 21) | def __init__(self):
    method on_next (line 26) | def on_next(self) -> Union[Callable[[Any], None], Awaitable]:
    method on_next (line 30) | def on_next(self, callback: Union[Callable[[Any], None], Awaitable]) -...
    method on_error (line 34) | def on_error(self) -> Union[Callable[[Exception], None], Awaitable]:
    method on_error (line 38) | def on_error(self, callback: Union[Callable[[Exception], None], Awaita...
  class RetryPolicy (line 42) | class RetryPolicy:
    method __init__ (line 43) | def __init__(self, max_attempts: int, delay_in_ms: float):
    method get_max_attempts (line 47) | def get_max_attempts(self) -> int:
    method get_delay_in_ms (line 55) | def get_delay_in_ms(self) -> float:
  class TokenManagerConfig (line 64) | class TokenManagerConfig:
    method __init__ (line 65) | def __init__(
    method get_expiration_refresh_ratio (line 79) | def get_expiration_refresh_ratio(self) -> float:
    method get_lower_refresh_bound_millis (line 90) | def get_lower_refresh_bound_millis(self) -> int:
    method get_token_request_execution_timeout_in_ms (line 103) | def get_token_request_execution_timeout_in_ms(self) -> int:
    method get_retry_policy (line 112) | def get_retry_policy(self) -> RetryPolicy:
  class TokenManager (line 121) | class TokenManager:
    method __init__ (line 122) | def __init__(
    method __del__ (line 132) | def __del__(self):
    method start (line 136) | def start(
    method start_async (line 184) | async def start_async(
    method stop (line 208) | def stop(self):
    method acquire_token (line 214) | def acquire_token(self, force_refresh=False) -> TokenResponse:
    method acquire_token_async (line 228) | async def acquire_token_async(self, force_refresh=False) -> TokenRespo...
    method _calculate_renewal_delay (line 244) | def _calculate_renewal_delay(self, expire_date: float, issue_date: flo...
    method _delay_for_lower_refresh (line 251) | def _delay_for_lower_refresh(self, expire_date: float):
    method _delay_for_ratio_refresh (line 258) | def _delay_for_ratio_refresh(self, expire_date: float, issue_date: flo...
    method _renew_token (line 270) | def _renew_token(self, skip_initial: bool = False):
    method _renew_token_async (line 311) | async def _renew_token_async(
  function _async_to_sync_wrapper (line 358) | def _async_to_sync_wrapper(loop, coro_func, *args, **kwargs):

FILE: redis/background.py
  class BackgroundScheduler (line 7) | class BackgroundScheduler:
    method __init__ (line 12) | def __init__(self):
    method __del__ (line 23) | def __del__(self):
    method stop (line 26) | def stop(self):
    method run_once (line 46) | def run_once(self, delay: float, callback: Callable, *args):
    method run_recurring (line 67) | def run_recurring(self, interval: float, callback: Callable, *args):
    method run_recurring_coro (line 88) | def run_recurring_coro(
    method run_coro_sync (line 112) | def run_coro_sync(
    method run_coro_fire_and_forget (line 160) | def run_coro_fire_and_forget(
    method _ensure_health_check_loop (line 198) | def _ensure_health_check_loop(self, timeout: float = 5.0):
    method _run_health_check_loop (line 258) | def _run_health_check_loop(self):
    method _call_later_recurring_coro (line 281) | def _call_later_recurring_coro(
    method _execute_recurring_coro (line 296) | def _execute_recurring_coro(
    method run_recurring_async (line 357) | async def run_recurring_async(
    method _call_later (line 418) | def _call_later(
    method _call_later_recurring (line 426) | def _call_later_recurring(
    method _execute_recurring (line 440) | def _execute_recurring(
  function _start_event_loop_in_thread (line 469) | def _start_event_loop_in_thread(

FILE: redis/backoff.py
  class AbstractBackoff (line 10) | class AbstractBackoff(ABC):
    method reset (line 13) | def reset(self):
    method compute (line 22) | def compute(self, failures: int) -> float:
  class ConstantBackoff (line 27) | class ConstantBackoff(AbstractBackoff):
    method __init__ (line 30) | def __init__(self, backoff: float) -> None:
    method __hash__ (line 34) | def __hash__(self) -> int:
    method __eq__ (line 37) | def __eq__(self, other) -> bool:
    method compute (line 43) | def compute(self, failures: int) -> float:
  class NoBackoff (line 47) | class NoBackoff(ConstantBackoff):
    method __init__ (line 50) | def __init__(self) -> None:
  class ExponentialBackoff (line 54) | class ExponentialBackoff(AbstractBackoff):
    method __init__ (line 57) | def __init__(self, cap: float = DEFAULT_CAP, base: float = DEFAULT_BASE):
    method __hash__ (line 65) | def __hash__(self) -> int:
    method __eq__ (line 68) | def __eq__(self, other) -> bool:
    method compute (line 74) | def compute(self, failures: int) -> float:
  class FullJitterBackoff (line 78) | class FullJitterBackoff(AbstractBackoff):
    method __init__ (line 81) | def __init__(self, cap: float = DEFAULT_CAP, base: float = DEFAULT_BAS...
    method __hash__ (line 89) | def __hash__(self) -> int:
    method __eq__ (line 92) | def __eq__(self, other) -> bool:
    method compute (line 98) | def compute(self, failures: int) -> float:
  class EqualJitterBackoff (line 102) | class EqualJitterBackoff(AbstractBackoff):
    method __init__ (line 105) | def __init__(self, cap: float = DEFAULT_CAP, base: float = DEFAULT_BAS...
    method __hash__ (line 113) | def __hash__(self) -> int:
    method __eq__ (line 116) | def __eq__(self, other) -> bool:
    method compute (line 122) | def compute(self, failures: int) -> float:
  class DecorrelatedJitterBackoff (line 127) | class DecorrelatedJitterBackoff(AbstractBackoff):
    method __init__ (line 130) | def __init__(self, cap: float = DEFAULT_CAP, base: float = DEFAULT_BAS...
    method __hash__ (line 139) | def __hash__(self) -> int:
    method __eq__ (line 142) | def __eq__(self, other) -> bool:
    method reset (line 148) | def reset(self) -> None:
    method compute (line 151) | def compute(self, failures: int) -> float:
  class ExponentialWithJitterBackoff (line 158) | class ExponentialWithJitterBackoff(AbstractBackoff):
    method __init__ (line 161) | def __init__(self, cap: float = DEFAULT_CAP, base: float = DEFAULT_BAS...
    method __hash__ (line 169) | def __hash__(self) -> int:
    method __eq__ (line 172) | def __eq__(self, other) -> bool:
    method compute (line 178) | def compute(self, failures: int) -> float:
  function default_backoff (line 182) | def default_backoff():

FILE: redis/cache.py
  class CacheEntryStatus (line 10) | class CacheEntryStatus(Enum):
  class EvictionPolicyType (line 15) | class EvictionPolicyType(Enum):
  class CacheKey (line 21) | class CacheKey:
  class CacheEntry (line 39) | class CacheEntry:
    method __init__ (line 40) | def __init__(
    method __hash__ (line 52) | def __hash__(self):
    method __eq__ (line 57) | def __eq__(self, other):
  class EvictionPolicyInterface (line 61) | class EvictionPolicyInterface(ABC):
    method cache (line 64) | def cache(self):
    method cache (line 69) | def cache(self, value):
    method type (line 74) | def type(self) -> EvictionPolicyType:
    method evict_next (line 78) | def evict_next(self) -> CacheKey:
    method evict_many (line 82) | def evict_many(self, count: int) -> List[CacheKey]:
    method touch (line 86) | def touch(self, cache_key: CacheKey) -> None:
  class CacheConfigurationInterface (line 90) | class CacheConfigurationInterface(ABC):
    method get_cache_class (line 92) | def get_cache_class(self):
    method get_max_size (line 96) | def get_max_size(self) -> int:
    method get_eviction_policy (line 100) | def get_eviction_policy(self):
    method is_exceeds_max_size (line 104) | def is_exceeds_max_size(self, count: int) -> bool:
    method is_allowed_to_cache (line 108) | def is_allowed_to_cache(self, command: str) -> bool:
  class CacheInterface (line 112) | class CacheInterface(ABC):
    method collection (line 115) | def collection(self) -> OrderedDict:
    method config (line 120) | def config(self) -> CacheConfigurationInterface:
    method eviction_policy (line 125) | def eviction_policy(self) -> EvictionPolicyInterface:
    method size (line 130) | def size(self) -> int:
    method get (line 134) | def get(self, key: CacheKey) -> Union[CacheEntry, None]:
    method set (line 138) | def set(self, entry: CacheEntry) -> bool:
    method delete_by_cache_keys (line 142) | def delete_by_cache_keys(self, cache_keys: List[CacheKey]) -> List[bool]:
    method delete_by_redis_keys (line 146) | def delete_by_redis_keys(self, redis_keys: List[bytes]) -> List[bool]:
    method flush (line 150) | def flush(self) -> int:
    method is_cachable (line 154) | def is_cachable(self, key: CacheKey) -> bool:
  class DefaultCache (line 158) | class DefaultCache(CacheInterface):
    method __init__ (line 159) | def __init__(
    method collection (line 169) | def collection(self) -> OrderedDict:
    method config (line 173) | def config(self) -> CacheConfigurationInterface:
    method eviction_policy (line 177) | def eviction_policy(self) -> EvictionPolicyInterface:
    method size (line 181) | def size(self) -> int:
    method set (line 184) | def set(self, entry: CacheEntry) -> bool:
    method get (line 193) | def get(self, key: CacheKey) -> Union[CacheEntry, None]:
    method delete_by_cache_keys (line 202) | def delete_by_cache_keys(self, cache_keys: List[CacheKey]) -> List[bool]:
    method delete_by_redis_keys (line 214) | def delete_by_redis_keys(
    method flush (line 241) | def flush(self) -> int:
    method is_cachable (line 246) | def is_cachable(self, key: CacheKey) -> bool:
  class CacheProxy (line 250) | class CacheProxy(CacheInterface):
    method __init__ (line 255) | def __init__(self, cache: CacheInterface):
    method collection (line 259) | def collection(self) -> OrderedDict:
    method config (line 263) | def config(self) -> CacheConfigurationInterface:
    method eviction_policy (line 267) | def eviction_policy(self) -> EvictionPolicyInterface:
    method size (line 271) | def size(self) -> int:
    method get (line 274) | def get(self, key: CacheKey) -> Union[CacheEntry, None]:
    method set (line 277) | def set(self, entry: CacheEntry) -> bool:
    method delete_by_cache_keys (line 292) | def delete_by_cache_keys(self, cache_keys: List[CacheKey]) -> List[bool]:
    method delete_by_redis_keys (line 295) | def delete_by_redis_keys(self, redis_keys: List[bytes]) -> List[bool]:
    method flush (line 298) | def flush(self) -> int:
    method is_cachable (line 301) | def is_cachable(self, key: CacheKey) -> bool:
  class LRUPolicy (line 305) | class LRUPolicy(EvictionPolicyInterface):
    method __init__ (line 306) | def __init__(self):
    method cache (line 310) | def cache(self):
    method cache (line 314) | def cache(self, cache: CacheInterface):
    method type (line 318) | def type(self) -> EvictionPolicyType:
    method evict_next (line 321) | def evict_next(self) -> CacheKey:
    method evict_many (line 326) | def evict_many(self, count: int) -> List[CacheKey]:
    method touch (line 339) | def touch(self, cache_key: CacheKey) -> None:
    method _assert_cache (line 347) | def _assert_cache(self):
  class EvictionPolicy (line 352) | class EvictionPolicy(Enum):
  class CacheConfig (line 356) | class CacheConfig(CacheConfigurationInterface):
    method __init__ (line 438) | def __init__(
    method get_cache_class (line 448) | def get_cache_class(self):
    method get_max_size (line 451) | def get_max_size(self) -> int:
    method get_eviction_policy (line 454) | def get_eviction_policy(self) -> EvictionPolicy:
    method is_exceeds_max_size (line 457) | def is_exceeds_max_size(self, count: int) -> bool:
    method is_allowed_to_cache (line 460) | def is_allowed_to_cache(self, command: str) -> bool:
  class CacheFactoryInterface (line 464) | class CacheFactoryInterface(ABC):
    method get_cache (line 466) | def get_cache(self) -> CacheInterface:
  class CacheFactory (line 470) | class CacheFactory(CacheFactoryInterface):
    method __init__ (line 471) | def __init__(self, cache_config: Optional[CacheConfig] = None):
    method get_cache (line 477) | def get_cache(self) -> CacheInterface:

FILE: redis/client.py
  function is_debug_log_enabled (line 98) | def is_debug_log_enabled():
  function add_debug_log_for_operation_failure (line 102) | def add_debug_log_for_operation_failure(connection: "AbstractConnection"):
  class CaseInsensitiveDict (line 109) | class CaseInsensitiveDict(dict):
    method __init__ (line 112) | def __init__(self, data: Dict[str, str]) -> None:
    method __contains__ (line 116) | def __contains__(self, k):
    method __delitem__ (line 119) | def __delitem__(self, k):
    method __getitem__ (line 122) | def __getitem__(self, k):
    method get (line 125) | def get(self, k, default=None):
    method __setitem__ (line 128) | def __setitem__(self, k, v):
    method update (line 131) | def update(self, data):
  class AbstractRedis (line 136) | class AbstractRedis:
  class Redis (line 140) | class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
    method from_url (line 159) | def from_url(cls, url: str, **kwargs) -> "Redis":
    method from_pool (line 210) | def from_pool(
    method __init__ (line 235) | def __init__(
    method __repr__ (line 486) | def __repr__(self) -> str:
    method get_encoder (line 492) | def get_encoder(self) -> "Encoder":
    method get_connection_kwargs (line 496) | def get_connection_kwargs(self) -> Dict:
    method get_retry (line 500) | def get_retry(self) -> Optional[Retry]:
    method set_retry (line 503) | def set_retry(self, retry: Retry) -> None:
    method set_response_callback (line 507) | def set_response_callback(self, command: str, callback: Callable) -> N...
    method load_external_module (line 511) | def load_external_module(self, funcname, func) -> None:
    method pipeline (line 534) | def pipeline(self, transaction=True, shard_hint=None) -> "Pipeline":
    method transaction (line 546) | def transaction(
    method lock (line 570) | def lock(
    method pubsub (line 651) | def pubsub(self, **kwargs):
    method monitor (line 661) | def monitor(self):
    method client (line 664) | def client(self):
    method __enter__ (line 670) | def __enter__(self):
    method __exit__ (line 673) | def __exit__(self, exc_type, exc_value, traceback):
    method __del__ (line 676) | def __del__(self):
    method close (line 682) | def close(self) -> None:
    method _send_command_parse_response (line 697) | def _send_command_parse_response(self, conn, command_name, *args, **op...
    method _close_connection (line 704) | def _close_connection(
    method execute_command (line 735) | def execute_command(self, *args, **options):
    method _execute_command (line 738) | def _execute_command(self, *args, **options):
    method parse_response (line 795) | def parse_response(self, connection, command_name, **options):
    method get_cache (line 818) | def get_cache(self) -> Optional[CacheInterface]:
  class Monitor (line 825) | class Monitor:
    method __init__ (line 835) | def __init__(self, connection_pool):
    method __enter__ (line 839) | def __enter__(self):
    method __exit__ (line 843) | def __exit__(self, *args):
    method next_command (line 847) | def next_command(self):
    method listen (line 892) | def listen(self):
    method _start_monitor (line 897) | def _start_monitor(self):
  class PubSub (line 906) | class PubSub:
    method __init__ (line 919) | def __init__(
    method __enter__ (line 954) | def __enter__(self) -> "PubSub":
    method __exit__ (line 957) | def __exit__(self, exc_type, exc_value, traceback) -> None:
    method __del__ (line 960) | def __del__(self) -> None:
    method reset (line 969) | def reset(self) -> None:
    method close (line 984) | def close(self) -> None:
    method on_connect (line 987) | def on_connect(self, connection) -> None:
    method subscribed (line 1033) | def subscribed(self) -> bool:
    method execute_command (line 1037) | def execute_command(self, *args):
    method clean_health_check_responses (line 1063) | def clean_health_check_responses(self) -> None:
    method _reconnect (line 1081) | def _reconnect(
    method _execute (line 1109) | def _execute(self, conn, command, *args, **kwargs):
    method parse_response (line 1164) | def parse_response(self, block=True, timeout=0):
    method is_health_check_response (line 1232) | def is_health_check_response(self, response) -> bool:
    method check_health (line 1255) | def check_health(self) -> None:
    method _normalize_keys (line 1267) | def _normalize_keys(self, data) -> Dict:
    method psubscribe (line 1277) | def psubscribe(self, *args, **kwargs):
    method punsubscribe (line 1303) | def punsubscribe(self, *args):
    method subscribe (line 1316) | def subscribe(self, *args, **kwargs):
    method unsubscribe (line 1342) | def unsubscribe(self, *args):
    method ssubscribe (line 1355) | def ssubscribe(self, *args, target_node=None, **kwargs):
    method sunsubscribe (line 1381) | def sunsubscribe(self, *args, target_node=None):
    method listen (line 1394) | def listen(self):
    method get_message (line 1401) | def get_message(
    method ping (line 1433) | def ping(self, message: Union[str, None] = None) -> bool:
    method handle_message (line 1443) | def handle_message(self, response, ignore_subscribe_messages=False):
    method run_in_thread (line 1532) | def run_in_thread(
  class PubSubWorkerThread (line 1564) | class PubSubWorkerThread(threading.Thread):
    method __init__ (line 1565) | def __init__(
    method run (line 1583) | def run(self) -> None:
    method stop (line 1605) | def stop(self) -> None:
  class Pipeline (line 1612) | class Pipeline(Redis):
    method __init__ (line 1634) | def __init__(
    method __enter__ (line 1651) | def __enter__(self) -> "Pipeline":
    method __exit__ (line 1654) | def __exit__(self, exc_type, exc_value, traceback):
    method __del__ (line 1657) | def __del__(self):
    method __len__ (line 1663) | def __len__(self) -> int:
    method __bool__ (line 1666) | def __bool__(self) -> bool:
    method reset (line 1670) | def reset(self) -> None:
    method close (line 1694) | def close(self) -> None:
    method multi (line 1698) | def multi(self) -> None:
    method execute_command (line 1711) | def execute_command(self, *args, **kwargs):
    method _disconnect_reset_raise_on_watching (line 1716) | def _disconnect_reset_raise_on_watching(
    method immediate_execute_command (line 1755) | def immediate_execute_command(self, *args, **options):
    method pipeline_execute_command (line 1812) | def pipeline_execute_command(self, *args, **options) -> "Pipeline":
    method _execute_transaction (line 1827) | def _execute_transaction(
    method _execute_pipeline (line 1899) | def _execute_pipeline(self, connection, commands, raise_on_error):
    method raise_first_error (line 1916) | def raise_first_error(self, commands, response):
    method annotate_exception (line 1922) | def annotate_exception(self, exception, number, command):
    method parse_response (line 1930) | def parse_response(self, connection, command_name, **options):
    method load_scripts (line 1938) | def load_scripts(self):
    method _disconnect_raise_on_watching (line 1951) | def _disconnect_raise_on_watching(
    method execute (line 1987) | def execute(self, raise_on_error: bool = True) -> List[Any]:
    method discard (line 2053) | def discard(self):
    method watch (line 2060) | def watch(self, *names):
    method unwatch (line 2066) | def unwatch(self) -> bool:

FILE: redis/cluster.py
  function is_debug_log_enabled (line 90) | def is_debug_log_enabled():
  function get_node_name (line 94) | def get_node_name(host: str, port: Union[str, int]) -> str:
  function get_connection (line 103) | def get_connection(redis_node: Redis, *args, **options) -> Connection:
  function parse_scan_result (line 107) | def parse_scan_result(command, res, **options):
  function parse_pubsub_numsub (line 118) | def parse_pubsub_numsub(command, res, **options):
  function parse_cluster_slots (line 131) | def parse_cluster_slots(
  function parse_cluster_shards (line 151) | def parse_cluster_shards(resp, **options):
  function parse_cluster_myshardid (line 173) | def parse_cluster_myshardid(resp, **options):
  function cleanup_kwargs (line 231) | def cleanup_kwargs(**kwargs):
  class MaintNotificationsAbstractRedisCluster (line 244) | class MaintNotificationsAbstractRedisCluster:
    method __init__ (line 254) | def __init__(
    method _update_connection_kwargs_for_maint_notifications (line 294) | def _update_connection_kwargs_for_maint_notifications(
  class AbstractRedisCluster (line 307) | class AbstractRedisCluster:
    method replace_default_node (line 529) | def replace_default_node(self, target_node: "ClusterNode" = None) -> N...
  class RedisCluster (line 554) | class RedisCluster(
    method from_url (line 561) | def from_url(cls, url: str, **kwargs: Any) -> "RedisCluster":
    method __init__ (line 616) | def __init__(
    method __enter__ (line 874) | def __enter__(self):
    method __exit__ (line 877) | def __exit__(self, exc_type, exc_value, traceback):
    method __del__ (line 880) | def __del__(self):
    method disconnect_connection_pools (line 886) | def disconnect_connection_pools(self):
    method on_connect (line 895) | def on_connect(self, connection):
    method get_redis_connection (line 915) | def get_redis_connection(self, node: "ClusterNode") -> Redis:
    method get_node (line 922) | def get_node(self, host=None, port=None, node_name=None):
    method get_primaries (line 925) | def get_primaries(self):
    method get_replicas (line 928) | def get_replicas(self):
    method get_random_node (line 931) | def get_random_node(self):
    method get_random_primary_or_all_nodes (line 934) | def get_random_primary_or_all_nodes(self, command_name):
    method get_nodes (line 943) | def get_nodes(self):
    method get_node_from_key (line 946) | def get_node_from_key(self, key, replica=False):
    method get_default_node (line 966) | def get_default_node(self):
    method get_nodes_from_slot (line 972) | def get_nodes_from_slot(self, command: str, *args):
    method _split_multi_shard_command (line 985) | def _split_multi_shard_command(self, *args, **kwargs) -> list[dict]:
    method get_special_nodes (line 1002) | def get_special_nodes(self) -> Optional[list["ClusterNode"]]:
    method get_random_primary_node (line 1013) | def get_random_primary_node(self) -> "ClusterNode":
    method _evaluate_all_succeeded (line 1019) | def _evaluate_all_succeeded(self, res):
    method set_default_node (line 1043) | def set_default_node(self, node):
    method set_retry (line 1054) | def set_retry(self, retry: Retry) -> None:
    method monitor (line 1057) | def monitor(self, target_node=None):
    method pubsub (line 1074) | def pubsub(self, node=None, host=None, port=None, **kwargs):
    method pipeline (line 1081) | def pipeline(self, transaction=None, shard_hint=None):
    method lock (line 1108) | def lock(
    method set_response_callback (line 1189) | def set_response_callback(self, command, callback):
    method _determine_nodes (line 1193) | def _determine_nodes(
    method _should_reinitialized (line 1230) | def _should_reinitialized(self):
    method keyslot (line 1240) | def keyslot(self, key):
    method _get_command_keys (line 1248) | def _get_command_keys(self, *args):
    method determine_slot (line 1263) | def determine_slot(self, *args) -> Optional[int]:
    method get_encoder (line 1326) | def get_encoder(self):
    method get_connection_kwargs (line 1332) | def get_connection_kwargs(self):
    method _is_nodes_flag (line 1338) | def _is_nodes_flag(self, target_nodes):
    method _parse_target_nodes (line 1341) | def _parse_target_nodes(self, target_nodes):
    method execute_command (line 1361) | def execute_command(self, *args, **kwargs):
    method _internal_execute_command (line 1364) | def _internal_execute_command(self, *args, **kwargs):
    method _execute_command (line 1505) | def _execute_command(self, target_node, *args, **kwargs):
    method _record_command_metric (line 1777) | def _record_command_metric(
    method _record_error_metric (line 1800) | def _record_error_metric(
    method _extracts_socket_address (line 1820) | def _extracts_socket_address(
    method close (line 1834) | def close(self) -> None:
    method _process_result (line 1843) | def _process_result(self, command, res, response_policy: ResponsePolic...
    method load_external_module (line 1863) | def load_external_module(self, funcname, func):
    method transaction (line 1873) | def transaction(self, func, *watches, **kwargs):
  class ClusterNode (line 1896) | class ClusterNode:
    method __init__ (line 1897) | def __init__(self, host, port, server_type=None, redis_connection=None):
    method __repr__ (line 1907) | def __repr__(self):
    method __eq__ (line 1916) | def __eq__(self, obj):
    method __hash__ (line 1919) | def __hash__(self):
  class LoadBalancingStrategy (line 1923) | class LoadBalancingStrategy(Enum):
  class LoadBalancer (line 1929) | class LoadBalancer:
    method __init__ (line 1934) | def __init__(self, start_index: int = 0) -> None:
    method get_server_index (line 1939) | def get_server_index(
    method reset (line 1954) | def reset(self) -> None:
    method _get_random_replica_index (line 1958) | def _get_random_replica_index(self, list_size: int) -> int:
    method _get_round_robin_index (line 1961) | def _get_round_robin_index(
  class NodesManager (line 1974) | class NodesManager:
    method __init__ (line 1975) | def __init__(
    method get_node (line 2033) | def get_node(
    method move_slot (line 2056) | def move_slot(self, e: Union[AskError, MovedError]):
    method get_node_from_slot (line 2104) | def get_node_from_slot(
    method get_nodes_by_server_type (line 2145) | def get_nodes_by_server_type(self, server_type: Literal["primary", "re...
    method populate_startup_nodes (line 2162) | def populate_startup_nodes(self, nodes):
    method move_node_to_end_of_cached_nodes (line 2170) | def move_node_to_end_of_cached_nodes(self, node_name: str) -> None:
    method check_slots_coverage (line 2187) | def check_slots_coverage(self, slots_cache):
    method create_redis_connections (line 2195) | def create_redis_connections(self, nodes):
    method create_redis_node (line 2216) | def create_redis_node(
    method _get_or_create_cluster_node (line 2252) | def _get_or_create_cluster_node(self, host, port, role, tmp_nodes_cache):
    method _get_epoch (line 2273) | def _get_epoch(self) -> int:
    method initialize (line 2281) | def initialize(
    method close (line 2487) | def close(self) -> None:
    method reset (line 2495) | def reset(self):
    method remap_host_port (line 2502) | def remap_host_port(self, host: str, port: int) -> Tuple[str, int]:
    method find_connection_owner (line 2512) | def find_connection_owner(self, connection: Connection) -> Optional[Cl...
  class ClusterPubSub (line 2525) | class ClusterPubSub(PubSub):
    method __init__ (line 2534) | def __init__(
    method set_pubsub_node (line 2579) | def set_pubsub_node(self, cluster, node=None, host=None, port=None):
    method get_pubsub_node (line 2612) | def get_pubsub_node(self):
    method _raise_on_invalid_node (line 2618) | def _raise_on_invalid_node(self, redis_cluster, node, host, port):
    method execute_command (line 2628) | def execute_command(self, *args):
    method _get_node_pubsub (line 2670) | def _get_node_pubsub(self, node):
    method _sharded_message_generator (line 2680) | def _sharded_message_generator(self, timeout=0.0):
    method _pubsubs_generator (line 2692) | def _pubsubs_generator(self):
    method get_sharded_message (line 2697) | def get_sharded_message(
    method ssubscribe (line 2723) | def ssubscribe(self, *args, **kwargs):
    method sunsubscribe (line 2743) | def sunsubscribe(self, *args):
    method get_redis_connection (line 2757) | def get_redis_connection(self):
    method disconnect (line 2764) | def disconnect(self):
  class ClusterPipeline (line 2774) | class ClusterPipeline(RedisCluster):
    method __init__ (line 2799) | def __init__(
    method __repr__ (line 2889) | def __repr__(self):
    method __enter__ (line 2893) | def __enter__(self):
    method __exit__ (line 2897) | def __exit__(self, exc_type, exc_value, traceback):
    method __del__ (line 2901) | def __del__(self):
    method __len__ (line 2907) | def __len__(self):
    method __bool__ (line 2911) | def __bool__(self):
    method execute_command (line 2915) | def execute_command(self, *args, **kwargs):
    method pipeline_execute_command (line 2921) | def pipeline_execute_command(self, *args, **options):
    method annotate_exception (line 2935) | def annotate_exception(self, exception, number, command):
    method execute (line 2941) | def execute(self, raise_on_error: bool = True) -> List[Any]:
    method reset (line 2951) | def reset(self):
    method send_cluster_commands (line 2957) | def send_cluster_commands(
    method exists (line 2964) | def exists(self, *keys):
    method eval (line 2967) | def eval(self):
    method multi (line 2971) | def multi(self):
    method load_scripts (line 2978) | def load_scripts(self):
    method discard (line 2982) | def discard(self):
    method watch (line 2986) | def watch(self, *names):
    method unwatch (line 2990) | def unwatch(self):
    method script_load_for_pipeline (line 2994) | def script_load_for_pipeline(self, *args, **kwargs):
    method delete (line 2997) | def delete(self, *names):
    method unlink (line 3000) | def unlink(self, *names):
  function block_pipeline_command (line 3004) | def block_pipeline_command(name: str) -> Callable[..., Any]:
  class PipelineCommand (line 3098) | class PipelineCommand:
    method __init__ (line 3101) | def __init__(self, args, options=None, position=None):
  class NodeCommands (line 3113) | class NodeCommands:
    method __init__ (line 3116) | def __init__(
    method append (line 3125) | def append(self, c):
    method write (line 3129) | def write(self):
    method read (line 3151) | def read(self):
  class ExecutionStrategy (line 3184) | class ExecutionStrategy(ABC):
    method command_queue (line 3187) | def command_queue(self):
    method execute_command (line 3191) | def execute_command(self, *args, **kwargs):
    method annotate_exception (line 3200) | def annotate_exception(self, exception, number, command):
    method pipeline_execute_command (line 3209) | def pipeline_execute_command(self, *args, **options):
    method execute (line 3218) | def execute(self, raise_on_error: bool = True) -> List[Any]:
    method send_cluster_commands (line 3227) | def send_cluster_commands(
    method reset (line 3238) | def reset(self):
    method exists (line 3247) | def exists(self, *keys):
    method eval (line 3251) | def eval(self):
    method multi (line 3255) | def multi(self):
    method load_scripts (line 3264) | def load_scripts(self):
    method watch (line 3268) | def watch(self, *names):
    method unwatch (line 3272) | def unwatch(self):
    method script_load_for_pipeline (line 3281) | def script_load_for_pipeline(self, *args, **kwargs):
    method delete (line 3285) | def delete(self, *names):
    method unlink (line 3294) | def unlink(self, *names):
    method discard (line 3303) | def discard(self):
  class AbstractStrategy (line 3307) | class AbstractStrategy(ExecutionStrategy):
    method __init__ (line 3308) | def __init__(
    method command_queue (line 3317) | def command_queue(self):
    method command_queue (line 3321) | def command_queue(self, queue: List[PipelineCommand]):
    method execute_command (line 3325) | def execute_command(self, *args, **kwargs):
    method pipeline_execute_command (line 3328) | def pipeline_execute_command(self, *args, **options):
    method execute (line 3335) | def execute(self, raise_on_error: bool = True) -> List[Any]:
    method send_cluster_commands (line 3339) | def send_cluster_commands(
    method reset (line 3345) | def reset(self):
    method exists (line 3348) | def exists(self, *keys):
    method eval (line 3351) | def eval(self):
    method load_scripts (line 3355) | def load_scripts(self):
    method script_load_for_pipeline (line 3359) | def script_load_for_pipeline(self, *args, **kwargs):
    method annotate_exception (line 3365) | def annotate_exception(self, exception, number, command):
  class PipelineStrategy (line 3377) | class PipelineStrategy(AbstractStrategy):
    method __init__ (line 3378) | def __init__(self, pipe: ClusterPipeline):
    method execute_command (line 3382) | def execute_command(self, *args, **kwargs):
    method _raise_first_error (line 3385) | def _raise_first_error(self, stack, start_time):
    method execute (line 3402) | def execute(self, raise_on_error: bool = True) -> List[Any]:
    method reset (line 3412) | def reset(self):
    method send_cluster_commands (line 3418) | def send_cluster_commands(
    method _send_cluster_commands (line 3455) | def _send_cluster_commands(
    method _is_nodes_flag (line 3697) | def _is_nodes_flag(self, target_nodes):
    method _parse_target_nodes (line 3700) | def _parse_target_nodes(self, target_nodes):
    method _determine_nodes (line 3720) | def _determine_nodes(
    method multi (line 3759) | def multi(self):
    method discard (line 3764) | def discard(self):
    method watch (line 3769) | def watch(self, *names):
    method unwatch (line 3774) | def unwatch(self, *names):
    method delete (line 3779) | def delete(self, *names):
    method unlink (line 3787) | def unlink(self, *names):
  class TransactionStrategy (line 3796) | class TransactionStrategy(AbstractStrategy):
    method __init__ (line 3808) | def __init__(self, pipe: ClusterPipeline):
    method _get_client_and_connection_for_transaction (line 3820) | def _get_client_and_connection_for_transaction(self) -> Tuple[Redis, C...
    method execute_command (line 3853) | def execute_command(self, *args, **kwargs):
    method _validate_watch (line 3884) | def _validate_watch(self):
    method _immediate_execute_command (line 3890) | def _immediate_execute_command(self, *args, **options):
    method _get_connection_and_send_command (line 3897) | def _get_connection_and_send_command(self, *args, **options):
    method _send_command_parse_response (line 3931) | def _send_command_parse_response(
    method _reinitialize_on_error (line 3945) | def _reinitialize_on_error(self, error, failure_count):
    method _raise_first_error (line 3993) | def _raise_first_error(self, responses, stack, start_time):
    method execute (line 4011) | def execute(self, raise_on_error: bool = True) -> List[Any]:
    method _execute_transaction_with_retries (line 4018) | def _execute_transaction_with_retries(
    method _execute_transaction (line 4029) | def _execute_transaction(
    method reset (line 4142) | def reset(self):
    method send_cluster_commands (line 4183) | def send_cluster_commands(
    method multi (line 4190) | def multi(self):
    method watch (line 4199) | def watch(self, *names):
    method unwatch (line 4205) | def unwatch(self):
    method discard (line 4211) | def discard(self):
    method delete (line 4214) | def delete(self, *names):
    method unlink (line 4217) | def unlink(self, *names):

FILE: redis/commands/bf/__init__.py
  class AbstractBloom (line 8) | class AbstractBloom:
    method append_items (line 21) | def append_items(params, items):
    method append_error (line 27) | def append_error(params, error):
    method append_capacity (line 33) | def append_capacity(params, capacity):
    method append_expansion (line 39) | def append_expansion(params, expansion):
    method append_no_scale (line 45) | def append_no_scale(params, noScale):
    method append_weights (line 51) | def append_weights(params, weights):
    method append_no_create (line 58) | def append_no_create(params, noCreate):
    method append_items_and_increments (line 64) | def append_items_and_increments(params, items, increments):
    method append_values_and_weights (line 71) | def append_values_and_weights(params, items, weights):
    method append_max_iterations (line 78) | def append_max_iterations(params, max_iterations):
    method append_bucket_size (line 84) | def append_bucket_size(params, bucket_size):
  class CMSBloom (line 90) | class CMSBloom(CMSCommands, AbstractBloom):
    method __init__ (line 91) | def __init__(self, client, **kwargs):
  class TOPKBloom (line 120) | class TOPKBloom(TOPKCommands, AbstractBloom):
    method __init__ (line 121) | def __init__(self, client, **kwargs):
  class CFBloom (line 151) | class CFBloom(CFCommands, AbstractBloom):
    method __init__ (line 152) | def __init__(self, client, **kwargs):
  class TDigestBloom (line 186) | class TDigestBloom(TDigestCommands, AbstractBloom):
    method __init__ (line 187) | def __init__(self, client, **kwargs):
  class BFBloom (line 222) | class BFBloom(BFCommands, AbstractBloom):
    method __init__ (line 223) | def __init__(self, client, **kwargs):

FILE: redis/commands/bf/commands.py
  class BFCommands (line 59) | class BFCommands:
    method create (line 62) | def create(self, key, errorRate, capacity, expansion=None, noScale=None):
    method add (line 76) | def add(self, key, item):
    method madd (line 83) | def madd(self, key, *items):
    method insert (line 90) | def insert(
    method exists (line 118) | def exists(self, key, item):
    method mexists (line 125) | def mexists(self, key, *items):
    method scandump (line 132) | def scandump(self, key, iter):
    method loadchunk (line 146) | def loadchunk(self, key, iter, data):
    method info (line 157) | def info(self, key):
    method card (line 164) | def card(self, key):
  class CFCommands (line 173) | class CFCommands:
    method create (line 176) | def create(
    method add (line 191) | def add(self, key, item):
    method addnx (line 198) | def addnx(self, key, item):
    method insert (line 206) | def insert(self, key, items, capacity=None, nocreate=None):
    method insertnx (line 219) | def insertnx(self, key, items, capacity=None, nocreate=None):
    method exists (line 232) | def exists(self, key, item):
    method mexists (line 239) | def mexists(self, key, *items):
    method delete (line 246) | def delete(self, key, item):
    method count (line 253) | def count(self, key, item):
    method scandump (line 260) | def scandump(self, key, iter):
    method loadchunk (line 273) | def loadchunk(self, key, iter, data):
    method info (line 283) | def info(self, key):
  class TOPKCommands (line 292) | class TOPKCommands:
    method reserve (line 295) | def reserve(self, key, k, width, depth, decay):
    method add (line 303) | def add(self, key, *items):
    method incrby (line 310) | def incrby(self, key, items, increments):
    method query (line 324) | def query(self, key, *items):
    method count (line 332) | def count(self, key, *items):
    method list (line 339) | def list(self, key, withcount=False):
    method info (line 351) | def info(self, key):
  class TDigestCommands (line 359) | class TDigestCommands:
    method create (line 360) | def create(self, key, compression=100):
    method reset (line 367) | def reset(self, key):
    method add (line 374) | def add(self, key, values):
    method merge (line 382) | def merge(self, destination_key, num_keys, *keys, compression=None, ov...
    method min (line 399) | def min(self, key):
    method max (line 406) | def max(self, key):
    method quantile (line 413) | def quantile(self, key, quantile, *quantiles):
    method cdf (line 422) | def cdf(self, key, value, *values):
    method info (line 429) | def info(self, key):
    method trimmed_mean (line 437) | def trimmed_mean(self, key, low_cut_quantile, high_cut_quantile):
    method rank (line 447) | def rank(self, key, value, *values):
    method revrank (line 456) | def revrank(self, key, value, *values):
    method byrank (line 465) | def byrank(self, key, rank, *ranks):
    method byrevrank (line 473) | def byrevrank(self, key, rank, *ranks):
  class CMSCommands (line 482) | class CMSCommands:
    method initbydim (line 485) | def initbydim(self, key, width, depth):
    method initbyprob (line 492) | def initbyprob(self, key, error, probability):
    method incrby (line 499) | def incrby(self, key, items, increments):
    method query (line 513) | def query(self, key, *items):
    method merge (line 520) | def merge(self, destKey, numKeys, srcKeys, weights=[]):
    method info (line 533) | def info(self, key):

FILE: redis/commands/bf/info.py
  class BFInfo (line 4) | class BFInfo:
    method __init__ (line 11) | def __init__(self, args):
    method get (line 19) | def get(self, item):
    method __getitem__ (line 25) | def __getitem__(self, item):
  class CFInfo (line 29) | class CFInfo:
    method __init__ (line 39) | def __init__(self, args):
    method get (line 50) | def get(self, item):
    method __getitem__ (line 56) | def __getitem__(self, item):
  class CMSInfo (line 60) | class CMSInfo:
    method __init__ (line 65) | def __init__(self, args):
    method __getitem__ (line 71) | def __getitem__(self, item):
  class TopKInfo (line 75) | class TopKInfo:
    method __init__ (line 81) | def __init__(self, args):
    method __getitem__ (line 88) | def __getitem__(self, item):
  class TDigestInfo (line 92) | class TDigestInfo:
    method __init__ (line 102) | def __init__(self, args):
    method get (line 113) | def get(self, item):
    method __getitem__ (line 119) | def __getitem__(self, item):

FILE: redis/commands/cluster.py
  class ClusterMultiKeyCommands (line 167) | class ClusterMultiKeyCommands(ClusterCommandsProtocol):
    method _partition_keys_by_slot (line 172) | def _partition_keys_by_slot(self, keys: Iterable[KeyT]) -> Dict[int, L...
    method _partition_pairs_by_slot (line 182) | def _partition_pairs_by_slot(
    method _execute_pipeline_by_slot (line 194) | def _execute_pipeline_by_slot(
    method _reorder_keys_by_command (line 211) | def _reorder_keys_by_command(
    method mget_nonatomic (line 224) | def mget_nonatomic(self, keys: KeysT, *args: KeyT) -> List[Optional[An...
    method mset_nonatomic (line 247) | def mset_nonatomic(self, mapping: Mapping[AnyKeyT, EncodableT]) -> Lis...
    method _split_command_across_slots (line 266) | def _split_command_across_slots(self, command: str, *keys: KeyT) -> int:
    method exists (line 278) | def exists(self, *keys: KeyT) -> ResponseT:
    method delete (line 288) | def delete(self, *keys: KeyT) -> ResponseT:
    method touch (line 301) | def touch(self, *keys: KeyT) -> ResponseT:
    method unlink (line 316) | def unlink(self, *keys: KeyT) -> ResponseT:
  class AsyncClusterMultiKeyCommands (line 331) | class AsyncClusterMultiKeyCommands(ClusterMultiKeyCommands):
    method mget_nonatomic (line 336) | async def mget_nonatomic(self, keys: KeysT, *args: KeyT) -> List[Optio...
    method mset_nonatomic (line 359) | async def mset_nonatomic(self, mapping: Mapping[AnyKeyT, EncodableT]) ...
    method _split_command_across_slots (line 378) | async def _split_command_across_slots(self, command: str, *keys: KeyT)...
    method _execute_pipeline_by_slot (line 390) | async def _execute_pipeline_by_slot(
  class ClusterManagementCommands (line 410) | class ClusterManagementCommands(ManagementCommands):
    method slaveof (line 418) | def slaveof(self, *args, **kwargs) -> NoReturn:
    method replicaof (line 426) | def replicaof(self, *args, **kwargs) -> NoReturn:
    method swapdb (line 434) | def swapdb(self, *args, **kwargs) -> NoReturn:
    method cluster_myid (line 442) | def cluster_myid(self, target_node: "TargetNodesT") -> ResponseT:
    method cluster_addslots (line 453) | def cluster_addslots(
    method cluster_addslotsrange (line 468) | def cluster_addslotsrange(
    method cluster_countkeysinslot (line 486) | def cluster_countkeysinslot(self, slot_id: int) -> ResponseT:
    method cluster_count_failure_report (line 495) | def cluster_count_failure_report(self, node_id: str) -> ResponseT:
    method cluster_delslots (line 504) | def cluster_delslots(self, *slots: EncodableT) -> List[bool]:
    method cluster_delslotsrange (line 515) | def cluster_delslotsrange(self, *slots: EncodableT) -> ResponseT:
    method cluster_failover (line 526) | def cluster_failover(
    method cluster_info (line 550) | def cluster_info(self, target_nodes: Optional["TargetNodesT"] = None) ...
    method cluster_keyslot (line 560) | def cluster_keyslot(self, key: str) -> ResponseT:
    method cluster_meet (line 569) | def cluster_meet(
    method cluster_nodes (line 582) | def cluster_nodes(self) -> ResponseT:
    method cluster_replicate (line 591) | def cluster_replicate(
    method cluster_reset (line 603) | def cluster_reset(
    method cluster_save_config (line 618) | def cluster_save_config(
    method cluster_get_keys_in_slot (line 628) | def cluster_get_keys_in_slot(self, slot: int, num_keys: int) -> Respon...
    method cluster_set_config_epoch (line 636) | def cluster_set_config_epoch(
    method cluster_setslot (line 648) | def cluster_setslot(
    method cluster_setslot_stable (line 668) | def cluster_setslot_stable(self, slot_id: int) -> ResponseT:
    method cluster_replicas (line 677) | def cluster_replicas(
    method cluster_slots (line 690) | def cluster_slots(self, target_nodes: Optional["TargetNodesT"] = None)...
    method cluster_shards (line 698) | def cluster_shards(self, target_nodes=None):
    method cluster_myshardid (line 706) | def cluster_myshardid(self, target_nodes=None):
    method cluster_links (line 714) | def cluster_links(self, target_node: "TargetNodesT") -> ResponseT:
    method cluster_flushslots (line 726) | def cluster_flushslots(self, target_nodes: Optional["TargetNodesT"] = ...
    method cluster_bumpepoch (line 731) | def cluster_bumpepoch(self, target_nodes: Optional["TargetNodesT"] = N...
    method readonly (line 736) | def readonly(self, target_nodes: Optional["TargetNodesT"] = None) -> R...
    method readwrite (line 750) | def readwrite(self, target_nodes: Optional["TargetNodesT"] = None) -> ...
    method client_tracking_on (line 766) | def client_tracking_on(
    method client_tracking_off (line 801) | def client_tracking_off(
    method hotkeys_start (line 832) | def hotkeys_start(
    method hotkeys_stop (line 850) | def hotkeys_stop(self, **kwargs) -> Union[str, bytes]:
    method hotkeys_reset (line 860) | def hotkeys_reset(self, **kwargs) -> Union[str, bytes]:
    method hotkeys_get (line 870) | def hotkeys_get(self, **kwargs) -> list[dict[Union[str, bytes], Any]]:
  class AsyncClusterManagementCommands (line 881) | class AsyncClusterManagementCommands(
    method cluster_delslots (line 891) | async def cluster_delslots(self, *slots: EncodableT) -> List[bool]:
    method client_tracking_on (line 911) | async def client_tracking_on(
    method client_tracking_off (line 946) | async def client_tracking_off(
    method hotkeys_start (line 977) | async def hotkeys_start(
    method hotkeys_stop (line 995) | async def hotkeys_stop(self, **kwargs) -> Awaitable[Union[str, bytes]]:
    method hotkeys_reset (line 1005) | async def hotkeys_reset(self, **kwargs) -> Awaitable[Union[str, bytes]]:
    method hotkeys_get (line 1015) | async def hotkeys_get(
  class ClusterDataAccessCommands (line 1028) | class ClusterDataAccessCommands(DataAccessCommands):
    method stralgo (line 1036) | def stralgo(
    method scan_iter (line 1083) | def scan_iter(
  class AsyncClusterDataAccessCommands (line 1119) | class AsyncClusterDataAccessCommands(
    method scan_iter (line 1129) | async def scan_iter(
  class RedisClusterCommands (line 1167) | class RedisClusterCommands(
  class AsyncRedisClusterCommands (line 1198) | class AsyncRedisClusterCommands(

FILE: redis/commands/core.py
  class ACLCommands (line 101) | class ACLCommands(CommandsProtocol):
    method acl_cat (line 108) | def acl_cat(
    method acl_cat (line 113) | def acl_cat(
    method acl_cat (line 117) | def acl_cat(
    method acl_dryrun (line 133) | def acl_dryrun(
    method acl_dryrun (line 138) | def acl_dryrun(
    method acl_dryrun (line 142) | def acl_dryrun(self, username: str, *args: EncodableT, **kwargs) -> (
    method acl_deluser (line 153) | def acl_deluser(self: SyncClientProtocol, *username: str, **kwargs) ->...
    method acl_deluser (line 156) | def acl_deluser(
    method acl_deluser (line 160) | def acl_deluser(self, *username: str, **kwargs) -> int | Awaitable[int]:
    method acl_genpass (line 169) | def acl_genpass(
    method acl_genpass (line 174) | def acl_genpass(
    method acl_genpass (line 178) | def acl_genpass(self, bits: int | None = None, **kwargs) -> (
    method acl_getuser (line 200) | def acl_getuser(
    method acl_getuser (line 205) | def acl_getuser(
    method acl_getuser (line 209) | def acl_getuser(
    method acl_help (line 222) | def acl_help(self: SyncClientProtocol, **kwargs) -> list[bytes | str]:...
    method acl_help (line 225) | def acl_help(
    method acl_help (line 229) | def acl_help(self, **kwargs) -> list[bytes | str] | Awaitable[list[byt...
    method acl_list (line 238) | def acl_list(self: SyncClientProtocol, **kwargs) -> list[bytes | str]:...
    method acl_list (line 241) | def acl_list(
    method acl_list (line 245) | def acl_list(self, **kwargs) -> list[bytes | str] | Awaitable[list[byt...
    method acl_log (line 254) | def acl_log(
    method acl_log (line 259) | def acl_log(
    method acl_log (line 263) | def acl_log(
    method acl_log_reset (line 282) | def acl_log_reset(self: SyncClientProtocol, **kwargs) -> bool: ...
    method acl_log_reset (line 285) | def acl_log_reset(self: AsyncClientProtocol, **kwargs) -> Awaitable[bo...
    method acl_log_reset (line 287) | def acl_log_reset(self, **kwargs) -> bool | Awaitable[bool]:
    method acl_load (line 298) | def acl_load(self: SyncClientProtocol, **kwargs) -> bool: ...
    method acl_load (line 301) | def acl_load(self: AsyncClientProtocol, **kwargs) -> Awaitable[bool]: ...
    method acl_load (line 303) | def acl_load(self, **kwargs) -> bool | Awaitable[bool]:
    method acl_save (line 315) | def acl_save(self: SyncClientProtocol, **kwargs) -> bool: ...
    method acl_save (line 318) | def acl_save(self: AsyncClientProtocol, **kwargs) -> Awaitable[bool]: ...
    method acl_save (line 320) | def acl_save(self, **kwargs) -> bool | Awaitable[bool]:
    method acl_setuser (line 332) | def acl_setuser(
    method acl_setuser (line 352) | def acl_setuser(
    method acl_setuser (line 371) | def acl_setuser(
    method acl_users (line 563) | def acl_users(self: SyncClientProtocol, **kwargs) -> list[bytes | str]...
    method acl_users (line 566) | def acl_users(
    method acl_users (line 570) | def acl_users(self, **kwargs) -> list[bytes | str] | Awaitable[list[by...
    method acl_whoami (line 578) | def acl_whoami(self: SyncClientProtocol, **kwargs) -> bytes | str: ...
    method acl_whoami (line 581) | def acl_whoami(self: AsyncClientProtocol, **kwargs) -> Awaitable[bytes...
    method acl_whoami (line 583) | def acl_whoami(self, **kwargs) -> (bytes | str) | Awaitable[bytes | str]:
  class HotkeysMetricsTypes (line 594) | class HotkeysMetricsTypes(Enum):
  class ManagementCommands (line 599) | class ManagementCommands(CommandsProtocol):
    method auth (line 605) | def auth(
    method auth (line 613) | def auth(
    method auth (line 620) | def auth(
    method bgrewriteaof (line 636) | def bgrewriteaof(self: SyncClientProtocol, **kwargs) -> bool | bytes |...
    method bgrewriteaof (line 639) | def bgrewriteaof(
    method bgrewriteaof (line 643) | def bgrewriteaof(self, **kwargs) -> (bool | bytes | str) | Awaitable[
    method bgsave (line 653) | def bgsave(
    method bgsave (line 658) | def bgsave(
    method bgsave (line 662) | def bgsave(self, schedule: bool = True, **kwargs) -> (
    method role (line 677) | def role(self: SyncClientProtocol) -> list[Any]: ...
    method role (line 680) | def role(self: AsyncClientProtocol) -> Awaitable[list[Any]]: ...
    method role (line 682) | def role(self) -> list[Any] | Awaitable[list[Any]]:
    method client_kill (line 693) | def client_kill(self: SyncClientProtocol, address: str, **kwargs) -> b...
    method client_kill (line 696) | def client_kill(
    method client_kill (line 700) | def client_kill(self, address: str, **kwargs) -> (bool | int) | Awaita...
    method client_kill_filter (line 710) | def client_kill_filter(
    method client_kill_filter (line 723) | def client_kill_filter(
    method client_kill_filter (line 735) | def client_kill_filter(
    method client_info (line 790) | def client_info(self: SyncClientProtocol, **kwargs) -> dict[str, str |...
    method client_info (line 793) | def client_info(
    method client_info (line 797) | def client_info(
    method client_list (line 809) | def client_list(
    method client_list (line 817) | def client_list(
    method client_list (line 824) | def client_list(
    method client_getname (line 852) | def client_getname(self: SyncClientProtocol, **kwargs) -> bytes | str ...
    method client_getname (line 855) | def client_getname(
    method client_getname (line 859) | def client_getname(self, **kwargs) -> (bytes | str | None) | Awaitable[
    method client_getredir (line 870) | def client_getredir(self: SyncClientProtocol, **kwargs) -> int: ...
    method client_getredir (line 873) | def client_getredir(self: AsyncClientProtocol, **kwargs) -> Awaitable[...
    method client_getredir (line 875) | def client_getredir(self, **kwargs) -> int | Awaitable[int]:
    method client_reply (line 885) | def client_reply(
    method client_reply (line 892) | def client_reply(
    method client_reply (line 898) | def client_reply(self, reply: Literal["ON", "OFF", "SKIP"], **kwargs) ...
    method client_id (line 923) | def client_id(self: SyncClientProtocol, **kwargs) -> int: ...
    method client_id (line 926) | def client_id(self: AsyncClientProtocol, **kwargs) -> Awaitable[int]: ...
    method client_id (line 928) | def client_id(self, **kwargs) -> int | Awaitable[int]:
    method client_tracking_on (line 937) | def client_tracking_on(
    method client_tracking_on (line 948) | def client_tracking_on(
    method client_tracking_on (line 958) | def client_tracking_on(
    method client_tracking_off (line 978) | def client_tracking_off(
    method client_tracking_off (line 989) | def client_tracking_off(
    method client_tracking_off (line 999) | def client_tracking_off(
    method client_tracking (line 1019) | def client_tracking(
    method client_tracking (line 1032) | def client_tracking(
    method client_tracking (line 1044) | def client_tracking(
    method client_trackinginfo (line 1105) | def client_trackinginfo(
    method client_trackinginfo (line 1110) | def client_trackinginfo(
    method client_trackinginfo (line 1114) | def client_trackinginfo(
    method client_setname (line 1126) | def client_setname(self: SyncClientProtocol, name: str, **kwargs) -> b...
    method client_setname (line 1129) | def client_setname(
    method client_setname (line 1133) | def client_setname(self, name: str, **kwargs) -> bool | Awaitable[bool]:
    method client_setinfo (line 1148) | def client_setinfo(
    method client_setinfo (line 1153) | def client_setinfo(
    method client_setinfo (line 1157) | def client_setinfo(self, attr: str, value: str, **kwargs) -> bool | Aw...
    method client_unblock (line 1165) | def client_unblock(
    method client_unblock (line 1170) | def client_unblock(
    method client_unblock (line 1174) | def client_unblock(
    method client_pause (line 1191) | def client_pause(
    method client_pause (line 1196) | def client_pause(
    method client_pause (line 1200) | def client_pause(
    method client_unpause (line 1231) | def client_unpause(self: SyncClientProtocol, **kwargs) -> bytes | str:...
    method client_unpause (line 1234) | def client_unpause(
    method client_unpause (line 1238) | def client_unpause(self, **kwargs) -> (bytes | str) | Awaitable[bytes ...
    method client_no_evict (line 1247) | def client_no_evict(self: SyncClientProtocol, mode: str) -> bytes | st...
    method client_no_evict (line 1250) | def client_no_evict(
    method client_no_evict (line 1254) | def client_no_evict(self, mode: str) -> (bytes | str) | Awaitable[byte...
    method client_no_touch (line 1263) | def client_no_touch(self: SyncClientProtocol, mode: str) -> bytes | st...
    method client_no_touch (line 1266) | def client_no_touch(
    method client_no_touch (line 1270) | def client_no_touch(self, mode: str) -> (bytes | str) | Awaitable[byte...
    method command (line 1282) | def command(self: SyncClientProtocol, **kwargs) -> dict[str, dict[str,...
    method command (line 1285) | def command(
    method command (line 1289) | def command(
    method command_info (line 1299) | def command_info(self, **kwargs) -> None:
    method command_count (line 1305) | def command_count(self: SyncClientProtocol, **kwargs) -> int: ...
    method command_count (line 1308) | def command_count(self: AsyncClientProtocol, **kwargs) -> Awaitable[in...
    method command_count (line 1310) | def command_count(self, **kwargs) -> int | Awaitable[int]:
    method command_list (line 1314) | def command_list(
    method command_list (line 1322) | def command_list(
    method command_list (line 1329) | def command_list(
    method command_getkeysandflags (line 1358) | def command_getkeysandflags(
    method command_getkeysandflags (line 1363) | def command_getkeysandflags(
    method command_getkeysandflags (line 1367) | def command_getkeysandflags(
    method command_docs (line 1377) | def command_docs(self, *args):
    method config_get (line 1387) | def config_get(
    method config_get (line 1392) | def config_get(
    method config_get (line 1396) | def config_get(
    method config_set (line 1407) | def config_set(
    method config_set (line 1416) | def config_set(
    method config_set (line 1424) | def config_set(
    method config_resetstat (line 1438) | def config_resetstat(self: SyncClientProtocol, **kwargs) -> bool: ...
    method config_resetstat (line 1441) | def config_resetstat(self: AsyncClientProtocol, **kwargs) -> Awaitable...
    method config_resetstat (line 1443) | def config_resetstat(self, **kwargs) -> bool | Awaitable[bool]:
    method config_rewrite (line 1452) | def config_rewrite(self: SyncClientProtocol, **kwargs) -> bytes | str:...
    method config_rewrite (line 1455) | def config_rewrite(
    method config_rewrite (line 1459) | def config_rewrite(self, **kwargs) -> (bytes | str) | Awaitable[bytes ...
    method dbsize (line 1468) | def dbsize(self: SyncClientProtocol, **kwargs) -> int: ...
    method dbsize (line 1471) | def dbsize(self: AsyncClientProtocol, **kwargs) -> Awaitable[int]: ...
    method dbsize (line 1473) | def dbsize(self, **kwargs) -> int | Awaitable[int]:
    method debug_object (line 1482) | def debug_object(
    method debug_object (line 1487) | def debug_object(
    method debug_object (line 1491) | def debug_object(self, key: KeyT, **kwargs) -> (
    method debug_segfault (line 1501) | def debug_segfault(self, **kwargs) -> None:
    method echo (line 1511) | def echo(self: SyncClientProtocol, value: EncodableT, **kwargs) -> byt...
    method echo (line 1514) | def echo(
    method echo (line 1518) | def echo(self, value: EncodableT, **kwargs) -> (bytes | str) | Awaitable[
    method flushall (line 1529) | def flushall(
    method flushall (line 1534) | def flushall(
    method flushall (line 1538) | def flushall(self, asynchronous: bool = False, **kwargs) -> bool | Awa...
    method flushdb (line 1553) | def flushdb(
    method flushdb (line 1558) | def flushdb(
    method flushdb (line 1562) | def flushdb(self, asynchronous: bool = False, **kwargs) -> bool | Awai...
    method sync (line 1577) | def sync(self: SyncClientProtocol) -> bytes: ...
    method sync (line 1580) | def sync(self: AsyncClientProtocol) -> Awaitable[bytes]: ...
    method sync (line 1582) | def sync(self) -> bytes | Awaitable[bytes]:
    method psync (line 1595) | def psync(self: SyncClientProtocol, replicationid: str, offset: int) -...
    method psync (line 1598) | def psync(
    method psync (line 1602) | def psync(self, replicationid: str, offset: int) -> bytes | Awaitable[...
    method swapdb (line 1616) | def swapdb(self: SyncClientProtocol, first: int, second: int, **kwargs...
    method swapdb (line 1619) | def swapdb(
    method swapdb (line 1623) | def swapdb(self, first: int, second: int, **kwargs) -> bool | Awaitabl...
    method select (line 1632) | def select(self: SyncClientProtocol, index: int, **kwargs) -> bool: ...
    method select (line 1635) | def select(self: AsyncClientProtocol, index: int, **kwargs) -> Awaitab...
    method select (line 1637) | def select(self, index: int, **kwargs) -> bool | Awaitable[bool]:
    method info (line 1645) | def info(
    method info (line 1653) | def info(
    method info (line 1660) | def info(
    method lastsave (line 1680) | def lastsave(self: SyncClientProtocol, **kwargs) -> datetime.datetime:...
    method lastsave (line 1683) | def lastsave(
    method lastsave (line 1687) | def lastsave(self, **kwargs) -> datetime.datetime | Awaitable[datetime...
    method latency_doctor (line 1696) | def latency_doctor(self):
    method latency_graph (line 1710) | def latency_graph(self):
    method lolwut (line 1725) | def lolwut(
    method lolwut (line 1730) | def lolwut(
    method lolwut (line 1734) | def lolwut(self, *version_numbers: Union[str, float], **kwargs) -> (
    method reset (line 1748) | def reset(self: SyncClientProtocol) -> bytes | str: ...
    method reset (line 1751) | def reset(self: AsyncClientProtocol) -> Awaitable[bytes | str]: ...
    method reset (line 1753) | def reset(self) -> (bytes | str) | Awaitable[bytes | str]:
    method migrate (line 1761) | def migrate(
    method migrate (line 1775) | def migrate(
    method migrate (line 1788) | def migrate(
    method object (line 1837) | def object(self: SyncClientProtocol, infotype: str, key: KeyT, **kwarg...
    method object (line 1840) | def object(
    method object (line 1844) | def object(self, infotype: str, key: KeyT, **kwargs) -> Any | Awaitabl...
    method memory_doctor (line 1852) | def memory_doctor(self, **kwargs) -> None:
    method memory_help (line 1861) | def memory_help(self, **kwargs) -> None:
    method memory_stats (line 1871) | def memory_stats(self: SyncClientProtocol, **kwargs) -> dict[str, Any]...
    method memory_stats (line 1874) | def memory_stats(
    method memory_stats (line 1878) | def memory_stats(self, **kwargs) -> dict[str, Any] | Awaitable[dict[st...
    method memory_malloc_stats (line 1887) | def memory_malloc_stats(self: SyncClientProtocol, **kwargs) -> bytes |...
    method memory_malloc_stats (line 1890) | def memory_malloc_stats(
    method memory_malloc_stats (line 1894) | def memory_malloc_stats(self, **kwargs) -> (bytes | str) | Awaitable[b...
    method memory_usage (line 1903) | def memory_usage(
    method memory_usage (line 1908) | def memory_usage(
    method memory_usage (line 1912) | def memory_usage(self, key: KeyT, samples: int | None = None, **kwargs...
    method memory_purge (line 1931) | def memory_purge(self: SyncClientProtocol, **kwargs) -> bool: ...
    method memory_purge (line 1934) | def memory_purge(self: AsyncClientProtocol, **kwargs) -> Awaitable[boo...
    method memory_purge (line 1936) | def memory_purge(self, **kwargs) -> bool | Awaitable[bool]:
    method latency_histogram (line 1944) | def latency_histogram(self, *args):
    method latency_history (line 1954) | def latency_history(self: SyncClientProtocol, event: str) -> list[list...
    method latency_history (line 1957) | def latency_history(
    method latency_history (line 1961) | def latency_history(
    method latency_latest (line 1972) | def latency_latest(self: SyncClientProtocol) -> list[list[bytes | str ...
    method latency_latest (line 1975) | def latency_latest(
    method latency_latest (line 1979) | def latency_latest(
    method latency_reset (line 1990) | def latency_reset(self: SyncClientProtocol, *events: str) -> int: ...
    method latency_reset (line 1993) | def latency_reset(self: AsyncClientProtocol, *events: str) -> Awaitabl...
    method latency_reset (line 1995) | def latency_reset(self, *events: str) -> int | Awaitable[int]:
    method ping (line 2004) | def ping(self: SyncClientProtocol, **kwargs) -> bool: ...
    method ping (line 2007) | def ping(self: AsyncClientProtocol, **kwargs) -> Awaitable[bool]: ...
    method ping (line 2009) | def ping(self, **kwargs) -> Union[Awaitable[bool], bool]:
    method quit (line 2025) | def quit(self: SyncClientProtocol, **kwargs) -> bool: ...
    method quit (line 2028) | def quit(self: AsyncClientProtocol, **kwargs) -> Awaitable[bool]: ...
    method quit (line 2030) | def quit(self, **kwargs) -> bool | Awaitable[bool]:
    method replicaof (line 2039) | def replicaof(self: SyncClientProtocol, *args, **kwargs) -> bytes | st...
    method replicaof (line 2042) | def replicaof(
    method replicaof (line 2046) | def replicaof(self, *args, **kwargs) -> (bytes | str) | Awaitable[byte...
    method save (line 2060) | def save(self: SyncClientProtocol, **kwargs) -> bool: ...
    method save (line 2063) | def save(self: AsyncClientProtocol, **kwargs) -> Awaitable[bool]: ...
    method save (line 2065) | def save(self, **kwargs) -> bool | Awaitable[bool]:
    method shutdown (line 2074) | def shutdown(
    method slaveof (line 2117) | def slaveof(
    method slaveof (line 2125) | def slaveof(
    method slaveof (line 2132) | def slaveof(
    method slowlog_get (line 2147) | def slowlog_get(
    method slowlog_get (line 2152) | def slowlog_get(
    method slowlog_get (line 2156) | def slowlog_get(
    method slowlog_len (line 2176) | def slowlog_len(self: SyncClientProtocol, **kwargs) -> int: ...
    method slowlog_len (line 2179) | def slowlog_len(self: AsyncClientProtocol, **kwargs) -> Awaitable[int]...
    method slowlog_len (line 2181) | def slowlog_len(self, **kwargs) -> int | Awaitable[int]:
    method slowlog_reset (line 2190) | def slowlog_reset(self: SyncClientProtocol, **kwargs) -> bool: ...
    method slowlog_reset (line 2193) | def slowlog_reset(self: AsyncClientProtocol, **kwargs) -> Awaitable[bo...
    method slowlog_reset (line 2195) | def slowlog_reset(self, **kwargs) -> bool | Awaitable[bool]:
    method time (line 2204) | def time(self: SyncClientProtocol, **kwargs) -> tuple[int, int]: ...
    method time (line 2207) | def time(self: AsyncClientProtocol, **kwargs) -> Awaitable[tuple[int, ...
    method time (line 2209) | def time(self, **kwargs) -> tuple[int, int] | Awaitable[tuple[int, int]]:
    method wait (line 2219) | def wait(
    method wait (line 2224) | def wait(
    method wait (line 2228) | def wait(self, num_replicas: int, timeout: int, **kwargs) -> int | Awa...
    method waitaof (line 2240) | def waitaof(
    method waitaof (line 2249) | def waitaof(
    method waitaof (line 2257) | def waitaof(
    method hello (line 2272) | def hello(self):
    method failover (line 2281) | def failover(self):
    method hotkeys_start (line 2291) | def hotkeys_start(
    method hotkeys_start (line 2302) | def hotkeys_start(
    method hotkeys_start (line 2312) | def hotkeys_start(
    method hotkeys_stop (line 2361) | def hotkeys_stop(self: SyncClientProtocol, **kwargs) -> bytes | str: ...
    method hotkeys_stop (line 2364) | def hotkeys_stop(self: AsyncClientProtocol, **kwargs) -> Awaitable[byt...
    method hotkeys_stop (line 2366) | def hotkeys_stop(self, **kwargs) -> (bytes | str) | Awaitable[bytes | ...
    method hotkeys_reset (line 2376) | def hotkeys_reset(self: SyncClientProtocol, **kwargs) -> bytes | str: ...
    method hotkeys_reset (line 2379) | def hotkeys_reset(
    method hotkeys_reset (line 2383) | def hotkeys_reset(self, **kwargs) -> (bytes | str) | Awaitable[bytes |...
    method hotkeys_get (line 2393) | def hotkeys_get(
    method hotkeys_get (line 2398) | def hotkeys_get(
    method hotkeys_get (line 2402) | def hotkeys_get(
  class AsyncManagementCommands (line 2421) | class AsyncManagementCommands(ManagementCommands):
    method command_info (line 2422) | async def command_info(self, **kwargs) -> None:
    method debug_segfault (line 2425) | async def debug_segfault(self, **kwargs) -> None:
    method memory_doctor (line 2428) | async def memory_doctor(self, **kwargs) -> None:
    method memory_help (line 2431) | async def memory_help(self, **kwargs) -> None:
    method shutdown (line 2434) | async def shutdown(
  class BitFieldOperation (line 2472) | class BitFieldOperation:
    method __init__ (line 2477) | def __init__(
    method reset (line 2491) | def reset(self):
    method overflow (line 2499) | def overflow(self, overflow: str):
    method incrby (line 2512) | def incrby(
    method get (line 2538) | def get(self, fmt: str, offset: BitfieldOffsetT):
    method set (line 2551) | def set(self, fmt: str, offset: BitfieldOffsetT, value: int):
    method command (line 2566) | def command(self):
    method execute (line 2572) | def execute(self) -> ResponseT:
  class DataPersistOptions (line 2584) | class DataPersistOptions(Enum):
  class BasicKeyCommands (line 2594) | class BasicKeyCommands(CommandsProtocol):
    method append (line 2600) | def append(self: SyncClientProtocol, key: KeyT, value: EncodableT) -> ...
    method append (line 2603) | def append(
    method append (line 2607) | def append(self, key: KeyT, value: EncodableT) -> int | Awaitable[int]:
    method bitcount (line 2618) | def bitcount(
    method bitcount (line 2627) | def bitcount(
    method bitcount (line 2635) | def bitcount(
    method bitfield (line 2658) | def bitfield(
    method bitfield_ro (line 2672) | def bitfield_ro(
    method bitfield_ro (line 2681) | def bitfield_ro(
    method bitfield_ro (line 2689) | def bitfield_ro(
    method bitop (line 2713) | def bitop(
    method bitop (line 2718) | def bitop(
    method bitop (line 2722) | def bitop(self, operation: str, dest: KeyT, *keys: KeyT) -> int | Awai...
    method bitpos (line 2732) | def bitpos(
    method bitpos (line 2742) | def bitpos(
    method bitpos (line 2751) | def bitpos(
    method copy (line 2783) | def copy(
    method copy (line 2792) | def copy(
    method copy (line 2800) | def copy(
    method decrby (line 2827) | def decrby(self: SyncClientProtocol, name: KeyT, amount: int = 1) -> i...
    method decrby (line 2830) | def decrby(
    method decrby (line 2834) | def decrby(self, name: KeyT, amount: int = 1) -> int | Awaitable[int]:
    method delete (line 2846) | def delete(self: SyncClientProtocol, *names: KeyT) -> int: ...
    method delete (line 2849) | def delete(self: AsyncClientProtocol, *names: KeyT) -> Awaitable[int]:...
    method delete (line 2851) | def delete(self, *names: KeyT) -> int | Awaitable[int]:
    method __delitem__ (line 2857) | def __delitem__(self, name: KeyT):
    method delex (line 2861) | def delex(
    method delex (line 2871) | def delex(
    method delex (line 2881) | def delex(
    method dump (line 2932) | def dump(self: SyncClientProtocol, name: KeyT) -> bytes | None: ...
    method dump (line 2935) | def dump(self: AsyncClientProtocol, name: KeyT) -> Awaitable[bytes | N...
    method dump (line 2937) | def dump(self, name: KeyT) -> (bytes | None) | Awaitable[bytes | None]:
    method exists (line 2951) | def exists(self: SyncClientProtocol, *names: KeyT) -> int: ...
    method exists (line 2954) | def exists(self: AsyncClientProtocol, *names: KeyT) -> Awaitable[int]:...
    method exists (line 2956) | def exists(self, *names: KeyT) -> int | Awaitable[int]:
    method expire (line 2967) | def expire(
    method expire (line 2978) | def expire(
    method expire (line 2988) | def expire(
    method expireat (line 3026) | def expireat(
    method expireat (line 3037) | def expireat(
    method expireat (line 3047) | def expireat(
    method expiretime (line 3085) | def expiretime(self: SyncClientProtocol, key: str) -> int: ...
    method expiretime (line 3088) | def expiretime(self: AsyncClientProtocol, key: str) -> Awaitable[int]:...
    method expiretime (line 3090) | def expiretime(self, key: str) -> int | Awaitable[int]:
    method digest_local (line 3100) | def digest_local(self, value: bytes | str) -> bytes | str:
    method digest (line 3138) | def digest(self: SyncClientProtocol, name: KeyT) -> str | bytes | None...
    method digest (line 3141) | def digest(
    method digest (line 3146) | def digest(self, name: KeyT) -> (str | bytes | None) | Awaitable[
    method get (line 3174) | def get(self: SyncClientProtocol, name: KeyT) -> bytes | str | None: ...
    method get (line 3177) | def get(self: AsyncClientProtocol, name: KeyT) -> Awaitable[bytes | st...
    method get (line 3179) | def get(self, name: KeyT) -> (bytes | str | None) | Awaitable[bytes | ...
    method getdel (line 3188) | def getdel(self: SyncClientProtocol, name: KeyT) -> bytes | str | None...
    method getdel (line 3191) | def getdel(
    method getdel (line 3195) | def getdel(self, name: KeyT) -> (bytes | str | None) | Awaitable[
    method getex (line 3209) | def getex(
    method getex (line 3220) | def getex(
    method getex (line 3230) | def getex(
    method __getitem__ (line 3272) | def __getitem__(self, name: KeyT):
    method getbit (line 3283) | def getbit(self: SyncClientProtocol, name: KeyT, offset: int) -> int: ...
    method getbit (line 3286) | def getbit(
    method getbit (line 3290) | def getbit(self, name: KeyT, offset: int) -> int | Awaitable[int]:
    method getrange (line 3299) | def getrange(
    method getrange (line 3304) | def getrange(
    method getrange (line 3308) | def getrange(self, key: KeyT, start: int, end: int) -> (bytes | str) |...
    method getset (line 3320) | def getset(
    method getset (line 3325) | def getset(
    method getset (line 3329) | def getset(self, name: KeyT, value: EncodableT) -> (bytes | str | None...
    method incrby (line 3344) | def incrby(self: SyncClientProtocol, name: KeyT, amount: int = 1) -> i...
    method incrby (line 3347) | def incrby(
    method incrby (line 3351) | def incrby(self, name: KeyT, amount: int = 1) -> int | Awaitable[int]:
    method incrbyfloat (line 3363) | def incrbyfloat(
    method incrbyfloat (line 3368) | def incrbyfloat(
    method incrbyfloat (line 3372) | def incrbyfloat(self, name: KeyT, amount: float = 1.0) -> float | Awai...
    method keys (line 3382) | def keys(
    method keys (line 3387) | def keys(
    method keys (line 3391) | def keys(
    method lmove (line 3402) | def lmove(
    method lmove (line 3411) | def lmove(
    method lmove (line 3419) | def lmove(
    method blmove (line 3433) | def blmove(
    method blmove (line 3443) | def blmove(
    method blmove (line 3452) | def blmove(
    method mget (line 3469) | def mget(
    method mget (line 3474) | def mget(
    method mget (line 3478) | def mget(
    method mset (line 3500) | def mset(
    method mset (line 3505) | def mset(
    method mset (line 3509) | def mset(self, mapping: Mapping[AnyKeyT, EncodableT]) -> bool | Awaita...
    method msetex (line 3527) | def msetex(
    method msetex (line 3539) | def msetex(
    method msetex (line 3550) | def msetex(
    method msetnx (line 3616) | def msetnx(
    method msetnx (line 3621) | def msetnx(
    method msetnx (line 3625) | def msetnx(self, mapping: Mapping[AnyKeyT, EncodableT]) -> bool | Awai...
    method move (line 3644) | def move(self: SyncClientProtocol, name: KeyT, db: int) -> bool: ...
    method move (line 3647) | def move(self: AsyncClientProtocol, name: KeyT, db: int) -> Awaitable[...
    method move (line 3649) | def move(self, name: KeyT, db: int) -> bool | Awaitable[bool]:
    method persist (line 3658) | def persist(self: SyncClientProtocol, name: KeyT) -> bool: ...
    method persist (line 3661) | def persist(self: AsyncClientProtocol, name: KeyT) -> Awaitable[bool]:...
    method persist (line 3663) | def persist(self, name: KeyT) -> bool | Awaitable[bool]:
    method pexpire (line 3672) | def pexpire(
    method pexpire (line 3683) | def pexpire(
    method pexpire (line 3693) | def pexpire(
    method pexpireat (line 3730) | def pexpireat(
    method pexpireat (line 3741) | def pexpireat(
    method pexpireat (line 3751) | def pexpireat(
    method pexpiretime (line 3787) | def pexpiretime(self: SyncClientProtocol, key: str) -> int: ...
    method pexpiretime (line 3790) | def pexpiretime(self: AsyncClientProtocol, key: str) -> Awaitable[int]...
    method pexpiretime (line 3792) | def pexpiretime(self, key: str) -> int | Awaitable[int]:
    method psetex (line 3802) | def psetex(
    method psetex (line 3807) | def psetex(
    method psetex (line 3811) | def psetex(
    method pttl (line 3826) | def pttl(self: SyncClientProtocol, name: KeyT) -> int: ...
    method pttl (line 3829) | def pttl(self: AsyncClientProtocol, name: KeyT) -> Awaitable[int]: ...
    method pttl (line 3831) | def pttl(self, name: KeyT) -> int | Awaitable[int]:
    method hrandfield (line 3840) | def hrandfield(
    method hrandfield (line 3848) | def hrandfield(
    method hrandfield (line 3855) | def hrandfield(
    method randomkey (line 3882) | def randomkey(self: SyncClientProtocol, **kwargs) -> bytes | str | Non...
    method randomkey (line 3885) | def randomkey(
    method randomkey (line 3889) | def randomkey(self, **kwargs) -> (bytes | str | None) | Awaitable[
    method rename (line 3900) | def rename(self: SyncClientProtocol, src: KeyT, dst: KeyT) -> bool: ...
    method rename (line 3903) | def rename(self: AsyncClientProtocol, src: KeyT, dst: KeyT) -> Awaitab...
    method rename (line 3905) | def rename(self, src: KeyT, dst: KeyT) -> bool | Awaitable[bool]:
    method renamenx (line 3914) | def renamenx(self: SyncClientProtocol, src: KeyT, dst: KeyT) -> bool: ...
    method renamenx (line 3917) | def renamenx(
    method renamenx (line 3921) | def renamenx(self, src: KeyT, dst: KeyT) -> bool | Awaitable[bool]:
    method restore (line 3930) | def restore(
    method restore (line 3942) | def restore(
    method restore (line 3953) | def restore(
    method set (line 4004) | def set(
    method set (line 4023) | def set(
    method set (line 4042) | def set(
    method __setitem__ (line 4154) | def __setitem__(self, name: KeyT, value: EncodableT):
    method setbit (line 4158) | def setbit(
    method setbit (line 4163) | def setbit(
    method setbit (line 4167) | def setbit(self, name: KeyT, offset: int, value: int) -> int | Awaitab...
    method setex (line 4178) | def setex(
    method setex (line 4183) | def setex(
    method setex (line 4187) | def setex(
    method setnx (line 4202) | def setnx(self: SyncClientProtocol, name: KeyT, value: EncodableT) -> ...
    method setnx (line 4205) | def setnx(
    method setnx (line 4209) | def setnx(self, name: KeyT, value: EncodableT) -> bool | Awaitable[bool]:
    method setrange (line 4218) | def setrange(
    method setrange (line 4223) | def setrange(
    method setrange (line 4227) | def setrange(
    method stralgo (line 4245) | def stralgo(
    method stralgo (line 4259) | def stralgo(
    method stralgo (line 4272) | def stralgo(
    method strlen (line 4337) | def strlen(self: SyncClientProtocol, name: KeyT) -> int: ...
    method strlen (line 4340) | def strlen(self: AsyncClientProtocol, name: KeyT) -> Awaitable[int]: ...
    method strlen (line 4342) | def strlen(self, name: KeyT) -> int | Awaitable[int]:
    method substr (line 4351) | def substr(
    method substr (line 4356) | def substr(
    method substr (line 4360) | def substr(self, name: KeyT, start: int, end: int = -1) -> (
    method touch (line 4370) | def touch(self: SyncClientProtocol, *args: KeyT) -> int: ...
    method touch (line 4373) | def touch(self: AsyncClientProtocol, *args: KeyT) -> Awaitable[int]: ...
    method touch (line 4375) | def touch(self, *args: KeyT) -> int | Awaitable[int]:
    method ttl (line 4385) | def ttl(self: SyncClientProtocol, name: KeyT) -> int: ...
    method ttl (line 4388) | def ttl(self: AsyncClientProtocol, name: KeyT) -> Awaitable[int]: ...
    method ttl (line 4390) | def ttl(self, name: KeyT) -> int | Awaitable[int]:
    method type (line 4399) | def type(self: SyncClientProtocol, name: KeyT) -> bytes | str: ...
    method type (line 4402) | def type(self: AsyncClientProtocol, name: KeyT) -> Awaitable[bytes | s...
    method type (line 4404) | def type(self, name: KeyT) -> (bytes | str) | Awaitable[bytes | str]:
    method watch (line 4412) | def watch(self, *names: KeyT) -> None:
    method unwatch (line 4420) | def unwatch(self) -> None:
    method unlink (line 4429) | def unlink(self: SyncClientProtocol, *names: KeyT) -> int: ...
    method unlink (line 4432) | def unlink(self: AsyncClientProtocol, *names: KeyT) -> Awaitable[int]:...
    method unlink (line 4434) | def unlink(self, *names: KeyT) -> int | Awaitable[int]:
    method lcs (line 4443) | def lcs(
    method lcs (line 4454) | def lcs(
    method lcs (line 4464) | def lcs(
  class AsyncBasicKeyCommands (line 4496) | class AsyncBasicKeyCommands(BasicKeyCommands):
    method __delitem__ (line 4497) | def __delitem__(self, name: KeyT):
    method __contains__ (line 4500) | def __contains__(self, name: KeyT):
    method __getitem__ (line 4503) | def __getitem__(self, name: KeyT):
    method __setitem__ (line 4506) | def __setitem__(self, name: KeyT, value: EncodableT):
    method watch (line 4509) | async def watch(self, *names: KeyT) -> None:
    method unwatch (line 4512) | async def unwatch(self) -> None:
  class ListCommands (line 4516) | class ListCommands(CommandsProtocol):
    method blpop (line 4523) | def blpop(
    method blpop (line 4528) | def blpop(
    method blpop (line 4532) | def blpop(
    method brpop (line 4554) | def brpop(
    method brpop (line 4559) | def brpop(
    method brpop (line 4563) | def brpop(
    method brpoplpush (line 4585) | def brpoplpush(
    method brpoplpush (line 4590) | def brpoplpush(
    method brpoplpush (line 4594) | def brpoplpush(self, src: KeyT, dst: KeyT, timeout: Number | None = 0)...
    method blmpop (line 4612) | def blmpop(
    method blmpop (line 4622) | def blmpop(
    method blmpop (line 4631) | def blmpop(
    method lmpop (line 4653) | def lmpop(
    method lmpop (line 4662) | def lmpop(
    method lmpop (line 4670) | def lmpop(
    method lindex (line 4690) | def lindex(
    method lindex (line 4695) | def lindex(
    method lindex (line 4699) | def lindex(self, name: KeyT, index: int) -> (bytes | str | None) | Awa...
    method linsert (line 4713) | def linsert(
    method linsert (line 4718) | def linsert(
    method linsert (line 4722) | def linsert(
    method llen (line 4737) | def llen(self: SyncClientProtocol, name: KeyT) -> int: ...
    method llen (line 4740) | def llen(self: AsyncClientProtocol, name: KeyT) -> Awaitable[int]: ...
    method llen (line 4742) | def llen(self, name: KeyT) -> int | Awaitable[int]:
    method lpop (line 4751) | def lpop(
    method lpop (line 4758) | def lpop(
    method lpop (line 4764) | def lpop(
    method lpush (line 4786) | def lpush(self: SyncClientProtocol, name: KeyT, *values: FieldT) -> in...
    method lpush (line 4789) | def lpush(
    method lpush (line 4793) | def lpush(self, name: KeyT, *values: FieldT) -> int | Awaitable[int]:
    method lpushx (line 4802) | def lpushx(self: SyncClientProtocol, name: KeyT, *values: FieldT) -> i...
    method lpushx (line 4805) | def lpushx(
    method lpushx (line 4809) | def lpushx(self, name: KeyT, *values: FieldT) -> int | Awaitable[int]:
    method lrange (line 4818) | def lrange(
    method lrange (line 4823) | def lrange(
    method lrange (line 4827) | def lrange(
    method lrem (line 4842) | def lrem(self: SyncClientProtocol, name: KeyT, count: int, value: str)...
    method lrem (line 4845) | def lrem(
    method lrem (line 4849) | def lrem(self, name: KeyT, count: int, value: str) -> int | Awaitable[...
    method lset (line 4864) | def lset(self: SyncClientProtocol, name: KeyT, index: int, value: str)...
    method lset (line 4867) | def lset(
    method lset (line 4871) | def lset(self, name: KeyT, index: int, value: str) -> bool | Awaitable...
    method ltrim (line 4880) | def ltrim(self: SyncClientProtocol, name: KeyT, start: int, end: int) ...
    method ltrim (line 4883) | def ltrim(
    method ltrim (line 4887) | def ltrim(self, name: KeyT, start: int, end: int) -> bool | Awaitable[...
    method rpop (line 4900) | def rpop(
    method rpop (line 4907) | def rpop(
    method rpop (line 4913) | def rpop(
    method rpoplpush (line 4935) | def rpoplpush(
    method rpoplpush (line 4940) | def rpoplpush(
    method rpoplpush (line 4944) | def rpoplpush(self, src: KeyT, dst: KeyT) -> (bytes | str | None) | Aw...
    method rpush (line 4956) | def rpush(self: SyncClientProtocol, name: KeyT, *values: FieldT) -> in...
    method rpush (line 4959) | def rpush(
    method rpush (line 4963) | def rpush(self, name: KeyT, *values: FieldT) -> int | Awaitable[int]:
    method rpushx (line 4972) | def rpushx(self: SyncClientProtocol, name: KeyT, *values: str) -> int:...
    method rpushx (line 4975) | def rpushx(
    method rpushx (line 4979) | def rpushx(self, name: KeyT, *values: str) -> int | Awaitable[int]:
    method lpos (line 4988) | def lpos(
    method lpos (line 4998) | def lpos(
    method lpos (line 5007) | def lpos(
    method sort (line 5053) | def sort(
    method sort (line 5067) | def sort(
    method sort (line 5080) | def sort(
    method sort_ro (line 5154) | def sort_ro(
    method sort_ro (line 5166) | def sort_ro(
    method sort_ro (line 5177) | def sort_ro(
  class ScanCommands (line 5214) | class ScanCommands(CommandsProtocol):
    method scan (line 5221) | def scan(
    method scan (line 5231) | def scan(
    method scan (line 5240) | def scan(
    method scan_iter (line 5273) | def scan_iter(
    method sscan (line 5302) | def sscan(
    method sscan (line 5311) | def sscan(
    method sscan (line 5319) | def sscan(
    method sscan_iter (line 5343) | def sscan_iter(
    method hscan (line 5363) | def hscan(
    method hscan (line 5373) | def hscan(
    method hscan (line 5382) | def hscan(
    method hscan_iter (line 5411) | def hscan_iter(
    method zscan (line 5439) | def zscan(
    method zscan (line 5449) | def zscan(
    method zscan (line 5458) | def zscan(
    method zscan_iter (line 5486) | def zscan_iter(
  class AsyncScanCommands (line 5515) | class AsyncScanCommands(ScanCommands):
    method scan_iter (line 5516) | async def scan_iter(
    method sscan_iter (line 5545) | async def sscan_iter(
    method hscan_iter (line 5567) | async def hscan_iter(
    method zscan_iter (line 5596) | async def zscan_iter(
  class SetCommands (line 5626) | class SetCommands(CommandsProtocol):
    method sadd (line 5633) | def sadd(self: SyncClientProtocol, name: KeyT, *values: FieldT) -> int...
    method sadd (line 5636) | def sadd(
    method sadd (line 5640) | def sadd(self, name: KeyT, *values: FieldT) -> int | Awaitable[int]:
    method scard (line 5649) | def scard(self: SyncClientProtocol, name: KeyT) -> int: ...
    method scard (line 5652) | def scard(self: AsyncClientProtocol, name: KeyT) -> Awaitable[int]: ...
    method scard (line 5654) | def scard(self, name: KeyT) -> int | Awaitable[int]:
    method sdiff (line 5663) | def sdiff(
    method sdiff (line 5668) | def sdiff(
    method sdiff (line 5672) | def sdiff(
    method sdiffstore (line 5684) | def sdiffstore(
    method sdiffstore (line 5689) | def sdiffstore(
    method sdiffstore (line 5693) | def sdiffstore(self, dest: str, keys: List, *args: List) -> int | Awai...
    method sinter (line 5704) | def sinter(
    method sinter (line 5709) | def sinter(
    method sinter (line 5713) | def sinter(
    method sintercard (line 5725) | def sintercard(
    method sintercard (line 5730) | def sintercard(
    method sintercard (line 5734) | def sintercard(
    method sinterstore (line 5750) | def sinterstore(
    method sinterstore (line 5755) | def sinterstore(
    method sinterstore (line 5759) | def sinterstore(self, dest: KeyT, keys: List, *args: List) -> int | Aw...
    method sismember (line 5770) | def sismember(
    method sismember (line 5775) | def sismember(
    method sismember (line 5779) | def sismember(self, name: KeyT, value: str) -> (
    method smembers (line 5792) | def smembers(self: SyncClientProtocol, name: KeyT) -> set[bytes | str]...
    method smembers (line 5795) | def smembers(
    method smembers (line 5799) | def smembers(self, name: KeyT) -> set[bytes | str] | Awaitable[set[byt...
    method smismember (line 5808) | def smismember(
    method smismember (line 5813) | def smismember(
    method smismember (line 5817) | def smismember(
    method smove (line 5832) | def smove(self: SyncClientProtocol, src: KeyT, dst: KeyT, value: str) ...
    method smove (line 5835) | def smove(
    method smove (line 5839) | def smove(self, src: KeyT, dst: KeyT, value: str) -> bool | Awaitable[...
    method spop (line 5848) | def spop(
    method spop (line 5853) | def spop(
    method spop (line 5857) | def spop(self, name: KeyT, count: int | None = None) -> (
    method srandmember (line 5869) | def srandmember(
    method srandmember (line 5874) | def srandmember(
    method srandmember (line 5878) | def srandmember(self, name: KeyT, number: int | None = None) -> (
    method srem (line 5894) | def srem(self: SyncClientProtocol, name: KeyT, *values: FieldT) -> int...
    method srem (line 5897) | def srem(
    method srem (line 5901) | def srem(self, name: KeyT, *values: FieldT) -> int | Awaitable[int]:
    method sunion (line 5910) | def sunion(
    method sunion (line 5915) | def sunion(
    method sunion (line 5919) | def sunion(
    method sunionstore (line 5931) | def sunionstore(
    method sunionstore (line 5936) | def sunionstore(
    method sunionstore (line 5940) | def sunionstore(self, dest: KeyT, keys: List, *args: List) -> int | Aw...
  class StreamCommands (line 5954) | class StreamCommands(CommandsProtocol):
    method xack (line 5961) | def xack(
    method xack (line 5966) | def xack(
    method xack (line 5970) | def xack(
    method xackdel (line 5986) | def xackdel(
    method xackdel (line 5995) | def xackdel(
    method xackdel (line 6003) | def xackdel(
    method xadd (line 6026) | def xadd(
    method xadd (line 6042) | def xadd(
    method xadd (line 6057) | def xadd(
    method xcfgset (line 6148) | def xcfgset(
    method xcfgset (line 6156) | def xcfgset(
    method xcfgset (line 6163) | def xcfgset(
    method xautoclaim (line 6228) | def xautoclaim(
    method xautoclaim (line 6240) | def xautoclaim(
    method xautoclaim (line 6251) | def xautoclaim(
    method xclaim (line 6303) | def xclaim(
    method xclaim (line 6318) | def xclaim(
    method xclaim (line 6332) | def xclaim(
    method xdel (line 6416) | def xdel(self: SyncClientProtocol, name: KeyT, *ids: StreamIdT) -> int...
    method xdel (line 6419) | def xdel(
    method xdel (line 6423) | def xdel(self, name: KeyT, *ids: StreamIdT) -> int | Awaitable[int]:
    method xdelex (line 6436) | def xdelex(
    method xdelex (line 6444) | def xdelex(
    method xdelex (line 6451) | def xdelex(
    method xgroup_create (line 6472) | def xgroup_create(
    method xgroup_create (line 6482) | def xgroup_create(
    method xgroup_create (line 6491) | def xgroup_create(
    method xgroup_delconsumer (line 6516) | def xgroup_delconsumer(
    method xgroup_delconsumer (line 6521) | def xgroup_delconsumer(
    method xgroup_delconsumer (line 6528) | def xgroup_delconsumer(
    method xgroup_destroy (line 6544) | def xgroup_destroy(
    method xgroup_destroy (line 6549) | def xgroup_destroy(
    method xgroup_destroy (line 6553) | def xgroup_destroy(self, name: KeyT, groupname: GroupT) -> bool | Awai...
    method xgroup_createconsumer (line 6564) | def xgroup_createconsumer(
    method xgroup_createconsumer (line 6569) | def xgroup_createconsumer(
    method xgroup_createconsumer (line 6576) | def xgroup_createconsumer(
    method xgroup_setid (line 6594) | def xgroup_setid(
    method xgroup_setid (line 6603) | def xgroup_setid(
    method xgroup_setid (line 6611) | def xgroup_setid(
    method xinfo_consumers (line 6632) | def xinfo_consumers(
    method xinfo_consumers (line 6637) | def xinfo_consumers(
    method xinfo_consumers (line 6641) | def xinfo_consumers(
    method xinfo_groups (line 6654) | def xinfo_groups(self: SyncClientProtocol, name: KeyT) -> list[dict[st...
    method xinfo_groups (line 6657) | def xinfo_groups(
    method xinfo_groups (line 6661) | def xinfo_groups(
    method xinfo_stream (line 6673) | def xinfo_stream(
    method xinfo_stream (line 6678) | def xinfo_stream(
    method xinfo_stream (line 6682) | def xinfo_stream(
    method xlen (line 6700) | def xlen(self: SyncClientProtocol, name: KeyT) -> int: ...
    method xlen (line 6703) | def xlen(self: AsyncClientProtocol, name: KeyT) -> Awaitable[int]: ...
    method xlen (line 6705) | def xlen(self, name: KeyT) -> int | Awaitable[int]:
    method xpending (line 6714) | def xpending(
    method xpending (line 6719) | def xpending(
    method xpending (line 6723) | def xpending(
    method xpending_range (line 6736) | def xpending_range(
    method xpending_range (line 6748) | def xpending_range(
    method xpending_range (line 6759) | def xpending_range(
    method xrange (line 6817) | def xrange(
    method xrange (line 6826) | def xrange(
    method xrange (line 6834) | def xrange(
    method xread (line 6867) | def xread(
    method xread (line 6875) | def xread(
    method xread (line 6882) | def xread(
    method xreadgroup (line 6935) | def xreadgroup(
    method xreadgroup (line 6947) | def xreadgroup(
    method xreadgroup (line 6958) | def xreadgroup(
    method xrevrange (line 7039) | def xrevrange(
    method xrevrange (line 7048) | def xrevrange(
    method xrevrange (line 7056) | def xrevrange(
    method xtrim (line 7089) | def xtrim(
    method xtrim (line 7100) | def xtrim(
    method xtrim (line 7110) | def xtrim(
  class SortedSetCommands (line 7167) | class SortedSetCommands(CommandsProtocol):
    method zadd (line 7173) | def zadd(
    method zcard (line 7250) | def zcard(self, name: KeyT) -> ResponseT:
    method zcount (line 7259) | def zcount(
    method zcount (line 7264) | def zcount(
    method zcount (line 7268) | def zcount(
    method zdiff (line 7280) | def zdiff(
    method zdiff (line 7285) | def zdiff(
    method zdiff (line 7289) | def zdiff(
    method zdiffstore (line 7304) | def zdiffstore(self: SyncClientProtocol, dest: KeyT, keys: KeysT) -> i...
    method zdiffstore (line 7307) | def zdiffstore(
    method zdiffstore (line 7311) | def zdiffstore(self, dest: KeyT, keys: KeysT) -> int | Awaitable[int]:
    method zincrby (line 7322) | def zincrby(
    method zincrby (line 7327) | def zincrby(
    method zincrby (line 7331) | def zincrby(self, name: KeyT, amount: float, value: EncodableT) -> (
    method zinter (line 7342) | def zinter(
    method zinter (line 7350) | def zinter(
    method zinter (line 7357) | def zinter(
    method zinterstore (line 7374) | def zinterstore(
    method zinterstore (line 7382) | def zinterstore(
    method zinterstore (line 7389) | def zinterstore(
    method zintercard (line 7409) | def zintercard(
    method zintercard (line 7414) | def zintercard(
    method zintercard (line 7418) | def zintercard(
    method zlexcount (line 7434) | def zlexcount(
    method zlexcount (line 7439) | def zlexcount(
    method zlexcount (line 7443) | def zlexcount(
    method zpopmax (line 7455) | def zpopmax(
    method zpopmax (line 7460) | def zpopmax(
    method zpopmax (line 7464) | def zpopmax(
    method zpopmin (line 7478) | def zpopmin(
    method zpopmin (line 7483) | def zpopmin(
    method zpopmin (line 7487) | def zpopmin(
    method zrandmember (line 7501) | def zrandmember(
    method zrandmember (line 7509) | def zrandmember(
    method zrandmember (line 7516) | def zrandmember(
    method bzpopmax (line 7543) | def bzpopmax(
    method bzpopmax (line 7548) | def bzpopmax(
    method bzpopmax (line 7552) | def bzpopmax(
    method bzpopmin (line 7574) | def bzpopmin(
    method bzpopmin (line 7579) | def bzpopmin(
    method bzpopmin (line 7583) | def bzpopmin(
    method zmpop (line 7605) | def zmpop(
    method zmpop (line 7615) | def zmpop(
    method zmpop (line 7624) | def zmpop(
    method bzmpop (line 7650) | def bzmpop(
    method bzmpop (line 7661) | def bzmpop(
    method bzmpop (line 7671) | def bzmpop(
    method _zrange (line 7703) | def _zrange(
    method zrange (line 7745) | def zrange(
    method zrange (line 7760) | def zrange(
    method zrange (line 7774) | def zrange(
    method zrevrange (line 7836) | def zrevrange(
    method zrevrange (line 7846) | def zrevrange(
    method zrevrange (line 7855) | def zrevrange(
    method zrangestore (line 7884) | def zrangestore(
    method zrangestore (line 7898) | def zrangestore(
    method zrangestore (line 7911) | def zrangestore(
    method zrangebylex (line 7962) | def zrangebylex(
    method zrangebylex (line 7972) | def zrangebylex(
    method zrangebylex (line 7981) | def zrangebylex(
    method zrevrangebylex (line 8006) | def zrevrangebylex(
    method zrevrangebylex (line 8016) | def zrevrangebylex(
    method zrevrangebylex (line 8025) | def zrevrangebylex(
    method zrangebyscore (line 8050) | def zrangebyscore(
    method zrangebyscore (line 8062) | def zrangebyscore(
    method zrangebyscore (line 8073) | def zrangebyscore(
    method zrevrangebyscore (line 8109) | def zrevrangebyscore(
    method zrevrangebyscore (line 8121) | def zrevrangebyscore(
    method zrevrangebyscore (line 8132) | def zrevrangebyscore(
    method zrank (line 8168) | def zrank(
    method zrank (line 8177) | def zrank(
    method zrank (line 8185) | def zrank(
    method zrem (line 8211) | def zrem(self: SyncClientProtocol, name: KeyT, *values: FieldT) -> int...
    method zrem (line 8214) | def zrem(
    method zrem (line 8218) | def zrem(self, name: KeyT, *values: FieldT) -> int | Awaitable[int]:
    method zremrangebylex (line 8227) | def zremrangebylex(
    method zremrangebylex (line 8232) | def zremrangebylex(
    method zremrangebylex (line 8236) | def zremrangebylex(
    method zremrangebyrank (line 8250) | def zremrangebyrank(
    method zremrangebyrank (line 8255) | def zremrangebyrank(
    method zremrangebyrank (line 8259) | def zremrangebyrank(self, name: KeyT, min: int, max: int) -> int | Awa...
    method zremrangebyscore (line 8271) | def zremrangebyscore(
    method zremrangebyscore (line 8276) | def zremrangebyscore(
    method zremrangebyscore (line 8280) | def zremrangebyscore(
    method zrevrank (line 8292) | def zrevrank(
    method zrevrank (line 8301) | def zrevrank(
    method zrevrank (line 8309) | def zrevrank(
    method zscore (line 8335) | def zscore(
    method zscore (line 8340) | def zscore(
    method zscore (line 8344) | def zscore(self, name: KeyT, value: EncodableT) -> (float | None) | Aw...
    method zunion (line 8355) | def zunion(
    method zunion (line 8364) | def zunion(
    method zunion (line 8372) | def zunion(
    method zunionstore (line 8399) | def zunionstore(
    method zunionstore (line 8407) | def zunionstore(
    method zunionstore (line 8414) | def zunionstore(
    method zmscore (line 8430) | def zmscore(
    method zmscore (line 8435) | def zmscore(
    method zmscore (line 8439) | def zmscore(
    method _zaggregate (line 8457) | def _zaggregate(
  class HyperlogCommands (line 8492) | class HyperlogCommands(CommandsProtocol):
    method pfadd (line 8499) | def pfadd(self: SyncClientProtocol, name: KeyT, *values: FieldT) -> in...
    method pfadd (line 8502) | def pfadd(
    method pfadd (line 8506) | def pfadd(self, name: KeyT, *values: FieldT) -> int | Awaitable[int]:
    method pfcount (line 8515) | def pfcount(self: SyncClientProtocol, *sources: KeyT) -> int: ...
    method pfcount (line 8518) | def pfcount(self: AsyncClientProtocol, *sources: KeyT) -> Awaitable[in...
    method pfcount (line 8520) | def pfcount(self, *sources: KeyT) -> int | Awaitable[int]:
    method pfmerge (line 8530) | def pfmerge(self: SyncClientProtocol, dest: KeyT, *sources: KeyT) -> b...
    method pfmerge (line 8533) | def pfmerge(
    method pfmerge (line 8537) | def pfmerge(self, dest: KeyT, *sources: KeyT) -> bool | Awaitable[bool]:
  class HashDataPersistOptions (line 8549) | class HashDataPersistOptions(Enum):
  class HashCommands (line 8559) | class HashCommands(CommandsProtocol):
    method hdel (line 8566) | def hdel(self: SyncClientProtocol, name: str, *keys: str) -> int: ...
    method hdel (line 8569) | def hdel(self: AsyncClientProtocol, name: str, *keys: str) -> Awaitabl...
    method hdel (line 8571) | def hdel(self, name: str, *keys: str) -> int | Awaitable[int]:
    method hexists (line 8580) | def hexists(self: SyncClientProtocol, name: str, key: str) -> bool: ...
    method hexists (line 8583) | def hexists(self: AsyncClientProtocol, name: str, key: str) -> Awaitab...
    method hexists (line 8585) | def hexists(self, name: str, key: str) -> bool | Awaitable[bool]:
    method hget (line 8594) | def hget(self: SyncClientProtocol, name: str, key: str) -> bytes | str...
    method hget (line 8597) | def hget(
    method hget (line 8601) | def hget(self, name: str, key: str) -> (bytes | str | None) | Awaitable[
    method hgetall (line 8612) | def hgetall(
    method hgetall (line 8617) | def hgetall(
    method hgetall (line 8621) | def hgetall(
    method hgetdel (line 8632) | def hgetdel(
    method hgetdel (line 8637) | def hgetdel(
    method hgetdel (line 8641) | def hgetdel(
    method hgetex (line 8659) | def hgetex(
    method hgetex (line 8671) | def hgetex(
    method hgetex (line 8682) | def hgetex(
    method hincrby (line 8735) | def hincrby(
    method hincrby (line 8740) | def hincrby(
    method hincrby (line 8744) | def hincrby(self, name: str, key: str, amount: int = 1) -> int | Await...
    method hincrbyfloat (line 8753) | def hincrbyfloat(
    method hincrbyfloat (line 8758) | def hincrbyfloat(
    method hincrbyfloat (line 8762) | def hincrbyfloat(
    method hkeys (line 8773) | def hkeys(self: SyncClientProtocol, name: str) -> list[bytes | str]: ...
    method hkeys (line 8776) | def hkeys(self: AsyncClientProtocol, name: str) -> Awaitable[list[byte...
    method hkeys (line 8778) | def hkeys(self, name: str) -> list[bytes | str] | Awaitable[list[bytes...
    method hlen (line 8787) | def hlen(self: SyncClientProtocol, name: str) -> int: ...
    method hlen (line 8790) | def hlen(self: AsyncClientProtocol, name: str) -> Awaitable[int]: ...
    method hlen (line 8792) | def hlen(self, name: str) -> int | Awaitable[int]:
    method hset (line 8801) | def hset(
    method hset (line 8811) | def hset(
    method hset (line 8820) | def hset(
    method hsetex (line 8854) | def hsetex(
    method hsetex (line 8870) | def hsetex(
    method hsetex (line 8885) | def hsetex(
    method hsetnx (line 8968) | def hsetnx(self: SyncClientProtocol, name: str, key: str, value: str) ...
    method hsetnx (line 8971) | def hsetnx(
    method hsetnx (line 8975) | def hsetnx(self, name: str, key: str, value: str) -> int | Awaitable[i...
    method hmset (line 8985) | def hmset(self: SyncClientProtocol, name: str, mapping: dict) -> bool:...
    method hmset (line 8988) | def hmset(
    method hmset (line 8997) | def hmset(self, name: str, mapping: dict) -> bool | Awaitable[bool]:
    method hmget (line 9012) | def hmget(
    method hmget (line 9017) | def hmget(
    method hmget (line 9021) | def hmget(
    method hvals (line 9033) | def hvals(self: SyncClientProtocol, name: str) -> list[bytes | str]: ...
    method hvals (line 9036) | def hvals(self: AsyncClientProtocol, name: str) -> Awaitable[list[byte...
    method hvals (line 9038) | def hvals(self, name: str) -> list[bytes | str] | Awaitable[list[bytes...
    method hstrlen (line 9047) | def hstrlen(self: SyncClientProtocol, name: str, key: str) -> int: ...
    method hstrlen (line 9050) | def hstrlen(self: AsyncClientProtocol, name: str, key: str) -> Awaitab...
    method hstrlen (line 9052) | def hstrlen(self, name: str, key: str) -> int | Awaitable[int]:
    method hexpire (line 9062) | def hexpire(
    method hexpire (line 9074) | def hexpire(
    method hexpire (line 9085) | def hexpire(
    method hpexpire (line 9146) | def hpexpire(
    method hpexpire (line 9158) | def hpexpire(
    method hpexpire (line 9169) | def hpexpire(
    method hexpireat (line 9230) | def hexpireat(
    method hexpireat (line 9242) | def hexpireat(
    method hexpireat (line 9253) | def hexpireat(
    method hpexpireat (line 9320) | def hpexpireat(
    method hpexpireat (line 9332) | def hpexpireat(
    method hpexpireat (line 9343) | def hpexpireat(
    method hpersist (line 9410) | def hpersist(self: SyncClientProtocol, name: KeyT, *fields: str) -> li...
    method hpersist (line 9413) | def hpersist(
    method hpersist (line 9417) | def hpersist(self, name: KeyT, *fields: str) -> list[int] | Awaitable[...
    method hexpiretime (line 9437) | def hexpiretime(self: SyncClientProtocol, key: KeyT, *fields: str) -> ...
    method hexpiretime (line 9440) | def hexpiretime(
    method hexpiretime (line 9444) | def hexpiretime(self, key: KeyT, *fields: str) -> list[int] | Awaitabl...
    method hpexpiretime (line 9467) | def hpexpiretime(
    method hpexpiretime (line 9472) | def hpexpiretime(
    method hpexpiretime (line 9476) | def hpexpiretime(self, key: KeyT, *fields: str) -> list[int] | Awaitab...
    method httl (line 9499) | def httl(self: SyncClientProtocol, key: KeyT, *fields: str) -> list[in...
    method httl (line 9502) | def httl(
    method httl (line 9506) | def httl(self, key: KeyT, *fields: str) -> list[int] | Awaitable[list[...
    method hpttl (line 9529) | def hpttl(self: SyncClientProtocol, key: KeyT, *fields: str) -> list[i...
    method hpttl (line 9532) | def hpttl(
    method hpttl (line 9536) | def hpttl(self, key: KeyT, *fields: str) -> list[int] | Awaitable[list...
  class Script (line 9562) | class Script:
    method __init__ (line 9567) | def __init__(self, registered_client: "redis.client.Redis", script: Sc...
    method __call__ (line 9579) | def __call__(
    method get_encoder (line 9606) | def get_encoder(self):
  class AsyncScript (line 9625) | class AsyncScript:
    method __init__ (line 9630) | def __init__(
    method __call__ (line 9650) | async def __call__(
  class PubSubCommands (line 9678) | class PubSubCommands(CommandsProtocol):
    method publish (line 9685) | def publish(
    method publish (line 9690) | def publish(
    method publish (line 9694) | def publish(
    method spublish (line 9711) | def spublish(
    method spublish (line 9716) | def spublish(
    method spublish (line 9720) | def spublish(
    method pubsub_channels (line 9738) | def pubsub_channels(
    method pubsub_channels (line 9743) | def pubsub_channels(
    method pubsub_channels (line 9747) | def pubsub_channels(
    method pubsub_shardchannels (line 9758) | def pubsub_shardchannels(
    method pubsub_shardchannels (line 9763) | def pubsub_shardchannels(
    method pubsub_shardchannels (line 9767) | def pubsub_shardchannels(
    method pubsub_numpat (line 9778) | def pubsub_numpat(self: SyncClientProtocol, **kwargs) -> int: ...
    method pubsub_numpat (line 9781) | def pubsub_numpat(self: AsyncClientProtocol, **kwargs) -> Awaitable[in...
    method pubsub_numpat (line 9783) | def pubsub_numpat(self, **kwargs) -> int | Awaitable[int]:
    method pubsub_numsub (line 9792) | def pubsub_numsub(
    method pubsub_numsub (line 9797) | def pubsub_numsub(
    method pubsub_numsub (line 9801) | def pubsub_numsub(
    method pubsub_shardnumsub (line 9813) | def pubsub_shardnumsub(
    method pubsub_shardnumsub (line 9818) | def pubsub_shardnumsub(
    method pubsub_shardnumsub (line 9822) | def pubsub_shardnumsub(
  class ScriptCommands (line 9837) | class ScriptCommands(CommandsProtocol):
    method _eval (line 9843) | def _eval(
    method eval (line 9853) | def eval(
    method eval (line 9861) | def eval(
    method eval (line 9868) | def eval(
    method eval_ro (line 9884) | def eval_ro(
    method eval_ro (line 9892) | def eval_ro(
    method eval_ro (line 9899) | def eval_ro(
    method _evalsha (line 9913) | def _evalsha(
    method evalsha (line 9923) | def evalsha(
    method evalsha (line 9931) | def evalsha(
    method evalsha (line 9938) | def evalsha(
    method evalsha_ro (line 9955) | def evalsha_ro(
    method evalsha_ro (line 9963) | def evalsha_ro(
    method evalsha_ro (line 9970) | def evalsha_ro(
    method script_exists (line 9986) | def script_exists(self: SyncClientProtocol, *args: str) -> list[bool]:...
    method script_exists (line 9989) | def script_exists(
    method script_exists (line 9993) | def script_exists(self, *args: str) -> list[bool] | Awaitable[list[boo...
    method script_debug (line 10003) | def script_debug(self, *args) -> None:
    method script_flush (line 10009) | def script_flush(
    method script_flush (line 10015) | def script_flush(
    method script_flush (line 10020) | def script_flush(
    method script_kill (line 10045) | def script_kill(self: SyncClientProtocol) -> bool: ...
    method script_kill (line 10048) | def script_kill(self: AsyncClientProtocol) -> Awaitable[bool]: ...
    method script_kill (line 10050) | def script_kill(self) -> bool | Awaitable[bool]:
    method script_load (line 10059) | def script_load(self: SyncClientProtocol, script: ScriptTextT) -> str:...
    method script_load (line 10062) | def script_load(
    method script_load (line 10066) | def script_load(self, script: ScriptTextT) -> str | Awaitable[str]:
    method register_script (line 10074) | def register_script(self: "redis.client.Redis", script: ScriptTextT) -...
  class AsyncScriptCommands (line 10084) | class AsyncScriptCommands(ScriptCommands):
    method script_debug (line 10085) | async def script_debug(self, *args) -> None:
    method register_script (line 10088) | def register_script(
  class GeoCommands (line 10101) | class GeoCommands(CommandsProtocol):
    method geoadd (line 10108) | def geoadd(
    method geoadd (line 10118) | def geoadd(
    method geoadd (line 10127) | def geoadd(
    method geodist (line 10170) | def geodist(
    method geodist (line 10179) | def geodist(
    method geodist (line 10187) | def geodist(
    method geohash (line 10206) | def geohash(
    method geohash (line 10211) | def geohash(
    method geohash (line 10215) | def geohash(
    method geopos (line 10227) | def geopos(
    method geopos (line 10232) | def geopos(
    method geopos (line 10236) | def geopos(
    method georadius (line 10249) | def georadius(
    method georadius (line 10267) | def georadius(
    method georadius (line 10284) | def georadius(
    method georadiusbymember (line 10348) | def georadiusbymember(
    method georadiusbymember (line 10365) | def georadiusbymember(
    method georadiusbymember (line 10381) | def georadiusbymember(
    method _georadiusgeneric (line 10420) | def _georadiusgeneric(
    method geosearch (line 10467) | def geosearch(
    method geosearch (line 10486) | def geosearch(
    method geosearch (line 10504) | def geosearch(
    method geosearchstore (line 10586) | def geosearchstore(
    method geosearchstore (line 10604) | def geosearchstore(
    method geosearchstore (line 10621) | def geosearchstore(
    method _geosearchgeneric (line 10668) | def _geosearchgeneric(
  class ModuleCommands (line 10738) | class ModuleCommands(CommandsProtocol):
    method module_load (line 10745) | def module_load(self: SyncClientProtocol, path, *args) -> bool: ...
    method module_load (line 10748) | def module_load(self: AsyncClientProtocol, path, *args) -> Awaitable[b...
    method module_load (line 10750) | def module_load(self, path, *args) -> bool | Awaitable[bool]:
    method module_loadex (line 10761) | def module_loadex(
    method module_loadex (line 10769) | def module_loadex(
    method module_loadex (line 10776) | def module_loadex(
    method module_unload (line 10798) | def module_unload(self: SyncClientProtocol, name) -> bool: ...
    method module_unload (line 10801) | def module_unload(self: AsyncClientProtocol, name) -> Awaitable[bool]:...
    method module_unload (line 10803) | def module_unload(self, name) -> bool | Awaitable[bool]:
    method module_list (line 10813) | def module_list(self: SyncClientProtocol) -> list[dict[Any, Any]]: ...
    method module_list (line 10816) | def module_list(self: AsyncClientProtocol) -> Awaitable[list[dict[Any,...
    method module_list (line 10818) | def module_list(self) -> list[dict[Any, Any]] | Awaitable[list[dict[An...
    method command_info (line 10827) | def command_info(self) -> None:
    method command_count (line 10833) | def command_count(self: SyncClientProtocol) -> int: ...
    method command_count (line 10836) | def command_count(self: AsyncClientProtocol) -> Awaitable[int]: ...
    method command_count (line 10838) | def command_count(self) -> int | Awaitable[int]:
    method command_getkeys (line 10842) | def command_getkeys(self: SyncClientProtocol, *args) -> list[bytes | s...
    method command_getkeys (line 10845) | def command_getkeys(
    method command_getkeys (line 10849) | def command_getkeys(
    method command (line 10855) | def command(self: SyncClientProtocol) -> dict[str, dict[str, Any]]: ...
    method command (line 10858) | def command(
    method command (line 10862) | def command(
  class AsyncModuleCommands (line 10868) | class AsyncModuleCommands(ModuleCommands):
    method command_info (line 10869) | async def command_info(self) -> None:
  class ClusterCommands (line 10873) | class ClusterCommands(CommandsProtocol):
    method cluster (line 10879) | def cluster(self: SyncClientProtocol, cluster_arg, *args, **kwargs) ->...
    method cluster (line 10882) | def cluster(
    method cluster (line 10886) | def cluster(self, cluster_arg, *args, **kwargs) -> Any | Awaitable[Any]:
    method readwrite (line 10890) | def readwrite(self: SyncClientProtocol, **kwargs) -> bool: ...
    method readwrite (line 10893) | def readwrite(self: AsyncClientProtocol, **kwargs) -> Awaitable[bool]:...
    method readwrite (line 10895) | def readwrite(self, **kwargs) -> bool | Awaitable[bool]:
    method readonly (line 10904) | def readonly(self: SyncClientProtocol, **kwargs) -> bool: ...
    method readonly (line 10907) | def readonly(self: AsyncClientProtocol, **kwargs) -> Awaitable[bool]: ...
    method readonly (line 10909) | def readonly(self, **kwargs) -> bool | Awaitable[bool]:
  class FunctionCommands (line 10921) | class FunctionCommands:
    method function_load (line 10927) | def function_load(
    method function_load (line 10932) | def function_load(
    method function_load (line 10936) | def function_load(self, code: str, replace: bool | None = False) -> (
    method function_delete (line 10954) | def function_delete(self: SyncClientProtocol, library: str) -> bool: ...
    method function_delete (line 10957) | def function_delete(self: AsyncClientProtocol, library: str) -> Awaita...
    method function_delete (line 10959) | def function_delete(self, library: str) -> bool | Awaitable[bool]:
    method function_flush (line 10968) | def function_flush(self: SyncClientProtocol, mode: str = "SYNC") -> bo...
    method function_flush (line 10971) | def function_flush(
    method function_flush (line 10975) | def function_flush(self, mode: str = "SYNC") -> bool | Awaitable[bool]:
    method function_list (line 10984) | def function_list(
    method function_list (line 10991) | def function_list(
    method function_list (line 10997) | def function_list(
    method _fcall (line 11014) | def _fcall(self, command: str, function, numkeys: int, *keys_and_args:...
    method fcall (line 11018) | def fcall(
    method fcall (line 11023) | def fcall(
    method fcall (line 11027) | def fcall(
    method fcall_ro (line 11038) | def fcall_ro(
    method fcall_ro (line 11043) | def fcall_ro(
    method fcall_ro (line 11047) | def fcall_ro(
    method function_dump (line 11059) | def function_dump(self: SyncClientProtocol) -> bytes: ...
    method function_dump (line 11062) | def function_dump(self: AsyncClientProtocol) -> Awaitable[bytes]: ...
    method function_dump (line 11064) | def function_dump(self) -> bytes | Awaitable[bytes]:
    method function_restore (line 11078) | def function_restore(
    method function_restore (line 11083) | def function_restore(
    method function_restore (line 11087) | def function_restore(
    method function_kill (line 11100) | def function_kill(self: SyncClientProtocol) -> bytes | str: ...
    method function_kill (line 11103) | def function_kill(self: AsyncClientProtocol) -> Awaitable[bytes | str]...
    method function_kill (line 11105) | def function_kill(self) -> (bytes | str) | Awaitable[bytes | str]:
    method function_stats (line 11114) | def function_stats(self: SyncClientProtocol) -> Any: ...
    method function_stats (line 11117) | def function_stats(self: AsyncClientProtocol) -> Awaitable[Any]: ...
    method function_stats (line 11119) | def function_stats(self) -> Any | Awaitable[Any]:
  class DataAccessCommands (line 11132) | class DataAccessCommands(
  class AsyncDataAccessCommands (line 11149) | class AsyncDataAccessCommands(
  class CoreCommands (line 11166) | class CoreCommands(
  class AsyncCoreCommands (line 11182) | class AsyncCoreCommands(

FILE: redis/commands/helpers.py
  function list_or_args (line 10) | def list_or_args(keys: KeysT, args: Tuple[KeyT, ...]) -> List[KeyT]:
  function nativestr (line 27) | def nativestr(x):
  function delist (line 35) | def delist(x):
  function parse_to_list (line 42) | def parse_to_list(response):
  function random_string (line 75) | def random_string(length=10):
  function decode_dict_keys (line 84) | def decode_dict_keys(obj):
  function get_protocol_version (line 94) | def get_protocol_version(client):
  function at_most_one_value_set (line 101) | def at_most_one_value_set(iterable: Iterable[Any]):

FILE: redis/commands/json/__init__.py
  class JSON (line 10) | class JSON(JSONCommands):
    method __init__ (line 21) | def __init__(
    method _decode (line 82) | def _decode(self, obj):
    method _encode (line 100) | def _encode(self, obj):
    method pipeline (line 104) | def pipeline(self, transaction=True, shard_hint=None):
  class ClusterPipeline (line 142) | class ClusterPipeline(JSONCommands, redis.cluster.ClusterPipeline):
  class Pipeline (line 146) | class Pipeline(JSONCommands, redis.client.Pipeline):

FILE: redis/commands/json/commands.py
  class JSONCommands (line 13) | class JSONCommands:
    method arrappend (line 16) | def arrappend(
    method arrindex (line 29) | def arrindex(
    method arrinsert (line 54) | def arrinsert(
    method arrlen (line 67) | def arrlen(
    method arrpop (line 77) | def arrpop(
    method arrtrim (line 90) | def arrtrim(
    method type (line 100) | def type(self, name: str, path: Optional[str] = Path.root_path()) -> L...
    method resp (line 107) | def resp(self, name: str, path: Optional[str] = Path.root_path()) -> L...
    method objkeys (line 114) | def objkeys(
    method objlen (line 124) | def objlen(
    method numincrby (line 134) | def numincrby(self, name: str, path: str, number: int) -> str:
    method nummultby (line 145) | def nummultby(self, name: str, path: str, number: int) -> str:
    method clear (line 155) | def clear(self, name: str, path: Optional[str] = Path.root_path()) -> ...
    method delete (line 166) | def delete(self, key: str, path: Optional[str] = Path.root_path()) -> ...
    method get (line 176) | def get(
    method mget (line 206) | def mget(self, keys: List[str], path: str) -> List[JsonType]:
    method set (line 218) | def set(
    method mset (line 257) | def mset(self, triplets: List[Tuple[str, str, JsonType]]) -> Optional[...
    method merge (line 274) | def merge(
    method set_file (line 297) | def set_file(
    method set_path (line 322) | def set_path(
    method strlen (line 360) | def strlen(self, name: str, path: Optional[str] = None) -> List[Option...
    method toggle (line 371) | def toggle(
    method strappend (line 381) | def strappend(
    method debug (line 393) | def debug(
    method jsonget (line 418) | def jsonget(self, *args, **kwargs):
    method jsonmget (line 424) | def jsonmget(self, *args, **kwargs):
    method jsonset (line 430) | def jsonset(self, *args, **kwargs):

FILE: redis/commands/json/decoders.py
  function bulk_of_jsons (line 7) | def bulk_of_jsons(d):
  function decode_dict_keys (line 21) | def decode_dict_keys(obj):
  function unstring (line 31) | def unstring(obj):
  function decode_list (line 49) | def decode_list(b):

FILE: redis/commands/json/path.py
  class Path (line 1) | class Path:
    method root_path (line 7) | def root_path():
    method __init__ (line 11) | def __init__(self, path):
    method __repr__ (line 15) | def __repr__(self):

FILE: redis/commands/policies.py
  class PolicyResolver (line 124) | class PolicyResolver(ABC):
    method resolve (line 126) | def resolve(self, command_name: str) -> Optional[CommandPolicies]:
    method with_fallback (line 139) | def with_fallback(self, fallback: "PolicyResolver") -> "PolicyResolver":
  class AsyncPolicyResolver (line 152) | class AsyncPolicyResolver(ABC):
    method resolve (line 154) | async def resolve(self, command_name: str) -> Optional[CommandPolicies]:
    method with_fallback (line 167) | def with_fallback(self, fallback: "AsyncPolicyResolver") -> "AsyncPoli...
  class BasePolicyResolver (line 180) | class BasePolicyResolver(PolicyResolver):
    method __init__ (line 185) | def __init__(
    method resolve (line 191) | def resolve(self, command_name: str) -> Optional[CommandPolicies]:
    method with_fallback (line 214) | def with_fallback(self, fallback: "PolicyResolver") -> "PolicyResolver":
  class AsyncBasePolicyResolver (line 218) | class AsyncBasePolicyResolver(AsyncPolicyResolver):
    method __init__ (line 223) | def __init__(
    method resolve (line 229) | async def resolve(self, command_name: str) -> Optional[CommandPolicies]:
    method with_fallback (line 252) | def with_fallback(self, fallback: "AsyncPolicyResolver") -> "AsyncPoli...
  class DynamicPolicyResolver (line 256) | class DynamicPolicyResolver(BasePolicyResolver):
    method __init__ (line 261) | def __init__(
    method with_fallback (line 273) | def with_fallback(self, fallback: "PolicyResolver") -> "PolicyResolver":
  class StaticPolicyResolver (line 277) | class StaticPolicyResolver(BasePolicyResolver):
    method __init__ (line 282) | def __init__(self, fallback: Optional[PolicyResolver] = None) -> None:
    method with_fallback (line 290) | def with_fallback(self, fallback: "PolicyResolver") -> "PolicyResolver":
  class AsyncDynamicPolicyResolver (line 294) | class AsyncDynamicPolicyResolver(AsyncBasePolicyResolver):
    method __init__ (line 299) | def __init__(
    method with_fallback (line 312) | def with_fallback(self, fallback: "AsyncPolicyResolver") -> "AsyncPoli...
  class AsyncStaticPolicyResolver (line 316) | class AsyncStaticPolicyResolver(AsyncBasePolicyResolver):
    method __init__ (line 321) | def __init__(self, fallback: Optional[AsyncPolicyResolver] = None) -> ...
    method with_fallback (line 329) | def with_fallback(self, fallback: "AsyncPolicyResolver") -> "AsyncPoli...

FILE: redis/commands/redismodules.py
  class RedisModuleCommands (line 14) | class RedisModuleCommands:
    method json (line 19) | def json(self, encoder=JSONEncoder(), decoder=JSONDecoder()) -> JSON:
    method ft (line 27) | def ft(self, index_name="idx") -> Search:
    method ts (line 35) | def ts(self) -> TimeSeries:
    method bf (line 45) | def bf(self) -> BFBloom:
    method cf (line 53) | def cf(self) -> CFBloom:
    method cms (line 61) | def cms(self) -> CMSBloom:
    method topk (line 69) | def topk(self) -> TOPKBloom:
    method tdigest (line 77) | def tdigest(self) -> TDigestBloom:
    method vset (line 85) | def vset(self) -> VectorSet:
  class AsyncRedisModuleCommands (line 94) | class AsyncRedisModuleCommands(RedisModuleCommands):
    method ft (line 95) | def ft(self, index_name="idx") -> AsyncSearch:
    method vset (line 103) | def vset(self) -> AsyncVectorSet:

FILE: redis/commands/search/__init__.py
  class Search (line 20) | class Search(SearchCommands):
    class BatchIndexer (line 26) | class BatchIndexer:
      method __init__ (line 32) | def __init__(self, client, chunk_size=1000):
      method __del__ (line 40) | def __del__(self):
      method add_document (line 44) | def add_document(
      method add_document_hash (line 74) | def add_document_hash(self, doc_id, score=1.0, replace=False):
      method commit (line 86) | def commit(self):
    method __init__ (line 93) | def __init__(self, client, index_name="idx"):
    method pipeline (line 116) | def pipeline(self, transaction=True, shard_hint=None):
  class AsyncSearch (line 130) | class AsyncSearch(Search, AsyncSearchCommands):
    class BatchIndexer (line 131) | class BatchIndexer(Search.BatchIndexer):
      method add_document (line 137) | async def add_document(
      method commit (line 167) | async def commit(self):
    method pipeline (line 174) | def pipeline(self, transaction=True, shard_hint=None):
  class Pipeline (line 188) | class Pipeline(SearchCommands, RedisPipeline):
  class AsyncPipeline (line 194) | class AsyncPipeline(AsyncSearchCommands, AsyncioPipeline, Pipeline):

FILE: redis/commands/search/_util.py
  function to_string (line 1) | def to_string(s, encoding: str = "utf-8"):

FILE: redis/commands/search/aggregation.py
  class Limit (line 8) | class Limit:
    method __init__ (line 9) | def __init__(self, offset: int = 0, count: int = 0) -> None:
    method build_args (line 13) | def build_args(self):
  class Reducer (line 20) | class Reducer:
    method __init__ (line 29) | def __init__(self, *args: str) -> None:
    method alias (line 34) | def alias(self, alias: str) -> "Reducer":
    method args (line 59) | def args(self) -> Tuple[str, ...]:
  class SortDirection (line 63) | class SortDirection:
    method __init__ (line 70) | def __init__(self, field: str) -> None:
  class Asc (line 74) | class Asc(SortDirection):
  class Desc (line 82) | class Desc(SortDirection):
  class AggregateRequest (line 90) | class AggregateRequest:
    method __init__ (line 95) | def __

[
  {
    "path": ".agent/sync_async_type_hints_overload_guide.md",
    "chars": 59859,
    "preview": "# Agent Overload Implementation Guide\n\n## Purpose\nThis document provides instructions for implementing `@overload` signa"
  },
  {
    "path": ".dockerignore",
    "chars": 46,
    "preview": "**/__pycache__\n**/*.pyc\n.coverage\n.coverage.*\n"
  },
  {
    "path": ".github/CODEOWNERS",
    "chars": 29,
    "preview": "doctests/* @dmaier-redislabs\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE.md",
    "chars": 559,
    "preview": "Thanks for wanting to report an issue you've found in redis-py. Please delete this text and fill in the template below. "
  },
  {
    "path": ".github/PULL_REQUEST_TEMPLATE.md",
    "chars": 674,
    "preview": "### Description of change\n\n_Please provide a description of the change here._\n\n### Pull Request check-list\n\n_Please make"
  },
  {
    "path": ".github/actions/run-tests/action.yml",
    "chars": 7000,
    "preview": "name: 'Run redis-py tests'\ndescription: 'Runs redis-py tests against different Redis versions and configurations'\ninputs"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 153,
    "preview": "version: 2\nupdates:\n  - package-ecosystem: \"github-actions\"\n    directory: \"/\"\n    labels:\n      - \"maintenance\"\n    sch"
  },
  {
    "path": ".github/release-drafter-config.yml",
    "chars": 1056,
    "preview": "name-template: '$NEXT_MINOR_VERSION'\ntag-template: 'v$NEXT_MINOR_VERSION'\nfilter-by-commitish: true\ncommitish: master\nau"
  },
  {
    "path": ".github/spellcheck-settings.yml",
    "chars": 533,
    "preview": "matrix:\n- name: Markdown\n  expect_match: false\n  apsell:\n    lang: en\n    d: en_US\n    ignore-case: true\n  dictionary:\n "
  },
  {
    "path": ".github/wordlist.txt",
    "chars": 1686,
    "preview": "APM\nARGV\nBFCommands\nbalancer\nCacheImpl\ncancelling\nCAS\nCFCommands\nCMSCommands\nClusterNode\nClusterNodes\nClusterPipeline\nCl"
  },
  {
    "path": ".github/workflows/codeql-analysis.yml",
    "chars": 2289,
    "preview": "# For most projects, this workflow file will not need changing; you simply need\n# to commit it to your repository.\n#\n# Y"
  },
  {
    "path": ".github/workflows/docs.yaml",
    "chars": 1049,
    "preview": "name: Docs CI\n\non:\n  push:\n    branches:\n      - master\n      - '[0-9].[0-9]'\n  pull_request:\n    branches:\n      - mast"
  },
  {
    "path": ".github/workflows/hiredis-py-integration.yaml",
    "chars": 2108,
    "preview": "name: Hiredis-py integration tests\n\non:\n  workflow_dispatch:\n    inputs:\n      redis-py-branch:\n        description: 're"
  },
  {
    "path": ".github/workflows/install_and_test.sh",
    "chars": 1284,
    "preview": "#!/bin/bash\n\nset -e\n\nSUFFIX=$1\nif [ -z ${SUFFIX} ]; then\n    echo \"Supply valid python package extension such as whl or "
  },
  {
    "path": ".github/workflows/integration.yaml",
    "chars": 8641,
    "preview": "name: CI\n\non:\n  push:\n    paths-ignore:\n      - 'docs/**'\n      - '**/*.rst'\n      - '**/*.md'\n    branches:\n      - mas"
  },
  {
    "path": ".github/workflows/pypi-publish.yaml",
    "chars": 734,
    "preview": "name: Publish tag to Pypi\n\non:\n  release:\n    types: [published]\n  workflow_dispatch:\n\npermissions:\n  contents: read  # "
  },
  {
    "path": ".github/workflows/release-drafter.yml",
    "chars": 767,
    "preview": "name: Release Drafter\n\non:\n  push:\n    # branches to consider in the event; optional, defaults to all\n    branches:\n    "
  },
  {
    "path": ".github/workflows/spellcheck.yml",
    "chars": 341,
    "preview": "name: spellcheck\non:\n  pull_request:\njobs:\n  check-spelling:\n    runs-on: ubuntu-latest\n    steps:\n      - name: Checkou"
  },
  {
    "path": ".github/workflows/stale-issues.yml",
    "chars": 3713,
    "preview": "name: \"Stale Issue Management\"\non:\n  schedule:\n    # Run daily at midnight UTC\n    - cron: \"0 0 * * *\"\n  workflow_dispat"
  },
  {
    "path": ".gitignore",
    "chars": 358,
    "preview": "*.pyc\nredis.egg-info\nbuild/\ndist/\ndump.rdb\n_build\nvagrant/.vagrant\n.python-version\n.cache\n.eggs\n.idea\n.vscode\n.coverage\n"
  },
  {
    "path": ".mypy.ini",
    "chars": 626,
    "preview": "[mypy]\n#, docs/examples, tests\nfiles = redis\ncheck_untyped_defs = True\nfollow_imports_for_stubs asyncio.= True\n#disallow"
  },
  {
    "path": ".readthedocs.yml",
    "chars": 199,
    "preview": "version: 2\n\npython:\n  install:\n    - requirements: docs/requirements.txt\n    - method: pip\n      path: .\n\nbuild:\n  os: u"
  },
  {
    "path": "CHANGES",
    "chars": 46901,
    "preview": "This file contains only the changes history before redis-py version 4.0.0\nAfter redis-py version 4.0.0 all changes can b"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 5940,
    "preview": "# Contributing\n\n## Introduction\n\nWe appreciate your interest in considering contributing to redis-py.\nCommunity contribu"
  },
  {
    "path": "LICENSE",
    "chars": 1074,
    "preview": "MIT License\n\nCopyright (c) 2022-2023, Redis, inc.\n\nPermission is hereby granted, free of charge, to any person obtaining"
  },
  {
    "path": "README.md",
    "chars": 10278,
    "preview": "# redis-py\n\nThe Python interface to the Redis key-value store.\n\n[![CI](https://github.com/redis/redis-py/workflows/CI/ba"
  },
  {
    "path": "benchmarks/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "benchmarks/base.py",
    "chars": 1355,
    "preview": "import functools\nimport itertools\nimport sys\nimport timeit\n\nimport redis\n\n\nclass Benchmark:\n    ARGUMENTS = ()\n\n    def "
  },
  {
    "path": "benchmarks/basic_operations.py",
    "chars": 4866,
    "preview": "import time\nfrom argparse import ArgumentParser\nfrom functools import wraps\n\nimport redis\n\n\ndef parse_args():\n    parser"
  },
  {
    "path": "benchmarks/cluster_async.py",
    "chars": 7234,
    "preview": "import asyncio\nimport functools\nimport time\n\nimport aioredis_cluster\nimport aredis\nimport uvloop\n\nimport redis.asyncio a"
  },
  {
    "path": "benchmarks/cluster_async_pipeline.py",
    "chars": 2597,
    "preview": "import asyncio\nimport functools\nimport time\n\nimport aioredis_cluster\nimport aredis\nimport uvloop\n\nimport redis.asyncio a"
  },
  {
    "path": "benchmarks/command_packer_benchmark.py",
    "chars": 3273,
    "preview": "from base import Benchmark\n\nfrom redis.connection import SYM_CRLF, SYM_DOLLAR, SYM_EMPTY, SYM_STAR, Connection\n\n\nclass S"
  },
  {
    "path": "benchmarks/otel_benchmark.py",
    "chars": 47157,
    "preview": "#!/usr/bin/env python3\n\"\"\"\nOpenTelemetry Benchmark for redis-py.\n\nThis module provides benchmarking infrastructure to me"
  },
  {
    "path": "benchmarks/socket_read_size.py",
    "chars": 797,
    "preview": "from base import Benchmark\n\nfrom redis.connection import PythonParser, _HiredisParser\n\n\nclass SocketReadBenchmark(Benchm"
  },
  {
    "path": "codecov.yml",
    "chars": 208,
    "preview": "ignore:\n  - \"benchmarks/**\"\n  - \"tasks.py\"\n\ncodecov:\n  require_ci_to_pass: yes\n\ncoverage:\n  precision: 2\n  round: down\n "
  },
  {
    "path": "dev_requirements.txt",
    "chars": 1057,
    "preview": "build\nbuild==1.2.2.post1 ; platform_python_implementation == \"PyPy\"\nclick==8.0.4\ninvoke==2.2.0\npackaging>=20.4\npackaging"
  },
  {
    "path": "docker-compose.yml",
    "chars": 3772,
    "preview": "---\n# image tag 8.0-RC2-pre is the one matching the 8.0 GA release\nx-client-libs-stack-image: &client-libs-stack-image\n "
  },
  {
    "path": "dockers/sentinel.conf",
    "chars": 374,
    "preview": "sentinel resolve-hostnames yes\nsentinel monitor redis-py-test redis 6379 2\n# Be much more tolerant to transient stalls ("
  },
  {
    "path": "docs/Makefile",
    "chars": 5572,
    "preview": "# Makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS    =\nSPHINXBUILD "
  },
  {
    "path": "docs/_static/.keep",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "docs/_templates/.keep",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "docs/advanced_features.rst",
    "chars": 22410,
    "preview": "Advanced Features\n=================\n\nA note about threading\n----------------------\n\nRedis client instances can safely be"
  },
  {
    "path": "docs/backoff.rst",
    "chars": 87,
    "preview": ".. _backoff-label:\n\nBackoff\n#############\n\n.. automodule:: redis.backoff\n    :members: "
  },
  {
    "path": "docs/clustering.rst",
    "chars": 10995,
    "preview": "Clustering\n==========\n\nredis-py now supports cluster mode and provides a client for `Redis\nCluster <https://redis.io/top"
  },
  {
    "path": "docs/commands.rst",
    "chars": 959,
    "preview": "Redis Commands\n##############\n\nCore Commands\n*************\n\nThe following functions can be used to replicate their equiv"
  },
  {
    "path": "docs/conf.py",
    "chars": 9845,
    "preview": "# redis-py documentation build configuration file, created by\n# sphinx-quickstart on Fri Feb  8 00:47:08 2013.\n#\n# This "
  },
  {
    "path": "docs/connections.rst",
    "chars": 2531,
    "preview": "Connecting to Redis\n###################\n\n\nGeneric Client\n**************\n\nThis is the client used to connect directly to "
  },
  {
    "path": "docs/examples/README.md",
    "chars": 134,
    "preview": "# Examples\n\nExamples of redis-py usage go here. They're being linked to the [generated documentation](https://redis.read"
  },
  {
    "path": "docs/examples/asyncio_examples.ipynb",
    "chars": 11397,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {\n    \"collapsed\": true,\n    \"pycharm\": {\n     \"name\": \"#%%"
  },
  {
    "path": "docs/examples/connection_examples.ipynb",
    "chars": 12916,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Connection Examples\"\n   ]\n  },\n  "
  },
  {
    "path": "docs/examples/opentelemetry/README.md",
    "chars": 1195,
    "preview": "# Example for redis-py OpenTelemetry instrumentation\n\nThis example demonstrates how to monitor Redis using [OpenTelemetr"
  },
  {
    "path": "docs/examples/opentelemetry/config/alertmanager.yml",
    "chars": 1692,
    "preview": "# See https://prometheus.io/docs/alerting/latest/configuration/ for details.\n\nglobal:\n  # The smarthost and SMTP sender "
  },
  {
    "path": "docs/examples/opentelemetry/config/otel-collector.yaml",
    "chars": 1249,
    "preview": "extensions:\n  health_check:\n  pprof:\n    endpoint: 0.0.0.0:1777\n  zpages:\n    endpoint: 0.0.0.0:55679\n\nreceivers:\n  otlp"
  },
  {
    "path": "docs/examples/opentelemetry/config/vector.toml",
    "chars": 923,
    "preview": "[sources.syslog_logs]\ntype = \"demo_logs\"\nformat = \"syslog\"\ninterval = 0.1\n\n[sources.apache_common_logs]\ntype = \"demo_log"
  },
  {
    "path": "docs/examples/opentelemetry/docker-compose.yml",
    "chars": 1752,
    "preview": "version: \"3\"\n\nservices:\n  clickhouse:\n    image: clickhouse/clickhouse-server:22.7\n    restart: on-failure\n    environme"
  },
  {
    "path": "docs/examples/opentelemetry/main.py",
    "chars": 1277,
    "preview": "#!/usr/bin/env python3\n\nimport time\n\nimport redis\nimport uptrace\nfrom opentelemetry import trace\nfrom opentelemetry.inst"
  },
  {
    "path": "docs/examples/opentelemetry/requirements.txt",
    "chars": 73,
    "preview": "redis==4.3.4\nuptrace==1.14.0\nopentelemetry-instrumentation-redis==0.35b0\n"
  },
  {
    "path": "docs/examples/opentelemetry/uptrace.yml",
    "chars": 8596,
    "preview": "##\n## Uptrace configuration file.\n## See https://uptrace.dev/get/config.html for details.\n##\n## You can use environment "
  },
  {
    "path": "docs/examples/opentelemetry_api_examples.ipynb",
    "chars": 14417,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"id\": \"7b02ea52\",\n   \"metadata\": {},\n   \"source\": [\n    \"# OpenTelemetr"
  },
  {
    "path": "docs/examples/pipeline_examples.ipynb",
    "chars": 8549,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Pipeline examples\\n\",\n    \"\\n\",\n "
  },
  {
    "path": "docs/examples/redis-stream-example.ipynb",
    "chars": 19064,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Redis Stream Examples\"\n   ]\n  },\n"
  },
  {
    "path": "docs/examples/search_json_examples.ipynb",
    "chars": 7989,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Indexing / querying JSON document"
  },
  {
    "path": "docs/examples/search_vector_similarity_examples.ipynb",
    "chars": 53727,
    "preview": "{\n \"cells\": [\n  {\n   \"attachments\": {},\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Vector Simi"
  },
  {
    "path": "docs/examples/set_and_get_examples.ipynb",
    "chars": 5495,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"id\": \"a3b456e8\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Basic ```set"
  },
  {
    "path": "docs/examples/ssl_connection_examples.ipynb",
    "chars": 7805,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# SSL Connection Examples\"\n   ]\n  }"
  },
  {
    "path": "docs/examples/timeseries_examples.ipynb",
    "chars": 14243,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Timeseries\\n\",\n    \"\\n\",\n    \"`re"
  },
  {
    "path": "docs/examples.rst",
    "chars": 402,
    "preview": "Examples\n########\n\n.. toctree::\n   :maxdepth: 3\n   :glob:\n\n   examples/connection_examples\n   examples/ssl_connection_ex"
  },
  {
    "path": "docs/exceptions.rst",
    "chars": 92,
    "preview": ".. _exceptions-label:\n\nExceptions\n##########\n\n.. automodule:: redis.exceptions\n    :members:"
  },
  {
    "path": "docs/genindex.rst",
    "chars": 25,
    "preview": "Module Index\n============"
  },
  {
    "path": "docs/geographic_failover.rst",
    "chars": 20468,
    "preview": "Client-side geographic failover (Active-Active)\n=====================================\n\nThe multi-database client allows "
  },
  {
    "path": "docs/index.rst",
    "chars": 2020,
    "preview": ".. redis-py documentation master file, created by\n   sphinx-quickstart on Thu Jul 28 13:55:57 2011.\n   You can adapt thi"
  },
  {
    "path": "docs/lock.rst",
    "chars": 57,
    "preview": "Lock\n#########\n\n.. automodule:: redis.lock\n    :members: "
  },
  {
    "path": "docs/lua_scripting.rst",
    "chars": 3950,
    "preview": "Lua Scripting\n===\n\n`Lua Scripting <#lua-scripting-in-default-connections>`__ \\|\n`Pipelines <#pipelines>`__ \\| `Cluster m"
  },
  {
    "path": "docs/opentelemetry.rst",
    "chars": 14735,
    "preview": "Integrating OpenTelemetry\n=========================\n\nWhat is OpenTelemetry?\n----------------------\n\n`OpenTelemetry <http"
  },
  {
    "path": "docs/redismodules.rst",
    "chars": 3227,
    "preview": "Redis Modules Commands\n######################\n\nAccessing redis module commands requires the installation of the supporte"
  },
  {
    "path": "docs/requirements.txt",
    "chars": 100,
    "preview": "sphinx>=5.0,<7.0\ndocutils<0.18\nnbsphinx\nsphinx_gallery\nipython\nsphinx-autodoc-typehints\nfuro\npandoc\n"
  },
  {
    "path": "docs/resp3_features.rst",
    "chars": 3992,
    "preview": "RESP 3 Features\n===============\n\nAs of version 5.0, redis-py supports the `RESP 3 standard <https://github.com/redis/red"
  },
  {
    "path": "docs/retry.rst",
    "chars": 3454,
    "preview": "Retry Helpers\n#############\n\n.. automodule:: redis.retry\n    :members:\n\n\nRetry in Redis Standalone\n*********************"
  },
  {
    "path": "doctests/README.md",
    "chars": 1230,
    "preview": "# Command examples for redis.io\n\n## How to add an example\n\nCreate regular python file in the current folder with meaning"
  },
  {
    "path": "doctests/cmds_cnxmgmt.py",
    "chars": 752,
    "preview": "# EXAMPLE: cmds_cnxmgmt\n# HIDE_START\nimport redis\n\nr = redis.Redis(decode_responses=True)\n# HIDE_END\n\n# STEP_START auth1"
  },
  {
    "path": "doctests/cmds_generic.py",
    "chars": 3265,
    "preview": "# EXAMPLE: cmds_generic\n# HIDE_START\nimport redis\n\nr = redis.Redis(decode_responses=True)\n# HIDE_END\n\n# STEP_START del\nr"
  },
  {
    "path": "doctests/cmds_hash.py",
    "chars": 1680,
    "preview": "# EXAMPLE: cmds_hash\n# HIDE_START\nimport redis\n\nr = redis.Redis(host=\"localhost\", port=6379, db=0, decode_responses=True"
  },
  {
    "path": "doctests/cmds_list.py",
    "chars": 2384,
    "preview": "# EXAMPLE: cmds_list\n# HIDE_START\nimport redis\n\nr = redis.Redis(decode_responses=True)\n# HIDE_END\n\n# STEP_START lpush\nre"
  },
  {
    "path": "doctests/cmds_servermgmt.py",
    "chars": 510,
    "preview": "# EXAMPLE: cmds_servermgmt\n# HIDE_START\nimport redis\n\nr = redis.Redis(decode_responses=True)\n# HIDE_END\n\n# STEP_START fl"
  },
  {
    "path": "doctests/cmds_set.py",
    "chars": 632,
    "preview": "# EXAMPLE: cmds_set\n# HIDE_START\nimport redis\n\nr = redis.Redis(decode_responses=True)\n# HIDE_END\n\n# STEP_START sadd\nres1"
  },
  {
    "path": "doctests/cmds_sorted_set.py",
    "chars": 1765,
    "preview": "# EXAMPLE: cmds_sorted_set\n# HIDE_START\nimport redis\n\nr = redis.Redis(host=\"localhost\", port=6379, db=0, decode_response"
  },
  {
    "path": "doctests/cmds_string.py",
    "chars": 319,
    "preview": "# EXAMPLE: cmds_string\n# HIDE_START\nimport redis\n\nr = redis.Redis(host=\"localhost\", port=6379, db=0, decode_responses=Tr"
  },
  {
    "path": "doctests/data/query_em.json",
    "chars": 7035,
    "preview": "[\n  {\n\t  \"pickup_zone\": \"POLYGON((-74.0610 40.7578, -73.9510 40.7578, -73.9510 40.6678, -74.0610 40.6678, -74.0610 40.75"
  },
  {
    "path": "doctests/data/query_vector.json",
    "chars": 9083,
    "preview": "[\n  {\n    \"model\": \"Jigger\",\n    \"brand\": \"Velorim\",\n    \"price\": 270,\n    \"type\": \"Kids bikes\",\n    \"specs\": {\n      \"m"
  },
  {
    "path": "doctests/dt_bitfield.py",
    "chars": 746,
    "preview": "# EXAMPLE: bitfield_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Bitfield doc pages:\n    https://redis.io/docs/latest/deve"
  },
  {
    "path": "doctests/dt_bitmap.py",
    "chars": 3435,
    "preview": "# EXAMPLE: bitmap_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Bitmap doc pages:\n    https://redis.io/docs/latest/develop/"
  },
  {
    "path": "doctests/dt_bloom.py",
    "chars": 881,
    "preview": "# EXAMPLE: bf_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Bloom filter doc pages:\n    https://redis.io/docs/latest/develo"
  },
  {
    "path": "doctests/dt_cms.py",
    "chars": 821,
    "preview": "# EXAMPLE: cms_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Count-min sketch doc pages:\n    https://redis.io/docs/latest/d"
  },
  {
    "path": "doctests/dt_cuckoo.py",
    "chars": 791,
    "preview": "# EXAMPLE: cuckoo_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Cuckoo filter doc pages:\n    https://redis.io/docs/latest/d"
  },
  {
    "path": "doctests/dt_geo.py",
    "chars": 967,
    "preview": "# EXAMPLE: geo_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Geospatial doc pages:\n    https://redis.io/docs/latest/develop"
  },
  {
    "path": "doctests/dt_hash.py",
    "chars": 1975,
    "preview": "# EXAMPLE: hash_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Hash doc pages:\n    https://redis.io/docs/latest/develop/data"
  },
  {
    "path": "doctests/dt_hll.py",
    "chars": 744,
    "preview": "# # EXAMPLE: hll_tutorial\n# HIDE_START\n\"\"\"\nCode samples for HyperLogLog doc pages:\n    https://redis.io/docs/latest/deve"
  },
  {
    "path": "doctests/dt_json.py",
    "chars": 11265,
    "preview": "# EXAMPLE: json_tutorial\n# HIDE_START\n\"\"\"\nCode samples for JSON doc pages:\n    https://redis.io/docs/latest/develop/data"
  },
  {
    "path": "doctests/dt_list.py",
    "chars": 6857,
    "preview": "# EXAMPLE: list_tutorial\n# HIDE_START\n\"\"\"\nCode samples for List doc pages:\n    https://redis.io/docs/latest/develop/data"
  },
  {
    "path": "doctests/dt_set.py",
    "chars": 4168,
    "preview": "# EXAMPLE: sets_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Set doc pages:\n    https://redis.io/docs/latest/develop/data-"
  },
  {
    "path": "doctests/dt_ss.py",
    "chars": 2673,
    "preview": "# EXAMPLE: ss_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Sorted set doc pages:\n    https://redis.io/docs/latest/develop/"
  },
  {
    "path": "doctests/dt_stream.py",
    "chars": 10190,
    "preview": "# EXAMPLE: stream_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Stream doc pages:\n    https://redis.io/docs/latest/develop/"
  },
  {
    "path": "doctests/dt_string.py",
    "chars": 1169,
    "preview": "# EXAMPLE: set_tutorial\n# HIDE_START\n\"\"\"\nCode samples for String doc pages:\n    https://redis.io/docs/latest/develop/dat"
  },
  {
    "path": "doctests/dt_tdigest.py",
    "chars": 1524,
    "preview": "# EXAMPLE: tdigest_tutorial\n# HIDE_START\n\"\"\"\nCode samples for t-digest pages:\n    https://redis.io/docs/latest/develop/d"
  },
  {
    "path": "doctests/dt_time_series.py",
    "chars": 12577,
    "preview": "# EXAMPLE: time_series_tutorial\n# HIDE_START\n\"\"\"\nCode samples for time series page:\n    https://redis.io/docs/latest/dev"
  },
  {
    "path": "doctests/dt_topk.py",
    "chars": 803,
    "preview": "# EXAMPLE: topk_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Top-K pages:\n    https://redis.io/docs/latest/develop/data-ty"
  },
  {
    "path": "doctests/dt_vec_set.py",
    "chars": 6200,
    "preview": "# EXAMPLE: vecset_tutorial\n# HIDE_START\n\"\"\"\nCode samples for Vector set doc pages:\n    https://redis.io/docs/latest/deve"
  },
  {
    "path": "doctests/geo_index.py",
    "chars": 3737,
    "preview": "# EXAMPLE: geoindex\nimport redis\nfrom redis.commands.json.path import Path\nfrom redis.commands.search.field import TextF"
  },
  {
    "path": "doctests/home_json.py",
    "chars": 4568,
    "preview": "# EXAMPLE: py_home_json\n# BINDER_ID python-py_home_json\n\"\"\"\nJSON examples from redis-py \"home\" page\"\n https://redis.io/d"
  },
  {
    "path": "doctests/home_prob_dts.py",
    "chars": 5583,
    "preview": "# EXAMPLE: home_prob_dts\n\"\"\"\nProbabilistic data type examples:\n https://redis.io/docs/latest/develop/connect/clients/pyt"
  },
  {
    "path": "doctests/query_agg.py",
    "chars": 3378,
    "preview": "# EXAMPLE: query_agg\n# HIDE_START\nimport json\nimport redis\nfrom redis.commands.json.path import Path\nfrom redis.commands"
  },
  {
    "path": "doctests/query_combined.py",
    "chars": 3108,
    "preview": "# EXAMPLE: query_combined\n# HIDE_START\nimport json\nimport numpy as np\nimport redis\nimport warnings\nfrom redis.commands.j"
  },
  {
    "path": "doctests/query_em.py",
    "chars": 2694,
    "preview": "# EXAMPLE: query_em\n# HIDE_START\nimport json\nimport redis\nfrom redis.commands.json.path import Path\nfrom redis.commands."
  },
  {
    "path": "doctests/query_ft.py",
    "chars": 3368,
    "preview": "# EXAMPLE: query_ft\n# HIDE_START\nimport json\nimport sys\nimport redis\nfrom redis.commands.json.path import Path\nfrom redi"
  },
  {
    "path": "doctests/query_geo.py",
    "chars": 1914,
    "preview": "# EXAMPLE: query_geo\n# HIDE_START\nimport json\nimport sys\nimport redis\nfrom redis.commands.json.path import Path\nfrom red"
  },
  {
    "path": "doctests/query_range.py",
    "chars": 1958,
    "preview": "# EXAMPLE: query_range\n# HIDE_START\nimport json\nimport sys\nimport redis\nfrom redis.commands.json.path import Path\nfrom r"
  },
  {
    "path": "doctests/requirements.txt",
    "chars": 90,
    "preview": "numpy\npandas\nrequests\nsentence_transformers\ntabulate\nredis #install latest stable version\n"
  },
  {
    "path": "doctests/run_examples.sh",
    "chars": 243,
    "preview": "#!/bin/sh\n\n\nbasepath=`readlink -f $1`\nif [ $? -ne 0 ]; then\nbasepath=`readlink -f $(dirname $0)`\nfi\necho \"No path specif"
  },
  {
    "path": "doctests/search_quickstart.py",
    "chars": 13016,
    "preview": "# EXAMPLE: search_quickstart\n# HIDE_START\n\"\"\"\nCode samples for document database quickstart pages:\n    https://redis.io/"
  },
  {
    "path": "doctests/search_vss.py",
    "chars": 9300,
    "preview": "# EXAMPLE: search_vss\n# HIDE_START\n\"\"\"\nCode samples for vector database quickstart pages:\n    https://redis.io/docs/late"
  },
  {
    "path": "doctests/string_set_get.py",
    "chars": 474,
    "preview": "# EXAMPLE: set_and_get\n# HIDE_START\n\"\"\"\nCode samples for data structure store quickstart pages:\n    https://redis.io/doc"
  },
  {
    "path": "doctests/trans_pipe.py",
    "chars": 2540,
    "preview": "# EXAMPLE: pipe_trans_tutorial\n# HIDE_START\n\"\"\"\nCode samples for vector database quickstart pages:\n    https://redis.io/"
  },
  {
    "path": "pyproject.toml",
    "chars": 4069,
    "preview": "[build-system]\nrequires = [\"hatchling\"]\nbuild-backend = \"hatchling.build\"\n\n[project]\nname = \"redis\"\ndynamic = [\"version\""
  },
  {
    "path": "redis/__init__.py",
    "chars": 2108,
    "preview": "from redis import asyncio  # noqa\nfrom redis.backoff import default_backoff\nfrom redis.client import Redis, StrictRedis\n"
  },
  {
    "path": "redis/_parsers/__init__.py",
    "chars": 693,
    "preview": "from .base import (\n    AsyncPushNotificationsParser,\n    BaseParser,\n    PushNotificationsParser,\n    _AsyncRESPBase,\n)"
  },
  {
    "path": "redis/_parsers/base.py",
    "chars": 20226,
    "preview": "import logging\nimport sys\nfrom abc import ABC\nfrom asyncio import IncompleteReadError, StreamReader, TimeoutError\nfrom t"
  },
  {
    "path": "redis/_parsers/commands.py",
    "chars": 28493,
    "preview": "from enum import Enum\nfrom typing import TYPE_CHECKING, Any, Awaitable, Dict, Optional, Tuple, Union\n\nfrom redis.excepti"
  },
  {
    "path": "redis/_parsers/encoders.py",
    "chars": 1734,
    "preview": "from ..exceptions import DataError\n\n\nclass Encoder:\n    \"Encode strings to bytes-like and decode bytes-like to strings\"\n"
  },
  {
    "path": "redis/_parsers/helpers.py",
    "chars": 31453,
    "preview": "import datetime\n\nfrom redis.utils import str_if_bytes\n\n\ndef timestamp_to_datetime(response):\n    \"Converts a unix timest"
  },
  {
    "path": "redis/_parsers/hiredis.py",
    "chars": 11201,
    "preview": "import asyncio\nimport socket\nimport sys\nfrom logging import getLogger\nfrom typing import Callable, List, Optional, Typed"
  },
  {
    "path": "redis/_parsers/resp2.py",
    "chars": 5031,
    "preview": "from typing import Any, Union\n\nfrom ..exceptions import ConnectionError, InvalidResponse, ResponseError\nfrom ..typing im"
  },
  {
    "path": "redis/_parsers/resp3.py",
    "chars": 10899,
    "preview": "from logging import getLogger\nfrom typing import Any, Union\n\nfrom ..exceptions import ConnectionError, InvalidResponse, "
  },
  {
    "path": "redis/_parsers/socket.py",
    "chars": 5520,
    "preview": "import errno\nimport io\nimport socket\nfrom io import SEEK_END\nfrom typing import Optional, Union\n\nfrom ..exceptions impor"
  },
  {
    "path": "redis/asyncio/__init__.py",
    "chars": 1489,
    "preview": "from redis.asyncio.client import Redis, StrictRedis\nfrom redis.asyncio.cluster import RedisCluster\nfrom redis.asyncio.co"
  },
  {
    "path": "redis/asyncio/client.py",
    "chars": 77148,
    "preview": "import asyncio\nimport copy\nimport inspect\nimport re\nimport time\nimport warnings\nfrom typing import (\n    TYPE_CHECKING,\n"
  },
  {
    "path": "redis/asyncio/cluster.py",
    "chars": 114542,
    "preview": "import asyncio\nimport collections\nimport random\nimport socket\nimport threading\nimport time\nimport warnings\nfrom abc impo"
  },
  {
    "path": "redis/asyncio/connection.py",
    "chars": 63681,
    "preview": "import asyncio\nimport copy\nimport enum\nimport inspect\nimport socket\nimport sys\nimport time\nimport warnings\nimport weakre"
  },
  {
    "path": "redis/asyncio/http/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "redis/asyncio/http/http_client.py",
    "chars": 7947,
    "preview": "import asyncio\nfrom abc import ABC, abstractmethod\nfrom concurrent.futures import ThreadPoolExecutor\nfrom typing import "
  },
  {
    "path": "redis/asyncio/lock.py",
    "chars": 13249,
    "preview": "import asyncio\nimport logging\nimport threading\nimport uuid\nfrom types import SimpleNamespace\nfrom typing import TYPE_CHE"
  },
  {
    "path": "redis/asyncio/multidb/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "redis/asyncio/multidb/client.py",
    "chars": 21532,
    "preview": "import asyncio\nimport logging\nfrom typing import Any, Awaitable, Callable, List, Literal, Optional, Union\n\nfrom redis.as"
  },
  {
    "path": "redis/asyncio/multidb/command_executor.py",
    "chars": 12390,
    "preview": "from abc import abstractmethod\nfrom asyncio import iscoroutinefunction\nfrom datetime import datetime\nfrom typing import "
  },
  {
    "path": "redis/asyncio/multidb/config.py",
    "chars": 9662,
    "preview": "from dataclasses import dataclass, field\nfrom enum import Enum\nfrom typing import List, Optional, Type, Union\n\nimport py"
  },
  {
    "path": "redis/asyncio/multidb/database.py",
    "chars": 1931,
    "preview": "from abc import abstractmethod\nfrom typing import Optional, Union\n\nfrom redis.asyncio import Redis, RedisCluster\nfrom re"
  },
  {
    "path": "redis/asyncio/multidb/event.py",
    "chars": 2788,
    "preview": "from typing import List\n\nfrom redis.asyncio import Redis\nfrom redis.asyncio.multidb.database import AsyncDatabase\nfrom r"
  },
  {
    "path": "redis/asyncio/multidb/failover.py",
    "chars": 3635,
    "preview": "import time\nfrom abc import ABC, abstractmethod\n\nfrom redis.asyncio.multidb.database import AsyncDatabase, Databases\nfro"
  },
  {
    "path": "redis/asyncio/multidb/failure_detector.py",
    "chars": 1263,
    "preview": "from abc import ABC, abstractmethod\n\nfrom redis.multidb.failure_detector import FailureDetector\n\n\nclass AsyncFailureDete"
  },
  {
    "path": "redis/asyncio/multidb/healthcheck.py",
    "chars": 17774,
    "preview": "import asyncio\nimport inspect\nimport logging\nfrom abc import ABC, abstractmethod\nfrom enum import Enum\nfrom typing impor"
  },
  {
    "path": "redis/asyncio/observability/__init__.py",
    "chars": 439,
    "preview": "\"\"\"\nAsync observability module for Redis async clients.\n\nThis module provides async-safe APIs for recording Redis metric"
  },
  {
    "path": "redis/asyncio/observability/recorder.py",
    "chars": 18234,
    "preview": "\"\"\"\nAsync-compatible API for recording observability metrics.\n\nThis module provides an async-safe interface for Redis as"
  },
  {
    "path": "redis/asyncio/retry.py",
    "chars": 2515,
    "preview": "from asyncio import sleep\nfrom typing import (\n    TYPE_CHECKING,\n    Any,\n    Awaitable,\n    Callable,\n    Optional,\n  "
  },
  {
    "path": "redis/asyncio/sentinel.py",
    "chars": 14868,
    "preview": "import asyncio\nimport random\nimport weakref\nfrom typing import AsyncIterator, Iterable, Mapping, Optional, Sequence, Tup"
  },
  {
    "path": "redis/asyncio/utils.py",
    "chars": 744,
    "preview": "from typing import TYPE_CHECKING, Any\n\nif TYPE_CHECKING:\n    from redis.asyncio.client import Pipeline, Redis\n\n\ndef from"
  },
  {
    "path": "redis/auth/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "redis/auth/err.py",
    "chars": 694,
    "preview": "from typing import Iterable\n\n\nclass RequestTokenErr(Exception):\n    \"\"\"\n    Represents an exception during token request"
  },
  {
    "path": "redis/auth/idp.py",
    "chars": 631,
    "preview": "from abc import ABC, abstractmethod\n\nfrom redis.auth.token import TokenInterface\n\n\"\"\"\nThis interface is the facade of an"
  },
  {
    "path": "redis/auth/token.py",
    "chars": 3317,
    "preview": "from abc import ABC, abstractmethod\nfrom datetime import datetime, timezone\n\nfrom redis.auth.err import InvalidTokenSche"
  },
  {
    "path": "redis/auth/token_manager.py",
    "chars": 12388,
    "preview": "import asyncio\nimport logging\nimport threading\nfrom datetime import datetime, timezone\nfrom time import sleep\nfrom typin"
  },
  {
    "path": "redis/background.py",
    "chars": 16982,
    "preview": "import asyncio\nimport logging\nimport threading\nfrom typing import Any, Callable, Coroutine\n\n\nclass BackgroundScheduler:\n"
  },
  {
    "path": "redis/backoff.py",
    "chars": 5285,
    "preview": "import random\nfrom abc import ABC, abstractmethod\n\n# Maximum backoff between each retry in seconds\nDEFAULT_CAP = 0.512\n#"
  },
  {
    "path": "redis/cache.py",
    "chars": 12089,
    "preview": "from abc import ABC, abstractmethod\nfrom collections import OrderedDict\nfrom dataclasses import dataclass\nfrom enum impo"
  },
  {
    "path": "redis/client.py",
    "chars": 80204,
    "preview": "import copy\nimport logging\nimport re\nimport threading\nimport time\nfrom itertools import chain\nfrom typing import (\n    T"
  },
  {
    "path": "redis/cluster.py",
    "chars": 161409,
    "preview": "import logging\nimport random\nimport socket\nimport sys\nimport threading\nimport time\nfrom abc import ABC, abstractmethod\nf"
  },
  {
    "path": "redis/commands/__init__.py",
    "chars": 576,
    "preview": "from .cluster import READ_COMMANDS, AsyncRedisClusterCommands, RedisClusterCommands\nfrom .core import AsyncCoreCommands,"
  },
  {
    "path": "redis/commands/bf/__init__.py",
    "chars": 8019,
    "preview": "from redis._parsers.helpers import bool_ok\n\nfrom ..helpers import get_protocol_version, parse_to_list\nfrom .commands imp"
  },
  {
    "path": "redis/commands/bf/commands.py",
    "chars": 21283,
    "preview": "from redis.client import NEVER_DECODE\nfrom redis.utils import deprecated_function\n\nBF_RESERVE = \"BF.RESERVE\"\nBF_ADD = \"B"
  },
  {
    "path": "redis/commands/bf/info.py",
    "chars": 3355,
    "preview": "from ..helpers import nativestr\n\n\nclass BFInfo:\n    capacity = None\n    size = None\n    filterNum = None\n    insertedNum"
  },
  {
    "path": "redis/commands/cluster.py",
    "chars": 40782,
    "preview": "import asyncio\nfrom typing import (\n    TYPE_CHECKING,\n    Any,\n    AsyncIterator,\n    Awaitable,\n    Dict,\n    Iterable"
  },
  {
    "path": "redis/commands/core.py",
    "chars": 371073,
    "preview": "from __future__ import annotations\n\nimport datetime\nimport hashlib\nimport inspect\n\n# Try to import the xxhash library as"
  },
  {
    "path": "redis/commands/helpers.py",
    "chars": 3152,
    "preview": "import copy\nimport random\nimport string\nfrom typing import Any, Iterable, List, Tuple\n\nimport redis\nfrom redis.typing im"
  },
  {
    "path": "redis/commands/json/__init__.py",
    "chars": 4845,
    "preview": "from json import JSONDecodeError, JSONDecoder, JSONEncoder\n\nimport redis\n\nfrom ..helpers import get_protocol_version, na"
  },
  {
    "path": "redis/commands/json/_util.py",
    "chars": 137,
    "preview": "from typing import List, Mapping, Union\n\nJsonType = Union[\n    str, int, float, bool, None, Mapping[str, \"JsonType\"], Li"
  },
  {
    "path": "redis/commands/json/commands.py",
    "chars": 15711,
    "preview": "import os\nfrom json import JSONDecodeError, loads\nfrom typing import Dict, List, Optional, Tuple, Union\n\nfrom redis.exce"
  },
  {
    "path": "redis/commands/json/decoders.py",
    "chars": 1411,
    "preview": "import copy\nimport re\n\nfrom ..helpers import nativestr\n\n\ndef bulk_of_jsons(d):\n    \"\"\"Replace serialized JSON values wit"
  },
  {
    "path": "redis/commands/json/path.py",
    "chars": 393,
    "preview": "class Path:\n    \"\"\"This class represents a path in a JSON value.\"\"\"\n\n    strPath = \"\"\n\n    @staticmethod\n    def root_pa"
  },
  {
    "path": "redis/commands/policies.py",
    "chars": 11267,
    "preview": "from abc import ABC, abstractmethod\nfrom typing import Optional\n\nfrom redis._parsers.commands import (\n    CommandPolici"
  },
  {
    "path": "redis/commands/redismodules.py",
    "chars": 2794,
    "preview": "from __future__ import annotations\n\nfrom json import JSONDecoder, JSONEncoder\nfrom typing import TYPE_CHECKING\n\nif TYPE_"
  },
  {
    "path": "redis/commands/search/__init__.py",
    "chars": 5959,
    "preview": "from typing import Literal\n\nfrom redis.client import Pipeline as RedisPipeline\n\nfrom ...asyncio.client import Pipeline a"
  },
  {
    "path": "redis/commands/search/_util.py",
    "chars": 219,
    "preview": "def to_string(s, encoding: str = \"utf-8\"):\n    if isinstance(s, str):\n        return s\n    elif isinstance(s, bytes):\n  "
  },
  {
    "path": "redis/commands/search/aggregation.py",
    "chars": 11578,
    "preview": "from typing import List, Optional, Tuple, Union\n\nfrom redis.commands.search.dialect import DEFAULT_DIALECT\n\nFIELDNAME = "
  },
  {
    "path": "redis/commands/search/commands.py",
    "chars": 44070,
    "preview": "import itertools\nimport time\nfrom typing import Any, Dict, List, Optional, Union\n\nfrom redis._parsers.helpers import pai"
  },
  {
    "path": "redis/commands/search/dialect.py",
    "chars": 105,
    "preview": "# Value for the default dialect to be used as a part of\n# Search or Aggregate query.\nDEFAULT_DIALECT = 2\n"
  },
  {
    "path": "redis/commands/search/document.py",
    "chars": 413,
    "preview": "class Document:\n    \"\"\"\n    Represents a single document in a result set\n    \"\"\"\n\n    def __init__(self, id, payload=Non"
  },
  {
    "path": "redis/commands/search/field.py",
    "chars": 5935,
    "preview": "from typing import List\n\nfrom redis import DataError\n\n\nclass Field:\n    \"\"\"\n    A class representing a field in a docume"
  },
  {
    "path": "redis/commands/search/hybrid_query.py",
    "chars": 13270,
    "preview": "from enum import Enum\nfrom typing import Any, Dict, List, Optional, Union\n\nfrom redis.utils import experimental\n\ntry:\n  "
  },
  {
    "path": "redis/commands/search/hybrid_result.py",
    "chars": 815,
    "preview": "from dataclasses import dataclass\nfrom typing import Any, Dict, List, Union\n\n\n@dataclass\nclass HybridResult:\n    \"\"\"\n   "
  },
  {
    "path": "redis/commands/search/index_definition.py",
    "chars": 2489,
    "preview": "from enum import Enum\n\n\nclass IndexType(Enum):\n    \"\"\"Enum of the currently supported index types.\"\"\"\n\n    HASH = 1\n    "
  },
  {
    "path": "redis/commands/search/profile_information.py",
    "chars": 249,
    "preview": "from typing import Any\n\n\nclass ProfileInformation:\n    \"\"\"\n    Wrapper around FT.PROFILE response\n    \"\"\"\n\n    def __ini"
  },
  {
    "path": "redis/commands/search/query.py",
    "chars": 12361,
    "preview": "from typing import List, Optional, Tuple, Union\n\nfrom redis.commands.search.dialect import DEFAULT_DIALECT\n\n\nclass Query"
  },
  {
    "path": "redis/commands/search/querystring.py",
    "chars": 7597,
    "preview": "def tags(*t):\n    \"\"\"\n    Indicate that the values should be matched to a tag field\n\n    ### Parameters\n\n    - **t**: Ta"
  },
  {
    "path": "redis/commands/search/reducers.py",
    "chars": 4220,
    "preview": "from typing import Union\n\nfrom .aggregation import Asc, Desc, Reducer, SortDirection\n\n\nclass FieldOnlyReducer(Reducer):\n"
  },
  {
    "path": "redis/commands/search/result.py",
    "chars": 2624,
    "preview": "from typing import Optional\n\nfrom ._util import to_string\nfrom .document import Document\n\n\nclass Result:\n    \"\"\"\n    Rep"
  },
  {
    "path": "redis/commands/search/suggestion.py",
    "chars": 1612,
    "preview": "from typing import Optional\n\nfrom ._util import to_string\n\n\nclass Suggestion:\n    \"\"\"\n    Represents a single suggestion"
  },
  {
    "path": "redis/commands/sentinel.py",
    "chars": 5299,
    "preview": "import warnings\n\n\nclass SentinelCommands:\n    \"\"\"\n    A class containing the commands specific to redis sentinel. This c"
  },
  {
    "path": "redis/commands/timeseries/__init__.py",
    "chars": 3450,
    "preview": "import redis\nfrom redis._parsers.helpers import bool_ok\n\nfrom ..helpers import get_protocol_version, parse_to_list\nfrom "
  },
  {
    "path": "redis/commands/timeseries/commands.py",
    "chars": 47291,
    "preview": "from typing import Dict, List, Optional, Tuple, Union\n\nfrom redis.exceptions import DataError\nfrom redis.typing import K"
  },
  {
    "path": "redis/commands/timeseries/info.py",
    "chars": 3223,
    "preview": "from ..helpers import nativestr\nfrom .utils import list_to_dict\n\n\nclass TSInfo:\n    \"\"\"\n    Hold information and statist"
  },
  {
    "path": "redis/commands/timeseries/utils.py",
    "chars": 1319,
    "preview": "from ..helpers import nativestr\n\n\ndef list_to_dict(aList):\n    return {nativestr(aList[i][0]): nativestr(aList[i][1]) fo"
  },
  {
    "path": "redis/commands/vectorset/__init__.py",
    "chars": 1968,
    "preview": "import json\nfrom typing import Literal\n\nfrom redis._parsers.helpers import pairs_to_dict\nfrom redis.commands.vectorset.u"
  }
]

// ... and 172 more files (download for full content)