pypomes-iam 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

pypomes_iam/iam_services.py

@@ -0,0 +1,243 @@
+import json
+from flask import Request, Response, request, jsonify
+from logging import Logger
+from typing import Any
+
+from .iam_common import IamServer, _get_logger, _get_iam_server
+from .iam_pomes import user_login, user_logout, user_token, token_exchange, login_callback
+
+
+# @flask_app.route(rule=<login_endpoint>,  # JUSBR_LOGIN_ENDPOINT: /iam/jusbr:login
+#                  methods=["GET"])
+# @flask_app.route(rule=<login_endpoint>,  # KEYCLOAK_LOGIN_ENDPOINT: /iam/keycloak:logout
+#                  methods=["GET"])
+def service_login() -> Response:
+    """
+    Entry point for the IAM server's login service.
+
+    Return the URL for the IAM server's authentication page, with the appropriate parameters.
+
+    :return: the response from the operation
+    """
+    # declare the return variable
+    result: Response | None = None
+
+    # retrieve the operations's logger
+    logger: Logger = _get_logger()
+    if logger:
+        # log the request
+        logger.debug(msg=_log_init(request=request))
+
+    # retrieve the IAM server
+    errors: list[str] = []
+    iam_server: IamServer = _get_iam_server(endpoint=request.endpoint,
+                                            errors=errors,
+                                            logger=logger)
+    if iam_server:
+        # obtain the login URL
+        login_data: dict[str,  str] = user_login(iam_server=iam_server,
+                                                 args=request.args,
+                                                 errors=errors,
+                                                 logger=logger)
+        if login_data:
+            result = jsonify(login_data)
+
+    if errors:
+        result = Response("; ".join(errors))
+        result.status_code = 400
+
+    # log the response
+    if logger:
+        logger.debug(msg=f"Response {result}")
+
+    return result
+
+
+# @flask_app.route(rule=<logout_endpoint>,  # JUSBR_LOGOUT_ENDPOINT
+#                  methods=["GET"])
+# @flask_app.route(rule=<login_endpoint>,  # KEYCLOAK_LOGOUT_ENDPOINT
+#                  methods=["GET"])
+def service_logout() -> Response:
+    """
+    Entry point for the JusBR logout service.
+
+    Remove all data associating the user from the *IAM* server's registry.
+
+    :return: response *OK*, or response *BAD REQUEST* if error
+    """
+    # declare the return variable
+    result: Response | None
+
+    # retrieve the operations's logger
+    logger: Logger = _get_logger()
+    if logger:
+        # log the request
+        logger.debug(msg=_log_init(request=request))
+
+    # retrieve the IAM server
+    errors: list[str] = []
+    iam_server: IamServer = _get_iam_server(endpoint=request.endpoint,
+                                            errors=errors,
+                                            logger=logger)
+    if iam_server:
+        # logout the user
+        user_logout(iam_server=iam_server,
+                    args=request.args,
+                    errors=errors,
+                    logger=logger)
+    if errors:
+        result = Response("; ".join(errors))
+        result.status_code = 400
+    else:
+        result = Response(status=200)
+
+    # log the response
+    if logger:
+        logger.debug(msg=f"Response {result}")
+
+    return result
+
+
+# @flask_app.route(rule=<callback_endpoint>,  # JUSBR_CALLBACK_ENDPOINT
+#                  methods=["GET", "POST"])
+# @flask_app.route(rule=<callback_endpoint>,  # KEYCLOAK_CALLBACK_ENDPOINT
+#                  methods=["POST"])
+def service_callback() -> Response:
+    """
+    Entry point for the callback from JusBR on authentication operation.
+
+    This callback is typically invoked from a front-end application after a successful login at the
+    JusBR login page, forwarding the data received.
+
+    :return: the response containing the token, or *BAD REQUEST*
+    """
+    # retrieve the operations's logger
+    logger: Logger = _get_logger()
+    if logger:
+        # log the request
+        logger.debug(msg=_log_init(request=request))
+
+    # retrieve the IAM server
+    errors: list[str] = []
+    token_data: tuple[str, str] | None = None
+    iam_server: IamServer = _get_iam_server(endpoint=request.endpoint,
+                                            errors=errors,
+                                            logger=logger)
+    if iam_server:
+        # process the callback operation
+        token_data = login_callback(iam_server=iam_server,
+                                    args=request.args,
+                                    errors=errors,
+                                    logger=logger)
+    result: Response
+    if errors:
+        result = jsonify({"errors": "; ".join(errors)})
+        result.status_code = 400
+        if logger:
+            logger.error(msg=json.dumps(obj=result))
+    else:
+        result = jsonify({
+            "user-id": token_data[0],
+            "access-token": token_data[1]})
+
+    # log the response
+    if logger:
+        logger.debug(msg=f"Response {result}")
+
+    return result
+
+
+# @flask_app.route(rule=<token_endpoint>,  # JUSBR_ENDPOINT_TOKEN
+# @flask_app.route(rule=<token_endpoint>,  # KEYCLOAK_ENDPOINT_TOKEN
+#                  methods=["GET"])
+#                  methods=["GET"])
+def service_token() -> Response:
+    """
+    Entry point for retrieving token from the *IAM* server.
+
+    :return: the response containing the token, or *UNAUTHORIZED*
+    """
+    # retrieve the operations's logger
+    logger: Logger = _get_logger()
+    if logger:
+        # log the request
+        logger.debug(msg=_log_init(request=request))
+
+    # retrieve the IAM server
+    errors: list[str] = []
+    iam_server: IamServer = _get_iam_server(endpoint=request.endpoint,
+                                            errors=errors,
+                                            logger=logger)
+    # retrieve the token
+    token: str | None = None
+    if iam_server:
+        errors: list[str] = []
+        token: str = user_token(iam_server=iam_server,
+                                args=request.args,
+                                errors=errors,
+                                logger=logger)
+    result: Response
+    if errors:
+        result = Response("; ".join(errors))
+        result.status_code = 400
+    else:
+        result = jsonify({"token": token})
+
+    # log the response
+    if logger:
+        logger.debug(msg=f"Response {result}")
+
+    return result
+
+
+# @flask_app.route(rule=<callback_endpoint>,  # KEYCLOAK_ENDPOINT_EXCHANGE
+#                  methods=["POST"])
+def service_exchange() -> Response:
+    """
+    Entry point for requesting the *IAM* server to exchange the token.
+
+    This is currently limit to the *Keycloak* server
+
+    :return: the response containing the token, or *UNAUTHORIZED*
+    """
+    # retrieve the operations's logger
+    logger: Logger = _get_logger()
+
+    # retrieve the IAM server (currently, only 'Keycloak' is supported)
+    errors: list[str] = []
+    iam_server: IamServer = _get_iam_server(endpoint=request.endpoint,
+                                            errors=errors,
+                                            logger=logger)
+    # exchange the token
+    token_data: dict[str, Any] | None = None
+    if iam_server:
+        errors: list[str] = []
+        token_data = token_exchange(iam_server=iam_server,
+                                    args=request.args,
+                                    errors=errors,
+                                    logger=logger)
+    result: Response
+    if errors:
+        result = Response("; ".join(errors))
+        result.status_code = 400
+    else:
+        result = jsonify(token_data)
+
+    # log the response
+    if logger:
+        logger.debug(msg=f"Response {result}")
+
+    return result
+
+
+def _log_init(request: Request) -> str:
+    """
+    Build the messages for logging the request entry.
+
+    :param request: the Request object
+    :return: the log message
+    """
+
+    params: str = json.dumps(obj=request.args,
+                             ensure_ascii=False)
+    return f"Request {request.method}:{request.path}, params {params}"

