oidcauthlib 3.0.6__tar.gz → 3.0.7__tar.gz

oidcauthlib-3.0.7/MANIFEST.in

@@ -0,0 +1 @@
+include VERSION

{oidcauthlib-3.0.6/oidcauthlib.egg-info → oidcauthlib-3.0.7}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: oidcauthlib
-Version: 3.0.6
+Version: 3.0.7
 Summary: oidcauthlib
-Home-page: https://github.com/icanbwell/oidc-auth-lib
-Author: Imran Qureshi
-Author-email: imran.qureshi@bwell.com
+Author-email: Imran Qureshi <imran.qureshi@bwell.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/icanbwell/oidc-auth-lib
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -23,15 +22,6 @@ Requires-Dist: starlette>=0.49.1
 Requires-Dist: py-key-value-aio[memory,mongodb,pydantic,redis]>=0.4.4
 Requires-Dist: opentelemetry-api>=1.39.1
 Requires-Dist: simple-container>=1.0.2
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # oidcauthlib

oidcauthlib-3.0.7/VERSION

@@ -0,0 +1 @@
+3.0.7

{oidcauthlib-3.0.6 → oidcauthlib-3.0.7}/oidcauthlib/auth/auth_helper.py

@@ -21,9 +21,7 @@ class AuthHelper:
             A base64url encoded string of the content.
         """
         json_content = json.dumps(content)
-        encoded_content = base64.urlsafe_b64encode(json_content.encode("utf-8")).decode(
-            "utf-8"
-        )
+        encoded_content = base64.urlsafe_b64encode(json_content.encode("utf-8")).decode("utf-8")
         return encoded_content.rstrip("=")
 
     @staticmethod
@@ -56,9 +54,7 @@ class AuthHelper:
                 logger.error(f"Failed to decode state (JSON error): {e}")
                 raise ValueError("Invalid JSON in decoded state") from e
             if not isinstance(result, dict):
-                logger.error(
-                    "Failed to decode state: Decoded state is not a dictionary"
-                )
+                logger.error("Failed to decode state: Decoded state is not a dictionary")
                 raise ValueError("Decoded state is not a dictionary")
             return result
         except Exception:

{oidcauthlib-3.0.6 → oidcauthlib-3.0.7}/oidcauthlib/auth/auth_manager.py

@@ -1,3 +1,4 @@
+import json
 import logging
 import os
 import time
@@ -70,17 +71,13 @@ class AuthManager:
         if self.environment_variables is None:
             raise ValueError("environment_variables must not be None")
         if not isinstance(self.environment_variables, AbstractEnvironmentVariables):
-            raise TypeError(
-                "environment_variables must be an instance of EnvironmentVariables"
-            )
+            raise TypeError("environment_variables must be an instance of EnvironmentVariables")
 
         self.auth_config_reader: AuthConfigReader = auth_config_reader
         if self.auth_config_reader is None:
             raise ValueError("auth_config_reader must not be None")
         if not isinstance(self.auth_config_reader, AuthConfigReader):
-            raise TypeError(
-                "auth_config_reader must be an instance of AuthConfigReader"
-            )
+            raise TypeError("auth_config_reader must be an instance of AuthConfigReader")
 
         self.token_reader: TokenReader = token_reader
         if self.token_reader is None:
@@ -88,17 +85,11 @@ class AuthManager:
         if not isinstance(self.token_reader, TokenReader):
             raise TypeError("token_reader must be an instance of TokenReader")
 
-        self.well_known_configuration_manager: WellKnownConfigurationManager = (
-            well_known_configuration_manager
-        )
+        self.well_known_configuration_manager: WellKnownConfigurationManager = well_known_configuration_manager
         if self.well_known_configuration_manager is None:
             raise ValueError("well_known_configuration_manager must not be None")
-        if not isinstance(
-            self.well_known_configuration_manager, WellKnownConfigurationManager
-        ):
-            raise TypeError(
-                "well_known_configuration_manager must be an instance of WellKnownConfigurationManager"
-            )
+        if not isinstance(self.well_known_configuration_manager, WellKnownConfigurationManager):
+            raise TypeError("well_known_configuration_manager must be an instance of WellKnownConfigurationManager")
 
         self._dcr_manager: DcrManager | None = dcr_manager
 
@@ -109,9 +100,7 @@ class AuthManager:
             else OAuthMongoCache(environment_variables=environment_variables)
         )
 
-        logger.debug(
-            f"Initializing AuthManager with cache type {type(self.cache)} cache id: {self.cache.id}"
-        )
+        logger.debug(f"Initializing AuthManager with cache type {type(self.cache)} cache id: {self.cache.id}")
         # OIDC PKCE setup
         self.redirect_uri = os.getenv("AUTH_REDIRECT_URI")
         if self.redirect_uri is None:
@@ -119,17 +108,13 @@ class AuthManager:
         # https://docs.authlib.org/en/latest/client/frameworks.html#frameworks-clients
         self._oauth: OAuth = OAuth(cache=self.cache)
         self._registered_dynamic_providers: set[str] = set()
-        self.auth_configs: List[AuthConfig] = (
-            self.auth_config_reader.get_auth_configs_for_all_auth_providers()
-        )
+        self.auth_configs: List[AuthConfig] = self.auth_config_reader.get_auth_configs_for_all_auth_providers()
 
     async def ensure_initialized_async(self) -> None:
         auth_config: AuthConfig
         for auth_config in self.auth_configs:
             if auth_config.well_known_uri:
-                await self.well_known_configuration_manager.get_async(
-                    auth_config=auth_config
-                )
+                await self.well_known_configuration_manager.get_async(auth_config=auth_config)
             await self.register_dynamic_provider(auth_config=auth_config)
 
     async def register_dynamic_provider(
@@ -162,9 +147,7 @@ class AuthManager:
                 registration_url=auth_config.registration_url,
             )
             if dcr_result is None or not dcr_result.client_id:
-                raise ValueError(
-                    f"DCR failed to obtain client_id for '{auth_config.auth_provider}'"
-                )
+                raise ValueError(f"DCR failed to obtain client_id for '{auth_config.auth_provider}'")
             client_id = dcr_result.client_id
             client_secret = dcr_result.client_secret
             logger.info(
@@ -278,12 +261,20 @@ class AuthManager:
             f" with state {state_content} and encoded state {state}"
         )
 
-        rv: Dict[str, Any] = await client.create_authorization_url(
-            redirect_uri=redirect_uri, state=state
-        )
+        rv: Dict[str, Any] = await client.create_authorization_url(redirect_uri=redirect_uri, state=state)
         logger.debug(f"Authorization URL created: {rv}")
-        # request is only needed if we are using the session to store the state
-        await client.save_authorize_data(request=None, redirect_uri=redirect_uri, **rv)
+        # Save OAuth state data (code_verifier, nonce, redirect_uri) to our
+        # own cache rather than relying on authlib's save_authorize_data which
+        # requires request.session (SessionMiddleware).  This allows the
+        # callback to retrieve the data without SessionMiddleware.
+        state_data: Dict[str, Any] = {"redirect_uri": redirect_uri}
+        if "code_verifier" in rv:
+            state_data["code_verifier"] = rv["code_verifier"]
+        if "nonce" in rv:
+            state_data["nonce"] = rv["nonce"]
+        cache_key = f"_state_{auth_provider}_{state}"
+        await self.cache.set(cache_key, json.dumps({"data": state_data}))
+        logger.debug(f"Saved OAuth state to cache key={cache_key} data={state_data}")
         return cast(str, rv["url"])
 
     async def create_oauth_client(self, *, name: str) -> StarletteOAuth2App:
@@ -327,17 +318,11 @@ class AuthManager:
                 resp.raise_for_status()
                 token_url = resp.json().get("token_endpoint")
             except Exception as e:
-                raise AuthorizationNeededException(
-                    message=f"Failed to discover token endpoint: {e}"
-                )
+                raise AuthorizationNeededException(message=f"Failed to discover token endpoint: {e}")
         if not token_url and auth_config.issuer:
-            token_url = (
-                auth_config.issuer.rstrip("/") + "/protocol/openid-connect/token"
-            )
+            token_url = auth_config.issuer.rstrip("/") + "/protocol/openid-connect/token"
         if not token_url:
-            raise AuthorizationNeededException(
-                message="No token endpoint found in AuthConfig."
-            )
+            raise AuthorizationNeededException(message="No token endpoint found in AuthConfig.")
 
         # Prepare OAuth2 client
         client_id = auth_config.client_id
@@ -369,9 +354,7 @@ class AuthManager:
 
         return access_token
 
-    def get_auth_config_for_auth_provider(
-        self, *, auth_provider: str
-    ) -> AuthConfig | None:
+    def get_auth_config_for_auth_provider(self, *, auth_provider: str) -> AuthConfig | None:
         if not auth_provider:
             raise ValueError("auth_provider must not be empty")
         for auth_config in self.auth_configs:
@@ -380,9 +363,7 @@ class AuthManager:
         return None
 
     @staticmethod
-    def wait_till_well_known_configuration_available(
-        *, auth_config: AuthConfig, timeout_seconds: int = 30
-    ) -> None:
+    def wait_till_well_known_configuration_available(*, auth_config: AuthConfig, timeout_seconds: int = 30) -> None:
         """
         Wait until the well-known configuration is available for the given AuthConfig.
 
