redis-py

https://redis.readthedocs.io/en/stable/
Admin
redis-py is a Python client library for Redis that provides commands for connecting to Redis...
Tokens:548,755
Snippets:4,026
Trust Score:9.6
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install numpy

Source: https://redis.readthedocs.io/en/stable/examples/search_vector_similarity_examples.html

Install the numpy library, which is required for generating random vectors in the examples.

```bash
%pip install numpy
```

--------------------------------

### Basic OpenTelemetry setup with redis-py

Source: https://redis.readthedocs.io/en/stable/opentelemetry.html

Initializes OpenTelemetry observability once at application startup. All Redis clients will automatically collect metrics. The example sets up a MeterProvider with an OTLP exporter, initializes redis-py observability, performs Redis operations, and shuts down observability at exit.

```python
from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter

# 1. Set up OpenTelemetry MeterProvider
exporter = OTLPMetricExporter(endpoint="http://localhost:4318/v1/metrics")
reader = PeriodicExportingMetricReader(exporter=exporter, export_interval_millis=10000)
provider = MeterProvider(metric_readers=[reader])
metrics.set_meter_provider(provider)

# 2. Initialize redis-py observability
from redis.observability import get_observability_instance, OTelConfig

otel = get_observability_instance()
otel.init(OTelConfig())

# 3. Use Redis as usual - metrics are collected automatically
import redis
r = redis.Redis(host='localhost', port=6379)
r.set('key', 'value')  # Metrics collected automatically
r.get('key')

# 4. Shutdown observability at application exit
otel.shutdown()
```

--------------------------------

### Install OpenTelemetry packages

Source: https://redis.readthedocs.io/en/stable/examples/opentelemetry_api_examples.html

Install the OpenTelemetry API and SDK packages. The output shows the packages are already installed in the user's environment.

```bash
pip install opentelemetry-api opentelemetry-sdk

```

--------------------------------

### Install Cohere client

Source: https://redis.readthedocs.io/en/stable/examples/search_vector_similarity_examples.html

Installs the Cohere Python client library in the current environment.

```python
%pip install cohere
```

--------------------------------

### ConnectionPool.make_connection start

Source: https://redis.readthedocs.io/en/stable/_modules/redis/connection.html

Starts creating a fresh connection by acquiring the lock if the pool is in maintenance mode. The method is incomplete in the source, showing only the beginning of the implementation.

```python
    def make_connection(self):
        "Make a fresh connection."
        try:
            if self._in_maintenance:
                self._lock.acquire()
                self._locked = True
```

--------------------------------

### Install opentelemetry-instrumentation-redis

Source: https://redis.readthedocs.io/en/stable/opentelemetry.html

Install the external OpenTelemetry instrumentation package for redis-py using pip.

```bash
pip install opentelemetry-instrumentation-redis

```

--------------------------------

### Sentinel class with usage example

Source: https://redis.readthedocs.io/en/stable/_modules/redis/sentinel.html

Redis Sentinel cluster client. The docstring includes a usage example showing how to connect to sentinel nodes and use master/slave clients.

```python
[docs]class Sentinel(SentinelCommands):
    """
    Redis Sentinel cluster client

    >>> from redis.sentinel import Sentinel
    >>> sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)
    >>> master = sentinel.master_for('mymaster', socket_timeout=0.1)
    >>> master.set('foo', 'bar')
    >>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)
    >>> slave.get('foo')
    b'bar'

    ``sentinels`` is a list of sentinel nodes. Each node is represented by
    a pair (hostname, port).

    ``min_other_sentinels`` defined a minimum number of peers for a sentinel.
    When querying a sentinel, if it doesn't meet this threshold, responses
    from that sentinel won't be considered valid.

    ``sentinel_kwargs`` is a dictionary of connection arguments used when
    connecting to sentinel instances. Any argument that can be passed to
    a normal Redis connection can be specified here. If ``sentinel_kwargs`` is
    not specified, any socket_timeout and socket_keepalive options specified
    in ``connection_kwargs`` will be used.

    ``connection_kwargs`` are keyword arguments that will be used when
    establishing a connection to a Redis server.
    """
```

--------------------------------

### Set and get a key with redis-py

Source: https://redis.readthedocs.io/en/stable/commands.html

Basic example of setting and getting a string value in Redis using the redis-py client. The decode_responses=True parameter makes responses return strings instead of bytes.