pypomes_iam/jusbr_pomes.py

@@ -1,13 +1,14 @@
+import sys
 from cachetools import Cache, FIFOCache
-from datetime import datetime
 from flask import Flask
 from logging import Logger
 from pypomes_core import (
-    APP_PREFIX, TZ_LOCAL, env_get_int, env_get_str
+    APP_PREFIX, env_get_int, env_get_str
 )
 from typing import Any, Final
 
-from .iam_common import IAM_SERVERS, IamServer, _service_token
+from .iam_common import _IAM_SERVERS, IamServer
+from .iam_pomes import user_token
 
 JUSBR_CLIENT_ID: Final[str] = env_get_str(key=f"{APP_PREFIX}_JUSBR_CLIENT_ID")
 JUSBR_CLIENT_SECRET: Final[str] = env_get_str(key=f"{APP_PREFIX}_JUSBR_CLIENT_SECRET")
@@ -24,6 +25,8 @@ JUSBR_ENDPOINT_TOKEN: Final[str] = env_get_str(key=f"{APP_PREFIX}_JUSBR_ENDPOINT
 
 JUSBR_PUBLIC_KEY_LIFETIME: Final[int] = env_get_int(key=f"{APP_PREFIX}_JUSBR_PUBLIC_KEY_LIFETIME",
                                                     def_value=86400)  # 24 hours
+JUSBR_RECIPIENT_ATTR: Final[str] = env_get_str(key=f"{APP_PREFIX}_JUSBR_RECIPIENT_ATTR",
+                                               def_value="preferred_username")
 JUSBR_URL_AUTH_BASE: Final[str] = env_get_str(key=f"{APP_PREFIX}_JUSBR_URL_AUTH_BASE")
 
 
@@ -32,6 +35,7 @@ def jusbr_setup(flask_app: Flask,
                 client_secret: str = JUSBR_CLIENT_SECRET,
                 client_timeout: int = JUSBR_CLIENT_TIMEOUT,
                 public_key_lifetime: int = JUSBR_PUBLIC_KEY_LIFETIME,
+                recipient_attribute: str = JUSBR_RECIPIENT_ATTR,
                 callback_endpoint: str = JUSBR_ENDPOINT_CALLBACK,
                 token_endpoint: str = JUSBR_ENDPOINT_TOKEN,
                 login_endpoint: str = JUSBR_ENDPOINT_LOGIN,
@@ -48,24 +52,26 @@ def jusbr_setup(flask_app: Flask,
     :param client_secret: the client's password with JusBR
     :param client_timeout: timeout for login authentication (in seconds,defaults to no timeout)
     :param public_key_lifetime: how long to use JusBR's public key, before refreshing it (in seconds)
+    :param recipient_attribute: attribute in the token's payload holding the token's subject
     :param callback_endpoint: endpoint for the callback from JusBR
-    :param token_endpoint: endpoint for retrieving the JusBR authentication token
-    :param login_endpoint: endpoint for redirecting user to JusBR login page
+    :param token_endpoint: endpoint for retrieving JusBR's authentication token
+    :param login_endpoint: endpoint for redirecting user to JusBR's login page
     :param logout_endpoint: endpoint for terminating user access to JusBR
-    :param base_url: base URL to request the JusBR services
+    :param base_url: base URL to request JusBR services
     :param logger: optional logger
     """
-    from .iam_pomes import service_login, service_logout, service_callback, service_token
+    from .iam_services import service_login, service_logout, service_callback, service_token
 
     # configure the JusBR registry
     cache: Cache = FIFOCache(maxsize=1048576)
     cache["users"] = {}
-    IAM_SERVERS[IamServer.IAM_JUSRBR] = {
+    _IAM_SERVERS[IamServer.IAM_JUSRBR] = {
         "client-id": client_id,
         "client-secret": client_secret,
         "client-timeout": client_timeout,
+        "recipient-attr": recipient_attribute,
         "base-url": base_url,
-        "pk-expiration": int(datetime.now(tz=TZ_LOCAL).timestamp()),
+        "pk-expiration": sys.maxsize,
         "pk-lifetime": public_key_lifetime,
         "cache": cache,
         "logger": logger,
@@ -87,7 +93,7 @@ def jusbr_setup(flask_app: Flask,
         flask_app.add_url_rule(rule=callback_endpoint,
                                endpoint="jusbr-callback",
                                view_func=service_callback,
-                               methods=["GET", "POST"])
+                               methods=["GET"])
     if token_endpoint:
         flask_app.add_url_rule(rule=token_endpoint,
                                endpoint="jusbr-token",
@@ -108,7 +114,7 @@ def jusbr_get_token(user_id: str,
     """
     # retrieve the token
     args: dict[str, Any] = {"user-id": user_id}
-    return _service_token(registry=IAM_SERVERS[IamServer.IAM_JUSRBR],
-                          args=args,
-                          errors=errors,
-                          logger=logger)
+    return user_token(iam_server=IamServer.IAM_JUSRBR,
+                      args=args,
+                      errors=errors,
+                      logger=logger)

pypomes_iam/keycloak_pomes.py

@@ -1,30 +1,35 @@
+import sys
 from cachetools import Cache, FIFOCache
-from datetime import datetime
 from flask import Flask
 from logging import Logger
 from pypomes_core import (
-    APP_PREFIX, TZ_LOCAL, env_get_int, env_get_str
+    APP_PREFIX, env_get_int, env_get_str
 )
 from typing import Any, Final
 
-from .iam_common import IAM_SERVERS, IamServer, _service_token
+from .iam_common import _IAM_SERVERS, IamServer
+from .iam_pomes import user_token
 
 KEYCLOAK_CLIENT_ID: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_CLIENT_ID")
 KEYCLOAK_CLIENT_SECRET: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_CLIENT_SECRET")
 KEYCLOAK_CLIENT_TIMEOUT: Final[int] = env_get_int(key=f"{APP_PREFIX}_KEYCLOAK_CLIENT_TIMEOUT")
 
 KEYCLOAK_ENDPOINT_CALLBACK: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_ENDPOINT_CALLBACK",
-                                                     def_value="/iam/keycloak:callback")
+                                                     def_value="/iam/ijud:callback")
+KEYCLOAK_ENDPOINT_EXCHANGE: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_ENDPOINT_EXCHANGE",
+                                                     def_value="/iam/ijud:exchange-token")
 KEYCLOAK_ENDPOINT_LOGIN: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_ENDPOINT_LOGIN",
