openrunner-sdk 2.41.0__tar.gz → 2.41.2__tar.gz

{openrunner_sdk-2.41.0 → openrunner_sdk-2.41.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.41.0
+Version: 2.41.2
 Summary: OpenRunner SDK - W&B-compatible ML experiment tracking client
 Project-URL: Homepage, https://github.com/jqueguiner/openrunner
 Project-URL: Repository, https://github.com/jqueguiner/openrunner

{openrunner_sdk-2.41.0 → openrunner_sdk-2.41.2}/openrunner/__init__.py

@@ -181,7 +181,7 @@ launch.from_run = _launch_from_run  # type: ignore[attr-defined]
 # openrunner.trace.patch_openai() syntax
 trace.patch_openai = _patch_openai  # type: ignore[attr-defined]
 
-__version__ = "2.41.0"
+__version__ = "2.41.2"
 
 logger = logging.getLogger("openrunner")
 

openrunner_sdk-2.41.2/openrunner/_retry_transport.py

@@ -0,0 +1,94 @@
+"""A drop-in httpx transport that transparently retries transient failures.
+
+Wraps the default ``httpx.HTTPTransport`` and retries:
+  * connection/timeout/protocol errors (the request never reached the app), and
+  * ``502 / 503`` responses (bad gateway / unavailable — e.g. the API container
+    being recreated by a deploy, which the app also never processed), plus
+  * ``504`` and ``429`` — ``504`` only for idempotent methods (GET/HEAD/PUT/
+    DELETE/OPTIONS) so a POST that may have executed is never silently repeated;
+    ``429`` honours ``Retry-After``.
+
+Backoff is exponential with jitter, capped. This lets long-running SDK jobs
+(dataset materialise, bulk upload, run logging) ride out a transient blip instead
+of crashing — the failure mode that corrupted an EarningsCall fetch mid-download.
+"""
+from __future__ import annotations
+
+import random
+import time
+
+import httpx
+
+_IDEMPOTENT = frozenset({"GET", "HEAD", "PUT", "DELETE", "OPTIONS", "TRACE"})
+# 502/503: app never handled the request -> safe to retry for any method.
+# 504: request may have executed -> retry idempotent methods only.
+_RETRY_ALWAYS = frozenset({502, 503})
+
+
+class RetryTransport(httpx.BaseTransport):
+    """httpx transport retrying transient 5xx/429/network errors with backoff."""
+
+    def __init__(
+        self,
+        wrapped: httpx.BaseTransport | None = None,
+        *,
+        max_retries: int = 4,
+        base_delay: float = 1.0,
+        max_delay: float = 30.0,
+    ) -> None:
+        self._wrapped = wrapped if wrapped is not None else httpx.HTTPTransport()
+        self.max_retries = max_retries
+        self.base_delay = base_delay
+        self.max_delay = max_delay
+
+    def _sleep(self, attempt: int, retry_after: float = 0.0) -> None:
+        delay = min(self.base_delay * (2 ** attempt), self.max_delay)
+        delay = max(delay, min(retry_after, self.max_delay))
+        time.sleep(delay * (0.5 + random.random()))  # 0.5x–1.5x jitter
+
+    def _should_retry_status(self, code: int, method: str) -> bool:
+        if code in _RETRY_ALWAYS or code == 429:
+            return True
+        if code == 504 and method.upper() in _IDEMPOTENT:
+            return True
+        return False
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        last_exc: Exception | None = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                response = self._wrapped.handle_request(request)
+            except (
+                httpx.ConnectError,
+                httpx.ConnectTimeout,
+                httpx.ReadTimeout,
+                httpx.WriteTimeout,
+                httpx.PoolTimeout,
+                httpx.RemoteProtocolError,
+            ) as exc:
+                last_exc = exc
+                if attempt >= self.max_retries:
+                    raise
+                self._sleep(attempt)
+                continue
+
+            if attempt < self.max_retries and self._should_retry_status(
+                response.status_code, request.method
+            ):
+                retry_after = 0.0
+                try:
+                    retry_after = float(response.headers.get("Retry-After", 0) or 0)
+                except (TypeError, ValueError):
+                    retry_after = 0.0
+                response.close()
+                self._sleep(attempt, retry_after)
+                continue
+            return response
+
+        # Only reached if the last attempt raised then the loop fell through.
+        if last_exc is not None:
+            raise last_exc
+        raise httpx.HTTPError("request failed after retries")  # pragma: no cover
+
+    def close(self) -> None:
+        self._wrapped.close()

{openrunner_sdk-2.41.0 → openrunner_sdk-2.41.2}/openrunner/datasets.py

@@ -194,10 +194,12 @@ class DatasetsClient:
                or _g.get("base_url") or "http://localhost:8000")
         if not key:
             raise ValueError("API key required. Set OPENRUNNER_API_KEY, pass api_key=, or run `openrunner login`.")