```python
import redis
r = redis.Redis(decode_responses=True)
r.set('mykey', 'thevalueofmykey')
r.get('mykey')

```

--------------------------------

### RedisClient.__init__

Source: https://redis.readthedocs.io/en/stable/_modules/redis/asyncio/client.html

Documentation for the Redis client constructor, including all parameters and deprecation notes.

```APIDOC
## RedisClient.__init__

### Description
Initializes a new Redis client with configurable connection, retry, SSL, and authentication options. Supports both TCP and Unix socket connections, connection pooling, and various advanced settings.

### Method
Constructor

### Signature
```python
async def __init__(
    self,
    *,
    host: str = "localhost",
    port: int = 6379,
    db: str | int = 0,
    password: str | None = None,
    socket_timeout: float | None = DEFAULT_SOCKET_TIMEOUT,
    socket_connect_timeout: float | None = DEFAULT_SOCKET_CONNECT_TIMEOUT,
    socket_read_size: int = DEFAULT_SOCKET_READ_SIZE,
    socket_keepalive: bool | None = True,
    socket_keepalive_options: Mapping[int, int | bytes] | object | None = SENTINEL,
    connection_pool: ConnectionPool | None = None,
    unix_socket_path: str | None = None,
    encoding: str = "utf-8",
    encoding_errors: str = "strict",
    decode_responses: bool = False,
    retry_on_timeout: bool = False,
    retry: Retry = Retry(
        backoff=ExponentialWithJitterBackoff(
            base=DEFAULT_RETRY_BASE, cap=DEFAULT_RETRY_CAP
        ),
        retries=DEFAULT_RETRY_COUNT,
    ),
    retry_on_error: list | None = None,
    ssl: bool = False,
    ssl_keyfile: str | None = None,
    ssl_certfile: str | None = None,
    ssl_cert_reqs: "str | VerifyMode" = "required",
    ssl_include_verify_flags: List["VerifyFlags"] | None = None,
    ssl_exclude_verify_flags: List["VerifyFlags"] | None = None,
    ssl_ca_certs: str | None = None,
    ssl_ca_data: str | None = None,
    ssl_ca_path: str | None = None,
    ssl_check_hostname: bool = True,
    ssl_min_version: "TLSVersion | None" = None,
    ssl_ciphers: str | None = None,
    ssl_password: str | None = None,
    max_connections: int | None = None,
    single_connection_client: bool = False,
    health_check_interval: int = 0,
    client_name: str | None = None,
    lib_name: str | object | None = SENTINEL,
    lib_version: str | object | None = SENTINEL,
    driver_info: DriverInfo | object | None = SENTINEL,
    username: str | None = None,
    auto_close_connection_pool: bool | None = None,
    redis_connect_func=None,
    credential_provider: CredentialProvider | None = None,
    protocol: int | None = None,
    legacy_responses: bool = True,
    event_dispatcher: EventDispatcher | None = None,
    maint_notifications_config: MaintNotificationsConfig | None = None,
)
```

### Parameters
- **host** (str) - Optional - Hostname of the Redis server. Default: "localhost".
- **port** (int) - Optional - Port of the Redis server. Default: 6379.
- **db** (str | int) - Optional - Database index or name. Default: 0.
- **password** (str | None) - Optional - Password for authentication.
- **socket_timeout** (float | None) - Optional - Socket timeout in seconds.
- **socket_connect_timeout** (float | None) - Optional - Socket connect timeout in seconds.
- **socket_read_size** (int) - Optional - Socket read buffer size.
- **socket_keepalive** (bool | None) - Optional - Enable TCP keepalive. Default: True.
- **socket_keepalive_options** (Mapping[int, int | bytes] | object | None) - Optional - TCP keepalive options.
- **connection_pool** (ConnectionPool | None) - Optional - Custom connection pool. If provided, retry configuration from the pool is used.
- **unix_socket_path** (str | None) - Optional - Path to Unix socket.
- **encoding** (str) - Optional - Encoding for string responses. Default: "utf-8".
- **encoding_errors** (str) - Optional - Error handling for encoding. Default: "strict".
- **decode_responses** (bool) - Optional - Decode responses to strings. Default: False.
- **retry_on_timeout** (bool) - Optional - Deprecated. Retry on TimeoutError. Use retry_on_error or Retry object instead.
- **retry** (Retry) - Optional - Retry policy object. Default: Retry with ExponentialWithJitterBackoff.
- **retry_on_error** (list | None) - Optional - List of errors to retry on. Enriches default retry errors.
- **ssl** (bool) - Optional - Enable SSL/TLS. Default: False.
- **ssl_keyfile** (str | None) - Optional - Path to SSL key file.
- **ssl_certfile** (str | None) - Optional - Path to SSL certificate file.
- **ssl_cert_reqs** (str | VerifyMode) - Optional - SSL certificate requirements. Default: "required".
- **ssl_include_verify_flags** (List["VerifyFlags"] | None) - Optional - SSL verification flags to include.
- **ssl_exclude_verify_flags** (List["VerifyFlags"] | None) - Optional - SSL verification flags to exclude.
- **ssl_ca_certs** (str | None) - Optional - Path to CA certificates file.
- **ssl_ca_data** (str | None) - Optional - CA certificates data.
- **ssl_ca_path** (str | None) - Optional - Path to CA certificates directory.
- **ssl_check_hostname** (bool) - Optional - Check hostname in SSL certificate. Default: True.
- **ssl_min_version** (TLSVersion | None) - Optional - Minimum TLS version.
- **ssl_ciphers** (str | None) - Optional - Allowed SSL ciphers.
- **ssl_password** (str | None) - Optional - Password for SSL key file.
- **max_connections** (int | None) - Optional - Maximum number of connections in the pool.
- **single_connection_client** (bool) - Optional - Use a single connection for all commands. Default: False.
- **health_check_interval** (int) - Optional - Interval for health checks in seconds. Default: 0.
- **client_name** (str | None) - Optional - Client name to set on the connection.
- **lib_name** (str | object | None) - Optional - Deprecated. Library name for driver info.
- **lib_version** (str | object | None) - Optional - Deprecated. Library version for driver info.
- **driver_info** (DriverInfo | object | None) - Optional - Driver information object.
- **username** (str | None) - Optional - Username for authentication.
- **auto_close_connection_pool** (bool | None) - Optional - Automatically close the connection pool when client is closed.
- **redis_connect_func** - Optional - Custom connection function.
- **credential_provider** (CredentialProvider | None) - Optional - Credential provider for authentication.
- **protocol** (int | None) - Optional - Redis protocol version.
- **legacy_responses** (bool) - Optional - Use legacy response format. Default: True.
- **event_dispatcher** (EventDispatcher | None) - Optional - Event dispatcher for notifications.
- **maint_notifications_config** (MaintNotificationsConfig | None) - Optional - Configuration for maintenance notifications.

### Description
Initializes a new Redis client. To specify a retry policy for specific errors, you have two options: set `retry_on_error` to a list of errors to retry on (with optional `retry` object), or define a `Retry` object with configured `supported_errors` and set it to `retry`. `retry_on_timeout` is deprecated; include TimeoutError in the Retry object or `retry_on_error` list instead. When `connection_pool` is provided, the retry configuration of the provided pool will be used.

### Deprecations
- `retry_on_timeout` - Deprecated since version 6.0.0. TimeoutError is included by default.
- `lib_name` and `lib_version` - Deprecated. Use `driver_info` parameter instead.

```