-                                                  def_value="/iam/keycloak:login")
+                                                  def_value="/iam/ijud:login")
 KEYCLOAK_ENDPOINT_LOGOUT: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_ENDPOINT_LOGOUT",
-                                                   def_value="/iam/keycloak:logout")
+                                                   def_value="/iam/ijud:logout")
 KEYCLOAK_ENDPOINT_TOKEN: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_ENDPOINT_TOKEN",
-                                                  def_value="/iam/keycloak:get-token")
+                                                  def_value="/iam/ijud:get-token")
 
 KEYCLOAK_PUBLIC_KEY_LIFETIME: Final[int] = env_get_int(key=f"{APP_PREFIX}_KEYCLOAK_PUBLIC_KEY_LIFETIME",
                                                        def_value=86400)  # 24 hours
 KEYCLOAK_REALM: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_REALM")
+KEYCLOAK_RECIPIENT_ATTR: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_RECIPIENT_ATTR",
+                                                  def_value="preferred_username")
 KEYCLOAK_URL_AUTH_BASE: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_URL_AUTH_BASE")
 
 
@@ -33,11 +38,13 @@ def keycloak_setup(flask_app: Flask,
                    client_secret: str = KEYCLOAK_CLIENT_SECRET,
                    client_timeout: int = KEYCLOAK_CLIENT_TIMEOUT,
                    public_key_lifetime: int = KEYCLOAK_PUBLIC_KEY_LIFETIME,
+                   recipient_attribute: str = KEYCLOAK_RECIPIENT_ATTR,
                    realm: str = KEYCLOAK_REALM,
                    callback_endpoint: str = KEYCLOAK_ENDPOINT_CALLBACK,
-                   token_endpoint: str = KEYCLOAK_ENDPOINT_TOKEN,
+                   exchange_endpoint: str = KEYCLOAK_ENDPOINT_EXCHANGE,
                    login_endpoint: str = KEYCLOAK_ENDPOINT_LOGIN,
                    logout_endpoint: str = KEYCLOAK_ENDPOINT_LOGOUT,
+                   token_endpoint: str = KEYCLOAK_ENDPOINT_TOKEN,
                    base_url: str = KEYCLOAK_URL_AUTH_BASE,
                    logger: Logger = None) -> None:
     """
@@ -50,25 +57,30 @@ def keycloak_setup(flask_app: Flask,
     :param client_secret: the client's password with JusBR
     :param client_timeout: timeout for login authentication (in seconds,defaults to no timeout)
     :param public_key_lifetime: how long to use Keycloak's public key, before refreshing it (in seconds)
+    :param recipient_attribute: attribute in the token's payload holding the token's subject
     :param realm: the Keycloak realm
-    :param callback_endpoint: endpoint for the callback from JusBR
-    :param token_endpoint: endpoint for retrieving the JusBR authentication token
-    :param login_endpoint: endpoint for redirecting user to JusBR login page
-    :param logout_endpoint: endpoint for terminating user access to JusBR
-    :param base_url: base URL to request the JusBR services
+    :param callback_endpoint: endpoint for the callback from the front end
+    :param exchange_endpoint: endpoint fro requesting token exchange
+    :param token_endpoint: endpoint for retrieving Keycloak's authentication token
+    :param login_endpoint: endpoint for redirecting user to Keycloak's login page
+    :param logout_endpoint: endpoint for terminating user access to Keycloak
+    :param base_url: base URL to request Keycloak services
     :param logger: optional logger
     """
