redis 5.3.0b4__tar.gz → 5.3.0b5__tar.gz

{redis-5.3.0b4/redis.egg-info → redis-5.3.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis
-Version: 5.3.0b4
+Version: 5.3.0b5
 Summary: Python client for Redis database and key-value store
 Home-page: https://github.com/redis/redis-py
 Author: Redis Inc.

{redis-5.3.0b4 → redis-5.3.0b5}/redis/asyncio/client.py

@@ -1554,7 +1554,7 @@ class Pipeline(Redis):  # lgtm [py/init-calls-subclass]
             await self.reset()
             raise
 
-    async def execute(self, raise_on_error: bool = True):
+    async def execute(self, raise_on_error: bool = True) -> List[Any]:
         """Execute all the commands in the current pipeline"""
         stack = self.command_stack
         if not stack and not self.watching:

{redis-5.3.0b4 → redis-5.3.0b5}/redis/client.py

@@ -4,7 +4,17 @@ import threading
 import time
 import warnings
 from itertools import chain
-from typing import Any, Callable, Dict, List, Optional, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Type,
+    Union,
+)
 
 from redis._parsers.encoders import Encoder
 from redis._parsers.helpers import (
@@ -53,6 +63,11 @@ from redis.utils import (
     str_if_bytes,
 )
 
+if TYPE_CHECKING:
+    import ssl
+
+    import OpenSSL
+
 SYM_EMPTY = b""
 EMPTY_RESPONSE = "EMPTY_RESPONSE"
 
@@ -175,47 +190,47 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
 
     def __init__(
         self,
-        host="localhost",
-        port=6379,
-        db=0,
-        password=None,
-        socket_timeout=None,
-        socket_connect_timeout=None,
-        socket_keepalive=None,
-        socket_keepalive_options=None,
-        connection_pool=None,
-        unix_socket_path=None,
-        encoding="utf-8",
-        encoding_errors="strict",
-        charset=None,
-        errors=None,
-        decode_responses=False,
-        retry_on_timeout=False,
-        retry_on_error=None,
-        ssl=False,
-        ssl_keyfile=None,
-        ssl_certfile=None,
-        ssl_cert_reqs="required",
-        ssl_ca_certs=None,
-        ssl_ca_path=None,
-        ssl_ca_data=None,
-        ssl_check_hostname=False,
-        ssl_password=None,
-        ssl_validate_ocsp=False,
-        ssl_validate_ocsp_stapled=False,
-        ssl_ocsp_context=None,
-        ssl_ocsp_expected_cert=None,
-        ssl_min_version=None,
-        ssl_ciphers=None,
-        max_connections=None,
-        single_connection_client=False,
-        health_check_interval=0,
-        client_name=None,
-        lib_name="redis-py",
-        lib_version=get_lib_version(),
-        username=None,
-        retry=None,
-        redis_connect_func=None,
+        host: str = "localhost",
+        port: int = 6379,
+        db: int = 0,
+        password: Optional[str] = None,
+        socket_timeout: Optional[float] = None,
+        socket_connect_timeout: Optional[float] = None,
+        socket_keepalive: Optional[bool] = None,
+        socket_keepalive_options: Optional[Mapping[int, Union[int, bytes]]] = None,
+        connection_pool: Optional[ConnectionPool] = None,
+        unix_socket_path: Optional[str] = None,
+        encoding: str = "utf-8",
+        encoding_errors: str = "strict",
+        charset: Optional[str] = None,
+        errors: Optional[str] = None,
+        decode_responses: bool = False,
+        retry_on_timeout: bool = False,
+        retry_on_error: Optional[List[Type[Exception]]] = None,
+        ssl: bool = False,
+        ssl_keyfile: Optional[str] = None,
+        ssl_certfile: Optional[str] = None,
+        ssl_cert_reqs: str = "required",
+        ssl_ca_certs: Optional[str] = None,
+        ssl_ca_path: Optional[str] = None,
+        ssl_ca_data: Optional[str] = None,
+        ssl_check_hostname: bool = False,
+        ssl_password: Optional[str] = None,
+        ssl_validate_ocsp: bool = False,
+        ssl_validate_ocsp_stapled: bool = False,
+        ssl_ocsp_context: Optional["OpenSSL.SSL.Context"] = None,
+        ssl_ocsp_expected_cert: Optional[str] = None,
+        ssl_min_version: Optional["ssl.TLSVersion"] = None,
+        ssl_ciphers: Optional[str] = None,
+        max_connections: Optional[int] = None,
+        single_connection_client: bool = False,
+        health_check_interval: int = 0,
+        client_name: Optional[str] = None,
+        lib_name: Optional[str] = "redis-py",
+        lib_version: Optional[str] = get_lib_version(),
+        username: Optional[str] = None,
+        retry: Optional[Retry] = None,
+        redis_connect_func: Optional[Callable[[], None]] = None,
         credential_provider: Optional[CredentialProvider] = None,
         protocol: Optional[int] = 2,
         cache: Optional[CacheInterface] = None,
@@ -550,7 +565,7 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
     def __del__(self):
         self.close()
 
-    def close(self):
+    def close(self) -> None:
         # In case a connection property does not yet exist
         # (due to a crash earlier in the Redis() constructor), return
         # immediately as there is nothing to clean-up.
@@ -1551,11 +1566,10 @@ class Pipeline(Redis):
             conn.retry_on_error is None
             or isinstance(error, tuple(conn.retry_on_error)) is False
         ):
-
             self.reset()
             raise error
 
-    def execute(self, raise_on_error=True):
+    def execute(self, raise_on_error: bool = True) -> List[Any]:
         """Execute all the commands in the current pipeline"""
         stack = self.command_stack
         if not stack and not self.watching:

{redis-5.3.0b4 → redis-5.3.0b5}/redis/cluster.py

@@ -1244,7 +1244,7 @@ class RedisCluster(AbstractRedisCluster, RedisClusterCommands):
 
         raise ClusterError("TTL exhausted.")
 
-    def close(self):
+    def close(self) -> None:
         try:
             with self._lock:
                 if self.nodes_manager:
@@ -1686,7 +1686,7 @@ class NodesManager:
         # If initialize was called after a MovedError, clear it
         self._moved_exception = None
 
-    def close(self):
+    def close(self) -> None:
         self.default_node = None
         for node in self.nodes_cache.values():
             if node.redis_connection:
@@ -2067,7 +2067,7 @@ class ClusterPipeline(RedisCluster):
         )
         exception.args = (msg,) + exception.args[1:]
 
