PyPI - mainsequence-metatable - Versions diffs - 0.1.39.dev71__tar.gz → 0.1.40.dev72__tar.gz - Mend

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.39.dev71
+Version: 0.1.40.dev72
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

@@ -147,7 +147,9 @@ its branch to discover the API; declare it on the Job:
 `upgrade_application()` waits up to five minutes for the API to wake or finish
 replacing its pods before it fails with `ApiResolutionError`; other client calls
-wait 30 seconds.
+wait 30 seconds. Within the same budget, the runtime-context request is retried
+while the API answers 502, 503 or 504, for example while it cannot yet verify
+callers; the final error keeps the API's last detail.
 Team membership takes effect on the workload's next request, in the catalog and in
 the database. When a workload User changes, add the new one to the Team; nothing

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "mainsequence-metatable"
-version = "0.1.39.dev71"
+version = "0.1.40.dev72"
 description = "Main Sequence MetaTables Python client and standalone API"
 readme = "README.md"
 requires-python = ">=3.13"

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.39.dev71
+Version: 0.1.40.dev72
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

@@ -254,9 +254,8 @@ def resolve_api_endpoint() -> ApiEndpoint:
         pending, generation = _pending, _generation
     if owner:
         try:
-            budget = operation.discovery_timeout if operation is not None else DISCOVERY_TIMEOUT
             endpoint = (ApiEndpoint(explicit, generation=generation) if explicit
-                        else _discover(generation, environment_uid, budget))
+                        else _discover(generation, environment_uid, discovery_budget()))
         except BaseException as exc:
             pending.set_exception(exc)
             with _lock:
@@ -275,6 +274,12 @@ def get_api_url() -> str:
     return resolve_api_endpoint().url