@@ -406,9 +387,7 @@ class AuthManager:
                     resp = client.get(auth_config.well_known_uri)
                 resp.raise_for_status()
                 # Successfully fetched the configuration
-                logger.info(
-                    f"Well-known configuration is now available at {auth_config.well_known_uri}"
-                )
+                logger.info(f"Well-known configuration is now available at {auth_config.well_known_uri}")
                 return
             except Exception as e:
                 elapsed_time = time.time() - start_time
@@ -416,7 +395,5 @@ class AuthManager:
                     raise TimeoutError(
                         f"Timed out waiting for well-known configuration at {auth_config.well_known_uri}"
                     ) from e
-                logger.debug(
-                    f"Well-known configuration not yet available, retrying... ({elapsed_time:.1f}s elapsed)"
-                )
+                logger.debug(f"Well-known configuration not yet available, retrying... ({elapsed_time:.1f}s elapsed)")
                 time.sleep(2)  # Wait before retrying

{oidcauthlib-3.0.6 → oidcauthlib-3.0.7}/oidcauthlib/auth/cache/oauth_mongo_cache.py

@@ -43,30 +43,20 @@ class OAuthMongoCache(OAuthCache):
 
         """
         self.id_ = uuid.uuid4()
-        self.repository: AsyncBaseRepository[CacheItem] = (
-            RepositoryFactory.get_repository(
-                repository_type=environment_variables.oauth_cache,
-                environment_variables=environment_variables,
-            )
-        )
-        collection_name: str | None = (
-            environment_variables.mongo_db_auth_cache_collection_name
+        self.repository: AsyncBaseRepository[CacheItem] = RepositoryFactory.get_repository(
+            repository_type=environment_variables.oauth_cache,
+            environment_variables=environment_variables,
         )
+        collection_name: str | None = environment_variables.mongo_db_auth_cache_collection_name
         if collection_name is None:
-            raise ValueError(
-                "MONGO_DB_AUTH_CACHE_COLLECTION_NAME environment variable must be set"
-            )
+            raise ValueError("MONGO_DB_AUTH_CACHE_COLLECTION_NAME environment variable must be set")
         self.collection_name: str = collection_name
 
         self.environment_variables: AbstractEnvironmentVariables = environment_variables
         if self.environment_variables is None:
-            raise ValueError(
-                "OAuthMongoCache requires an EnvironmentVariables instance."
-            )
+            raise ValueError("OAuthMongoCache requires an EnvironmentVariables instance.")
         if not isinstance(self.environment_variables, AbstractEnvironmentVariables):
-            raise TypeError(
-                "environment_variables must be an instance of EnvironmentVariables"
-            )
+            raise TypeError("environment_variables must be an instance of EnvironmentVariables")
 
     @property
     @override
@@ -92,9 +82,7 @@ class OAuthMongoCache(OAuthCache):
                 "key": key,
             },
         )
-        disable_delete: bool | None = (
-            self.environment_variables.mongo_db_cache_disable_delete
-        )
+        disable_delete: bool | None = self.environment_variables.mongo_db_cache_disable_delete
         if cache_item is not None and cache_item.id is not None:
             # delete the cache item if it exists
             logger.debug(f" ====== Deleting {cache_item.id} =====")
@@ -131,9 +119,7 @@ class OAuthMongoCache(OAuthCache):
                 "key": key,
             },
         )
-        logger.debug(
-            f" ====== For key {key} found {cache_item} default {default} ====="
-        )
+        logger.debug(f" ====== For key {key} found {cache_item} default {default} =====")
         return cache_item.value if cache_item is not None else default
 
     @override
@@ -166,21 +152,13 @@ class OAuthMongoCache(OAuthCache):
                 model_class=CacheItem,
             )
             if updated_cache_item is None:
-                raise ValueError(
-                    f"Failed to update cache item with ID: {existing_cache_item_id} for key: {key}"
-                )
-            logger.debug(
-                f"Cache item updated with ID: {updated_cache_item.id} for key: {key} with value: {value}.\n"
-            )
+                raise ValueError(f"Failed to update cache item with ID: {existing_cache_item_id} for key: {key}")
+            logger.debug(f"Cache item updated with ID: {updated_cache_item.id} for key: {key} with value: {value}.\n")
         else:
             logger.debug(f" ====== Creating new cache item {key}: {value} =====")
-            cache_item = CacheItem(
-                key=key, value=value, created=datetime.now(timezone.utc)
-            )
+            cache_item = CacheItem(key=key, value=value, created=datetime.now(timezone.utc))
             new_object_id = await self.repository.insert(
                 collection_name=self.collection_name,
                 model=cache_item,
             )
-            logger.debug(
-                f"New cache item created with ID: {new_object_id}: {cache_item}"
-            )
+            logger.debug(f"New cache item created with ID: {new_object_id}: {cache_item}")

{oidcauthlib-3.0.6 → oidcauthlib-3.0.7}/oidcauthlib/auth/config/auth_config.py

@@ -77,7 +77,6 @@ class AuthConfig(BaseModel):
     def _require_client_id_or_registration_url(self) -> Self:
         if not self.client_id and not self.registration_url:
             raise ValueError(
-                f"AuthConfig for '{self.auth_provider}' must have either "
-                f"client_id or registration_url (for DCR)"
+                f"AuthConfig for '{self.auth_provider}' must have either client_id or registration_url (for DCR)"
             )
         return self

{oidcauthlib-3.0.6 → oidcauthlib-3.0.7}/oidcauthlib/auth/config/auth_config_reader.py

@@ -28,19 +28,13 @@ class AuthConfigReader:
         logger.debug("Initializing AuthConfigReader")
         self.environment_variables: AbstractEnvironmentVariables = environment_variables
         if self.environment_variables is None:
-            logger.error(
-                "AuthConfigReader initialization failed: environment_variables is None"
-            )
-            raise ValueError(
-                "AuthConfigReader requires an EnvironmentVariables instance."
-            )
+            logger.error("AuthConfigReader initialization failed: environment_variables is None")
+            raise ValueError("AuthConfigReader requires an EnvironmentVariables instance.")
         if not isinstance(self.environment_variables, AbstractEnvironmentVariables):
             logger.error(
                 f"AuthConfigReader initialization failed: environment_variables is not an instance of AbstractEnvironmentVariables, got {type(environment_variables)}"
             )
-            raise TypeError(
-                "environment_variables must be an instance of EnvironmentVariables"
-            )
+            raise TypeError("environment_variables must be an instance of EnvironmentVariables")
         self._auth_configs: list[AuthConfig] | None = None
         # lock to protect first-time initialization of _auth_configs across threads
         self._lock: threading.Lock = threading.Lock()
@@ -83,9 +77,7 @@ class AuthConfigReader:
                 )
                 if auth_config is not None:
                     auth_configs.append(auth_config)
-                    logger.debug(
-                        f"Successfully loaded config for provider: {auth_provider}"
-                    )
+                    logger.debug(f"Successfully loaded config for provider: {auth_provider}")
                 else:
                     logger.warning(f"No config found for provider: {auth_provider}")
             # Assign atomically while still under lock
@@ -124,23 +116,17 @@ class AuthConfigReader:
             return
         with self._lock:
             if self._auth_configs is None:
-                auth_providers: list[str] | None = (
-                    self.environment_variables.auth_providers
-                )
+                auth_providers: list[str] | None = self.environment_variables.auth_providers
                 if auth_providers is None:
                     auth_providers = []
                 env_configs: list[AuthConfig] = []
                 for auth_provider in auth_providers:
-                    auth_config = self.read_config_for_auth_provider(
-                        auth_provider=auth_provider
-                    )
+                    auth_config = self.read_config_for_auth_provider(auth_provider=auth_provider)
                     if auth_config is not None:
                         env_configs.append(auth_config)
                 self._auth_configs = env_configs
 
-            existing_names: set[str] = {
-                c.auth_provider.lower() for c in self._auth_configs
-            }
+            existing_names: set[str] = {c.auth_provider.lower() for c in self._auth_configs}
             for config in configs:
                 if config.auth_provider.lower() not in existing_names:
                     self._auth_configs.append(config)
@@ -175,37 +161,23 @@ class AuthConfigReader:
         logger.debug(f"Standardized auth provider name to: {auth_provider_upper}")
         # read client_id and client_secret from the environment variables
         auth_client_id: str | None = os.getenv(f"AUTH_CLIENT_ID_{auth_provider_upper}")
-        auth_client_secret: str | None = os.getenv(
-            f"AUTH_CLIENT_SECRET_{auth_provider_upper}"
-        )
+        auth_client_secret: str | None = os.getenv(f"AUTH_CLIENT_SECRET_{auth_provider_upper}")
         if auth_client_secret:
             logger.debug(f"Found client secret for provider: {auth_provider_upper}")
         else:
             logger.debug(f"No client secret found for provider: {auth_provider_upper}")
-        auth_well_known_uri: str | None = os.getenv(
-            f"AUTH_WELL_KNOWN_URI_{auth_provider_upper}"
-        )
+        auth_well_known_uri: str | None = os.getenv(f"AUTH_WELL_KNOWN_URI_{auth_provider_upper}")
         issuer: str | None = os.getenv(f"AUTH_ISSUER_{auth_provider_upper}")
-        logger.debug(
-            f"Issuer for {auth_provider_upper}: {issuer if issuer else 'not set'}"
-        )
+        logger.debug(f"Issuer for {auth_provider_upper}: {issuer if issuer else 'not set'}")
         audience: str | None = os.getenv(f"AUTH_AUDIENCE_{auth_provider_upper}")
         if audience is None:
-            logger.error(
-                f"AUTH_AUDIENCE_{auth_provider_upper} environment variable is not set"
-            )
-            raise ValueError(
-                f"AUTH_AUDIENCE_{auth_provider_upper} environment variable must be set"
-            )
-        friendly_name: str | None = os.getenv(
-            f"AUTH_FRIENDLY_NAME_{auth_provider_upper}"
-        )
+            logger.error(f"AUTH_AUDIENCE_{auth_provider_upper} environment variable is not set")
+            raise ValueError(f"AUTH_AUDIENCE_{auth_provider_upper} environment variable must be set")
+        friendly_name: str | None = os.getenv(f"AUTH_FRIENDLY_NAME_{auth_provider_upper}")
         if not friendly_name:
             # if no friendly name is set, use the auth_provider as the friendly name
             friendly_name = auth_provider
-            logger.debug(
-                f"No friendly name set, using auth provider name: {friendly_name}"
-            )
+            logger.debug(f"No friendly name set, using auth provider name: {friendly_name}")
         else:
             logger.debug(f"Friendly name for {auth_provider}: {friendly_name}")
 
@@ -214,33 +186,21 @@ class AuthConfigReader:
             scope = "openid profile email"
 
         logger.info(f"Successfully read config for auth provider: {auth_provider}")
-        extra_info_text: str | None = os.getenv(
-            f"AUTH_EXTRA_INFO_{auth_provider_upper}"
-        )
+        extra_info_text: str | None = os.getenv(f"AUTH_EXTRA_INFO_{auth_provider_upper}")
         extra_info_dict: dict[str, Any] | None
         if extra_info_text:
             try:
                 extra_info_raw: object = json.loads(extra_info_text)
             except json.JSONDecodeError as exc:
-                raise ValueError(
-                    f"Invalid JSON in AUTH_EXTRA_INFO_{auth_provider_upper}: {exc.msg}"
-                ) from exc
+                raise ValueError(f"Invalid JSON in AUTH_EXTRA_INFO_{auth_provider_upper}: {exc.msg}") from exc
             if not isinstance(extra_info_raw, dict):
-                raise ValueError(
-                    f"AUTH_EXTRA_INFO_{auth_provider_upper} must be a JSON object"
-                )
+                raise ValueError(f"AUTH_EXTRA_INFO_{auth_provider_upper} must be a JSON object")
             extra_info_dict = {str(key): value for key, value in extra_info_raw.items()}
         else:
             extra_info_dict = None
-        authorization_endpoint: str | None = os.getenv(
-            f"AUTH_AUTHORIZATION_ENDPOINT_{auth_provider_upper}"
-        )
-        token_endpoint: str | None = os.getenv(
-            f"AUTH_TOKEN_ENDPOINT_{auth_provider_upper}"
-        )
-        registration_url: str | None = os.getenv(
-            f"AUTH_REGISTRATION_URL_{auth_provider_upper}"
-        )
+        authorization_endpoint: str | None = os.getenv(f"AUTH_AUTHORIZATION_ENDPOINT_{auth_provider_upper}")
+        token_endpoint: str | None = os.getenv(f"AUTH_TOKEN_ENDPOINT_{auth_provider_upper}")
+        registration_url: str | None = os.getenv(f"AUTH_REGISTRATION_URL_{auth_provider_upper}")
 
         return AuthConfig(
             auth_provider=auth_provider,
@@ -268,15 +228,11 @@ class AuthConfigReader:
             str: The audience for the specified auth provider.
         """
         logger.debug(f"Getting audience for provider: {auth_provider}")