-    def execute(self, raise_on_error=True):
+    def execute(self, raise_on_error: bool = True) -> List[Any]:
         """
         Execute all the commands in the current pipeline
         """

{redis-5.3.0b4 → redis-5.3.0b5}/redis/connection.py

@@ -9,7 +9,7 @@ from abc import abstractmethod
 from itertools import chain
 from queue import Empty, Full, LifoQueue
 from time import time
-from typing import Any, Callable, Dict, List, Optional, Type, Union
+from typing import Any, Callable, Dict, List, Optional, Type, TypeVar, Union
 from urllib.parse import parse_qs, unquote, urlparse
 
 from redis.cache import (
@@ -904,9 +904,11 @@ class CacheProxyConnection(ConnectionInterface):
                 and self._cache.get(self._current_command_cache_key).status
                 != CacheEntryStatus.IN_PROGRESS
             ):
-                return copy.deepcopy(
+                res = copy.deepcopy(
                     self._cache.get(self._current_command_cache_key).cache_value
                 )
+                self._current_command_cache_key = None
+                return res
 
         response = self._conn.read_response(
             disable_decoding=disable_decoding,
@@ -932,6 +934,8 @@ class CacheProxyConnection(ConnectionInterface):
                 cache_entry.cache_value = response
                 self._cache.set(cache_entry)
 
+            self._current_command_cache_key = None
+
         return response
 
     def pack_command(self, *args):
@@ -1259,6 +1263,9 @@ def parse_url(url):
     return kwargs
 
 
+_CP = TypeVar("_CP", bound="ConnectionPool")
+
+
 class ConnectionPool:
     """
     Create a connection pool. ``If max_connections`` is set, then this
@@ -1274,7 +1281,7 @@ class ConnectionPool:
     """
 
     @classmethod
-    def from_url(cls, url, **kwargs):
+    def from_url(cls: Type[_CP], url: str, **kwargs) -> _CP:
         """
         Return a connection pool configured from the given URL.
 
@@ -1374,6 +1381,7 @@ class ConnectionPool:
         # will notice the first thread already did the work and simply
         # release the lock.
         self._fork_lock = threading.Lock()
+        self._lock = threading.Lock()
         self.reset()
 
     def __repr__(self) -> (str, str):
@@ -1391,7 +1399,6 @@ class ConnectionPool:
         return self.connection_kwargs.get("protocol", None)
 
     def reset(self) -> None:
-        self._lock = threading.Lock()
         self._created_connections = 0
         self._available_connections = []
         self._in_use_connections = set()

{redis-5.3.0b4 → redis-5.3.0b5}/redis/typing.py

@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 
 
 Number = Union[int, float]
-EncodedT = Union[bytes, memoryview]
+EncodedT = Union[bytes, bytearray, memoryview]
 DecodedT = Union[str, int, float]
 EncodableT = Union[EncodedT, DecodedT]
 AbsExpiryT = Union[int, datetime]

{redis-5.3.0b4 → redis-5.3.0b5/redis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis
-Version: 5.3.0b4
+Version: 5.3.0b5
 Summary: Python client for Redis database and key-value store
 Home-page: https://github.com/redis/redis-py
 Author: Redis Inc.

{redis-5.3.0b4 → redis-5.3.0b5}/setup.py

@@ -8,7 +8,7 @@ setup(
     long_description_content_type="text/markdown",
     keywords=["Redis", "key-value store", "database"],
     license="MIT",
-    version="5.3.0b4",
+    version="5.3.0b5",
     packages=find_packages(
         include=[
             "redis",

{redis-5.3.0b4 → redis-5.3.0b5}/tests/conftest.py

@@ -5,7 +5,7 @@ import random
 import time
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Callable, TypeVar
+from typing import Callable, TypeVar, Union
 from unittest import mock
 from unittest.mock import Mock
 from urllib.parse import urlparse
@@ -17,6 +17,7 @@ from packaging.version import Version
 from redis import Sentinel
 from redis.auth.idp import IdentityProviderInterface
 from redis.auth.token import JWToken
+from redis.auth.token_manager import RetryPolicy, TokenManagerConfig
 from redis.backoff import NoBackoff
 from redis.cache import (
     CacheConfig,
@@ -29,12 +30,21 @@ from redis.connection import Connection, ConnectionInterface, SSLConnection, par
 from redis.credentials import CredentialProvider
 from redis.exceptions import RedisClusterException
 from redis.retry import Retry
-from redis_entraid.cred_provider import EntraIdCredentialsProvider, TokenAuthConfig
+from redis_entraid.cred_provider import (
+    DEFAULT_DELAY_IN_MS,
+    DEFAULT_EXPIRATION_REFRESH_RATIO,
+    DEFAULT_LOWER_REFRESH_BOUND_MILLIS,
+    DEFAULT_MAX_ATTEMPTS,
+    DEFAULT_TOKEN_REQUEST_EXECUTION_TIMEOUT_IN_MS,
+    EntraIdCredentialsProvider,
+)
 from redis_entraid.identity_provider import (
     ManagedIdentityIdType,
+    ManagedIdentityProviderConfig,
     ManagedIdentityType,
-    create_provider_from_managed_identity,
-    create_provider_from_service_principal,
+    ServicePrincipalIdentityProviderConfig,
+    _create_provider_from_managed_identity,
+    _create_provider_from_service_principal,
 )
 from tests.ssl_utils import get_tls_certificates
 
@@ -623,17 +633,33 @@ def identity_provider(request) -> IdentityProviderInterface:
         return mock_identity_provider()
 
     auth_type = kwargs.pop("auth_type", AuthType.SERVICE_PRINCIPAL)
+    config = get_identity_provider_config(request=request)
 
     if auth_type == "MANAGED_IDENTITY":
-        return _get_managed_identity_provider(request)
+        return _create_provider_from_managed_identity(config)
+
+    return _create_provider_from_service_principal(config)
 
-    return _get_service_principal_provider(request)
 
+def get_identity_provider_config(
+    request,
+) -> Union[ManagedIdentityProviderConfig, ServicePrincipalIdentityProviderConfig]:
+    if hasattr(request, "param"):
+        kwargs = request.param.get("idp_kwargs", {})
+    else:
+        kwargs = {}
+
+    auth_type = kwargs.pop("auth_type", AuthType.SERVICE_PRINCIPAL)
 
-def _get_managed_identity_provider(request):
-    authority = os.getenv("AZURE_AUTHORITY")
+    if auth_type == AuthType.MANAGED_IDENTITY:
+        return _get_managed_identity_provider_config(request)
+
+    return _get_service_principal_provider_config(request)
+
+
+def _get_managed_identity_provider_config(request) -> ManagedIdentityProviderConfig:
     resource = os.getenv("AZURE_RESOURCE")
-    id_value = os.getenv("AZURE_ID_VALUE", None)
+    id_value = os.getenv("AZURE_USER_ASSIGNED_MANAGED_ID", None)
 
     if hasattr(request, "param"):
         kwargs = request.param.get("idp_kwargs", {})
@@ -641,23 +667,24 @@ def _get_managed_identity_provider(request):
         kwargs = {}
 
     identity_type = kwargs.pop("identity_type", ManagedIdentityType.SYSTEM_ASSIGNED)
-    id_type = kwargs.pop("id_type", ManagedIdentityIdType.CLIENT_ID)
+    id_type = kwargs.pop("id_type", ManagedIdentityIdType.OBJECT_ID)
 
-    return create_provider_from_managed_identity(
+    return ManagedIdentityProviderConfig(
         identity_type=identity_type,
         resource=resource,
         id_type=id_type,
         id_value=id_value,
-        authority=authority,
-        **kwargs,
+        kwargs=kwargs,
     )
 
 
-def _get_service_principal_provider(request):
+def _get_service_principal_provider_config(
+    request,
+) -> ServicePrincipalIdentityProviderConfig:
     client_id = os.getenv("AZURE_CLIENT_ID")
     client_credential = os.getenv("AZURE_CLIENT_SECRET")
-    authority = os.getenv("AZURE_AUTHORITY")
-    scopes = os.getenv("AZURE_REDIS_SCOPES", [])
+    tenant_id = os.getenv("AZURE_TENANT_ID")
+    scopes = os.getenv("AZURE_REDIS_SCOPES", None)
 
     if hasattr(request, "param"):
         kwargs = request.param.get("idp_kwargs", {})
@@ -671,14 +698,14 @@ def _get_service_principal_provider(request):
     if isinstance(scopes, str):
         scopes = scopes.split(",")
 
-    return create_provider_from_service_principal(
+    return ServicePrincipalIdentityProviderConfig(
         client_id=client_id,
         client_credential=client_credential,
         scopes=scopes,
         timeout=timeout,
         token_kwargs=token_kwargs,
-        authority=authority,
-        **kwargs,
+        tenant_id=tenant_id,
+        app_kwargs=kwargs,
     )
 
 
@@ -690,31 +717,29 @@ def get_credential_provider(request) -> CredentialProvider:
         return cred_provider_class(**cred_provider_kwargs)
 
     idp = identity_provider(request)
-    initial_delay_in_ms = cred_provider_kwargs.get("initial_delay_in_ms", 0)
-    block_for_initial = cred_provider_kwargs.get("block_for_initial", False)
     expiration_refresh_ratio = cred_provider_kwargs.get(
-        "expiration_refresh_ratio", TokenAuthConfig.DEFAULT_EXPIRATION_REFRESH_RATIO
+        "expiration_refresh_ratio", DEFAULT_EXPIRATION_REFRESH_RATIO
     )
     lower_refresh_bound_millis = cred_provider_kwargs.get(
-        "lower_refresh_bound_millis", TokenAuthConfig.DEFAULT_LOWER_REFRESH_BOUND_MILLIS
-    )
-    max_attempts = cred_provider_kwargs.get(
-        "max_attempts", TokenAuthConfig.DEFAULT_MAX_ATTEMPTS
+        "lower_refresh_bound_millis", DEFAULT_LOWER_REFRESH_BOUND_MILLIS
     )
-    delay_in_ms = cred_provider_kwargs.get(
-        "delay_in_ms", TokenAuthConfig.DEFAULT_DELAY_IN_MS
+    max_attempts = cred_provider_kwargs.get("max_attempts", DEFAULT_MAX_ATTEMPTS)
+    delay_in_ms = cred_provider_kwargs.get("delay_in_ms", DEFAULT_DELAY_IN_MS)
+
+    token_mgr_config = TokenManagerConfig(
+        expiration_refresh_ratio=expiration_refresh_ratio,
+        lower_refresh_bound_millis=lower_refresh_bound_millis,
+        token_request_execution_timeout_in_ms=DEFAULT_TOKEN_REQUEST_EXECUTION_TIMEOUT_IN_MS,  # noqa
+        retry_policy=RetryPolicy(
+            max_attempts=max_attempts,
+            delay_in_ms=delay_in_ms,
+        ),
     )
 
-    auth_config = TokenAuthConfig(idp)
-    auth_config.expiration_refresh_ratio = expiration_refresh_ratio
-    auth_config.lower_refresh_bound_millis = lower_refresh_bound_millis
-    auth_config.max_attempts = max_attempts
-    auth_config.delay_in_ms = delay_in_ms
-
     return EntraIdCredentialsProvider(
-        config=auth_config,
-        initial_delay_in_ms=initial_delay_in_ms,
-        block_for_initial=block_for_initial,
+        identity_provider=idp,
+        token_manager_config=token_mgr_config,
+        initial_delay_in_ms=delay_in_ms,
     )
 
 

{redis-5.3.0b4 → redis-5.3.0b5}/tests/test_asyncio/conftest.py

@@ -17,14 +17,24 @@ from redis.asyncio.connection import Connection, parse_url
 from redis.asyncio.retry import Retry
 from redis.auth.idp import IdentityProviderInterface
 from redis.auth.token import JWToken
+from redis.auth.token_manager import RetryPolicy, TokenManagerConfig
 from redis.backoff import NoBackoff
 from redis.credentials import CredentialProvider
-from redis_entraid.cred_provider import EntraIdCredentialsProvider, TokenAuthConfig
+from redis_entraid.cred_provider import (
+    DEFAULT_DELAY_IN_MS,
+    DEFAULT_EXPIRATION_REFRESH_RATIO,
+    DEFAULT_LOWER_REFRESH_BOUND_MILLIS,
+    DEFAULT_MAX_ATTEMPTS,
+    DEFAULT_TOKEN_REQUEST_EXECUTION_TIMEOUT_IN_MS,
+    EntraIdCredentialsProvider,
+)
 from redis_entraid.identity_provider import (
     ManagedIdentityIdType,
+    ManagedIdentityProviderConfig,
     ManagedIdentityType,
-    create_provider_from_managed_identity,
-    create_provider_from_service_principal,
+    ServicePrincipalIdentityProviderConfig,
+    _create_provider_from_managed_identity,
+    _create_provider_from_service_principal,
 )
 from tests.conftest import REDIS_INFO
 
@@ -255,17 +265,33 @@ def identity_provider(request) -> IdentityProviderInterface:
         return mock_identity_provider()
 
     auth_type = kwargs.pop("auth_type", AuthType.SERVICE_PRINCIPAL)
+    config = get_identity_provider_config(request=request)
 
     if auth_type == "MANAGED_IDENTITY":
-        return _get_managed_identity_provider(request)
+        return _create_provider_from_managed_identity(config)
+
+    return _create_provider_from_service_principal(config)
+
+
+def get_identity_provider_config(
+    request,
+) -> Union[ManagedIdentityProviderConfig, ServicePrincipalIdentityProviderConfig]:
+    if hasattr(request, "param"):
+        kwargs = request.param.get("idp_kwargs", {})
+    else:
+        kwargs = {}
 
-    return _get_service_principal_provider(request)
+    auth_type = kwargs.pop("auth_type", AuthType.SERVICE_PRINCIPAL)
+
+    if auth_type == AuthType.MANAGED_IDENTITY:
+        return _get_managed_identity_provider_config(request)
 
+    return _get_service_principal_provider_config(request)
 
-def _get_managed_identity_provider(request):
-    authority = os.getenv("AZURE_AUTHORITY")
+
+def _get_managed_identity_provider_config(request) -> ManagedIdentityProviderConfig:
     resource = os.getenv("AZURE_RESOURCE")
-    id_value = os.getenv("AZURE_ID_VALUE", None)
+    id_value = os.getenv("AZURE_USER_ASSIGNED_MANAGED_ID", None)
 
     if hasattr(request, "param"):
         kwargs = request.param.get("idp_kwargs", {})
@@ -273,23 +299,24 @@ def _get_managed_identity_provider(request):
         kwargs = {}
 
     identity_type = kwargs.pop("identity_type", ManagedIdentityType.SYSTEM_ASSIGNED)
-    id_type = kwargs.pop("id_type", ManagedIdentityIdType.CLIENT_ID)
+    id_type = kwargs.pop("id_type", ManagedIdentityIdType.OBJECT_ID)
 
-    return create_provider_from_managed_identity(
+    return ManagedIdentityProviderConfig(
         identity_type=identity_type,
         resource=resource,
         id_type=id_type,
         id_value=id_value,
-        authority=authority,
-        **kwargs,
+        kwargs=kwargs,
     )
 
 
-def _get_service_principal_provider(request):
+def _get_service_principal_provider_config(
+    request,
+) -> ServicePrincipalIdentityProviderConfig:
     client_id = os.getenv("AZURE_CLIENT_ID")
     client_credential = os.getenv("AZURE_CLIENT_SECRET")
-    authority = os.getenv("AZURE_AUTHORITY")
-    scopes = os.getenv("AZURE_REDIS_SCOPES", [])
+    tenant_id = os.getenv("AZURE_TENANT_ID")
+    scopes = os.getenv("AZURE_REDIS_SCOPES", None)
 
     if hasattr(request, "param"):
         kwargs = request.param.get("idp_kwargs", {})
@@ -303,14 +330,14 @@ def _get_service_principal_provider(request):
     if isinstance(scopes, str):
         scopes = scopes.split(",")
 
-    return create_provider_from_service_principal(
+    return ServicePrincipalIdentityProviderConfig(
         client_id=client_id,
         client_credential=client_credential,
         scopes=scopes,
         timeout=timeout,
         token_kwargs=token_kwargs,
-        authority=authority,
-        **kwargs,
+        tenant_id=tenant_id,
+        app_kwargs=kwargs,
     )
 
 
@@ -322,31 +349,29 @@ def get_credential_provider(request) -> CredentialProvider:
         return cred_provider_class(**cred_provider_kwargs)
 
     idp = identity_provider(request)
-    initial_delay_in_ms = cred_provider_kwargs.get("initial_delay_in_ms", 0)
-    block_for_initial = cred_provider_kwargs.get("block_for_initial", False)
     expiration_refresh_ratio = cred_provider_kwargs.get(
-        "expiration_refresh_ratio", TokenAuthConfig.DEFAULT_EXPIRATION_REFRESH_RATIO
+        "expiration_refresh_ratio", DEFAULT_EXPIRATION_REFRESH_RATIO
     )
     lower_refresh_bound_millis = cred_provider_kwargs.get(
-        "lower_refresh_bound_millis", TokenAuthConfig.DEFAULT_LOWER_REFRESH_BOUND_MILLIS
-    )
-    max_attempts = cred_provider_kwargs.get(
-        "max_attempts", TokenAuthConfig.DEFAULT_MAX_ATTEMPTS
+        "lower_refresh_bound_millis", DEFAULT_LOWER_REFRESH_BOUND_MILLIS
     )
-    delay_in_ms = cred_provider_kwargs.get(
-        "delay_in_ms", TokenAuthConfig.DEFAULT_DELAY_IN_MS
+    max_attempts = cred_provider_kwargs.get("max_attempts", DEFAULT_MAX_ATTEMPTS)
+    delay_in_ms = cred_provider_kwargs.get("delay_in_ms", DEFAULT_DELAY_IN_MS)
+
+    token_mgr_config = TokenManagerConfig(
+        expiration_refresh_ratio=expiration_refresh_ratio,
+        lower_refresh_bound_millis=lower_refresh_bound_millis,
+        token_request_execution_timeout_in_ms=DEFAULT_TOKEN_REQUEST_EXECUTION_TIMEOUT_IN_MS,  # noqa
+        retry_policy=RetryPolicy(
+            max_attempts=max_attempts,
+            delay_in_ms=delay_in_ms,
+        ),
     )
 
-    auth_config = TokenAuthConfig(idp)
-    auth_config.expiration_refresh_ratio = expiration_refresh_ratio
-    auth_config.lower_refresh_bound_millis = lower_refresh_bound_millis
-    auth_config.max_attempts = max_attempts
-    auth_config.delay_in_ms = delay_in_ms
-
     return EntraIdCredentialsProvider(
-        config=auth_config,
-        initial_delay_in_ms=initial_delay_in_ms,
-        block_for_initial=block_for_initial,
+        identity_provider=idp,
+        token_manager_config=token_mgr_config,
+        initial_delay_in_ms=delay_in_ms,
     )