-    from .iam_pomes import service_login, service_logout, service_callback, service_token
+    from .iam_services import (
+        service_login, service_logout, service_callback, service_exchange, service_token
+    )
 
     # configure the Keycloak registry
     cache: Cache = FIFOCache(maxsize=1048576)
     cache["users"] = {}
-    IAM_SERVERS[IamServer.IAM_KEYCLOAK] = {
+    _IAM_SERVERS[IamServer.IAM_KEYCLOAK] = {
         "client-id": client_id,
         "client-secret": client_secret,
         "client-timeout": client_timeout,
+        "recipient-attr": recipient_attribute,
         "base-url": f"{base_url}/realms/{realm}",
-        "pk-expiration": int(datetime.now(tz=TZ_LOCAL).timestamp()),
+        "pk-expiration": sys.maxsize,
         "pk-lifetime": public_key_lifetime,
         "cache": cache,
         "logger": logger,
@@ -90,12 +102,17 @@ def keycloak_setup(flask_app: Flask,
         flask_app.add_url_rule(rule=callback_endpoint,
                                endpoint="keycloak-callback",
                                view_func=service_callback,
-                               methods=["POST"])
+                               methods=["GET"])
     if token_endpoint:
         flask_app.add_url_rule(rule=token_endpoint,
                                endpoint="keycloak-token",
                                view_func=service_token,
                                methods=["GET"])
+    if exchange_endpoint:
+        flask_app.add_url_rule(rule=exchange_endpoint,
+                               endpoint="keycloak-exchange",
+                               view_func=service_exchange,
+                               methods=["POST"])
 
 
 def keycloak_get_token(user_id: str,
@@ -111,7 +128,7 @@ def keycloak_get_token(user_id: str,
     """
     # retrieve the token
     args: dict[str, Any] = {"user-id": user_id}
-    return _service_token(registry=IAM_SERVERS[IamServer.IAM_KEYCLOAK],
-                          args=args,
-                          errors=errors,
-                          logger=logger)
+    return user_token(iam_server=IamServer.IAM_KEYCLOAK,
+                      args=args,
+                      errors=errors,
+                      logger=logger)

pypomes_iam/token_pomes.py

@@ -9,6 +9,8 @@ from typing import Any
 
 def token_validate(token: str,
                    issuer: str = None,
+                   recipient_id: str = None,
+                   recipient_attr: str = None,
                    public_key: str | bytes | PyJWK | RSAPublicKey = None,
                    errors: list[str] = None,
                    logger: Logger = None) -> dict[str, dict[str, Any]] | None:
@@ -24,12 +26,18 @@ def token_validate(token: str,
     If an asymmetric algorithm was used to sign the token and *public_key* is provided, then
     the token is validated, by using the data in its *signature* section.
 
+    The parameters *recipient_id* and *recipient_attr* refer the token's expected subject, respectively,
+    the subject's identification and the attribute in the token's payload data identifying its subject.
+    If both are provided, *recipient_id* is validated.
+
     On failure, *errors* will contain the reason(s) for rejecting *token*.
     On success, return the token's claims (*header* and *payload*).
 
     :param token: the token to be validated
     :param public_key: optional public key used to sign the token, in *PEM* format
     :param issuer: optional value to compare with the token's *iss* (issuer) attribute in its *payload*
+    :param recipient_id: identification of the expected token subject
+    :param recipient_attr: attribute in the token's payload holding the expected subject's identification
     :param errors: incidental error messages
     :param logger: optional logger
     :return: The token's claims (*header* and *payload*) if it is valid, *None* otherwise
@@ -87,10 +95,17 @@ def token_validate(token: str,
                                                  algorithms=[token_alg],
                                                  options=options,
                                                  issuer=issuer)
-            result = {
-                "header": token_header,
-                "payload": payload
-            }
+            if recipient_id and recipient_attr and \
+                    payload.get(recipient_attr) and recipient_id != payload.get(recipient_attr):
+                msg: str = f"Token was issued to '{payload.get(recipient_attr)}', not to '{recipient_id}'"
+                if logger:
+                    logger.error(msg=msg)
+                errors.append(msg)
+            else:
+                result = {
+                    "header": token_header,
+                    "payload": payload
+                }
         except Exception as e:
             exc_err: str = exc_format(exc=e,
                                       exc_info=sys.exc_info())

{pypomes_iam-0.3.0.dist-info → pypomes_iam-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypomes_iam
-Version: 0.3.0
+Version: 0.3.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

pypomes_iam-0.3.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+pypomes_iam/__init__.py,sha256=NB5ALh_kihQhfzl-7x_od4icrRBuSmYCSG5QSJujkuo,887
+pypomes_iam/iam_common.py,sha256=IWH9DVykF7K-Z9Sn3oP7To9_I2TkO2AzjVod238zUWc,13645
+pypomes_iam/iam_pomes.py,sha256=MqPcz39u5yBFGCnDBA8zFLMRZQyH6U4iZvG0q0XL0h8,15216
+pypomes_iam/iam_services.py,sha256=4NQR5agj5zNnFymldHaTURGYDEHMkK0nX8PqkAldFXQ,8221
+pypomes_iam/jusbr_pomes.py,sha256=M47h_PUUgbCmFQyKz2sN1H9T00BC5v_oPgwl5ATWMSA,5625
+pypomes_iam/keycloak_pomes.py,sha256=GtXJb4TZb-a_5b9ExYdJGetBcU1pEP96ONO6prA_vDo,6638
+pypomes_iam/provider_pomes.py,sha256=eP8XzjTUEpwejTkO0wmDiqKjqbIEOzRNCR2ju5E15og,5856
+pypomes_iam/token_pomes.py,sha256=cfHdv2qYbsciY-3aEuDYUwCM479uMRSm2uwr4-hCaBQ,5345
+pypomes_iam-0.3.2.dist-info/METADATA,sha256=8E8b97RrTn4eLYueJum1UugCVC-230nEoWBOQK2QkyM,694
+pypomes_iam-0.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pypomes_iam-0.3.2.dist-info/licenses/LICENSE,sha256=YvUELgV8qvXlaYsy9hXG5EW3Bmsrkw-OJmmILZnonAc,1086
+pypomes_iam-0.3.2.dist-info/RECORD,,

pypomes_iam-0.3.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-pypomes_iam/__init__.py,sha256=u-gNGbsayMf-2SWTB8VcoTCADoczZuwNEH50BPxTZZ8,682
-pypomes_iam/iam_common.py,sha256=_3Fx8kAJCthRTvQtlZg1gx0hWlUn4ko_ASROwsU9dJM,17017
-pypomes_iam/iam_pomes.py,sha256=O1acRMyisiZuB9rIkSboxwzGoLU_1hq_gNrg39CE9NQ,7835
-pypomes_iam/jusbr_pomes.py,sha256=Zh4nbKiBD2c4slYxgXoricCSScI8SROQproFfZ_55BI,5322
-pypomes_iam/keycloak_pomes.py,sha256=zVoLG0yNKGW1CP1bCf3yQiFw-8ZtOG7YG3VGZDq9_3c,5681
-pypomes_iam/provider_pomes.py,sha256=eP8XzjTUEpwejTkO0wmDiqKjqbIEOzRNCR2ju5E15og,5856
-pypomes_iam/token_pomes.py,sha256=OSllw00XnU-sE9EKXo8jZAto0zfFLBi83dvllLs-Sc0,4402
-pypomes_iam-0.3.0.dist-info/METADATA,sha256=-hmCE_h6DbGx97J44czCa2OD2wh4gXQkQ8HQzDmy6E0,694
-pypomes_iam-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pypomes_iam-0.3.0.dist-info/licenses/LICENSE,sha256=YvUELgV8qvXlaYsy9hXG5EW3Bmsrkw-OJmmILZnonAc,1086
-pypomes_iam-0.3.0.dist-info/RECORD,,