-        auth_config: AuthConfig | None = self.get_config_for_auth_provider(
-            auth_provider=auth_provider
-        )
+        auth_config: AuthConfig | None = self.get_config_for_auth_provider(auth_provider=auth_provider)
         if auth_config is None:
             logger.error(f"AuthConfig for provider {auth_provider} not found")
             raise ValueError(f"AuthConfig for audience {auth_provider} not found.")
-        logger.debug(
-            f"Found audience for provider {auth_provider}: {auth_config.audience}"
-        )
+        logger.debug(f"Found audience for provider {auth_provider}: {auth_config.audience}")
         return auth_config.audience
 
     def get_provider_for_audience(self, *, audience: str) -> str | None:
@@ -293,9 +249,7 @@ class AuthConfigReader:
         auth_configs: list[AuthConfig] = self.get_auth_configs_for_all_auth_providers()
         for auth_config in auth_configs:
             if auth_config.audience == audience:
-                logger.debug(
-                    f"Found provider for audience {audience}: {auth_config.auth_provider}"
-                )
+                logger.debug(f"Found provider for audience {audience}: {auth_config.auth_provider}")
                 return auth_config.auth_provider
         logger.warning(f"No provider found for audience: {audience}")
         return None
@@ -314,9 +268,7 @@ class AuthConfigReader:
         auth_configs: list[AuthConfig] = self.get_auth_configs_for_all_auth_providers()
         for auth_config in auth_configs:
             if auth_config.client_id == client_id:
-                logger.debug(
-                    f"Found provider for client_id {client_id}: {auth_config.auth_provider}"
-                )
+                logger.debug(f"Found provider for client_id {client_id}: {auth_config.auth_provider}")
                 return auth_config.auth_provider
         logger.warning(f"No provider found for client_id: {client_id}")
         return None

{oidcauthlib-3.0.6 → oidcauthlib-3.0.7}/oidcauthlib/auth/dcr/dcr_client.py

@@ -73,8 +73,7 @@ class DcrClient:
                     e.response.text[:500],
                 )
                 raise ValueError(
-                    f"DCR registration failed at '{registration_url}' "
-                    f"with status {e.response.status_code}"
+                    f"DCR registration failed at '{registration_url}' with status {e.response.status_code}"
                 ) from e
             dcr_response: dict[str, Any] = response.json()
 
@@ -86,13 +85,11 @@ class DcrClient:
                 response_keys,
             )
             raise ValueError(
-                f"DCR response from '{registration_url}' missing 'client_id'. "
-                f"Response keys: {response_keys}"
+                f"DCR response from '{registration_url}' missing 'client_id'. Response keys: {response_keys}"
             )
 
         logger.info(
-            "DCR: Registration successful at '%s' — client_id=%s, "
-            "has_secret=%s, expires_at=%s",
+            "DCR: Registration successful at '%s' — client_id=%s, has_secret=%s, expires_at=%s",
             registration_url,
             dcr_response["client_id"],
             "client_secret" in dcr_response,

{oidcauthlib-3.0.6 → oidcauthlib-3.0.7}/oidcauthlib/auth/dcr/dcr_manager.py

@@ -32,11 +32,9 @@ class DcrManager:
     ) -> None:
         self._collection_name = collection_name
         self._redirect_uri = redirect_uri
