driftless 0.2.8__tar.gz → 0.2.10__tar.gz

{driftless-0.2.8 → driftless-0.2.10}/CHANGELOG.md

@@ -17,6 +17,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [0.2.10] - 2026-07-01
+
+### Added
+
+- **P5.2 endpoint retry/backoff** — `run.endpoint_retries` (0–10) and
+  `run.endpoint_retry_backoff_seconds` retry transient HTTP (429/502/503/504)
+  and network errors with exponential backoff per input record.
+
+---
+
+## [0.2.9] - 2026-07-01
+
+### Added
+
+- **P5.2 endpoint concurrency** — optional `run.endpoint_concurrency` (1–32,
+  default 1) runs endpoint POSTs in parallel via `ThreadPoolExecutor`; output
+  line order always matches the input file.
+
+---
+
 ## [0.2.8] - 2026-07-01
 
 ### Added
@@ -164,9 +184,9 @@ First public release on [PyPI](https://pypi.org/project/driftless/0.1.0/).
 - **Docs** — project overview, repair algorithm spec, 2×2 migration methodology,
   Poetry + Dependabot product framing.
 
-[Unreleased]: https://github.com/driftless-dev/driftless/compare/v0.2.8...HEAD
-[0.2.8]: https://github.com/driftless-dev/driftless/releases/tag/v0.2.8
-[0.2.7]: https://github.com/driftless-dev/driftless/compare/v0.2.7...v0.2.8
+[Unreleased]: https://github.com/driftless-dev/driftless/compare/v0.2.10...HEAD
+[0.2.10]: https://github.com/driftless-dev/driftless/releases/tag/v0.2.10
+[0.2.9]: https://github.com/driftless-dev/driftless/compare/v0.2.9...v0.2.10
 [0.2.4]: https://github.com/driftless-dev/driftless/compare/v0.2.4...v0.2.5
 [0.2.3]: https://github.com/driftless-dev/driftless/compare/v0.2.3...v0.2.4
 [0.2.2]: https://github.com/driftless-dev/driftless/compare/v0.2.2...v0.2.3

{driftless-0.2.8 → driftless-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: driftless
-Version: 0.2.8
+Version: 0.2.10
 Summary: Keep prompts in sync when model or eval data changes — Poetry-style lock regeneration, Dependabot-style PRs.
 Project-URL: Homepage, https://github.com/driftless-dev/driftless
 Project-URL: Repository, https://github.com/driftless-dev/driftless
@@ -133,7 +133,7 @@ can run in CI. See `.github/workflows/` for a scheduled deprecation scan, weekly
 `plan --act` triage, and manually-triggered migration workflows.
 
 ```yaml
-- uses: driftless-dev/driftless@v0.2.8
+- uses: driftless-dev/driftless@v0.2.10
   with:
     command: scan
 ```

{driftless-0.2.8 → driftless-0.2.10}/README.md

@@ -94,7 +94,7 @@ can run in CI. See `.github/workflows/` for a scheduled deprecation scan, weekly
 `plan --act` triage, and manually-triggered migration workflows.
 
 ```yaml
-- uses: driftless-dev/driftless@v0.2.8
+- uses: driftless-dev/driftless@v0.2.10
   with:
     command: scan
 ```

{driftless-0.2.8 → driftless-0.2.10}/docs/RELEASE.md

@@ -153,7 +153,7 @@ After a release, users can pin the composite Action by release tag
 (`action.yml` lives at the repo root — no `/action` path segment):
 
 ```yaml
-- uses: driftless-dev/driftless@v0.2.8
+- uses: driftless-dev/driftless@v0.2.10
   with:
     command: scan
 ```
@@ -161,9 +161,9 @@ After a release, users can pin the composite Action by release tag
 Or pin the PyPI package in the Action input:
 
 ```yaml
-- uses: driftless-dev/driftless@v0.2.8
+- uses: driftless-dev/driftless@v0.2.10
   with:
-    version: "==0.2.8"
+    version: "==0.2.10"
     command: migrate
 ```
 
@@ -171,7 +171,7 @@ Optionally maintain a floating **`v1`** tag on the latest stable minor release
 (point it at the current release tag after each publish):
 
 ```bash
-git tag -f v1 v0.2.8 && git push origin v1 --force
+git tag -f v1 v0.2.10 && git push origin v1 --force
 ```
 
 Update [`action.yml`](../action.yml) default `version` input when cutting releases.

{driftless-0.2.8 → driftless-0.2.10}/site/docs.html

@@ -428,7 +428,7 @@ driftless view -w support_classifier</code></pre>
     <span class="tok-k">runs-on</span>: ubuntu-latest
     <span class="tok-k">steps</span>:
       - <span class="tok-k">uses</span>: actions/checkout@v4
-      - <span class="tok-k">uses</span>: driftless-dev/driftless@v0.2.8
+      - <span class="tok-k">uses</span>: driftless-dev/driftless@v0.2.10
         <span class="tok-k">with</span>:
           <span class="tok-k">command</span>: <span class="tok-s">plan</span></code></pre>
         <p>A scheduled <code class="inline">plan</code> gates CI when a deprecated model needs attention; a manually-triggered <code class="inline">migrate</code> opens a PR (or an issue when blocked) with the evidence attached.</p>

{driftless-0.2.8 → driftless-0.2.10}/src/driftless/__init__.py

@@ -1,3 +1,3 @@
 """driftless: Dependabot for LLM models."""
 
-__version__ = "0.2.8"
+__version__ = "0.2.10"

{driftless-0.2.8 → driftless-0.2.10}/src/driftless/contract.py

@@ -68,6 +68,14 @@ class RunSpec(StrictModel):
     # the shell runner, which uses ``{{ model }}`` substitution / env_var).
     model_param: str | None = None
     timeout_seconds: int = 1800
+    # For endpoints: max parallel POSTs (1 = sequential). Output order always
+    # matches input order regardless of completion order.
+    endpoint_concurrency: int = 1
+    # For endpoints: extra attempts after a transient failure (429/502/503/504 or
+    # network/timeout). 0 = fail on first error.
+    endpoint_retries: int = 0
+    # Base seconds for exponential backoff between endpoint retries (doubled each attempt).
+    endpoint_retry_backoff_seconds: float = 1.0
 
     @field_validator("command", "endpoint")
     @classmethod
@@ -76,6 +84,27 @@ class RunSpec(StrictModel):
             raise ValueError("must not be blank")
         return v
 
+    @field_validator("endpoint_concurrency")
+    @classmethod
+    def _endpoint_concurrency_range(cls, v: int) -> int:
+        if v < 1 or v > 32:
+            raise ValueError("run.endpoint_concurrency must be between 1 and 32")
+        return v
+
+    @field_validator("endpoint_retries")
+    @classmethod
+    def _endpoint_retries_range(cls, v: int) -> int:
+        if v < 0 or v > 10:
+            raise ValueError("run.endpoint_retries must be between 0 and 10")
+        return v
+
+    @field_validator("endpoint_retry_backoff_seconds")
+    @classmethod
+    def _endpoint_retry_backoff_range(cls, v: float) -> float:
+        if v < 0 or v > 60:
+            raise ValueError("run.endpoint_retry_backoff_seconds must be between 0 and 60")
+        return v
+
     @model_validator(mode="after")
     def _one_runner(self) -> "RunSpec":
         if not self.command and not self.endpoint:

{driftless-0.2.8 → driftless-0.2.10}/src/driftless/harness.py

@@ -16,6 +16,7 @@ import sys
 import time
 import urllib.error
 import urllib.request
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -198,6 +199,72 @@ def _read_jsonl(path: Path) -> list[dict]:
     return records
 
 
+def _retryable_http_status(code: int) -> bool:
+    return code in {429, 502, 503, 504}
+
+
+def _endpoint_post_record(
+    index: int,
+    rec: dict,
+    *,
+    endpoint: str,
+    model: str,
+    model_param: str,
+    headers: dict[str, str],
+    timeout: float,
+    id_field: str | None,
+    retries: int = 0,
+    retry_backoff: float = 1.0,
+) -> str:
+    """POST one input record and return the output JSONL line."""
+    body = dict(rec)
+    body[model_param] = model
+    payload = json.dumps(body).encode("utf-8")
+    max_attempts = 1 + retries
+    text: str | None = None
+
+    for attempt in range(max_attempts):
+        try:
+            text = _http_post(endpoint, payload, headers, timeout)
+            break
+        except urllib.error.HTTPError as exc:
+            if attempt < max_attempts - 1 and _retryable_http_status(exc.code):
+                if exc.fp:
+                    exc.read()
+                time.sleep(retry_backoff * (2**attempt))
+                continue
+            raise HarnessError(
+                f"endpoint returned HTTP {exc.code} on record {index}",
+                hint=_tail(exc.read().decode("utf-8", "replace")) if exc.fp else str(exc),
+            ) from exc
+        except (urllib.error.URLError, TimeoutError, OSError) as exc:
+            if attempt < max_attempts - 1:
+                time.sleep(retry_backoff * (2**attempt))
+                continue
+            raise HarnessError(
+                f"endpoint request failed on record {index}: {endpoint}",
+                hint=str(getattr(exc, "reason", exc)),
+            ) from exc
+
+    assert text is not None
+
+    try:
+        obj = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise HarnessError(
+            f"endpoint returned non-JSON on record {index}",
+            hint=_tail(text) or "expected a JSON object per record",
+        ) from exc
+    if not isinstance(obj, dict):
+        raise HarnessError(
+            f"endpoint response on record {index} must be a JSON object",
+            hint=f"got {type(obj).__name__}",
+        )
+    if id_field and id_field not in obj and id_field in rec:
+        obj[id_field] = rec[id_field]
+    return json.dumps(obj)
+
+
 def _run_endpoint(
     workflow: Workflow, model: str, *, cwd: Path, output_path: Path
 ) -> RunResult:
@@ -207,7 +274,10 @@ def _run_endpoint(
     ``run.model_param`` (default ``"model"``); the JSON response object is written
     as the corresponding output record. When ``eval.id_field`` is set and the
     response omits it, the input's id is copied through so output<->label
-    alignment still works.
+    alignment still works. Use ``run.endpoint_concurrency`` (>1) to POST in
+    parallel; output line order always matches the input file. Transient HTTP
+    (429/502/503/504) and network errors honor ``run.endpoint_retries`` with
+    exponential backoff from ``run.endpoint_retry_backoff_seconds``.
     """
     run = workflow.run
     input_path = (cwd / run.input_path).resolve()
@@ -225,48 +295,43 @@ def _run_endpoint(
     if token:
         headers["Authorization"] = f"Bearer {token}"
 
-    out_lines: list[str] = []
+    endpoint = run.endpoint
+    if endpoint is None:
+        raise HarnessError(
+            "no endpoint URL is configured",
+            hint="set run.endpoint in the contract",
+        )
+
+    concurrency = run.endpoint_concurrency
+    timeout = float(run.timeout_seconds)
+    retries = run.endpoint_retries
+    retry_backoff = run.endpoint_retry_backoff_seconds
     start = time.monotonic()
-    for i, rec in enumerate(records, start=1):
-        body = dict(rec)
-        body[model_param] = model
-        endpoint = run.endpoint
-        if endpoint is None:
-            raise HarnessError(
-                "no endpoint URL is configured",
-                hint="set run.endpoint in the contract",
-            )
-        try:
-            text = _http_post(
-                endpoint, json.dumps(body).encode("utf-8"), headers, run.timeout_seconds
-            )
-        except urllib.error.HTTPError as exc:
-            raise HarnessError(
-                f"endpoint returned HTTP {exc.code} on record {i}",
-                hint=_tail(exc.read().decode("utf-8", "replace")) if exc.fp else str(exc),
-            ) from exc
-        except (urllib.error.URLError, TimeoutError, OSError) as exc:
-            raise HarnessError(
-                f"endpoint request failed on record {i}: {run.endpoint}",
-                hint=str(getattr(exc, "reason", exc)),
-            ) from exc
 
-        try:
-            obj = json.loads(text)
-        except json.JSONDecodeError as exc:
-            raise HarnessError(
-                f"endpoint returned non-JSON on record {i}",
-                hint=_tail(text) or "expected a JSON object per record",
-            ) from exc
-        if not isinstance(obj, dict):
-            raise HarnessError(
-                f"endpoint response on record {i} must be a JSON object",
-                hint=f"got {type(obj).__name__}",
-            )
-        if id_field and id_field not in obj and id_field in rec:
-            obj[id_field] = rec[id_field]
-        out_lines.append(json.dumps(obj))
+    def post_one(index: int, rec: dict) -> tuple[int, str]:
+        line = _endpoint_post_record(
+            index,
+            rec,
+            endpoint=endpoint,
+            model=model,
+            model_param=model_param,
+            headers=headers,
+            timeout=timeout,
+            id_field=id_field,
+            retries=retries,
+            retry_backoff=retry_backoff,
+        )
+        return index, line
+
+    if concurrency <= 1 or len(records) <= 1:
+        indexed_lines = [post_one(i, rec) for i, rec in enumerate(records, start=1)]
+    else:
+        workers = min(concurrency, len(records))
+        pairs = [(i, rec) for i, rec in enumerate(records, start=1)]
+        with ThreadPoolExecutor(max_workers=workers) as pool:
+            indexed_lines = list(pool.map(lambda pair: post_one(pair[0], pair[1]), pairs))
 
+    out_lines = [line for _, line in indexed_lines]
     duration = time.monotonic() - start
     output_path.write_text("\n".join(out_lines) + "\n", encoding="utf-8")
     return RunResult(
@@ -274,7 +339,8 @@ def _run_endpoint(
         output_path=output_path,
         returncode=0,
         duration_seconds=duration,
-        stdout=f"{len(out_lines)} records via {run.endpoint}",
+        stdout=f"{len(out_lines)} records via {endpoint} "
+        f"(concurrency={concurrency}, retries={retries})",
         stderr="",
         env_overrides={},
     )

{driftless-0.2.8 → driftless-0.2.10}/tests/test_endpoint.py

@@ -118,3 +118,117 @@ def test_run_rejects_both_command_and_endpoint():
         RunSpec.model_validate(
             {"command": "echo hi", "endpoint": "http://x", "input_path": "i", "output_path": "o"}
         )
+
+
+def test_endpoint_concurrency_must_be_in_range():
+    with pytest.raises(ValueError, match="endpoint_concurrency"):
+        RunSpec.model_validate(
+            {
+                "endpoint": "http://x",
+                "input_path": "i",
+                "output_path": "o",
+                "endpoint_concurrency": 0,
+            }
+        )
+
+
+def test_endpoint_concurrency_preserves_order_and_parallelizes(tmp_path, monkeypatch):
+    import threading
+    import time
+
+    records = [{"id": str(i), "text": "x"} for i in range(8)]
+    _write_inputs(tmp_path, records)
+    lock = threading.Lock()
+    in_flight = 0
+    max_in_flight = 0
+
+    def fake_post(url, payload, headers, timeout):
+        nonlocal in_flight, max_in_flight
+        body = json.loads(payload.decode("utf-8"))
+        with lock:
+            in_flight += 1
+            max_in_flight = max(max_in_flight, in_flight)
+        time.sleep(0.03)
+        with lock:
+            in_flight -= 1
+        return json.dumps({"id": body["id"], "label": "ok"})
+
+    monkeypatch.setattr(harness, "_http_post", fake_post)
+    result = run_workflow(
+        _endpoint_workflow(endpoint_concurrency=4), "m1", cwd=tmp_path
+    )
+
+    assert result.ok
+    assert max_in_flight >= 3
+    rows = _read_out(result.output_path)
+    assert [r["id"] for r in rows] == [str(i) for i in range(8)]
+    assert "concurrency=4" in result.stdout
+    assert "retries=0" in result.stdout
+
+
+def test_endpoint_retries_transient_http_errors(tmp_path, monkeypatch):
+    import urllib.error
+
+    _write_inputs(tmp_path, [{"id": "a", "text": "x"}])
+    attempts = {"n": 0}
+    sleeps: list[float] = []
+
+    def fake_post(*args, **kwargs):
+        attempts["n"] += 1
+        if attempts["n"] < 3:
+            raise urllib.error.HTTPError(
+                url="http://x", code=503, msg="unavailable", hdrs={}, fp=None
+            )
+        return json.dumps({"id": "a", "label": "ok"})
+
+    monkeypatch.setattr(harness, "_http_post", fake_post)
+    monkeypatch.setattr(harness.time, "sleep", lambda s: sleeps.append(s))
+
+    result = run_workflow(
+        _endpoint_workflow(endpoint_retries=2, endpoint_retry_backoff_seconds=0.5),
+        "m1",
+        cwd=tmp_path,
+    )
+
+    assert result.ok
+    assert attempts["n"] == 3
+    assert sleeps == [0.5, 1.0]
+
+
+def test_endpoint_does_not_retry_client_errors(tmp_path, monkeypatch):
+    import urllib.error
+
+    _write_inputs(tmp_path, [{"id": "a", "text": "x"}])
+    attempts = {"n": 0}
+
+    def fake_post(*args, **kwargs):
+        attempts["n"] += 1
+        raise urllib.error.HTTPError(
+            url="http://x", code=400, msg="bad request", hdrs={}, fp=None
+        )
+
+    monkeypatch.setattr(harness, "_http_post", fake_post)
+
+    with pytest.raises(HarnessError, match="HTTP 400"):
+        run_workflow(_endpoint_workflow(endpoint_retries=3), "m1", cwd=tmp_path)
+    assert attempts["n"] == 1
+
+
+def test_endpoint_retries_network_errors(tmp_path, monkeypatch):
+    import urllib.error
+
+    _write_inputs(tmp_path, [{"id": "a", "text": "x"}])
+    attempts = {"n": 0}
+
+    def fake_post(*args, **kwargs):
+        attempts["n"] += 1
+        if attempts["n"] == 1:
+            raise urllib.error.URLError("connection reset")
+        return json.dumps({"id": "a", "label": "ok"})
+
+    monkeypatch.setattr(harness, "_http_post", fake_post)
+    monkeypatch.setattr(harness.time, "sleep", lambda _s: None)
+
+    result = run_workflow(_endpoint_workflow(endpoint_retries=1), "m1", cwd=tmp_path)
+    assert result.ok
+    assert attempts["n"] == 2