--------------------------------

### Execute Redis pipeline

Source: https://redis.readthedocs.io/en/stable/examples/pipeline_examples.html

Executes the pipeline and returns a list of responses. For the example, the output is [True, True, 'a value'] where the booleans indicate successful set commands and the last element is the result of get("a").

```python
pipe.execute()

```

--------------------------------

### hotkeys_start

Source: https://redis.readthedocs.io/en/stable/_modules/redis/commands/core.html

Starts a hotkeys collection session to track key access patterns based on CPU and network metrics.

```APIDOC
## hotkeys_start(metrics, count=None, duration=None, sample_ratio=None, slots=None, **kwargs)

### Description
Starts collecting hotkeys data. Returns an error if there is an ongoing collection session. Supports tracking CPU and network consumption metrics.

### Method
HOTKEYS START

### Parameters
- **metrics** (List[HotkeysMetricsTypes]) - Required - List of metrics to track. Supported values: `HotkeysMetricsTypes.CPU`, `HotkeysMetricsTypes.NET`.
- **count** (int) - Optional - The number of keys to collect in each criteria (CPU and network consumption).
- **duration** (int) - Optional - Automatically stop the collection after `duration` seconds.
- **sample_ratio** (int) - Optional - Commands are sampled with probability 1/ratio (1 means no sampling).
- **slots** (List[int]) - Optional - Only track keys on the specified hash slots.
- **kwargs** - Optional - Additional keyword arguments passed to the underlying command execution.

### Returns
- **bytes | str** - The result of the command execution.

### Example
```python
result = client.hotkeys_start(metrics=[HotkeysMetricsTypes.CPU], count=10)
```
```

