durable-workflow 2.5.10__tar.gz → 2.5.12__tar.gz

{durable_workflow-2.5.10/src/durable_workflow.egg-info → durable_workflow-2.5.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.10
+Version: 2.5.12
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -175,6 +175,14 @@ for immutable context, operation policies, shielded cleanup and recovery.
 
 ## Development
 
+The installed `durable-workflow-replay-conformance` command runs an offline
+Python replay shard. Its `sdk-python` artifact pin must match the installed
+distribution version reported by `importlib.metadata.version("durable-workflow")`.
+The report records that installed identity separately from the declared platform
+tuple and fails if metadata is missing or the SDK pin differs. Replay success
+does not prove installation or execution of the other declared artifacts; the
+aggregate runner supplies its own verified installation receipts.
+
 ```bash
 pip install -e '.[dev]'
 ruff check src/ tests/

{durable_workflow-2.5.10 → durable_workflow-2.5.12}/README.md

@@ -135,6 +135,14 @@ for immutable context, operation policies, shielded cleanup and recovery.
 
 ## Development
 
+The installed `durable-workflow-replay-conformance` command runs an offline
+Python replay shard. Its `sdk-python` artifact pin must match the installed
+distribution version reported by `importlib.metadata.version("durable-workflow")`.
+The report records that installed identity separately from the declared platform
+tuple and fails if metadata is missing or the SDK pin differs. Replay success
+does not prove installation or execution of the other declared artifacts; the
+aggregate runner supplies its own verified installation receipts.
+
 ```bash
 pip install -e '.[dev]'
 ruff check src/ tests/

{durable_workflow-2.5.10 → durable_workflow-2.5.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.5.10"
+version = "2.5.12"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -71,8 +71,8 @@ durable-workflow-replay-conformance = "durable_workflow.replay_conformance:main"
 durable-workflow-workflow-updates-conformance = "durable_workflow.workflow_updates_conformance:main"
 
 [tool.durable-workflow]
-product-train = "2.5.10"
-registry-version = "2.5.10"
+product-train = "2.5.12"
+registry-version = "2.5.12"
 supported-server-versions = "2.5.16"
 worker-protocol-version = "1.20"
 control-plane-version = "2"

{durable_workflow-2.5.10 → durable_workflow-2.5.12}/src/durable_workflow/client.py

@@ -4323,7 +4323,9 @@ class Client:
         Queries are synchronous and non-mutating. The server runs the named
         query handler inside the workflow process and returns the decoded
         result. Raises :class:`~durable_workflow.errors.QueryFailed` if the
-        query was rejected or the handler errored.
+        query was rejected, the handler errored, or the original query timed
+        out. A canonical query timeout is surfaced without automatically
+        admitting another query.
         """
         await self._require_query_support()
         body: dict[str, Any] = {}

{durable_workflow-2.5.10 → durable_workflow-2.5.12}/src/durable_workflow/replay_conformance.py

@@ -15,6 +15,7 @@ import json
 import sys
 from collections.abc import Mapping, Sequence
 from datetime import datetime, timezone
+from importlib import metadata
 from pathlib import Path
 from typing import Any
 
@@ -204,6 +205,17 @@ def compose_report(
     started_at = _timestamp()
     versions = _canonical_artifact_metadata(dict(artifact_versions or {}))
     sources = _canonical_artifact_metadata(dict(artifact_sources or {}))
+    try:
+        installed_version = metadata.version("durable-workflow")
+    except metadata.PackageNotFoundError:
+        installed_version = None
+    identity = {
+        "runtime": "sdk-python",
+        "package": "durable-workflow",
+        "version": installed_version,
+        "version_source": "installed_distribution_metadata" if installed_version else "unavailable",
+        "declared_version": _artifact_metadata(versions, "sdk-python"),
+    }
     scenario_results: dict[str, dict[str, Any]] = {}
     findings: list[dict[str, Any]] = []
     finding_links: dict[str, list[dict[str, Any]]] = {}
@@ -212,7 +224,7 @@ def compose_report(
         scenario_results,
         findings,
         finding_links,
-        _published_artifact_scenario(versions, sources),
+        _published_artifact_scenario(versions, sources, installed_version),
     )
 
     for family, scenario_id in COMPLETED_SCENARIOS.items():
@@ -242,6 +254,9 @@ def compose_report(
     has_failures = any(
         scenario.get("status") != "pass" for scenario in scenario_results.values()
     )
+    for scenario in scenario_results.values():
+        scenario["implementation_identity"] = dict(identity)
+        scenario["artifact_tuple_evidence"] = "declared"
 
     return {
         "schema": RESULT_SCHEMA,
@@ -252,6 +267,8 @@ def compose_report(
         "finished_at": _timestamp(),
         "artifact_versions": versions,
         "artifact_sources": sources,
+        "artifact_tuple_evidence": "declared",
+        "implementation_identity": identity,
         "runtime_matrix": {
             "runtimes": ["sdk-python"],
         },
@@ -307,6 +324,7 @@ def _append_scenario(
 def _published_artifact_scenario(
     artifact_versions: Mapping[str, str],
     artifact_sources: Mapping[str, str],
+    installed_version: str | None,
 ) -> dict[str, Any]:
     missing_versions: list[str] = []
     missing_sources: list[str] = []
@@ -338,14 +356,14 @@ def _published_artifact_scenario(
             untrusted_sources[artifact] = source
 
     missing = sorted(set(missing_versions + missing_sources))
-    status = (
-        "pass"
-        if not missing
-        and not rejected_versions
-        and not forbidden_sources
-        and not untrusted_sources
-        else "fail"
-    )
+    declarations_valid = not missing and not rejected_versions and not forbidden_sources and not untrusted_sources
+    declared_version = _artifact_metadata(artifact_versions, "sdk-python")
+    identity_error = None
+    if not installed_version:
+        identity_error = "installed_sdk_metadata_missing"
+    elif declared_version != installed_version:
+        identity_error = "installed_sdk_version_mismatch"
+    status = "pass" if declarations_valid and identity_error is None else "fail"
 
     return _scenario(
         "published_artifact_install_only",
@@ -361,8 +379,14 @@ def _published_artifact_scenario(
             "rejected_versions": rejected_versions,
             "forbidden_sources": forbidden_sources,
             "untrusted_sources": untrusted_sources,
-            "published_artifacts_only": status == "pass",
-            "published_install_tuple_proven": status == "pass",
+            "declared_artifacts_published_only": bool(declarations_valid),
+            "declared_sdk_version": declared_version,
+            "installed_sdk_version": installed_version,
+            "sdk_identity_error": identity_error,
+            "sdk_version_matches": bool(installed_version and declared_version == installed_version),
+            "artifact_tuple_evidence": "declared",
+            "published_artifacts_only": False,
+            "published_install_tuple_proven": False,
         },
     )
 
@@ -589,11 +613,6 @@ def _scenario(
         "scenario_id": scenario_id,
         "status": status,
         "published_artifact_versions": dict(artifact_versions),
-        "implementation_identity": {
-            "runtime": "sdk-python",
-            "package": "durable-workflow",
-            "version": _artifact_metadata(artifact_versions, "sdk-python"),
-        },
         "runtime_matrix": {
             "runtimes": ["sdk-python"],
         },

{durable_workflow-2.5.10 → durable_workflow-2.5.12}/src/durable_workflow/retry_policy.py

@@ -17,6 +17,7 @@ import contextvars
 import json
 import logging
 import random
+import re
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from typing import TypeVar
@@ -34,6 +35,24 @@ _worker_storage_admission_stop: contextvars.ContextVar[Callable[[], bool] | None
 )
 
 
+def _query_timeout_refusal(exc: httpx.HTTPStatusError) -> bool:
+    request = exc.request
+    if (exc.response.status_code != 504 or request.method != "POST"
+            or request.headers.get("X-Durable-Workflow-Control-Plane-Version") != "2"
+            or re.search(r"/api/workflows/[^/]+/query/[^/]+$", request.url.path) is None):
+        return False
+    try:
+        body = exc.response.json()
+    except ValueError:
+        return False
+    # This response ends an admitted query. Another POST creates a new task,
+    # rather than retrying the original task or its remaining caller budget.
+    reason = body.get("reason") if isinstance(body, dict) else None
+    return isinstance(reason, str) and reason in {
+        "query_worker_timeout", "query_worker_execution_timeout", "query_task_not_claimed",
+    }
+
+
 def _storage_refusal(exc: Exception) -> tuple[ServerError, str | None] | None:
     if not isinstance(exc, httpx.HTTPStatusError):
         return None
@@ -194,6 +213,8 @@ class TransportRetryPolicy:
     :class:`durable_workflow.workflow.ChildWorkflowRetryPolicy`.
 
     Uses exponential backoff with jitter to avoid thundering herd.
+    Canonical query timeouts end the original query and are surfaced without
+    another query admission; unrelated transient HTTP failures still retry.
     """
 
     max_attempts: int = 3
@@ -213,7 +234,7 @@ class TransportRetryPolicy:
 
         # Retry 5xx server errors and 429 rate limit
         if isinstance(exc, httpx.HTTPStatusError):
-            if _poll_capacity_refusal(exc):
+            if _query_timeout_refusal(exc) or _poll_capacity_refusal(exc):
                 return False
             return exc.response.status_code >= 500 or exc.response.status_code == 429
 

{durable_workflow-2.5.10 → durable_workflow-2.5.12/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.10
+Version: 2.5.12
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -175,6 +175,14 @@ for immutable context, operation policies, shielded cleanup and recovery.
 
 ## Development
 
+The installed `durable-workflow-replay-conformance` command runs an offline
+Python replay shard. Its `sdk-python` artifact pin must match the installed
+distribution version reported by `importlib.metadata.version("durable-workflow")`.
+The report records that installed identity separately from the declared platform
+tuple and fails if metadata is missing or the SDK pin differs. Replay success
+does not prove installation or execution of the other declared artifacts; the
+aggregate runner supplies its own verified installation receipts.
+
 ```bash
 pip install -e '.[dev]'
 ruff check src/ tests/

{durable_workflow-2.5.10 → durable_workflow-2.5.12}/src/durable_workflow.egg-info/SOURCES.txt

@@ -95,6 +95,7 @@ tests/test_public_boundary_scanner.py
 tests/test_pypi_project_surface.py
 tests/test_python_conformance.py
 tests/test_queries.py
+tests/test_query_timeout_retry.py
 tests/test_readme_quickstart.py
 tests/test_redrive_replay.py
 tests/test_registration_ambiguity.py

durable_workflow-2.5.12/tests/test_query_timeout_retry.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import httpx
+import pytest
+
+from durable_workflow import Client
+from durable_workflow.errors import QueryFailed
+from durable_workflow.retry_policy import TransportRetryPolicy
+
+
+@pytest.mark.parametrize("protocol", ["1.20", "1.19"])
+@pytest.mark.parametrize("reason", [
+    "query_worker_execution_timeout", "query_task_not_claimed", "query_worker_timeout",
+])
+@pytest.mark.parametrize("prefix", ["", "/api/runtime/v1/namespaces/example"])
+async def test_query_exposes_original_canonical_timeout_without_another_admission(
+    monkeypatch: pytest.MonkeyPatch, protocol: str, reason: str, prefix: str,
+) -> None:
+    monkeypatch.setenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", protocol)
+    original = {"reason": reason, "message": "Original query ended.",
+                "control_plane": {"operation": "query", "reason": reason}}
+    admissions = 0
+    discovery_protocols = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        nonlocal admissions
+        if request.url.path.endswith("/api/cluster/info"):
+            discovery_protocols.append(request.headers["X-Durable-Workflow-Protocol-Version"])
+            return httpx.Response(200, json={
+                "worker_protocol": {"server_capabilities": {"query_tasks": True}},
+            })
+        assert request.url.path == prefix + "/api/workflows/original/query/total"
+        assert request.headers["X-Durable-Workflow-Control-Plane-Version"] == "2"
+        admissions += 1
+        if admissions == 1:
+            return httpx.Response(504, json=original)
+        # The old policy hides the original failure behind a distinct admission.
+        return httpx.Response(200, json={"result": "replacement-query"})
+
+    async with Client("https://runtime.example" + prefix, worker_token="worker", control_token="control",
+                      retry_policy=TransportRetryPolicy(initial_backoff_seconds=0, jitter=False)) as client:
+        await client._http.aclose()
+        client._http = httpx.AsyncClient(base_url=client.base_url, transport=httpx.MockTransport(handle))
+        with pytest.raises(QueryFailed) as failure:
+            await client.query_workflow("original", "total")
+    assert admissions == 1
+    assert discovery_protocols == [protocol]
+    assert failure.value.status == 504 and failure.value.reason == reason
+    assert failure.value.body == original
+
+
+@pytest.mark.parametrize(("method", "path", "status", "body", "headers"), [
+    ("POST", "/api/workflows/w/query/q", 504, {"reason": "gateway_timeout"},
+     {"X-Durable-Workflow-Control-Plane-Version": "2"}),
+    ("POST", "/api/workflows/w/query/q", 503, {"reason": "query_worker_timeout"},
+     {"X-Durable-Workflow-Control-Plane-Version": "2"}),
+    ("GET", "/api/workflows/w/query/q", 504, {"reason": "query_worker_timeout"},
+     {"X-Durable-Workflow-Control-Plane-Version": "2"}),
+    ("POST", "/api/workflows/w/signals/q", 504, {"reason": "query_worker_timeout"},
+     {"X-Durable-Workflow-Control-Plane-Version": "2"}),
+    ("POST", "/api/workflows/w/query/q", 504, {"reason": "query_worker_timeout"}, {}),
+    ("POST", "/api/workflows/w/query/q", 504, [],
+     {"X-Durable-Workflow-Control-Plane-Version": "2"}),
+    ("POST", "/api/workflows/w/query/q", 504, {"reason": []},
+     {"X-Durable-Workflow-Control-Plane-Version": "2"}),
+])
+def test_other_transport_failures_keep_existing_retry_policy(
+    method: str, path: str, status: int, body: object, headers: dict[str, str],
+) -> None:
+    request = httpx.Request(method, "https://runtime.example" + path, headers=headers)
+    response = httpx.Response(status, request=request, json=body)
+    error = httpx.HTTPStatusError("transport failure", request=request, response=response)
+    assert TransportRetryPolicy().should_retry(error, 0) is True

{durable_workflow-2.5.10 → durable_workflow-2.5.12}/tests/test_replay_conformance.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import json
+from importlib import metadata
 from pathlib import Path
 from typing import Any
 
+import pytest
+
 from durable_workflow.replay_conformance import (
     COVERAGE_SCOPE,
     RESULT_SCHEMA,
@@ -25,6 +28,11 @@ def artifact_versions() -> dict[str, str]:
     }
 
 
+@pytest.fixture(autouse=True)
+def installed_sdk_metadata(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(metadata, "version", lambda package: "0.4.73")
+
+
 def artifact_sources() -> dict[str, str]:
     return {
         "server": "docker_image",
@@ -81,7 +89,7 @@ def test_compose_report_emits_python_replay_conformance_shard() -> None:
         assert indexed[scenario_id]["status"] == "pass"
 
 
-def test_report_proves_published_artifact_install_policy() -> None:
+def test_report_validates_declared_tuple_without_claiming_installation_proof() -> None:
     report = compose_report(
         artifact_versions=artifact_versions(),
         artifact_sources=artifact_sources(),
@@ -90,13 +98,46 @@ def test_report_proves_published_artifact_install_policy() -> None:
     observed = published["observed_outputs"]
 
     assert published["status"] == "pass"
-    assert observed["published_artifacts_only"] is True
-    assert observed["published_install_tuple_proven"] is True
+    assert observed["published_artifacts_only"] is False
+    assert observed["published_install_tuple_proven"] is False
+    assert observed["declared_artifacts_published_only"] is True
+    assert observed["artifact_tuple_evidence"] == "declared"
+    assert observed["installed_sdk_version"] == "0.4.73"
+    assert observed["sdk_version_matches"] is True
+    assert observed["sdk_identity_error"] is None
+    assert report["implementation_identity"]["version"] == "0.4.73"
     assert observed["missing_artifacts"] == []
     assert observed["artifact_sources"]["server"] == "docker_image"
     assert observed["artifact_sources"]["sdk-python"] == "pypi_package"
 
 
+def test_report_rejects_declared_sdk_version_mismatch(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(metadata, "version", lambda package: "2.5.10")
+    report = compose_report(artifact_versions=artifact_versions(), artifact_sources=artifact_sources())
+    install = scenarios(report)["published_artifact_install_only"]
+    assert report["outcome"] == "fail"
+    assert install["status"] == "fail"
+    assert install["observed_outputs"]["installed_sdk_version"] == "2.5.10"
+    assert install["observed_outputs"]["declared_sdk_version"] == "0.4.73"
+    assert install["observed_outputs"]["sdk_identity_error"] == "installed_sdk_version_mismatch"
+    assert install["observed_outputs"]["published_install_tuple_proven"] is False
+    assert all(scenario["implementation_identity"]["version"] == "2.5.10" for scenario in report["scenario_results"])
+    assert report["finding_links"]["published_artifact_install_only"]
+
+
+def test_report_rejects_missing_installed_sdk_metadata(monkeypatch: pytest.MonkeyPatch) -> None:
+    def missing_metadata(package: str) -> str:
+        raise metadata.PackageNotFoundError(package)
+
+    monkeypatch.setattr(metadata, "version", missing_metadata)
+    report = compose_report(artifact_versions=artifact_versions(), artifact_sources=artifact_sources())
+    install = scenarios(report)["published_artifact_install_only"]
+    assert report["outcome"] == "fail"
+    assert install["observed_outputs"]["sdk_identity_error"] == "installed_sdk_metadata_missing"
+    assert install["implementation_identity"]["version"] is None
+    assert install["observed_outputs"]["published_install_tuple_proven"] is False
+
+
 def test_report_rejects_missing_versions_and_sources() -> None:
     report = compose_report(
         artifact_versions={"sdk-python": "0.4.73"},

{durable_workflow-2.5.10 → durable_workflow-2.5.12}/tests/test_replay_regression_corpus.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 from collections.abc import Mapping, Sequence
+from importlib import metadata
 from pathlib import Path
 from typing import Any
 from unittest.mock import AsyncMock
@@ -11,6 +12,7 @@ import pytest
 from durable_workflow import Replayer, Worker, serializer, workflow
 from durable_workflow.client import PROTOCOL_VERSION, Client, WorkflowExecution, WorkflowStreamAppendItem
 from durable_workflow.errors import NonDeterministicReplayError, WorkflowCancelled, WorkflowPayloadDecodeError
+from durable_workflow.replay_conformance import compose_report
 from durable_workflow.workflow import (
     LocalActivityExecutionAborted,
     WorkflowContext,
@@ -371,6 +373,27 @@ def _execute_fixture(fixture: dict[str, Any]) -> list[dict[str, Any]]:
     assert isinstance(workflow, dict)
     workflow_type = workflow.get("type")
     assert isinstance(workflow_type, str) and workflow_type
+    if workflow_type == "sdk.replay-conformance-report":
+        # This public command executes the SDK's offline replay scenarios. Its
+        # regression input is artifact declarations, not an invented history.
+        assert "history" not in fixture
+        inputs = workflow.get("input")
+        assert isinstance(inputs, list) and len(inputs) == 1 and isinstance(inputs[0], dict)
+        report = compose_report(**inputs[0])
+        install = next(scenario for scenario in report["scenario_results"]
+                       if scenario["scenario_id"] == "published_artifact_install_only")
+        observed = install["observed_outputs"]
+        commands = [{
+            "type": "replay_conformance_report",
+            "outcome": report["outcome"],
+            "sdk_identity_error": observed.get("sdk_identity_error"),
+            "declared_sdk_version": observed.get("declared_sdk_version"),
+            "published_install_tuple_proven": observed["published_install_tuple_proven"],
+        }]
+        _assert_matches(fixture["command_sequence"], commands, f"{fixture['id']}.command_sequence")
+        _assert_matches(fixture["expected"], {"command_sequence": commands}, f"{fixture['id']}.expected")
+        assert report["implementation_identity"]["version"] == metadata.version("durable-workflow")
+        return commands
     assert workflow_type in WORKFLOW_TYPES, (
         f"replay fixture workflow {workflow_type!r} has no Python implementation; "
         "register its reproducer workflow in WORKFLOWS"
@@ -462,6 +485,9 @@ def test_checked_in_replay_regression_corpus_uses_official_replayer(
     assert isinstance(workflow, dict)
     expected = fixture.get("expected")
     assert isinstance(expected, dict) and expected
+    if workflow.get("type") == "sdk.replay-conformance-report":
+        _execute_fixture(fixture)
+        return
     expected_error = expected.get("error")
     expected_replay_error = fixture.get("expected_replay_error")
     if isinstance(expected_replay_error, dict):