+def discovery_budget() -> float:
+    """How long the current operation waits for a waking or restarting API."""
+    operation = _operation.get()
+    return operation.discovery_timeout if operation is not None else DISCOVERY_TIMEOUT
 @contextmanager
 def api_endpoint_scope(endpoint: ApiEndpoint | None = None, *, discovery_timeout: float | None = None):
     """Pin the first selected target for a complete request or workflow.

@@ -0,0 +1,48 @@
+"""Effective storage is selected by the API for every MetaTables client."""
+from __future__ import annotations
+import time
+from metatables.endpoint import discovery_budget, pin_api_endpoint
+from metatables.runtime_contract import RuntimeContext
+# Answers while the API restarts, wakes, or cannot yet verify callers, such as the
+# SDK's 503 when the platform's caller keys are unavailable.
+_UNAVAILABLE = frozenset({502, 503, 504})
+_FIRST_RETRY_DELAY = 0.5
+_MAX_RETRY_DELAY = 5.0
+@pin_api_endpoint
+def get_runtime_context() -> RuntimeContext:
+    # No global cache: API restarts, source changes, and process forks must never
+    # silently reuse a previous effective source or authorization context.
+    from mainsequence.client.exceptions import raise_for_response
+    from mainsequence.client.utils import make_request
+    from metatables.models import _MetaTablesBaseObjectOrm
+    class RuntimeResource(_MetaTablesBaseObjectOrm):
+        ENDPOINT = "runtime-context/"
+    # The GET is read-only; the discovery budget decides whether another one is
+    # sent, never how long one may take. The last answer keeps the server's detail.
+    deadline = time.monotonic() + discovery_budget()
+    delay = _FIRST_RETRY_DELAY
+    while True:
+        response = make_request(
+            s=RuntimeResource.build_session(),
+            loaders=RuntimeResource.LOADERS,
+            r_type="GET",
+            url=RuntimeResource.get_object_url(),
+            payload={"params": {"transfer_contract": 1}},
+        )
+        if response.status_code not in _UNAVAILABLE or time.monotonic() + delay >= deadline:
+            break
+        time.sleep(delay)
+        delay = min(delay * 2, _MAX_RETRY_DELAY)
+    raise_for_response(response)
+    context = RuntimeContext.model_validate(response.json())
+    context.require_data_source_uid()
+    return context

@@ -137,3 +137,74 @@ def test_api_runtime_response_validates_source_before_returning(monkeypatch, sou
     with api_endpoint_scope(ApiEndpoint("https://runtime.test")):
         with pytest.raises(DataSourceResolutionError, match="DataSource"):
             get_runtime_context()
+def answer_runtime_context(monkeypatch, *statuses):
+    """Answer each runtime-context GET with the next status on a fake clock."""
+    import json
+    from mainsequence.client import utils
+    from requests import Response
+    import metatables.runtime_context as runtime_context
+    from metatables.models import _MetaTablesBaseObjectOrm
+    now, sent = [0.0], []
+    def request(**kwargs):
+        status = statuses[min(len(sent), len(statuses) - 1)]
+        sent.append(now[0])
+        response = Response()
+        response.status_code = status
+        body = context().model_dump() if status == 200 else {"detail": "Caller authentication is unavailable."}
+        response._content = json.dumps(body).encode()
+        return response
+    def sleep(delay):
+        now[0] += delay
+    monkeypatch.setattr(utils, "make_request", request)
+    monkeypatch.setattr(_MetaTablesBaseObjectOrm, "build_session", classmethod(lambda cls: object()))
+    monkeypatch.setattr(runtime_context.time, "monotonic", lambda: now[0])
+    monkeypatch.setattr(runtime_context.time, "sleep", sleep)
+    return sent
+@pytest.mark.parametrize("status", [502, 503, 504])
+def test_runtime_context_waits_out_an_unavailable_api(monkeypatch, status):
+    from metatables.endpoint import ApiEndpoint, api_endpoint_scope
+    from metatables.runtime_context import get_runtime_context
+    sent = answer_runtime_context(monkeypatch, status, status, 200)
+    with api_endpoint_scope(ApiEndpoint("https://runtime.test")):
+        assert get_runtime_context().data_source["uid"] == SOURCE_UID
+    assert sent == [0.0, 0.5, 1.5]
+@pytest.mark.parametrize("budget", [None, 300.0])
+def test_runtime_context_reports_the_last_unavailable_answer_within_its_budget(monkeypatch, budget):
+    from mainsequence.client.exceptions import ServerError
+    from metatables.endpoint import ApiEndpoint, api_endpoint_scope
+    from metatables.runtime_context import get_runtime_context
+    sent = answer_runtime_context(monkeypatch, 503)
+    with api_endpoint_scope(ApiEndpoint("https://runtime.test"), discovery_timeout=budget):
+        with pytest.raises(ServerError, match="Caller authentication is unavailable"):
+            get_runtime_context()
+    # Migrations get five minutes, every other call the 30 s discovery budget.
+    limit = budget or 30.0
+    assert limit - 5 <= sent[-1] < limit
+def test_runtime_context_does_not_retry_other_server_errors(monkeypatch):
+    from mainsequence.client.exceptions import ServerError
+    from metatables.endpoint import ApiEndpoint, api_endpoint_scope
+    from metatables.runtime_context import get_runtime_context
+    sent = answer_runtime_context(monkeypatch, 500)
+    with api_endpoint_scope(ApiEndpoint("https://runtime.test")):
+        with pytest.raises(ServerError):
+            get_runtime_context()
+    assert sent == [0.0]

@@ -854,7 +854,7 @@ mcp = [
 [[package]]
 name = "mainsequence-metatable"
-version = "0.1.39"
+version = "0.1.40"
 source = { editable = "." }
 dependencies = [
     { name = "alembic" },

mainsequence-metatable 0.1.39.dev71__tar.gz → 0.1.40.dev72__tar.gz

mainsequence-metatable 0.1.39.dev71tar.gz → 0.1.40.dev72tar.gz