--------------------------------

### get_connection: Blocking connection retrieval

Source: https://redis.readthedocs.io/en/stable/_modules/redis/asyncio/connection.html

Gets a connection from the pool, blocking until one is available. The method is deprecated for passing arguments; use get_connection() without args instead. Starts timing for wait time observability.

```python
@deprecated_args(
    args_to_warn=["*"],
    reason="Use get_connection() without args instead",
    version="5.3.0",
)
async def get_connection(self, command_name=None, *keys, **options):
    """Gets a connection from the pool, blocking until one is available"""
    # Start timing for wait time observability
    start_time_acquired = time.monotonic()
```

--------------------------------

### Use Sentinel master_for and slave_for to read and write

Source: https://redis.readthedocs.io/en/stable/connections.html

Creates a Sentinel client, obtains a master client and a slave client for the 'mymaster' service, writes a key to the master, and reads it from the slave. The output shows the value returned by the slave.

```python
>>> from redis.sentinel import Sentinel
>>> sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)
>>> master = sentinel.master_for('mymaster', socket_timeout=0.1)
>>> master.set('foo', 'bar')
>>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)
>>> slave.get('foo')
b'bar'

```

--------------------------------

### Connect to Redis via SSL and validate OCSP status

Source: https://redis.readthedocs.io/en/stable/examples/ssl_connection_examples.html

Connects to Redis over SSL and validates the OCSP status of the certificate. Requires installing redis[ocsp] for extra libraries. The example expects a ConnectionError with message 'No AIA information present in ssl certificate' because the certificate lacks an AIA extension.

```python
import os
import redis

pki_dir = os.path.join("..", "..", "dockers", "stunnel", "keys")

r = redis.Redis(
    host="localhost",
    port=6666,
    ssl=True,
    ssl_certfile=os.path.join(pki_dir, "client-cert.pem"),
    ssl_keyfile=os.path.join(pki_dir, "client-key.pem"),
    ssl_cert_reqs="required",
    ssl_ca_certs=os.path.join(pki_dir, "ca-cert.pem"),
    ssl_validate_ocsp=True,
)

try:
    r.ping()
except redis.ConnectionError as e:
    assert e.args[0] == "No AIA information present in ssl certificate"
    print("OCSP validation failed as expected.")

```

```output
OCSP validation failed as expected.

```

--------------------------------

### Create a topk list and access the results

Source: https://redis.readthedocs.io/en/stable/redismodules.html

Reserves a Top-K list named "mytopk" with 3 items, width 50, depth 4, and decay 0.9, then retrieves its information. Requires the RedisBloom module.

```python
import redis
r = redis.Redis()
r.topk().reserve("mytopk", 3, 50, 4, 0.9)
r.topk().info("mytopk")

```

--------------------------------

### get(key, latest=False)

Source: https://redis.readthedocs.io/en/stable/redismodules.html

Gets the last sample of a time series.

```APIDOC
## get(key, latest=False)

### Description
Get the last sample of key.

### Method
Function

### Endpoint
RedisTimeSeries command: TS.GET

### Parameters
- **key** (Union[bytes, str, memoryview]) - Required - The time-series key.
- **latest** (bool | None) - Optional - Used when a time series is a compaction, reports the compacted value of the latest (possibly partial) bucket.

### Returns
- tuple[int, float] | list[int | float] | None - The last sample.
```

--------------------------------

### Install OpenAI Package

Source: https://redis.readthedocs.io/en/stable/examples/search_vector_similarity_examples.html

Installs the OpenAI Python package using pip.

```python
%pip install openai
```

--------------------------------

### hotkeys_start

Source: https://redis.readthedocs.io/en/stable/_modules/redis/commands/cluster.html