+        from ._retry_transport import RetryTransport
         self._http = httpx.Client(
             base_url=f"{url.rstrip('/')}/api/v1",
             headers={"Authorization": f"Bearer {key}"},
             timeout=timeout,
+            transport=RetryTransport(),
         )
 
     # -- resolution ----------------------------------------------------------

{openrunner_sdk-2.41.0 → openrunner_sdk-2.41.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openrunner-sdk"
-version = "2.41.0"
+version = "2.41.2"
 description = "OpenRunner SDK - W&B-compatible ML experiment tracking client"
 readme = "README.md"
 license = {text = "MIT"}

openrunner_sdk-2.41.2/tests/test_retry_transport.py

@@ -0,0 +1,66 @@
+"""Tests for RetryTransport — the SDK-level transient-failure retry."""
+import httpx
+import pytest
+
+from openrunner._retry_transport import RetryTransport
+
+
+def _client(responder, **kw):
+    mock = httpx.MockTransport(responder)
+    return httpx.Client(base_url="http://t", transport=RetryTransport(mock, base_delay=0.0, **kw))
+
+
+def test_retries_502_then_succeeds():
+    calls = {"n": 0}
+    def responder(req):
+        calls["n"] += 1
+        return httpx.Response(502 if calls["n"] < 3 else 200, text="ok")
+    r = _client(responder).get("/x")
+    assert r.status_code == 200 and calls["n"] == 3
+
+
+def test_gives_up_after_max_retries():
+    calls = {"n": 0}
+    def responder(req):
+        calls["n"] += 1
+        return httpx.Response(503)
+    r = _client(responder, max_retries=2).get("/x")
+    assert r.status_code == 503 and calls["n"] == 3  # 1 + 2 retries
+
+
+def test_4xx_not_retried():
+    calls = {"n": 0}
+    def responder(req):
+        calls["n"] += 1
+        return httpx.Response(404)
+    r = _client(responder).get("/x")
+    assert r.status_code == 404 and calls["n"] == 1
+
+
+def test_504_retried_for_get_but_not_post():
+    for method, expect in [("GET", 3), ("POST", 1)]:
+        calls = {"n": 0}
+        def responder(req):
+            calls["n"] += 1
+            return httpx.Response(504)
+        _client(responder, max_retries=2).request(method, "/x")
+        assert calls["n"] == expect, method
+
+
+def test_connect_error_retried_then_raises():
+    calls = {"n": 0}
+    def responder(req):
+        calls["n"] += 1
+        raise httpx.ConnectError("boom")
+    with pytest.raises(httpx.ConnectError):
+        _client(responder, max_retries=2).get("/x")
+    assert calls["n"] == 3
+
+
+def test_429_honored_and_retried():
+    calls = {"n": 0}
+    def responder(req):
+        calls["n"] += 1
+        return httpx.Response(429, headers={"Retry-After": "0"}) if calls["n"] < 2 else httpx.Response(200)
+    r = _client(responder).get("/x")
+    assert r.status_code == 200 and calls["n"] == 2