-        self._repository: AsyncBaseRepository[DcrRegistration] = (
-            RepositoryFactory.get_repository(
-                repository_type=environment_variables.oauth_cache,
-                environment_variables=environment_variables,
-            )
+        self._repository: AsyncBaseRepository[DcrRegistration] = RepositoryFactory.get_repository(
+            repository_type=environment_variables.oauth_cache,
+            environment_variables=environment_variables,
         )
         self._dcr_client = dcr_client or DcrClient()
 
@@ -53,8 +51,7 @@ class DcrManager:
     ) -> DcrRegistration | None:
         if client_id:
             logger.info(
-                "DCR: Skipping registration for '%s' — client_id already "
-                "provided (client_id=%s)",
+                "DCR: Skipping registration for '%s' — client_id already provided (client_id=%s)",
                 auth_provider,
                 client_id,
             )
@@ -62,13 +59,11 @@ class DcrManager:
 
         if not registration_url:
             logger.error(
-                "DCR: No registration_url and no client_id for '%s' — "
-                "cannot resolve credentials",
+                "DCR: No registration_url and no client_id for '%s' — cannot resolve credentials",
                 auth_provider,
             )
             raise ValueError(
-                f"registration_url is required for DCR when client_id is not "
-                f"provided (auth_provider='{auth_provider}')"
+                f"registration_url is required for DCR when client_id is not provided (auth_provider='{auth_provider}')"
             )
 
         validate_url(registration_url)
