Valkey GLIDE Async client

Warnings

• gotcha OpenTelemetry can only be initialized once per process. Attempting to re-initialize it will not apply new configurations and requires a full application restart for changes to take effect.
  Fix: Ensure OpenTelemetry configuration is set up once at application startup. For changes, restart the application.
• gotcha Connecting to a TLS-enabled Valkey server without setting `use_tls=True` in the client configuration will result in connection timeouts.
  Fix: Always explicitly set `use_tls=True` in `GlideClientConfiguration` or `GlideClusterClientConfiguration` when connecting to a TLS-enabled server. If using custom certificates, also provide the `root_certificates` parameter.
• gotcha Currently, Alpine Linux / MUSL is NOT officially supported for the Python client. Users on these platforms may encounter compilation or runtime issues.
  Fix: Use a supported Linux distribution (e.g., Ubuntu, Amazon Linux) or macOS. Monitor official documentation for future Alpine/MUSL support.
• gotcha Automatic compression/decompression in Valkey GLIDE is NOT compatible with Valkey commands that manipulate string data on the server side.
  Fix: Avoid using client-side compression for commands such as `APPEND`, `SETRANGE`, `GETRANGE`, etc., where the server needs to interpret or modify string data directly. Consult documentation for a full list of incompatible commands.
• gotcha The synchronous Python client (from `glide_sync`) introduced in version 2.1 does not yet support all features available in the asynchronous client, specifically: Pub/Sub, Cluster scan, configuring an In-flight request limit, and OpenTelemetry integration.
  Fix: If these features are required, use the asynchronous client (from `glide`). For synchronous workflows requiring these features, consider using an `asyncio` event loop to run asynchronous client calls.

Install

• pip install valkey-glide Install latest version

Imports

• GlideClient

  from glide import GlideClient, NodeAddress

• GlideClusterClient

  from glide import GlideClusterClient, NodeAddress

• GlideClient (sync)

  from glide_sync import GlideClient, NodeAddress

  For the synchronous client, import from `glide_sync`.
• GlideClusterClient (sync)

  from glide_sync import GlideClusterClient, NodeAddress

  For the synchronous cluster client, import from `glide_sync`.

Quickstart

This quickstart demonstrates connecting to a standalone Valkey instance and a Valkey cluster using `valkey-glide`'s asynchronous clients. It performs a `PING` command to verify connection and `SET`/`GET` operations. For cluster mode, ensure `VALKEY_CLUSTER_HOST` and `VALKEY_CLUSTER_PORT` environment variables are set to your cluster's entry point, or adjust the default `localhost:7000` to a running cluster node.

import asyncio
from glide import GlideClient, GlideClusterClient, NodeAddress
import os

async def main():
    # Example for a standalone Valkey instance
    # Ensure a Valkey server is running on localhost:6379 (e.g., via Docker)
    # docker run -d --name valkey-server -p 6379:6379 valkey/valkey:latest
    print("\n--- Standalone Client Example ---")
    standalone_client = GlideClient([NodeAddress("localhost", 6379)])
    try:
        pong_response = await standalone_client.ping()
        print(f"Standalone PING response: {pong_response}")

        await standalone_client.set("mykey", "myvalue")
        value = await standalone_client.get("mykey")
        print(f"Standalone GET mykey: {value}")
    except Exception as e:
        print(f"Error with Standalone Client: {e}")
    finally:
        await standalone_client.close()

    # Example for a Valkey cluster instance
    # Replace with actual cluster addresses
    # For local testing, you might need a local Valkey cluster setup
    print("\n--- Cluster Client Example ---")
    cluster_addresses = [NodeAddress(os.environ.get('VALKEY_CLUSTER_HOST', 'localhost'), int(os.environ.get('VALKEY_CLUSTER_PORT', '7000')))]
    cluster_client = GlideClusterClient(cluster_addresses)
    try:
        cluster_pong_response = await cluster_client.ping()
        print(f"Cluster PING response: {cluster_pong_response}")

        await cluster_client.set("cluster_key", "cluster_value")
        cluster_value = await cluster_client.get("cluster_key")
        print(f"Cluster GET cluster_key: {cluster_value}")
    except Exception as e:
        print(f"Error with Cluster Client: {e}")
    finally:
        await cluster_client.close()

if __name__ == "__main__":
    asyncio.run(main())