Starts hotkeys monitoring. Not supported in cluster mode; raises NotImplementedError.

```APIDOC
## hotkeys_start

### Description
Cluster client does not support hotkeys command. Please use the non-cluster client.

### Method
HOTKEYS START

### Parameters
#### Required Parameters
- **metrics** (List[HotkeysMetricsTypes]) - Required - The metrics to monitor.

#### Optional Parameters
- **count** (int | None) - Optional - Number of hotkeys to return.
- **duration** (int | None) - Optional - Duration of monitoring.
- **sample_ratio** (int | None) - Optional - Sample ratio.
- **slots** (List[int] | None) - Optional - Slots to monitor.
- **kwargs** - Optional - Additional keyword arguments.

### Request Example
```python
try:
    cluster.hotkeys_start(metrics=["all"])
except NotImplementedError as e:
    print(e)
```

### Response
Raises NotImplementedError.

### More Information
For more information see https://redis.io/commands/hotkeys-start
```

--------------------------------

### module_loadex(path, options=None, args=None)

Source: https://redis.readthedocs.io/en/stable/commands.html

Loads a module with configuration directives.

```APIDOC
## module_loadex(path, options=None, args=None)

### Description
Loads a module from a dynamic library at runtime with configuration directives.

### Parameters
- **path** (str) - Required - Path to the module.
- **options** (Optional[List[str]]) - Optional - Configuration options.
- **args** (Optional[List[str]]) - Optional - Additional arguments.

### Return Type
Union[bytes, str, Awaitable[bytes | str]]
```

--------------------------------

### Example query embedding output

Source: https://redis.readthedocs.io/en/stable/examples/search_vector_similarity_examples.html

Example output of the query embedding array.

```python
array([-0.49682617,  1.7070312 ,  0.3466797 , ...,  0.58984375,
        0.1060791 , -2.9023438 ], dtype=float32)
```

--------------------------------

### argetrange(name, start, end)

Source: https://redis.readthedocs.io/en/stable/commands.html

Returns the values in the inclusive index range [`start`, `end`] in the array stored at `name`. If `start` is greater than `end`, elements are returned in reverse index order.

```APIDOC
## argetrange(name, start, end)

### Description
Return the values in the inclusive index range [`start`, `end`] in the array stored at `name`. If `start` is greater than `end`, elements are returned in reverse index order.

### Parameters
- **name** (_Union_[bytes, str, memoryview]) - Required - The name of the array.
- **start** (_int_) - Required - The starting index.
- **end** (_int_) - Required - The ending index.

### Return Type
_Union_[list[bytes | str | None], _Awaitable_[list[bytes | str | None]]]

### Reference
https://redis.io/commands/argetrange
```

--------------------------------

### Setup for Redis pipeline performance comparison

Source: https://redis.readthedocs.io/en/stable/examples/pipeline_examples.html

Sets up the performance comparison by importing datetime and defining incr_value as 100000.

```python
from datetime import datetime

incr_value = 100000

```

--------------------------------

### Initialize Cohere client

Source: https://redis.readthedocs.io/en/stable/examples/search_vector_similarity_examples.html

Imports the Cohere library and initializes a client with your API key. Replace YOUR COHERE API KEY with a valid key.

```python
import cohere

co = cohere.Client("YOUR COHERE API KEY")
```

--------------------------------

### Sentinel.__init__: configure sentinel clients

Source: https://redis.readthedocs.io/en/stable/_modules/redis/sentinel.html

Initializes a Sentinel client with a list of sentinel host/port pairs. If sentinel_kwargs is not provided, it inherits any socket_* options from connection_kwargs. Creates a Redis client for each sentinel and stores the minimum number of other sentinels required for master validation.

```python
    def __init__(
        self,
        sentinels,
        min_other_sentinels=0,
        sentinel_kwargs=None,
        force_master_ip=None,
        **connection_kwargs,
    ):
        # if sentinel_kwargs isn't defined, use the socket_* options from
        # connection_kwargs
        if sentinel_kwargs is None:
            sentinel_kwargs = {
                k: v for k, v in connection_kwargs.items() if k.startswith("socket_")
            }
        self.sentinel_kwargs = sentinel_kwargs

        self.sentinels = [
            Redis(hostname, port, **self.sentinel_kwargs)
            for hostname, port in sentinels
        ]
        self.min_other_sentinels = min_other_sentinels
        self.connection_kwargs = connection_kwargs
        self._force_master_ip = force_master_ip
```

