mainsequence 9.0.8.dev44__py3-none-any.whl → 9.0.8.dev45__py3-none-any.whl

mainsequence/cli/config.py

@@ -29,6 +29,7 @@ from keyring import core as keyring_core
 from keyring import errors as keyring_errors
 
 from mainsequence.defaults import CANONICAL_BACKEND_ENV, STANDARD_BACKEND_URL
+from mainsequence.runtime_credential_exchange import runtime_credential_configured
 
 APP_NAME = "MainSequenceCLI"
 
@@ -804,13 +805,8 @@ def session_report() -> dict:
     refresh_expires_at = token_expiry(refresh)
 
     if auth_mode == "runtime_credential":
-        authenticated = bool(
-            access
-            or (
-                (os.environ.get("MAINSEQUENCE_RUNTIME_CREDENTIAL_ID") or "").strip()
-                and (os.environ.get("MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET") or "").strip()
-            )
-        )
+        # The credential is an ID with a bootstrap secret or an identity token file.
+        authenticated = bool(access or runtime_credential_configured())
         session_expires_at = None
     elif refresh:
         authenticated = refresh_expires_at is None or refresh_expires_at > now

mainsequence/client/utils.py

@@ -21,6 +21,14 @@ from requests.structures import CaseInsensitiveDict
 
 from mainsequence.defaults import resolve_backend_endpoint
 from mainsequence.logconf import logger
+from mainsequence.runtime_credential_exchange import (
+    RUNTIME_CREDENTIAL_ID_ENV,
+    RUNTIME_CREDENTIAL_SECRET_ENV,
+    RUNTIME_IDENTITY_TOKEN_FILE_ENV,
+    RuntimeIdentityTokenError,
+    exchange_runtime_credential,
+    identity_token_file_from_environment,
+)
 
 from ._transport import DEFAULT_ALLOWED_METHODS as DEFAULT_ALLOWED_METHODS
 from ._transport import DEFAULT_STATUS_FORCELIST as DEFAULT_STATUS_FORCELIST
@@ -309,6 +317,17 @@ class SessionJWTAuthProvider(BaseAuthProvider):
 
 @dataclass
 class RuntimeCredentialAuthProvider(BaseAuthProvider):
+    """
+    Exchange the runtime credential the platform injected for short-lived access tokens.
+
+    The proof is the projected workload identity token when
+    `MAINSEQUENCE_RUNTIME_IDENTITY_TOKEN_FILE` is set: the file is read for every
+    exchange, and `MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET` is never read or sent.
+    Otherwise the proof is that bootstrap secret. The token is never kept on the
+    provider. Throttled (`429`) and temporarily unavailable (`503`) exchanges are
+    retried within the timeout budget; a rejected one (`401`) fails at once.
+    """
+
     credential_id: str | None = None
     credential_secret: str | None = None
     token_url: str | None = None
@@ -316,13 +335,18 @@ class RuntimeCredentialAuthProvider(BaseAuthProvider):
     refresh_skew_seconds: int = 30
     timeout: tuple[float, float] = DEFAULT_TIMEOUT
     expires_at: float | None = None
+    identity_token_file: str | None = None
     _lock: threading.RLock = field(default_factory=threading.RLock, init=False, repr=False)
 
     def __post_init__(self):
         if self.credential_id is None:
-            self.credential_id = os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_ID")
-        if self.credential_secret is None:
-            self.credential_secret = os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET")
+            self.credential_id = os.getenv(RUNTIME_CREDENTIAL_ID_ENV)
+        if self.identity_token_file is None:
+            self.identity_token_file = identity_token_file_from_environment()
+        else:
+            self.identity_token_file = str(self.identity_token_file).strip() or None
+        if self.credential_secret is None and not self.identity_token_file:
+            self.credential_secret = os.getenv(RUNTIME_CREDENTIAL_SECRET_ENV)
         if not self.token_url:
             self.token_url = f"{API_ENDPOINT}/runtime-credentials/token/"
 
@@ -344,20 +368,48 @@ class RuntimeCredentialAuthProvider(BaseAuthProvider):
 
         return exp <= int(time.time()) + self.refresh_skew_seconds
 
