pypomes-iam 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

pypomes_iam/iam_services.py

@@ -3,8 +3,14 @@ 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
+from .iam_common import (
+    IamServer, _iam_lock,
+    _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_ENDPOINT_LOGIN
@@ -28,19 +34,20 @@ def service_login() -> Response:
         # 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)
+    with _iam_lock:
+        # retrieve the IAM server
+        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))
@@ -74,17 +81,18 @@ def service_logout() -> Response:
         # 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)
+    with _iam_lock:
+        # retrieve the IAM server
+        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
@@ -106,10 +114,11 @@ 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.
+    This callback is invoked from a front-end application after a successful login at the
+    *IAM* server's login page, forwarding the data received. In a typical OAuth2 flow faction,
+    this data is then used to effectively obtain the token from the *IAM* server.
 
-    :return: the response containing the token, or *BAD REQUEST*
+    :return: the *Response* containing the reference user identification and the token, or *BAD REQUEST*
     """
     # retrieve the operations's logger
     logger: Logger = _get_logger()
@@ -117,18 +126,19 @@ def service_callback() -> Response:
         # 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)
+    with _iam_lock:
+        # retrieve the IAM server
+        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)})
@@ -136,10 +146,8 @@ def service_callback() -> Response:
         if logger:
             logger.error(msg=json.dumps(obj=result))
     else:
-        result = jsonify({
-            "user-id": token_data[0],
-            "access-token": token_data[1]})
-
+        result = jsonify({"user-id": token_data[0],
+                          "access-token": token_data[1]})
     # log the response
     if logger:
         logger.debug(msg=f"Response {result}")
@@ -148,14 +156,14 @@ def service_callback() -> Response:
 
 
 # @flask_app.route(rule=<token_endpoint>,  # JUSBR_ENDPOINT_TOKEN
-# @flask_app.route(rule=<token_endpoint>,  # KEYCLOAK_ENDPOINT_TOKEN
 #                  methods=["GET"])
+# @flask_app.route(rule=<token_endpoint>,  # KEYCLOAK_ENDPOINT_TOKEN
 #                  methods=["GET"])
 def service_token() -> Response:
     """
-    Entry point for retrieving token from the *IAM* server.
+    Entry point for retrieving a token from the *IAM* server.
 
-    :return: the response containing the token, or *UNAUTHORIZED*
+    :return: the *Response* containing the user reference identification and the token, or *BAD REQUEST*
     """
     # retrieve the operations's logger
     logger: Logger = _get_logger()
@@ -163,26 +171,38 @@ def service_token() -> Response:
         # log the request
         logger.debug(msg=_log_init(request=request))
 
-    # retrieve the IAM server
+    # obtain the user's identification
+    args: dict[str, Any] = request.args
+    user_id: str = args.get("user-id") or args.get("user_id") or args.get("login")
+
     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)
+    if user_id:
+        with _iam_lock:
+            # retrieve the IAM server
+            iam_server: IamServer = _get_iam_server(endpoint=request.endpoint,
+                                                    errors=errors,
+                                                    logger=logger)
+            if iam_server:
+                # retrieve the token
+                errors: list[str] = []
+                token: str = user_token(iam_server=iam_server,
+                                        args=args,
+                                        errors=errors,
+                                        logger=logger)
+    else:
+        msg: str = "User identification not provided"
+        errors.append(msg)
+        if logger:
+            logger.error(msg=msg)
+
     result: Response
     if errors:
         result = Response("; ".join(errors))
         result.status_code = 400
     else:
-        result = jsonify({"token": token})
-
+        result = jsonify({"user-id": user_id,
+                          "token": token})
     # log the response
     if logger:
         logger.debug(msg=f"Response {result}")
@@ -196,26 +216,45 @@ def service_exchange() -> Response:
     """
     Entry point for requesting the *IAM* server to exchange the token.
 
