pypomes-iam 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

pypomes_iam/iam_actions.py

@@ -59,7 +59,7 @@ def action_login(iam_server: IamServer,
                                               errors=errors,
                                               logger=logger)
             if not errors:
-                user_data[UserParam.LOGIN_EXPIRATION] = int(datetime.now(tz=TZ_LOCAL).timestamp()) + timeout \
+                user_data[UserParam.LOGIN_EXPIRATION] = (int(datetime.now(tz=TZ_LOCAL).timestamp()) + timeout) \
                     if timeout else None
                 redirect_uri: str = args.get(UserParam.REDIRECT_URI)
                 user_data[UserParam.REDIRECT_URI] = redirect_uri
@@ -138,6 +138,7 @@ def action_token(iam_server: IamServer,
                                                        user_id=user_id,
                                                        errors=errors,
                                                        logger=logger)
+            # retrieve the stored access token
             token: str = user_data[UserParam.ACCESS_TOKEN] if user_data else None
             if token:
                 access_expiration: int = user_data.get(UserParam.ACCESS_EXPIRATION)
@@ -148,7 +149,7 @@ def action_token(iam_server: IamServer,
                     # access token has expired
                     refresh_token: str = user_data[UserParam.REFRESH_TOKEN]
                     if refresh_token:
-                        refresh_expiration = user_data[UserParam.REFRESH_EXPIRATION]
+                        refresh_expiration: int = user_data[UserParam.REFRESH_EXPIRATION]
                         if now < refresh_expiration:
                             header_data: dict[str, str] = {
                                 "Content-Type": "application/json"
@@ -242,7 +243,7 @@ def action_callback(iam_server: IamServer,
                 users.pop(oauth_state)
                 code: str = args.get("code")
                 header_data: dict[str, str] = {
-                    "Content-Type": "application/json"
+                    "Content-Type": "application/x-www-form-urlencoded"
                 }
                 body_data: dict[str, Any] = {
                     "grant_type": "authorization_code",
@@ -456,7 +457,7 @@ def __get_administrative_token(iam_server: IamServer,
                                                  logger=logger)
     if registry and registry[IamParam.ADMIN_ID] and registry[IamParam.ADMIN_SECRET]:
         header_data: dict[str, str] = {
-            "Content-Type": "application/json"
+            "Content-Type": "application/x-www-form-urlencoded"
         }
         body_data: dict[str, str] = {
             "grant-type": "password",
@@ -573,7 +574,7 @@ def __get_for_data(url: str,
                 logger.debug(msg=f"GET success, {json.dumps(obj=result,
                                                             ensure_ascii=False)}")
         else:
-            # request resulted in error
+            # request failed, report the problem
             msg: str = f"GET failure, status {response.status_code}, reason {response.reason}"
             if hasattr(response, "content") and response.content:
                 msg += f", content '{response.content}'"
@@ -615,7 +616,7 @@ def __post_data(url: str,
                                                    headers=header_data,
                                                    data=body_data)
         if response.status_code >= 400:
-            # request resulted in error
+            # request failed, report the problem
             msg = f"POST failure, status {response.status_code}, reason {response.reason}"
             if hasattr(response, "content") and response.content:
                 msg += f", content '{response.content}'"
@@ -735,7 +736,7 @@ def __post_for_token(iam_server: IamServer,
                         logger.debug(msg=f"POST success, {json.dumps(obj=result,
                                                                      ensure_ascii=False)}")
                 else:
-                    # request resulted in error
+                    # request failed, report the problem
                     err_msg = f"POST failure, status {response.status_code}, reason {response.reason}"
                     if hasattr(response, "content") and response.content:
                         err_msg += f", content '{response.content}'"

pypomes_iam/iam_common.py

@@ -58,16 +58,17 @@ class UserParam(StrEnum):
 # Specifying configuration parameters with environment variables can be done in two ways:
 #
 # 1. for a single *IAM* server, specify the data set
-#       - *<APP_PREFIX>_IAM_ADMIN_ID*             (optional, needed only if administrative duties are performed)
-#       - *<APP_PREFIX>_IAM_ADMIN_PWD*            (optional, needed only if administrative duties are performed)
+#       - *<APP_PREFIX>_IAM_ADMIN_ID*             (optional, needed if administrative duties are performed)
+#       - *<APP_PREFIX>_IAM_ADMIN_PWD*            (optional, needed if administrative duties are performed)
 #       - *<APP_PREFIX>_IAM_CLIENT_ID*            (required)
 #       - *<APP_PREFIX>_IAM_CLIENT_REALM*         (required)
 #       - *<APP_PREFIX>_IAM_CLIENT_SECRET*        (required)
-#       - *<APP_PREFIX>_IAM_ENDPOINT_CALLBACK*    (optional)
-#       - *<APP_PREFIX>_IAM_ENDPOINT_LOGIN*       (optional)
-#       - *<APP_PREFIX>_IAM_ENDPOINT_LOGOUT*      (optional)
-#       - *<APP_PREFIX>_IAM_ENDPOINT_TOKEN*       (optional)
-#       - *<APP_PREFIX>_IAM_ENDPOINT_EXCHANGE*    (optional)
+#       - *<APP_PREFIX>_IAM_ENDPOINT_CALLBACK*    (required)
+#       - *<APP_PREFIX>_IAM_ENDPOINT_EXCHANGE*    (required)
+#       - *<APP_PREFIX>_IAM_ENDPOINT_LOGIN*       (required)
+#       - *<APP_PREFIX>_IAM_ENDPOINT_LOGOUT*      (required)
+#       - *<APP_PREFIX>_IAM_ENDPOINT_PROVIDER*    (optional, needed if requesting tokens to providers)
+#       - *<APP_PREFIX>_IAM_ENDPOINT_TOKEN*       (required)
 #       - *<APP_PREFIX>_IAM_LOGIN_TIMEOUT*        (optional, defaults to no timeout)
 #       - *<APP_PREFIX>_IAM_PK_LIFETIME*          (optional, defaults to non-terminating lifetime)
 #       - *<APP_PREFIX>_IAM_RECIPIENT_ATTR*       (required)

pypomes_iam/provider_pomes.py

@@ -106,76 +106,137 @@ def provider_get_token(provider_id: str,
     # initialize the return variable
     result: str | None = None
 
-    err_msg: str | None = None
     with _provider_lock:
         provider: dict[str, Any] = _provider_registry.get(provider_id)
         if provider:
-            now: float = datetime.now(tz=TZ_LOCAL).timestamp()
-            if now > provider.get(ProviderParam.ACCESS_EXPIRATION):
-                user: str = provider.get(ProviderParam.USER)
-                pwd: str = provider.get(ProviderParam.PWD)
-                headers_data: dict[str, str] = provider.get(ProviderParam.HEADER_DATA) or {}
-                body_data: dict[str, str] = provider.get(ProviderParam.BODY_DATA) or {}
-                custom_auth: tuple[str, str] = provider.get(ProviderParam.CUSTOM_AUTH)
-                if custom_auth:
-                    body_data[custom_auth[0]] = user
-                    body_data[custom_auth[1]] = pwd
-                else:
-                    enc_bytes: bytes = b64encode(f"{user}:{pwd}".encode())
-                    headers_data["Authorization"] = f"Basic {enc_bytes.decode()}"
+            now: int = int(datetime.now(tz=TZ_LOCAL).timestamp())
+            if now < provider.get(ProviderParam.ACCESS_EXPIRATION):
+                # retrieve the stored access token
+                result = provider.get(ProviderParam.ACCESS_TOKEN)
+            else:
+                # access token has expired
+                header_data: dict[str, str] | None = None
+                body_data: dict[str, str] | None = None
                 url: str = provider.get(ProviderParam.URL)
-                if logger:
-                    logger.debug(msg=f"POST {url}, {json.dumps(obj=body_data,
-                                                               ensure_ascii=False)}")
-                try:
-                    # typical return on a token request:
-                    # {
-                    #   "token_type": "Bearer",
-                    #   "access_token": <str>,
-                    #   "expires_in": <number-of-seconds>,
-                    #   optional data:
-                    #   "refresh_token": <str>,
-                    #   "refresh_expires_in": <number-of-seconds>
-                    # }
-                    response: requests.Response = requests.post(url=url,
-                                                                data=body_data,
-                                                                headers=headers_data,
-                                                                timeout=None)
-                    if response.status_code < 200 or response.status_code >= 300:
-                        # request resulted in error, report the problem
-                        err_msg = (f"POST failure, "
-                                   f"status {response.status_code}, reason {response.reason}")
+                refresh_token: str = provider.get(ProviderParam.REFRESH_TOKEN)
+                if refresh_token:
+                    # refresh token exists
+                    refresh_expiration: int = provider.get(ProviderParam.REFRESH_EXPIRATION)
+                    if now < refresh_expiration:
+                        # refresh token has not expired
+                        header_data: dict[str, str] = {
+                            "Content-Type": "application/json"
+                        }
+                        body_data: dict[str, str] = {
+                            "grant_type": "refresh_token",
+                            "refresh_token": refresh_token
+                        }
+                if not body_data:
+                    # refresh token does not exist or has expired
+                    user: str = provider.get(ProviderParam.USER)
+                    pwd: str = provider.get(ProviderParam.PWD)
+                    headers_data: dict[str, str] = provider.get(ProviderParam.HEADER_DATA) or {}
+                    body_data: dict[str, str] = provider.get(ProviderParam.BODY_DATA) or {}
+                    custom_auth: tuple[str, str] = provider.get(ProviderParam.CUSTOM_AUTH)
+                    if custom_auth:
+                        body_data[custom_auth[0]] = user
+                        body_data[custom_auth[1]] = pwd
                     else:
-                        # request succeeded
-                        if logger:
-                            logger.debug(msg=f"POST success, status {response.status_code}")
-                        reply: dict[str, Any] = response.json()
-                        provider[ProviderParam.ACCESS_TOKEN] = reply.get("access_token")
-                        provider[ProviderParam.ACCESS_EXPIRATION] = now + int(reply.get("expires_in"))
-                        if reply.get(ProviderParam.REFRESH_TOKEN):
-                            provider[ProviderParam.REFRESH_TOKEN] = reply["refresh_token"]
-                            if reply.get("refresh_expires_in"):
-                                provider[ProviderParam.REFRESH_EXPIRATION] = now + int(reply.get("refresh_expires_in"))
-                            else:
-                                provider[ProviderParam.REFRESH_EXPIRATION] = sys.maxsize
-                        if logger:
-                            logger.debug(msg=f"POST {url}: status {response.status_code}")
-                except Exception as e:
-                    # the operation raised an exception
-                    err_msg = exc_format(exc=e,
-                                         exc_info=sys.exc_info())
-                    err_msg = f"POST error, '{err_msg}'"
-        else:
-            err_msg: str = f"Provider '{provider_id}' not registered"
-
-    if err_msg:
-        if isinstance(errors, list):
-            errors.append(err_msg)
-        if logger:
-            logger.error(msg=err_msg)
-    else:
-        result = provider.get(ProviderParam.ACCESS_TOKEN)
+                        enc_bytes: bytes = b64encode(f"{user}:{pwd}".encode())
+                        headers_data["Authorization"] = f"Basic {enc_bytes.decode()}"
+
+                # obtain the token
+                token_data: dict[str, Any] = __post_for_token(url=url,
+                                                              header_data=header_data,
+                                                              body_data=body_data,
+                                                              errors=errors,
+                                                              logger=logger)
+                if token_data:
+                    result = token_data.get("access_token")
+                    provider[ProviderParam.ACCESS_TOKEN] = result
+                    provider[ProviderParam.ACCESS_EXPIRATION] = now + token_data.get("expires_in")
+                    refresh_token = token_data.get("refresh_token")
+                    if refresh_token:
+                        provider[ProviderParam.REFRESH_TOKEN] = refresh_token
+                        refresh_exp: int = token_data.get("refresh_expires_in")
+                        provider[ProviderParam.REFRESH_EXPIRATION] = (now + refresh_exp) \
+                            if refresh_exp else sys.maxsize
+
+        elif logger or isinstance(errors, list):
+            msg: str = f"Unknown provider '{provider_id}'"
+            if logger:
+                logger.error(msg=msg)
+            if isinstance(errors, list):
+                errors.append(msg)
 
     return result
 
 
+def __post_for_token(url: str,
+                     header_data: dict[str, str],
+                     body_data: dict[str, Any],
+                     errors: list[str] | None,
+                     logger: Logger | None) -> dict[str, Any] | None:
+    """
+    Send a *POST* request to *url* and return the token data obtained.
+
+    Token acquisition and token refresh are the two types of requests contemplated herein.
+    For the former, *header_data* and *body_data* will have contents customized to the specific provider,
+    whereas the latter's *body_data* will contain these two attributes:
+        - "grant_type": "refresh_token"
+        - "refresh_token": <current-refresh-token>
+
+    The typical data set returned contains the following attributes:
+        {
+            "token_type": "Bearer",
+            "access_token": <str>,
+            "expires_in": <number-of-seconds>,
+            "refresh_token": <str>,
+            "refesh_expires_in": <number-of-seconds>
+        }
+
+    :param url: the target URL
+    :param header_data: the data to send in the header of the request
+    :param body_data: the data to send in the body of the request
+    :param errors: incidental errors
+    :param logger: optional logger
+    :return: the token data, or *None* if error
+    """
+    # initialize the return variable
+    result: dict[str, Any] | None = None
+
+    # log the POST
+    if logger:
+        logger.debug(msg=f"POST {url}, {json.dumps(obj=body_data,
+                                                   ensure_ascii=False)}")
+    try:
+        response: requests.Response = requests.post(url=url,
+                                                    data=body_data,
+                                                    headers=header_data,
+                                                    timeout=None)
+        if response.status_code == 200:
+            # request succeeded
+            result = response.json()
+            if logger:
+                logger.debug(msg=f"POST success, status {response.status_code}")
+        else:
+            # request failed, report the problem
+            msg: str = (f"POST failure, "
+                        f"status {response.status_code}, reason {response.reason}")
+            if hasattr(response, "content") and response.content:
+                msg += f", content '{response.content}'"
+            if logger:
+                logger.error(msg=msg)
+            if isinstance(errors, list):
+                errors.append(msg)
+    except Exception as e:
+        # the operation raised an exception
+        err_msg = exc_format(exc=e,
+                             exc_info=sys.exc_info())
+        msg: str = f"POST error, {err_msg}"
+        if logger:
+            logger.debug(msg=msg)
+        if isinstance(errors, list):
+            errors.append(msg)
+
+    return result

{pypomes_iam-0.6.0.dist-info → pypomes_iam-0.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypomes_iam
-Version: 0.6.0
+Version: 0.6.2
 Summary: A collection of Python pomes, penyeach (IAM modules)
 Project-URL: Homepage, https://github.com/TheWiseCoder/PyPomes-IAM
 Project-URL: Bug Tracker, https://github.com/TheWiseCoder/PyPomes-IAM/issues
@@ -10,7 +10,6 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.12
-Requires-Dist: cachetools>=6.2.1
 Requires-Dist: flask>=3.1.2
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: pypomes-core>=2.8.1

pypomes_iam-0.6.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+pypomes_iam/__init__.py,sha256=_6tSFfjuU-5p6TAMqNLHSL6IQmaJMSYuEW-TG3ybhTI,1044
+pypomes_iam/iam_actions.py,sha256=DhDZcY6j3uSWnm5Q5SrA5jriTUCatLqJKd9K7IjA2i8,39283
+pypomes_iam/iam_common.py,sha256=ki_-m6fqJqUbGjgTD41r9zaE-FOXgA_c_tLisIYYTfU,15457
+pypomes_iam/iam_pomes.py,sha256=XkxpwwGivUR3Y1TKR6McrqLUnpFJhRvIrsEn9T_Ut9A,7351
+pypomes_iam/iam_services.py,sha256=IkCjrKDX1Ix7BiHh-BL3VKz5xogcNC8prXkHyJzQoZ8,15862
+pypomes_iam/provider_pomes.py,sha256=3mMj5LQs53YEINUEOfFBAxOwOP3aOR_szlE4daEBLK0,10523
+pypomes_iam/token_pomes.py,sha256=K4nSAotKUoHIE2s3ltc_nVimlNeKS9tnD-IlslkAvkk,6626
+pypomes_iam-0.6.2.dist-info/METADATA,sha256=XeUm7yxjoWFURVvoHDSoYkF5iROCC696PPuHydJ1UIs,661
+pypomes_iam-0.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pypomes_iam-0.6.2.dist-info/licenses/LICENSE,sha256=YvUELgV8qvXlaYsy9hXG5EW3Bmsrkw-OJmmILZnonAc,1086
+pypomes_iam-0.6.2.dist-info/RECORD,,

pypomes_iam-0.6.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-pypomes_iam/__init__.py,sha256=_6tSFfjuU-5p6TAMqNLHSL6IQmaJMSYuEW-TG3ybhTI,1044
-pypomes_iam/iam_actions.py,sha256=Bmd8rBg3948Afsg10B6B1ZrFY4wYtbxi55rX4Rlqiyk,39167
-pypomes_iam/iam_common.py,sha256=4sn9V4_fRXrljz41Dh7P6ng4aqFfp0pLnrq_rURDKt4,15363
-pypomes_iam/iam_pomes.py,sha256=XkxpwwGivUR3Y1TKR6McrqLUnpFJhRvIrsEn9T_Ut9A,7351
-pypomes_iam/iam_services.py,sha256=IkCjrKDX1Ix7BiHh-BL3VKz5xogcNC8prXkHyJzQoZ8,15862
-pypomes_iam/provider_pomes.py,sha256=N0nL9_hgHmAjG9JKFoXC33zk8b1ckPG1veu1jTp-2JE,8045
-pypomes_iam/token_pomes.py,sha256=K4nSAotKUoHIE2s3ltc_nVimlNeKS9tnD-IlslkAvkk,6626
-pypomes_iam-0.6.0.dist-info/METADATA,sha256=xl-01mkMhab71h8WMqADHpX5qxS5ngFfcMyhSouQwt0,694
-pypomes_iam-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pypomes_iam-0.6.0.dist-info/licenses/LICENSE,sha256=YvUELgV8qvXlaYsy9hXG5EW3Bmsrkw-OJmmILZnonAc,1086
-pypomes_iam-0.6.0.dist-info/RECORD,,