--------------------------------

### Install redis-py OpenTelemetry dependencies

Source: https://redis.readthedocs.io/en/stable/opentelemetry.html

Installs the required dependencies for native OpenTelemetry support in redis-py.

```bash
pip install redis[otel]
```

--------------------------------

### Example embeddings output

Source: https://redis.readthedocs.io/en/stable/examples/search_vector_similarity_examples.html

Example output of the embeddings array, showing the shape and dtype of the generated embeddings.

```python
array([[-0.3034668 , -0.71533203, -0.2836914 , ...,  0.81152344,
         1.0253906 , -0.8095703 ],
       [-0.02560425, -1.4912109 ,  0.24267578, ..., -0.89746094,
         0.15625   , -3.203125  ],
       [ 0.10125732,  0.7246094 , -0.29516602, ..., -1.9638672 ,
         1.6630859 , -0.23291016],
       [-2.09375   ,  0.8588867 , -0.23352051, ..., -0.01541138,
         0.17053223, -3.4042969 ]], dtype=float32)
```

--------------------------------

### ClusterPipeline.initialize

Source: https://redis.readthedocs.io/en/stable/_modules/redis/asyncio/cluster.html

Documentation for the initialize method of the ClusterPipeline class.

```APIDOC
## ClusterPipeline.initialize

### Description
Initializes the pipeline by initializing the execution strategy. This method is called automatically when using the pipeline as an async context manager or with await.

### Method
initialize

### Returns
- **ClusterPipeline** - The initialized pipeline instance.

```

--------------------------------

### TOPK.INCRBY Example: topkincrby('A', ['foo'], [1])

Source: https://redis.readthedocs.io/en/stable/redismodules.html

Example usage of the TOPK.INCRBY command via the redis-py client. Adds/increments items in a Top-K filter key. The example shows calling topkincrby with key 'A', items ['foo'], and increments [1].

```python
>>> topkincrby('A', ['foo'], [1])
```

--------------------------------

### Monitor object listen() example

Source: https://redis.readthedocs.io/en/stable/advanced_features.html

Shows how to use the Monitor object to stream every command processed by the Redis server. Use listen() to block until a command is received.

```python
>>> r = redis.Redis(...)
>>> with r.monitor() as m:
>>>     for command in m.listen():
>>>         print(command)
```

--------------------------------

### Example search results

Source: https://redis.readthedocs.io/en/stable/examples/search_vector_similarity_examples.html

Example search results showing the two documents related to animals, with their scores and tags.

```python
[Document {'id': 'doc:1', 'payload': None, 'score': '0.658673524857', 'content': 'The dog next door barks really loudly.', 'tag': 'cohere'},
 Document {'id': 'doc:2', 'payload': None, 'score': '0.662699103355', 'content': 'My cat escaped and got out before I could close the door.', 'tag': 'cohere'}]
```

--------------------------------

### Create a Redis pipeline instance

Source: https://redis.readthedocs.io/en/stable/examples/pipeline_examples.html

Creates a pipeline instance from the Redis client r. This is the first step in using pipelines.

```python
pipe = r.pipeline()

```

--------------------------------

### Create JSON index and add documents

Source: https://redis.readthedocs.io/en/stable/examples/search_json_examples.html

Sets up four JSON documents under keys user:1 through user:4 and creates a RediSearch index on the JSON path fields name, city, and age. The index uses a prefix of "user:" and IndexType.JSON. The expected output is b'OK'.