-    This is currently limit to the *Keycloak* server
+    This is currently limited to the *KEYCLOAK* server. The token itself is stored in *KEYCLOAK*'s registry.
+    The expected parameters in the request are:
+        - client-id: identification for the reference user (aliases: 'client_id', 'login')
+        - token: the token to be exchanged
+
+    If the exchange is successful, the token data is stored in the *IAM* server's registry, and returned.
+    Otherwise, *errors* will contain the appropriate error message.
+
+    The typical *Response* 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>
+        }
 
-    :return: the response containing the token, or *UNAUTHORIZED*
+    :return: the *Response* containing the token data, 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 (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)
+    with _iam_lock:
+        # retrieve the IAM server (currently, only 'IAM_KEYCLOAK' is supported)
+        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))

pypomes_iam/jusbr_pomes.py

@@ -7,7 +7,7 @@ from pypomes_core import (
 )
 from typing import Any, Final
 
-from .iam_common import _IAM_SERVERS, IamServer
+from .iam_common import _IAM_SERVERS, IamServer, _iam_lock
 from .iam_pomes import user_token
 
 JUSBR_CLIENT_ID: Final[str] = env_get_str(key=f"{APP_PREFIX}_JUSBR_CLIENT_ID")
@@ -65,18 +65,19 @@ def jusbr_setup(flask_app: Flask,
     # configure the JusBR registry
     cache: Cache = FIFOCache(maxsize=1048576)
     cache["users"] = {}
-    _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": sys.maxsize,
-        "pk-lifetime": public_key_lifetime,
-        "cache": cache,
-        "logger": logger,
-        "redirect-uri": None
-    }
+    with _iam_lock:
+        _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": sys.maxsize,
+            "pk-lifetime": public_key_lifetime,
+            "cache": cache,
+            "logger": logger,
+            "redirect-uri": None
+        }
 
     # establish the endpoints
     if login_endpoint:
@@ -112,9 +113,14 @@ def jusbr_get_token(user_id: str,
     :param logger: optional logger
     :return: the uthentication tokem
     """
+    # declare the return variable
+    result: str
+
     # retrieve the token
     args: dict[str, Any] = {"user-id": user_id}
-    return user_token(iam_server=IamServer.IAM_JUSRBR,
-                      args=args,
-                      errors=errors,
-                      logger=logger)
+    with _iam_lock:
+        result = user_token(iam_server=IamServer.IAM_JUSRBR,
+                            args=args,
+                            errors=errors,
+                            logger=logger)
+    return result

pypomes_iam/keycloak_pomes.py

@@ -7,7 +7,7 @@ from pypomes_core import (
 )
 from typing import Any, Final
 
-from .iam_common import _IAM_SERVERS, IamServer
+from .iam_common import _IAM_SERVERS, IamServer, _iam_lock
 from .iam_pomes import user_token
 
 KEYCLOAK_CLIENT_ID: Final[str] = env_get_str(key=f"{APP_PREFIX}_KEYCLOAK_CLIENT_ID")
@@ -74,18 +74,19 @@ def keycloak_setup(flask_app: Flask,
     # configure the Keycloak registry
     cache: Cache = FIFOCache(maxsize=1048576)
     cache["users"] = {}
-    _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": sys.maxsize,
-        "pk-lifetime": public_key_lifetime,
-        "cache": cache,
-        "logger": logger,
-        "redirect-uri": None
-    }
+    with _iam_lock:
+        _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": sys.maxsize,
+            "pk-lifetime": public_key_lifetime,
+            "cache": cache,
+            "logger": logger,
+            "redirect-uri": None
+        }
 
     # establish the endpoints
     if login_endpoint:
@@ -126,9 +127,14 @@ def keycloak_get_token(user_id: str,
     :param logger: optional logger
     :return: the uthentication tokem
     """
+    # declare the return variable
+    result: str
+
     # retrieve the token
     args: dict[str, Any] = {"user-id": user_id}
-    return user_token(iam_server=IamServer.IAM_KEYCLOAK,
-                      args=args,
-                      errors=errors,
-                      logger=logger)
+    with _iam_lock:
+        result = user_token(iam_server=IamServer.IAM_KEYCLOAK,
+                            args=args,
+                            errors=errors,
+                            logger=logger)
+    return result

pypomes_iam/provider_pomes.py

@@ -4,7 +4,8 @@ from base64 import b64encode
 from datetime import datetime
 from logging import Logger
 from pypomes_core import TZ_LOCAL, exc_format
-from typing import Any
+from threading import Lock
+from typing import Any, Final
 
 # structure:
 # {
@@ -19,7 +20,11 @@ from typing import Any
 #      "expiration": <timestamp>
 #    }
 # }
-_provider_registry: dict[str, dict[str, Any]] = {}
+_provider_registry: Final[dict[str, dict[str, Any]]] = {}
+
+# the lock protecting the data in '_provider_registry'
+# (because it is 'Final' and set at declaration time, it can be accessed through simple imports)
+_provider_lock: Final[Lock] = Lock()
 
 
 def provider_register(provider_id: str,
@@ -48,18 +53,19 @@ def provider_register(provider_id: str,
     :param headers_data: optional key-value pairs to be added to the request headers
     :param body_data: optional key-value pairs to be added to the request body
     """
-    global _provider_registry  # noqa: PLW0602
+    global _provider_registry
 
-    _provider_registry[provider_id] = {
-        "url": auth_url,
-        "user": auth_user,
-        "pwd": auth_pwd,
-        "custom-auth": custom_auth,
-        "headers-data": headers_data,
-        "body-data": body_data,
-        "token": None,
-        "expiration": datetime.now(tz=TZ_LOCAL).timestamp()
-    }
+    with _provider_lock:
+        _provider_registry[provider_id] = {
+            "url": auth_url,
+            "user": auth_user,
+            "pwd": auth_pwd,
+            "custom-auth": custom_auth,
+            "headers-data": headers_data,
+            "body-data": body_data,
+            "token": None,
+            "expiration": datetime.now(tz=TZ_LOCAL).timestamp()
+        }
 
 
 def provider_get_token(provider_id: str,
@@ -78,53 +84,54 @@ def provider_get_token(provider_id: str,
     result: str | None = None
 
     err_msg: str | None = None
-    provider: dict[str, Any] = _provider_registry.get(provider_id)
-    if provider:
-        now: float = datetime.now(tz=TZ_LOCAL).timestamp()
-        if now > provider.get("expiration"):
-            user: str = provider.get("user")
-            pwd: str = provider.get("pwd")
-            headers_data: dict[str, str] = provider.get("headers-data") or {}
-            body_data: dict[str, str] = provider.get("body-data") or {}
-            custom_auth: tuple[str, str] = provider.get("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()}"
-            url: str = provider.get("url")
-            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 '{url}': failed, "
-                               f"status {response.status_code}, reason '{response.reason}'")
+    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("expiration"):
+                user: str = provider.get("user")
+                pwd: str = provider.get("pwd")
+                headers_data: dict[str, str] = provider.get("headers-data") or {}
+                body_data: dict[str, str] = provider.get("body-data") or {}
+                custom_auth: tuple[str, str] = provider.get("custom-auth")
+                if custom_auth:
+                    body_data[custom_auth[0]] = user
+                    body_data[custom_auth[1]] = pwd
                 else:
-                    reply: dict[str, Any] = response.json()
-                    provider["token"] = reply.get("access_token")
-                    provider["expiration"] = now + int(reply.get("expires_in"))
-                    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 '{url}': error, '{err_msg}'"
-    else:
-        err_msg: str = f"Provider '{provider_id}' not registered"
+                    enc_bytes: bytes = b64encode(f"{user}:{pwd}".encode())
+                    headers_data["Authorization"] = f"Basic {enc_bytes.decode()}"
+                url: str = provider.get("url")
+                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 '{url}': failed, "
+                                   f"status {response.status_code}, reason '{response.reason}'")
+                    else:
+                        reply: dict[str, Any] = response.json()
+                        provider["token"] = reply.get("access_token")
+                        provider["expiration"] = now + int(reply.get("expires_in"))
+                        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 '{url}': error, '{err_msg}'"
+        else:
+            err_msg: str = f"Provider '{provider_id}' not registered"
 
     if err_msg:
         if isinstance(errors, list):

pypomes_iam/token_pomes.py

@@ -40,7 +40,7 @@ def token_validate(token: str,
     :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
+    :return: The token's claims (*header* and *payload*), or *None* if error
     """
     # initialize the return variable
     result: dict[str, dict[str, Any]] | None = None

{pypomes_iam-0.3.4.dist-info → pypomes_iam-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypomes_iam
-Version: 0.3.4
+Version: 0.3.6
 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.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+pypomes_iam/__init__.py,sha256=H7rUCaUEJBLNJv2rtdmBxwcAB28OItdEPenpv_UEOVw,965
+pypomes_iam/iam_common.py,sha256=f74FUDcnMM2cgzJg-AF17GwCKwbfoezS8LppwxYwPys,10049
+pypomes_iam/iam_pomes.py,sha256=gvDpgff6arB4_Y8AAf6QH2CEWRmdy-kcnQLyD0hx4Y4,23966
+pypomes_iam/iam_services.py,sha256=Ae_hLz5luRjK-l_rhBcuuY03Ov7n7o67UYgBb5rbBys,10002
+pypomes_iam/jusbr_pomes.py,sha256=0qbjJ6EGnlx17K-4Lqh5XkfH58y0joVZiD6HykbwpoE,5823
+pypomes_iam/keycloak_pomes.py,sha256=5ZfpncofF20C1IB5ndO31vfrvfa8Ffy7FJxkGoKKoQQ,6836
+pypomes_iam/provider_pomes.py,sha256=3Rui68hmj8zwY0tnw4aWurz-yQ-niacJFQpi6nWzh-M,6355
+pypomes_iam/token_pomes.py,sha256=1g6PMNNMbmdwLrsvSXvpO8-zdRhso1IFnwAyndNmV4Q,5332
+pypomes_iam-0.3.6.dist-info/METADATA,sha256=q53TFkBnU4mUAZgsJ_r_730kASXLiIyCwW_5mkFz8TU,694
+pypomes_iam-0.3.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pypomes_iam-0.3.6.dist-info/licenses/LICENSE,sha256=YvUELgV8qvXlaYsy9hXG5EW3Bmsrkw-OJmmILZnonAc,1086
+pypomes_iam-0.3.6.dist-info/RECORD,,

pypomes_iam-0.3.4.dist-info/RECORD

@@ -1,12 +0,0 @@
-pypomes_iam/__init__.py,sha256=H7rUCaUEJBLNJv2rtdmBxwcAB28OItdEPenpv_UEOVw,965
-pypomes_iam/iam_common.py,sha256=IWH9DVykF7K-Z9Sn3oP7To9_I2TkO2AzjVod238zUWc,13645
-pypomes_iam/iam_pomes.py,sha256=g06NSz3r1qv4LzDpjQ9iozdVyabidt7qLEocQRv1yns,15230
-pypomes_iam/iam_services.py,sha256=osqDptxCqL9eZPCRecBwtlS35YiMRvO7EIgdcyovSU4,8182
-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.4.dist-info/METADATA,sha256=wt98InTB4_MY_-JQHDs9ZTZ1hb2T5MbJtAkduCUopNo,694
-pypomes_iam-0.3.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pypomes_iam-0.3.4.dist-info/licenses/LICENSE,sha256=YvUELgV8qvXlaYsy9hXG5EW3Bmsrkw-OJmmILZnonAc,1086
-pypomes_iam-0.3.4.dist-info/RECORD,,