-    def _require_credentials(self) -> tuple[str, str]:
+    @staticmethod
+    def _log_exchange_retry(status: int, delay: float) -> None:
+        logger.warning(f"Runtime credential exchange returned {status}; retrying in {delay:.1f} s.")
+
+    def _exchange(self) -> requests.Response:
         credential_id = (self.credential_id or "").strip()
-        credential_secret = (self.credential_secret or "").strip()
+        identity_token_file = self.identity_token_file
+        credential_secret = None if identity_token_file else (self.credential_secret or "").strip()
         if not credential_id:
             raise AuthError(
                 "MAINSEQUENCE_RUNTIME_CREDENTIAL_ID is required when "
                 "MAINSEQUENCE_AUTH_MODE=runtime_credential."
             )
-        if not credential_secret:
+        if not identity_token_file and not credential_secret:
             raise AuthError(
                 "MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET is required when "
-                "MAINSEQUENCE_AUTH_MODE=runtime_credential."
+                "MAINSEQUENCE_AUTH_MODE=runtime_credential and "
+                f"{RUNTIME_IDENTITY_TOKEN_FILE_ENV} is not set."
             )
-        return credential_id, credential_secret
+        try:
+            # One budget for every attempt and wait, inside the caller's budget if any.
+            with request_budget(self.timeout) as budget:
+
+                def post(body: dict[str, str]) -> requests.Response:
+                    return requests.post(
+                        self.token_url,
+                        json=body,
+                        headers={"Content-Type": "application/json"},
+                        timeout=budget.timeout(),
+                        allow_redirects=False,
+                    )
+
+                return exchange_runtime_credential(
+                    post,
+                    credential_id=credential_id,
+                    credential_secret=credential_secret,
+                    identity_token_file=identity_token_file,
+                    deadline=budget.deadline,
+                    on_retry=self._log_exchange_retry,
+                )
+        except RuntimeIdentityTokenError as exc:
+            raise AuthError(str(exc)) from None
 
     def refresh(
         self,
@@ -370,17 +422,7 @@ class RuntimeCredentialAuthProvider(BaseAuthProvider):
             if not force and not self._needs_exchange():
                 return
 
-            credential_id, credential_secret = self._require_credentials()
-            response = requests.post(
-                self.token_url,
-                json={
-                    "credential_id": credential_id,
-                    "credential_secret": credential_secret,
-                },
-                headers={"Content-Type": "application/json"},
-                timeout=remaining_timeout(self.timeout),
-                allow_redirects=False,
-            )
+            response = self._exchange()
             if response.status_code < 200 or response.status_code >= 300:
                 raise AuthError(
                     f"Runtime credential exchange failed with status {response.status_code}."

mainsequence/code_repository_context.py

@@ -10,6 +10,8 @@ from dataclasses import dataclass, replace
 from typing import Any, Literal
 from urllib.parse import urlsplit
 
+from mainsequence.runtime_credential_exchange import runtime_credential_configured
+
 CodeRepositoryContextStatus = Literal[
     "resolved",
     "code_repository_branch_not_registered",
@@ -204,9 +206,7 @@ def _exchange_authenticated_runtime_context_if_configured() -> None:
         return
     if (os.getenv("MAINSEQUENCE_AUTH_MODE") or "").strip().lower() != "runtime_credential":
         return
-    if not (os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_ID") or "").strip():
-        return
-    if not (os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET") or "").strip():
+    if not runtime_credential_configured():
         return
 
     from mainsequence.client.utils import AuthError, loaders

mainsequence/logconf.py

@@ -5,6 +5,7 @@ import logging
 import logging.config
 import os
 import sys
+import time
 import traceback
 from collections.abc import Mapping
 from importlib.metadata import PackageNotFoundError
@@ -22,6 +23,13 @@ from structlog.stdlib import BoundLogger
 from .defaults import resolve_backend_endpoint
 from .instrumentation import OTelJSONRenderer
 from .repository_identity_security import UNSUPPORTED_SOURCE_IDENTITY_ENV_NAMES
+from .runtime_credential_exchange import (
+    RUNTIME_CREDENTIAL_ID_ENV,
+    RUNTIME_CREDENTIAL_SECRET_ENV,
+    exchange_runtime_credential,
+    identity_token_file_from_environment,
+    runtime_credential_configured,
+)
 from .runtime_flags import is_running_in_pod
 
 logger = None
@@ -94,20 +102,31 @@ def _request_job_startup_state(*, timeout_s: float = 10.0) -> dict[str, Any]:
         return headers, False
 
     def _exchange_runtime_credential() -> bool:
-        credential_id = (os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_ID") or "").strip()
-        credential_secret = (os.getenv("MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET") or "").strip()
-        if not credential_id or not credential_secret:
+        if not runtime_credential_configured():
             return False
+        identity_token_file = identity_token_file_from_environment()
+        token_url = f"{_backend_base_url()}/api/v1/runtime-credentials/token/"
 
-        try:
-            token_resp = requests.post(
-                f"{_backend_base_url()}/api/v1/runtime-credentials/token/",
+        def _post(body: dict[str, str]) -> requests.Response:
+            return requests.post(
+                token_url,
                 headers={"Content-Type": "application/json"},
-                json={
-                    "credential_id": credential_id,
-                    "credential_secret": credential_secret,
-                },
+                json=body,
                 timeout=timeout_s,
+                allow_redirects=False,
+            )
+
+        try:
+            token_resp = exchange_runtime_credential(
+                _post,
+                credential_id=(os.getenv(RUNTIME_CREDENTIAL_ID_ENV) or "").strip(),
+                credential_secret=(
+                    None
+                    if identity_token_file
+                    else (os.getenv(RUNTIME_CREDENTIAL_SECRET_ENV) or "").strip()
+                ),
+                identity_token_file=identity_token_file,
+                deadline=time.monotonic() + timeout_s,
             )
         except Exception:
             return False

mainsequence/runtime_credential_exchange.py

@@ -0,0 +1,168 @@
+"""
+The runtime credential exchange, shared by the auth provider and the logger.
+
+A runtime started with ``MAINSEQUENCE_AUTH_MODE=runtime_credential`` exchanges its
+credential at ``POST /api/v1/runtime-credentials/token/`` for a short-lived access
+token. The request carries ``credential_id`` and exactly one proof:
+
+* ``workload_identity_token`` when ``MAINSEQUENCE_RUNTIME_IDENTITY_TOKEN_FILE`` is
+  set: the projected token read from that file for every exchange, because the
+  file is rotated. The bootstrap secret is then never read or sent, and a missing,
+  unreadable or empty file is an error, never a fallback to the secret.
+* ``credential_secret`` otherwise: ``MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET``.
+
+The token exists only inside one exchange request. It is not kept on any object,
+written to the environment or a file, logged, or included in an error message.
+
+The logger exchanges a runtime credential while it is being configured, so this
+module imports nothing from the SDK.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from collections.abc import Callable
+from typing import Any
+
+from urllib3.exceptions import InvalidHeader
+from urllib3.util import Retry
+
+RUNTIME_CREDENTIAL_ID_ENV = "MAINSEQUENCE_RUNTIME_CREDENTIAL_ID"
+RUNTIME_CREDENTIAL_SECRET_ENV = "MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET"
+RUNTIME_IDENTITY_TOKEN_FILE_ENV = "MAINSEQUENCE_RUNTIME_IDENTITY_TOKEN_FILE"
+
+# 429: the exchange is throttled. 503: verification is temporarily unavailable.
+# Neither exchanged anything, so the same request may be sent again.
+RETRYABLE_EXCHANGE_STATUSES = frozenset({429, 503})
+EXCHANGE_RETRIES = 3
+EXCHANGE_BACKOFF_FACTOR = 0.5
+
+_RETRY_AFTER = Retry(total=0)
+
+
+class RuntimeIdentityTokenError(Exception):
+    """The runtime identity token file cannot be used. The message never holds its content."""
+
+
+def _environment_value(name: str) -> str:
+    return (os.getenv(name) or "").strip()
+
+
+def identity_token_file_from_environment() -> str | None:
+    """Return the path in ``MAINSEQUENCE_RUNTIME_IDENTITY_TOKEN_FILE``, or None when unset."""
+    return _environment_value(RUNTIME_IDENTITY_TOKEN_FILE_ENV) or None
+
+
+def runtime_credential_configured() -> bool:
+    """
+    Say whether the environment holds a runtime credential to exchange.
+
+    That is a credential ID and one proof: the identity token file, or else the
+    bootstrap secret. Only the presence of the setting is checked. The token file
+    is read by the exchange itself, which reports a missing or empty file.
+    """
+    if not _environment_value(RUNTIME_CREDENTIAL_ID_ENV):
+        return False
+    if identity_token_file_from_environment():
+        return True
+    return bool(_environment_value(RUNTIME_CREDENTIAL_SECRET_ENV))
+
+
+def _read_identity_token(path: str) -> str:
+    source = f"The runtime identity token file {path} ({RUNTIME_IDENTITY_TOKEN_FILE_ENV})"
+    try:
+        with open(path, "rb") as token_file:
+            raw = token_file.read()
+    except FileNotFoundError:
+        raise RuntimeIdentityTokenError(f"{source} does not exist.") from None
+    except OSError as exc:
+        raise RuntimeIdentityTokenError(
+            f"{source} could not be read ({type(exc).__name__})."
+        ) from None
+    try:
+        token = raw.decode("utf-8").strip()
+    except UnicodeDecodeError:
+        # Raised below, outside this handler: the decode error holds the bytes.
+        token = None
+    if token is None:
+        raise RuntimeIdentityTokenError(f"{source} does not hold a token.")
+    if not token:
+        raise RuntimeIdentityTokenError(f"{source} is empty.")
+    return token
+
+
+def _request_body(
+    credential_id: str,
+    credential_secret: str | None,
+    identity_token_file: str | None,
+) -> dict[str, str]:
+    if identity_token_file:
+        return {
+            "credential_id": credential_id,
+            "workload_identity_token": _read_identity_token(identity_token_file),
+        }
+    return {"credential_id": credential_id, "credential_secret": credential_secret or ""}
+
+
+def _retry_delay(response: Any, attempt: int) -> float:
+    delay = min(EXCHANGE_BACKOFF_FACTOR * 2**attempt, Retry.DEFAULT_BACKOFF_MAX)
+    retry_after = (getattr(response, "headers", None) or {}).get("Retry-After")
+    if retry_after is not None:
+        try:
+            delay = max(delay, _RETRY_AFTER.parse_retry_after(str(retry_after)))
+        except InvalidHeader:
+            pass
+    return delay
+
+
+def exchange_runtime_credential(
+    send: Callable[[dict[str, str]], Any],
+    *,
+    credential_id: str,
+    credential_secret: str | None,
+    identity_token_file: str | None,
+    deadline: float,
+    on_retry: Callable[[int, float], None] | None = None,
+) -> Any:
+    """
+    Send one runtime credential exchange and return the last response.
+
+    Parameters
+    ----------
+    send:
+        Posts the JSON body it is given to the exchange route and returns the
+        response. It is called once per attempt.
+    credential_id:
+        The runtime credential ID.
+    credential_secret:
+        The bootstrap secret. Ignored when ``identity_token_file`` is set.
+    identity_token_file:
+        The projected token file. It is read again for every attempt.
+    deadline:
+        ``time.monotonic()`` value after which no retry starts.
+    on_retry:
+        Called with the status and the delay before each retry.
+
+    A ``429`` or ``503`` answer is retried up to ``EXCHANGE_RETRIES`` times. The
+    wait is the exponential backoff or the answer's ``Retry-After``, whichever is
+    longer; a wait that would not end before ``deadline`` ends the retries. Any
+    other answer, ``401`` included, is returned at once and the proof is never
+    switched. ``RuntimeIdentityTokenError`` is raised when the token file cannot
+    be used.
+    """
+    for attempt in range(EXCHANGE_RETRIES + 1):
+        response = send(_request_body(credential_id, credential_secret, identity_token_file))
+        status = response.status_code
+        if status not in RETRYABLE_EXCHANGE_STATUSES or attempt == EXCHANGE_RETRIES:
+            return response
+        delay = _retry_delay(response, attempt)
+        if delay >= deadline - time.monotonic():
+            return response
+        if on_retry is not None:
+            on_retry(status, delay)
+        close = getattr(response, "close", None)
+        if callable(close):
+            close()
+        time.sleep(delay)
+    raise AssertionError("Unreachable retry state")

{mainsequence-9.0.8.dev44.dist-info → mainsequence-9.0.8.dev45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 9.0.8.dev44
+Version: 9.0.8.dev45
 Summary: Main Sequence SDK
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence-9.0.8.dev44.dist-info → mainsequence-9.0.8.dev45.dist-info}/RECORD

@@ -12,11 +12,12 @@ mainsequence/__init__.py,sha256=70CbIo7ZG1mzi5uwkqDtVESunBE0RanHjeFg4ptfsA0,385
 mainsequence/__main__.py,sha256=KuAP69uduS2ImrPIgNMzbGBRepZzjqvUONu5vFh4v4A,176
 mainsequence/_request_identity.py,sha256=jiroPFVDM8vphEf9VXuggQJKUOGohfk7-pDwJSOILEw,1211
 mainsequence/bootstrap.py,sha256=AvG55Y46RcshVqJZsyqvUDN62CJg4CDbHu0Bvsbwfzs,2910
-mainsequence/code_repository_context.py,sha256=8Q1ammEJr0m8G8aMR4Mf6nLHMPe51sPr4m72PSwp3D4,28588
+mainsequence/code_repository_context.py,sha256=JRrWjwpnUy8I-OjSd9hHlrcq8-Ow3Zeh_N6cYvmtA3o,28545
 mainsequence/code_repository_skills.py,sha256=AyC1HFAxQXHXNBGbarVUJS2cHd4X5HwDx6u8XBophbE,23611
 mainsequence/defaults.py,sha256=5r6s7AI-X40rpm1D3IgcNsWam7iJg4_lIxB3F_1u2z0,408
-mainsequence/logconf.py,sha256=7OXSBb8yXrUbIbO4vX-l0vss1R8q1DlNi1-fBNkjX-w,18693
+mainsequence/logconf.py,sha256=RonnNIbUAP5IPdbYUHiuqBeWvRtHb5pj2YtWzHluEE4,19295
 mainsequence/repository_identity_security.py,sha256=Cdywndhiy1zJFUPh-FfM90RjZ3Hg3tjhxBr64FRhmXs,1035
+mainsequence/runtime_credential_exchange.py,sha256=US368h7_KKorqW9yeRtIhk_Du9xjs2XNgml21dEGcLk,6428
 mainsequence/runtime_flags.py,sha256=1eTM7VRRhnuZ_GXcmFhqAmdEKwyQYMyZcPsio88vJRQ,378
 mainsequence/scaffold_skills.py,sha256=k0V6eKC5AwbHr9wB9UGMJNF-8eJ0_1izF4-BU01KHrg,10606
 mainsequence/cli/__init__.py,sha256=sMWTnomCaISjnureLuXFRqOzkH2Y77uYEivsd-M6_8Y,28
@@ -24,7 +25,7 @@ mainsequence/cli/api.py,sha256=emn5UsIpQ0qvGLnW7MpNPYenQZjR4NJ6SGDKmLo6gHk,12740
 mainsequence/cli/browser_auth.py,sha256=C-Sbpt0Pr9Pv3Z9dO80TMk7zPcaaZ-4zvW0tbRVMrTU,9863
 mainsequence/cli/cli.py,sha256=zo3ptVxluTYAIeIAluGQPwgFY-_vr0SO3BthCGuVK-0,268962
 mainsequence/cli/code_repository_status.py,sha256=SHEnU8YSWFowPG6dEdE4Yd8CS1tIcJSE1MXFLfvD3Os,5975
-mainsequence/cli/config.py,sha256=4AGDEUPAJ1GzoDX3FzYYFvGMKfeAXM38Kh7Yv-OQLQQ,45595
+mainsequence/cli/config.py,sha256=Q4aGhSLxSeSjX2HqGgPDGg9kNAvrLhIBzWUJ-pY4lPg,45567
 mainsequence/cli/docker_utils.py,sha256=eAnp9MI042cHWwKasA5IF2I7INL3A6tV2JX-cSIe7rc,10687
 mainsequence/cli/doctor.py,sha256=_1XHd72jheRDt7dEJHd6hbBSSpCPpMwwFDUOLcdkii8,4550
 mainsequence/cli/local_ops.py,sha256=15XzdIxooWqUYgWDnKB81KCmXrCdYd3AGCVazVHD1MQ,4363
@@ -46,16 +47,16 @@ mainsequence/client/models_foundry.py,sha256=iN1jJzDokfniEQF0Ac5eepAB7L5pVjJnKav
 mainsequence/client/models_helpers.py,sha256=y7cgcsH8yO3dfIWPhRdcYam7ItWHw3Ps63-WYDe4YHE,46262
 mainsequence/client/models_user.py,sha256=co9uhe-LKkt7Kw5u8-wDMWcp0yL_lS2LuUOyauW5KF0,38557
 mainsequence/client/observability.py,sha256=_WrDKCaNk_TXmKElKCXC1inork6Exxxe8FRY4m1GI9s,16008
-mainsequence/client/utils.py,sha256=c4JjMIqKfwSz8DdkwLGmGtQ9lSmVn_KEw9KWGDwz_T0,30133
+mainsequence/client/utils.py,sha256=wg0tSaAe9R4-LD75_A-G9pf5p43kXZWRqXo6sHL8Q0Y,32123
 mainsequence/client/value_sets.py,sha256=7TA-mpuAd3hOduNgO1WTQQTuNOGaFgue-VqCsDWKaC8,6181
 mainsequence/instrumentation/__init__.py,sha256=J_9XmfjprElvz0u2t9rTyJT0kFdyKpxdbkdQiaw28_U,316
 mainsequence/instrumentation/utils.py,sha256=b-ihjSioAepeLfMpudM2SqCtvnxMqIXileHx3klBCQU,3377
 mainsequence/server/__init__.py,sha256=BHUAhtdWPDRdxX07NYO_6wrBv5mf0GsXflecO52PmUc,73
 mainsequence/server/caller_assertions.py,sha256=f9jHhVeoFK1ScDCmW8h3lEIU5V7zKw70SUSVV2P7wUI,10975
 mainsequence/server/fastapi.py,sha256=Y5QB51CRVbuUVRUcWh5GKQ5b5vMPjbs9scioTt684oQ,10712
-mainsequence-9.0.8.dev44.dist-info/licenses/LICENSE,sha256=b6Ecsk8wjsEby3lbSzdljR6hHiFGHBizt9iWV2p1c_I,1074
-mainsequence-9.0.8.dev44.dist-info/METADATA,sha256=2cyUFtw68GftzC-tFiPNUwc3ZV7Vqg4hpptgihrgOX0,7402
-mainsequence-9.0.8.dev44.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-mainsequence-9.0.8.dev44.dist-info/entry_points.txt,sha256=XGAOq3-mF2lWWpeRJvoaWyMarRcK167mH1g124aGdUs,88
-mainsequence-9.0.8.dev44.dist-info/top_level.txt,sha256=BFeblM_Q9q0cUWBvTxnfWcWQEHtf5XZi9nOS-Gdfwus,28
-mainsequence-9.0.8.dev44.dist-info/RECORD,,
+mainsequence-9.0.8.dev45.dist-info/licenses/LICENSE,sha256=b6Ecsk8wjsEby3lbSzdljR6hHiFGHBizt9iWV2p1c_I,1074
+mainsequence-9.0.8.dev45.dist-info/METADATA,sha256=z8ETo9B0eKLTBZxqULrm9ZNkbehM-ObnGFdieIR5WjA,7402
+mainsequence-9.0.8.dev45.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+mainsequence-9.0.8.dev45.dist-info/entry_points.txt,sha256=XGAOq3-mF2lWWpeRJvoaWyMarRcK167mH1g124aGdUs,88
+mainsequence-9.0.8.dev45.dist-info/top_level.txt,sha256=BFeblM_Q9q0cUWBvTxnfWcWQEHtf5XZi9nOS-Gdfwus,28
+mainsequence-9.0.8.dev45.dist-info/RECORD,,