@@ -95,16 +90,14 @@ class DcrManager:
 
         if cached and self._is_expired(cached):
             logger.info(
-                "DCR: Cached credentials for '%s' are expired "
-                "(client_id=%s, expired_at=%s) — re-registering",
+                "DCR: Cached credentials for '%s' are expired (client_id=%s, expired_at=%s) — re-registering",
                 auth_provider,
                 cached.client_id,
                 cached.client_secret_expires_at,
             )
         else:
             logger.info(
-                "DCR: No cached credentials found for '%s' — performing "
-                "new registration at '%s'",
+                "DCR: No cached credentials found for '%s' — performing new registration at '%s'",
                 auth_provider,
                 registration_url,
             )
@@ -137,8 +130,7 @@ class DcrManager:
         registration_url: str,
     ) -> DcrRegistration | None:
         logger.debug(
-            "DCR: Querying cache for auth_provider='%s', "
-            "registration_url='%s', collection='%s'",
+            "DCR: Querying cache for auth_provider='%s', registration_url='%s', collection='%s'",
             auth_provider,
             registration_url,
             self._collection_name,

{oidcauthlib-3.0.6 → oidcauthlib-3.0.7}/oidcauthlib/auth/dcr/dcr_registration.py

@@ -10,19 +10,13 @@ class DcrRegistration(BaseDbModel):
     """Persisted DCR credentials in MongoDB."""
 
     created: datetime = Field(description="When the registration was created.")
-    updated: Optional[datetime] = Field(
-        default=None, description="When the registration was last updated."
-    )
+    updated: Optional[datetime] = Field(default=None, description="When the registration was last updated.")
     auth_provider: str = Field(description="The normalized auth provider key.")
     registration_url: str = Field(description="The DCR endpoint URL.")
     client_id: str = Field(description="The client_id from DCR.")
-    client_secret: Optional[str] = Field(
-        default=None, description="The client_secret from DCR (if any)."
-    )
+    client_secret: Optional[str] = Field(default=None, description="The client_secret from DCR (if any).")
     client_secret_expires_at: int = Field(
         default=0,
         description="Unix timestamp when client_secret expires. 0 = no expiry.",
     )
-    registration_response: dict[str, Any] = Field(
-        default_factory=dict, description="The full DCR response."
-    )
+    registration_response: dict[str, Any] = Field(default_factory=dict, description="The full DCR response.")