```python
import redis
from redis.commands.json.path import Path
import redis.commands.search.aggregation as aggregations
import redis.commands.search.reducers as reducers
from redis.commands.search.field import TextField, NumericField, TagField
from redis.commands.search.index_definition import IndexDefinition, IndexType
from redis.commands.search.query import NumericFilter, Query


r = redis.Redis(host='localhost', port=6379)
user1 = {
    "user":{
        "name": "Paul John",
        "email": "paul.john@example.com",
        "age": 42,
        "city": "London"
    }
}
user2 = {
    "user":{
        "name": "Eden Zamir",
        "email": "eden.zamir@example.com",
        "age": 29,
        "city": "Tel Aviv"
    }
}
user3 = {
    "user":{
        "name": "Paul Zamir",
        "email": "paul.zamir@example.com",
        "age": 35,
        "city": "Tel Aviv"
    }
}

user4 = {
    "user":{
        "name": "Sarah Zamir",
        "email": "sarah.zamir@example.com",
        "age": 30,
        "city": "Paris"
    }
}
r.json().set("user:1", Path.root_path(), user1)
r.json().set("user:2", Path.root_path(), user2)
r.json().set("user:3", Path.root_path(), user3)
r.json().set("user:4", Path.root_path(), user4)

schema = (TextField("$.user.name", as_name="name"),TagField("$.user.city", as_name="city"), NumericField("$.user.age", as_name="age"))
r.ft().create_index(schema, definition=IndexDefinition(prefix=["user:"], index_type=IndexType.JSON))
```

```output
b'OK'
```

--------------------------------

### Get last sample with labels using ts.mget with_labels

Source: https://redis.readthedocs.io/en/stable/examples/timeseries_examples.html

Gets the last sample matching a label filter and also returns the label-value pairs of the sample. The with_labels=True option includes the labels in the response.

```python
ts.mget(["label1=1"], with_labels=True)

```

--------------------------------

### initialize: reset and prepare cluster state

Source: https://redis.readthedocs.io/en/stable/_modules/redis/asyncio/cluster.html

Starts cluster initialization by resetting the load balancer and preparing temporary caches for nodes and slots. Accepts optional startup node info and a last failed node name, and defaults additional_startup_nodes_info to an empty list when not provided.

```python
    async def initialize(
        self,
        additional_startup_nodes_info: Optional[List[Tuple[str, int]]] = None,
        last_failed_node_name: Optional[str] = None,
    ) -> None:
        self.read_load_balancer.reset()
        tmp_nodes_cache: Dict[str, "ClusterNode"] = {}
        tmp_slots: Dict[int, List["ClusterNode"]] = {}
        disagreements = []
        startup_nodes_reachable = False
        fully_covered = False
        exception = None
        epoch = self._epoch
        if additional_startup_nodes_info is None:
            additional_startup_nodes_info = []
```

--------------------------------

### Connect to a Sentinel instance

Source: https://redis.readthedocs.io/en/stable/examples/connection_examples.html

Creates a Sentinel instance with a list of sentinel hosts and a socket timeout, then discovers the master for the service name 'redis-py-test'.

```python
from redis.sentinel import Sentinel
sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)
sentinel.discover_master("redis-py-test")
```

--------------------------------

### Get last sample matching label with ts.mget

Source: https://redis.readthedocs.io/en/stable/examples/timeseries_examples.html

Gets the last sample matching a specific label filter. The filter syntax is 'label=value'. Returns a list of dictionaries with the timeseries key and sample data.

```python
ts.mget(["label1=1"])

```

--------------------------------

### ClusterPipeline usage example

Source: https://redis.readthedocs.io/en/stable/_modules/redis/asyncio/cluster.html

Usage example for ClusterPipeline: chains multiple commands and executes them. Commands that split across nodes (DELETE, EXISTS, TOUCH, UNLINK, mset_nonatomic) return multiple results in the array.

```python
result = await (
    rc.pipeline()
    .set("A", 1)
    .get("A")
    .hset("K", "F", "V")
    .hgetall("K")
    .mset_nonatomic({"A": 2, "B": 3})
    .get("A")
    .get("B")
    .delete("A", "B", "K")
    .execute()
)
# result = [True, "1", 1, {"F": "V"}, True, True, "2", "3", 1, 1, 1]
```

--------------------------------

### __aenter__ method

Source: https://redis.readthedocs.io/en/stable/_modules/redis/asyncio/cluster.html

Async context manager entry that initializes the pipeline.

```python
async def __aenter__(self) -> "ClusterPipeline":
    return await self.initialize()
```

--------------------------------

### Redis pubsub parse_response method with usage examples

Source: https://redis.readthedocs.io/en/stable/_modules/redis/client.html

Method definition for parse_response with docstring explaining block and timeout behavior. The docstring includes three usage examples showing blocking, non-blocking with timeout, and immediate return.

