Blacken and isorted.

Author: rohe

src/idpyoidc/server/oauth2/token.py

@@ -78,7 +78,7 @@ def configure_grant_types(self, grant_types_helpers):
                 raise ProcessError(f"Failed to initialize class {grant_class}: {e}")
 
     def _post_parse_request(
-            self, request: Union[Message, dict], client_id: Optional[str] = "", **kwargs
+        self, request: Union[Message, dict], client_id: Optional[str] = "", **kwargs
     ):
         grant_type = request["grant_type"]
         _helper = self.helper.get(grant_type)

src/idpyoidc/server/oauth2/token_helper.py

@@ -121,8 +121,9 @@ def process_request(self, req: Union[Message, dict], **kwargs):
         except KeyError:  # Missing code parameter - absolutely fatal
             return self.error_cls(error="invalid_request", error_description="Missing code")
 
-        _session_info = _mngr.get_session_info_by_token(_access_code, grant=True,
-                                                        handler_key="authorization_code")
+        _session_info = _mngr.get_session_info_by_token(
+            _access_code, grant=True, handler_key="authorization_code"
+        )
         client_id = _session_info["client_id"]
         if client_id != req["client_id"]:
             logger.debug("{} owner of token".format(client_id))
@@ -210,8 +211,9 @@ def post_parse_request(
 
         _mngr = self.endpoint.server_get("endpoint_context").session_manager
         try:
-            _session_info = _mngr.get_session_info_by_token(request["code"], grant=True,
-                                                            handler_key="authorization_code")
+            _session_info = _mngr.get_session_info_by_token(
+                request["code"], grant=True, handler_key="authorization_code"
+            )
         except (KeyError, UnknownToken):
             logger.error("Access Code invalid")
             return self.error_cls(error="invalid_grant", error_description="Unknown code")
@@ -244,8 +246,9 @@ def process_request(self, req: Union[Message, dict], **kwargs):
             return self.error_cls(error="invalid_request", error_description="Wrong grant_type")
 
         token_value = req["refresh_token"]
-        _session_info = _mngr.get_session_info_by_token(token_value, grant=True,
-                                                        handler_key="refresh_token")
+        _session_info = _mngr.get_session_info_by_token(
+            token_value, grant=True, handler_key="refresh_token"
+        )
         logger.debug("Session info: {}".format(_session_info))
 
         if _session_info["client_id"] != req["client_id"]:
@@ -339,8 +342,9 @@ def post_parse_request(
 
         _mngr = _context.session_manager
         try:
-            _session_info = _mngr.get_session_info_by_token(request["refresh_token"], grant=True,
-                                                            handler_key="refresh_token")
+            _session_info = _mngr.get_session_info_by_token(
+                request["refresh_token"], grant=True, handler_key="refresh_token"
+            )
         except (KeyError, UnknownToken):
             logger.error("Refresh token invalid")
             return self.error_cls(error="invalid_grant", error_description="Invalid refresh token")
@@ -422,7 +426,8 @@ def post_parse_request(self, request, client_id="", **kwargs):
             # token exchange is about minting one token based on another
             _handler_key = self.token_types_mapping[request["subject_token_type"]]
             _session_info = _mngr.get_session_info_by_token(
-                request["subject_token"], grant=True, handler_key=_handler_key)
+                request["subject_token"], grant=True, handler_key=_handler_key
+            )
         except (KeyError, UnknownToken, BadSyntax) as err:
             logger.error(f"Subject token invalid ({err}).")
             return self.error_cls(
@@ -522,7 +527,8 @@ def process_request(self, request, **kwargs):
         try:
             _handler_key = self.token_types_mapping[request["subject_token_type"]]
             _session_info = _mngr.get_session_info_by_token(
-                request["subject_token"], grant=True, handler_key=_handler_key)
+                request["subject_token"], grant=True, handler_key=_handler_key
+            )
         except ToOld:
             logger.error("Subject token has expired.")
             return self.error_cls(

src/idpyoidc/server/oidc/token_helper.py

@@ -30,8 +30,9 @@ def _get_session_info(self, request, session_manager):
         except KeyError:  # Missing code parameter - absolutely fatal
             return self.error_cls(error="invalid_request", error_description="Missing code")
 
-        _session_info = session_manager.get_session_info_by_token(_access_code, grant=True,
-                                                                  handler_key='authorization_code')
+        _session_info = session_manager.get_session_info_by_token(
+            _access_code, grant=True, handler_key="authorization_code"
+        )
         logger.debug(f"Session info: {_session_info}")
         return _session_info, _access_code
 
@@ -119,9 +120,9 @@ def process_request(self, req: Union[Message, dict], **kwargs):
                     _response["expires_in"] = token.expires_at - utc_time_sans_frac()
 
         if (
-                issue_refresh
-                and "refresh_token" in _supports_minting
-                and "refresh_token" in grant_types_supported
+            issue_refresh
+            and "refresh_token" in _supports_minting
+            and "refresh_token" in grant_types_supported
         ):
             try:
                 refresh_token = self._mint_token(
@@ -164,7 +165,7 @@ def process_request(self, req: Union[Message, dict], **kwargs):
         return _response
 
     def post_parse_request(
-            self, request: Union[Message, dict], client_id: Optional[str] = "", **kwargs
+        self, request: Union[Message, dict], client_id: Optional[str] = "", **kwargs
     ) -> Union[Message, dict]:
         """
         This is where clients come to get their access tokens
@@ -176,8 +177,9 @@ def post_parse_request(
 
         _mngr = self.endpoint.server_get("endpoint_context").session_manager
         try:
-            _session_info = _mngr.get_session_info_by_token(request["code"], grant=True,
-                                                            handler_key='authorization_code')
+            _session_info = _mngr.get_session_info_by_token(
+                request["code"], grant=True, handler_key="authorization_code"
+            )
         except (KeyError, UnknownToken):
             logger.error("Access Code invalid")
             return self.error_cls(error="invalid_grant", error_description="Unknown code")
@@ -215,8 +217,9 @@ def process_request(self, req: Union[Message, dict], **kwargs):
 
         token_value = req["refresh_token"]
 
-        _session_info = _mngr.get_session_info_by_token(token_value, handler_key="refresh_token",
-                                                        grant=True)
+        _session_info = _mngr.get_session_info_by_token(
+            token_value, handler_key="refresh_token", grant=True
+        )
         if _session_info["client_id"] != req["client_id"]:
             logger.debug("{} owner of token".format(_session_info["client_id"]))
             logger.warning("{} using token it was not given".format(req["client_id"]))
@@ -298,9 +301,9 @@ def process_request(self, req: Union[Message, dict], **kwargs):
         token.register_usage()
 
         if (
-                "client_id" in req
-                and req["client_id"] in _context.cdb
-                and "revoke_refresh_on_issue" in _context.cdb[req["client_id"]]
+            "client_id" in req
+            and req["client_id"] in _context.cdb
+            and "revoke_refresh_on_issue" in _context.cdb[req["client_id"]]
         ):
             revoke_refresh = _context.cdb[req["client_id"]].get("revoke_refresh_on_issue")
         else:
@@ -312,7 +315,7 @@ def process_request(self, req: Union[Message, dict], **kwargs):
         return _resp
 
     def post_parse_request(
-            self, request: Union[Message, dict], client_id: Optional[str] = "", **kwargs
+        self, request: Union[Message, dict], client_id: Optional[str] = "", **kwargs
     ):
         """
         This is where clients come to refresh their access tokens
@@ -333,9 +336,9 @@ def post_parse_request(
 
         _mngr = _context.session_manager
         try:
-            _session_info = _mngr.get_session_info_by_token(request["refresh_token"],
-                                                            handler_key="refresh_token",
-                                                            grant=True)
+            _session_info = _mngr.get_session_info_by_token(
+                request["refresh_token"], handler_key="refresh_token", grant=True
+            )
         except (KeyError, UnknownToken, BadSyntax):
             logger.error("Refresh token invalid")
             return self.error_cls(error="invalid_grant", error_description="Invalid refresh token")

src/idpyoidc/server/oidc/userinfo.py

@@ -49,15 +49,16 @@ def __init__(self, server_get: Callable, add_claims_by_scope: Optional[bool] = T
 
     def get_client_id_from_token(self, endpoint_context, token, request=None):
         _info = endpoint_context.session_manager.get_session_info_by_token(
-            token, handler_key="access_token")
+            token, handler_key="access_token"
+        )
         return _info["client_id"]
 
     def do_response(
-            self,
-            response_args: Optional[Union[Message, dict]] = None,
-            request: Optional[Union[Message, dict]] = None,
-            client_id: Optional[str] = "",
-            **kwargs
+        self,
+        response_args: Optional[Union[Message, dict]] = None,
+        request: Optional[Union[Message, dict]] = None,
+        client_id: Optional[str] = "",
+        **kwargs
     ) -> dict:
 
         if "error" in kwargs and kwargs["error"]:
@@ -114,8 +115,9 @@ def do_response(
     def process_request(self, request=None, **kwargs):
         _mngr = self.server_get("endpoint_context").session_manager
         try:
-            _session_info = _mngr.get_session_info_by_token(request["access_token"],
-                                                            grant=True, handler_key="access_token")
+            _session_info = _mngr.get_session_info_by_token(
+                request["access_token"], grant=True, handler_key="access_token"
+            )
         except (KeyError, ValueError):
             return self.error_cls(error="invalid_token", error_description="Invalid Token")
 

src/idpyoidc/server/session/manager.py

@@ -565,7 +565,7 @@ def get_session_info_by_token(
         grant: Optional[bool] = False,
         authentication_event: Optional[bool] = False,
         authorization_request: Optional[bool] = False,
-        handler_key: Optional[str] = '',
+        handler_key: Optional[str] = "",
     ) -> dict:
         if handler_key:
             _token_info = self.token_handler.handler[handler_key].info(token_value)

src/idpyoidc/server/token/jwt_token.py

@@ -6,25 +6,26 @@
 
 from idpyoidc.encrypter import init_encrypter
 from idpyoidc.server.exception import ToOld
-from . import is_expired
+
+from ..constant import DEFAULT_TOKEN_LIFETIME
 from . import Token
+from . import is_expired
 from .exception import UnknownToken
 from .exception import WrongTokenClass
-from ..constant import DEFAULT_TOKEN_LIFETIME
 
 
 class JWTToken(Token):
     def __init__(
-            self,
-            token_class,
-            # keyjar: KeyJar = None,
-            issuer: str = None,
-            aud: Optional[list] = None,
-            alg: str = "ES256",
-            lifetime: int = DEFAULT_TOKEN_LIFETIME,
-            server_get: Callable = None,
-            token_type: str = "Bearer",
-            **kwargs
+        self,
+        token_class,
+        # keyjar: KeyJar = None,
+        issuer: str = None,
+        aud: Optional[list] = None,
+        alg: str = "ES256",
+        lifetime: int = DEFAULT_TOKEN_LIFETIME,
+        server_get: Callable = None,
+        token_type: str = "Bearer",
+        **kwargs
     ):
         Token.__init__(self, token_class, **kwargs)
         self.token_type = token_type
@@ -45,11 +46,11 @@ def load_custom_claims(self, payload: dict = None):
         return payload
 
     def __call__(
-            self,
-            session_id: Optional[str] = "",
-            token_class: Optional[str] = "",
-            usage_rules: Optional[dict] = None,
-            **payload
+        self,
+        session_id: Optional[str] = "",
+        token_class: Optional[str] = "",
+        usage_rules: Optional[dict] = None,
+        **payload
     ) -> str:
         """
         Return a token.

tests/test_server_10_session_manager.py

@@ -364,8 +364,9 @@ def test_get_session_info_by_token(self):
 
         grant = self.session_manager.get_grant(_session_id)
         code = self._mint_token("authorization_code", grant, _session_id)
-        _session_info = self.session_manager.get_session_info_by_token(code.value,
-                                                                       handler_key="authorization_code")
+        _session_info = self.session_manager.get_session_info_by_token(
+            code.value, handler_key="authorization_code"
+        )
 
         assert set(_session_info.keys()) == {
             "client_id",

tests/test_server_24_oauth2_token_endpoint.py

@@ -354,7 +354,8 @@ def test_do_refresh_access_token(self):
 
         _token_value = _resp["response_args"]["refresh_token"]
         _session_info = self.session_manager.get_session_info_by_token(
-            _token_value, handler_key="refresh_token")
+            _token_value, handler_key="refresh_token"
+        )
         _token = self.session_manager.find_token(_session_info["session_id"], _token_value)
         _token.usage_rules["supports_minting"] = ["access_token", "refresh_token"]
 
@@ -410,8 +411,9 @@ def test_do_2nd_refresh_access_token(self):
 
         # Make sure ID Tokens can also be used by this refesh token
         _token_value = _resp["response_args"]["refresh_token"]
-        _session_info = self.session_manager.get_session_info_by_token(_token_value,
-                                                                       handler_key="refresh_token")
+        _session_info = self.session_manager.get_session_info_by_token(
+            _token_value, handler_key="refresh_token"
+        )
         _token = self.session_manager.find_token(_session_info["session_id"], _token_value)
         _token.usage_rules["supports_minting"] = [
             "access_token",
@@ -580,8 +582,9 @@ def test_refresh_scopes(self):
         }
 
         _token_value = _resp["response_args"]["access_token"]
-        _session_info = self.session_manager.get_session_info_by_token(_token_value,
-                                                                       handler_key="access_token")
+        _session_info = self.session_manager.get_session_info_by_token(
+            _token_value, handler_key="access_token"
+        )
         at = self.session_manager.find_token(_session_info["session_id"], _token_value)
         rt = self.session_manager.find_token(
             _session_info["session_id"], _resp["response_args"]["refresh_token"]
@@ -655,8 +658,9 @@ def test_refresh_more_scopes_2(self):
         }
 
         _token_value = _resp["response_args"]["access_token"]
-        _session_info = self.session_manager.get_session_info_by_token(_token_value,
-                                                                       handler_key="access_token")
+        _session_info = self.session_manager.get_session_info_by_token(
+            _token_value, handler_key="access_token"
+        )
         at = self.session_manager.find_token(_session_info["session_id"], _token_value)
         rt = self.session_manager.find_token(
             _session_info["session_id"], _resp["response_args"]["refresh_token"]
@@ -756,8 +760,9 @@ def test_refresh_token_request_other_client(self):
         _request["refresh_token"] = _resp["response_args"]["refresh_token"]
 
         _token_value = _resp["response_args"]["refresh_token"]
-        _session_info = self.session_manager.get_session_info_by_token(_token_value,
-                                                                       handler_key="refresh_token")
+        _session_info = self.session_manager.get_session_info_by_token(
+            _token_value, handler_key="refresh_token"
+        )
         _token = self.session_manager.find_token(_session_info["session_id"], _token_value)
         _token.usage_rules["supports_minting"] = ["access_token", "refresh_token"]
 

tests/test_server_30_oidc_end_session.py

@@ -295,7 +295,8 @@ def test_end_session_endpoint_with_cookie(self):
         _resp = self._code_auth("1234567")
         _code = _resp["response_args"]["code"]
         _session_info = self.session_manager.get_session_info_by_token(
-            _code, handler_key="authorization_code")
+            _code, handler_key="authorization_code"
+        )
         cookie = self._create_cookie(_session_info["session_id"])
         http_info = {"cookie": [cookie]}
         resp = self.session_endpoint.process_request({"state": "foo"}, http_info=http_info)
@@ -344,7 +345,8 @@ def test_end_session_endpoint_with_cookie_dual_login(self):
         self._code_auth2("abcdefg")
         _code = _resp["response_args"]["code"]
         _session_info = self.session_manager.get_session_info_by_token(
-            _code, handler_key="authorization_code")
+            _code, handler_key="authorization_code"
+        )
         cookie = self._create_cookie(_session_info["session_id"])
         http_info = {"cookie": [cookie]}
 
@@ -365,7 +367,8 @@ def test_end_session_endpoint_with_post_logout_redirect_uri(self):
         self._code_auth2("abcdefg")
         _code = _resp["response_args"]["code"]
         _session_info = self.session_manager.get_session_info_by_token(
-            _code, handler_key="authorization_code")
+            _code, handler_key="authorization_code"
+        )
         cookie = self._create_cookie(_session_info["session_id"])
         http_info = {"cookie": [cookie]}
 
@@ -597,7 +600,8 @@ def test_do_verified_logout(self):
             _resp = self._code_auth("1234567")
             _code = _resp["response_args"]["code"]
             _session_info = self.session_manager.get_session_info_by_token(
-                _code, handler_key="authorization_code")
+                _code, handler_key="authorization_code"
+            )
             _cdb = self.session_endpoint.server_get("endpoint_context").cdb
             _cdb["client_1"]["backchannel_logout_uri"] = "https://example.com/bc_logout"
             _cdb["client_1"]["client_id"] = "client_1"
@@ -609,7 +613,8 @@ def test_logout_from_client_unknow_sid(self):
         _resp = self._code_auth("1234567")
         _code = _resp["response_args"]["code"]
         _session_info = self.session_manager.get_session_info_by_token(
-            _code, handler_key="authorization_code")
+            _code, handler_key="authorization_code"
+        )
         self._code_auth2("abcdefg")
 
         _uid, _cid, _gid = self.session_manager.decrypt_session_id(_session_info["session_id"])
@@ -621,7 +626,8 @@ def test_logout_from_client_no_session(self):
         _resp = self._code_auth("1234567")
         _code = _resp["response_args"]["code"]
         _session_info = self.session_manager.get_session_info_by_token(
-            _code, handler_key="authorization_code")
+            _code, handler_key="authorization_code"
+        )
         self._code_auth2("abcdefg")
 
         # client0