Add support for Redis credential_provider in URL

[SorianoMarmol]

First of all, thank you for maintaining this excellent library!

Background

Celery and Kombu are adding native support for Redis credential_provider parameter, which is essential for modern authentication methods like Azure Redis with Entra ID (formerly Azure AD).

• Celery PR: Feature: Add support credential_provider to Redis Backend celery/celery#9879
• Kombu PR: Feat: add support for credential_provider to redis broker celery/kombu#2408

Current Situation

It's currently possible to inject the credential provider using a custom client class:

# Use your own redis client class, should be compatible or subclass redis.Redis
CACHEOPS_CLIENT_CLASS = 'your.redis.ClientClass'

However, this creates two different ways of configuring the same thing across Celery, Kombu, and cacheops

Problem

It would be ideal to configure it using CACHEOPS_REDIS with credential_provider as a URL query parameter (consistent with Celery/Kombu):

CACHEOPS_REDIS = 'rediss://host:6380/15?credential_provider=module.MyCredentialProvider'

But this currently doesn't work because the credential_provider value is parsed as a string instead of being imported and instantiated as an object, resulting in:

AttributeError: 'str' object has no attribute 'get_credentials'

Additional Issue: from_url() Forces Dictionary Configuration

When using CACHEOPS_CLIENT_CLASS with credential_provider support, the current implementation forces users to abandon URL-based configuration and switch to dictionary format.

Additional Issue: from_url() Forces Dictionary Configuration

Cacheops checks if CACHEOPS_REDIS is a string (redis.py line 48-49):

if isinstance(settings.CACHEOPS_REDIS, str):
    return client_class.from_url(settings.CACHEOPS_REDIS)The `from_url()` method:

1. Parses URL query parameters as strings
2. Creates a ConnectionPool internally with those parsed string values
3. By the time the custom client's __init__ runs, the pool is already created WITHOUT the credential_provider

This means even if you try to inject the credential_provider in your custom client's __init__, it's too late—the connection pool is already instantiated.

Suggestions
Option 1: Add support for parsing and instantiating credential_provider from URL parameters (to match Celery/Kombu behavior).
Option 2: At minimum, update the documentation with an example showing how to use CACHEOPS_CLIENT_CLASS with a custom client class to inject credential providers.

This would help users implement token-based authentication (Azure Entra ID, AWS IAM, etc.) consistently across their Django/Celery stack.

Thanks a lot!

[SorianoMarmol]

Edit:

I’ve run into an issue while injecting my credential provider into the custom Redis class.

from_url()` "Forces" Dictionary Configuration

Cacheops checks if CACHEOPS_REDIS is a string (redis.py line 48-49):

if isinstance(settings.CACHEOPS_REDIS, str):
    return client_class.from_url(settings.CACHEOPS_REDIS)

The from_url() method:

1. Parses URL query parameters as strings
2. Creates a ConnectionPool internally with those parsed string values
3. By the time the custom client's __init__ runs, the pool is already created WITHOUT the credential_provider

This means even if you try to inject the credential_provider in your custom client's __init__, it's too late—the connection pool is already instantiated.

[Suor]

This should be open for redis-py then. I simply pass string credentials as is.

[SorianoMarmol]

Thank you very much for your reply — and once again, great work on the repo.

Regarding string support, it’s an enhancement request tied to the Celery/Kombu implementation, and on the Celery side it has already been merged. You’re absolutely entitled to decide not to implement the proposal, of course =)

As for the other issue, which is slightly more important to me, Redis-py already provides a way to pass the credential provider through kwargs. However, in this case the call doesn’t propagate any kwargs, so the provider can’t be used without custom redis class:

if isinstance(settings.CACHEOPS_REDIS, str):
    return client_class.from_url(settings.CACHEOPS_REDIS)

Let me provide you with a couple of examples:

• Celery singleton provides a setting for redis kwargs:

https://github.com/steinitzu/celery-singleton/blob/master/celery_singleton/backends/redis.py#L11

class RedisBackend(BaseBackend):
    def __init__(self, *args, **kwargs):
        """
        args and kwargs are forwarded to redis.from_url
        """
        self.redis = Redis.from_url(*args, decode_responses=True, **kwargs)

*Note the **kwargs

So we can do something like:

    CELERY_SINGLETON_BACKEND_KWARGS = {
        'credential_provider': my_cred_provider()
    }

Without custom Redis class

• Django redis provides "CONNECTION_POOL_KWARGS"

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        # ...
        "OPTIONS": {
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
        }
    }
}

So we can inject params to connection_pool without custom Redis class

If possible, please consider adding a setting to support forwarding the kwargs, at least here

if isinstance(settings.CACHEOPS_REDIS, str):
    return client_class.from_url(settings.CACHEOPS_REDIS)

ty again!