```python
def parse_response(self, block=True, timeout=0):
    """
    Parse the response from a publish/subscribe command.

    Args:
        block: If True, block indefinitely until a message is available.
               If False, return immediately if no message is available.
               Default: True
        timeout: The timeout in seconds for reading a response when block=False.
                 This parameter is ignored when block=True.
                 Default: 0 (return immediately if no data available)

    Returns:
        The parsed response from the server, or None if no message is available
        within the timeout period (when block=False).

    Important:
        The block and timeout parameters work together:
        - When block=True: timeout is IGNORED, method blocks indefinitely
        - When block=False: timeout is USED, method returns after timeout expires

        Typically, you should use get_message(timeout=X) instead of calling
        parse_response() directly. The get_message() method automatically sets
        block=False when a timeout is provided, and block=True when timeout=None.

    Example:
        # Block indefinitely (timeout is ignored)
        response = pubsub.parse_response(block=True, timeout=0.1)

        # Non-blocking with 0.1 second timeout
        response = pubsub.parse_response(block=False, timeout=0.1)

        # Non-blocking, return immediately
        response = pubsub.parse_response(block=False, timeout=0)
    """
```

--------------------------------

### slowlog_len

Source: https://redis.readthedocs.io/en/stable/commands.html

Get the number of items in the slowlog.

```APIDOC
## slowlog_len(**kwargs)

### Description
Get the number of items in the slowlog.

### Method
slowlog_len

### Parameters
- **kwargs** – Optional

### Return Type
Union[int, Awaitable[int]]
```

--------------------------------

### ConnectionPool.__init__

Source: https://redis.readthedocs.io/en/stable/_modules/redis/connection.html

Constructor for the ConnectionPool class.

```APIDOC
## ConnectionPool.__init__

### Description
Initializes a new ConnectionPool instance. Sets the connection class, maximum connections, and connection keyword arguments. Raises ValueError if max_connections is not a positive integer.

### Method
constructor

### Signature
__init__(self, connection_class=Connection, max_connections: Optional[int] = None, cache_factory: Optional[CacheFactoryInterface] = None, maint_notifications_config: Optional[MaintNotificationsConfig] = None, **connection_kwargs)

### Parameters
- **connection_class** - Optional - The connection class to use (default: Connection).
- **max_connections** (int) - Optional - Maximum number of connections in the pool. Defaults to 100 if not provided.
- **cache_factory** (CacheFactoryInterface) - Optional - Factory for cache creation.
- **maint_notifications_config** (MaintNotificationsConfig) - Optional - Configuration for maintenance notifications. If not provided but protocol is 3, maintenance notifications are enabled by default.
- **connection_kwargs** - Optional - Additional keyword arguments passed to the connection class constructor.

### Raises
- **ValueError** - If max_connections is not a positive integer.
```

--------------------------------

### RedisCluster._initialize

Source: https://redis.readthedocs.io/en/stable/connections.html

Async method to initialize the cluster by fetching all nodes from startup nodes and creating connections if not already initialized.

```APIDOC
## RedisCluster._initialize(additional_startup_nodes_info=None, last_failed_node_name=None)

### Description
Get all nodes from startup nodes and create connections if not initialized.

### Method
async method

### Endpoint
RedisCluster._initialize(additional_startup_nodes_info=None, last_failed_node_name=None)

### Parameters
- **additional_startup_nodes_info** (Optional[List[Tuple[str, int]]]) - Optional - Additional startup node information.
- **last_failed_node_name** (Optional[str]) - Optional - Name of the last failed node.

### Response
#### Success Response
- **Return type**: RedisCluster
```

--------------------------------

### JSONCommands.arrlen

Source: https://redis.readthedocs.io/en/stable/redismodules.html

Get the length of a JSON array.

```APIDOC
## JSONCommands.arrlen

### Description
Return the length of the array JSON value under `path` at key `name`.

### Method
arrlen

### Parameters
- **name** (str) - Required - The key name.
- **path** (str, optional) - The path to the array. Defaults to root path.

### Returns
int | list[int | None] | None - The length of the array, or a list of lengths if multiple paths were affected.
```

--------------------------------

### RedisCluster.get_nodes

Source: https://redis.readthedocs.io/en/stable/connections.html

Method to get all nodes of the cluster.

```APIDOC
## RedisCluster.get_nodes()

### Description
Get all nodes of the cluster.

### Method
method

### Endpoint
RedisCluster.get_nodes()

### Response
#### Success Response
- **Return type**: List[ClusterNode]
```
Tokens:
Raw