durable-workflow 2.3.3__tar.gz → 2.3.5__tar.gz

{durable_workflow-2.3.3/src/durable_workflow.egg-info → durable_workflow-2.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.3.3
+Version: 2.3.5
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.3.3 → durable_workflow-2.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.3.3"
+version = "2.3.5"
 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.3.3"
-registry-version = "2.3.3"
+product-train = "2.3.5"
+registry-version = "2.3.5"
 supported-server-versions = "2.4.8"
 worker-protocol-version = "1.19"
 control-plane-version = "2"

{durable_workflow-2.3.3 → durable_workflow-2.3.5}/src/durable_workflow/client.py

@@ -1271,11 +1271,21 @@ class WorkflowHandle:
         """Return the server's current view of this workflow. See :meth:`Client.describe_workflow`."""
         return await self._client.describe_workflow(self.workflow_id)
 
-    async def get_history(self) -> Any:
-        """Fetch this run's durable history. See :meth:`Client.get_history`."""
+    async def get_history(
+        self,
+        *,
+        page_size: int | None = None,
+        next_page_token: str | None = None,
+    ) -> Any:
+        """Fetch one page of this run's history. See :meth:`Client.get_history`."""
         if self.run_id is None:
             raise ValueError("run_id is required to fetch workflow history from a handle")
-        return await self._client.get_history(self.workflow_id, self.run_id)
+        options: dict[str, Any] = {}
+        if page_size is not None:
+            options["page_size"] = page_size
+        if next_page_token is not None:
+            options["next_page_token"] = next_page_token
+        return await self._client.get_history(self.workflow_id, self.run_id, **options)
 
     async def export_history(self) -> Any:
         """Export this run's history as a replay bundle. See :meth:`Client.export_history`."""
@@ -3462,10 +3472,26 @@ class Client:
             next_page_token=data.get("next_page_token"),
         )
 
-    async def get_history(self, workflow_id: str, run_id: str) -> Any:
-        """Fetch the full durable history for one specific run of a workflow."""
+    async def get_history(
+        self,
+        workflow_id: str,
+        run_id: str,
+        *,
+        page_size: int | None = None,
+        next_page_token: str | None = None,
+    ) -> Any:
+        """Fetch one history page; pass its opaque next_page_token for the next page."""
+        params: dict[str, str] = {}
+        if page_size is not None:
+            params["page_size"] = str(page_size)
+        if next_page_token is not None:
+            params["next_page_token"] = next_page_token
+        query = urlencode(params)
+        path = f"/workflows/{workflow_id}/runs/{run_id}/history"
+        if query:
+            path += f"?{query}"
         return await self._request(
-            "GET", f"/workflows/{workflow_id}/runs/{run_id}/history", context=workflow_id
+            "GET", path, context=workflow_id
         )
 
     async def export_history(self, workflow_id: str, run_id: str) -> Any:
@@ -4240,34 +4266,44 @@ class Client:
                 run_id = handle.run_id or desc.run_id
                 if run_id is None:
                     raise WorkflowFailed("no run_id available to fetch history")
-                history = await self.get_history(handle.workflow_id, run_id)
-                events = history.get("events", [])
-                for ev in reversed(events):
-                    etype = ev.get("event_type")
-                    payload = ev.get("payload") or {}
-                    if etype == "WorkflowCompleted":
-                        return serializer.decode_envelope(
-                            payload.get("output"),
-                            codec=payload.get("payload_codec") or desc.payload_codec,
-                            external_storage=self.external_storage,
-                            external_storage_cache=self.external_storage_cache,
-                        )
-                    if etype == "WorkflowFailed":
-                        raise WorkflowFailed(
-                            payload.get("message", "workflow failed"),
-                            payload.get("exception_class"),
-                        )
-                    if etype == "WorkflowTerminated":
-                        raise WorkflowTerminated(
-                            payload.get("reason", "workflow was terminated")
-                        )
-                    if etype == "WorkflowCancelled":
-                        raise WorkflowCancelled(
-                            payload.get("reason", "workflow was cancelled")
-                        )
-                    if etype == "WorkflowTimedOut":
-                        raise WorkflowTimedOut()
-                return None
+                page_token: str | None = None
+                seen_tokens: set[str] = set()
+                while True:
+                    history = await self.get_history(
+                        handle.workflow_id, run_id, page_size=1000, next_page_token=page_token
+                    )
+                    events = history.get("events", [])
+                    for ev in reversed(events):
+                        etype = ev.get("event_type")
+                        payload = ev.get("payload") or {}
+                        if etype == "WorkflowCompleted":
+                            return serializer.decode_envelope(
+                                payload.get("output"),
+                                codec=payload.get("payload_codec") or desc.payload_codec,
+                                external_storage=self.external_storage,
+                                external_storage_cache=self.external_storage_cache,
+                            )
+                        if etype == "WorkflowFailed":
+                            raise WorkflowFailed(
+                                payload.get("message", "workflow failed"),
+                                payload.get("exception_class"),
+                            )
+                        if etype == "WorkflowTerminated":
+                            raise WorkflowTerminated(
+                                payload.get("reason", "workflow was terminated")
+                            )
+                        if etype == "WorkflowCancelled":
+                            raise WorkflowCancelled(
+                                payload.get("reason", "workflow was cancelled")
+                            )
+                        if etype == "WorkflowTimedOut":
+                            raise WorkflowTimedOut()
+                    page_token = history.get("next_page_token")
+                    if not page_token:
+                        return None
+                    if page_token in seen_tokens:
+                        raise RuntimeError("history pagination repeated a page token")
+                    seen_tokens.add(page_token)
             if asyncio.get_running_loop().time() > deadline:
                 raise TimeoutError(
                     f"workflow {handle.workflow_id} not terminal after {timeout}s (status={status})"

{durable_workflow-2.3.3 → durable_workflow-2.3.5}/src/durable_workflow/retry_policy.py

@@ -80,6 +80,18 @@ def _backend_unavailable_refusal(exc: Exception) -> tuple[bool, int | None]:
         "/api/worker/heartbeat": "heartbeat_worker",
     }
     operation = next((name for path, name in operations.items() if request.url.path.endswith(path)), None)
+    _, task_heartbeat_marker, task_heartbeat_tail = request.url.path.rpartition(
+        "/api/worker/workflow-tasks/"
+    )
+    task_id = task_heartbeat_tail.removesuffix("/heartbeat")
+    task_heartbeat = (
+        bool(task_heartbeat_marker)
+        and task_heartbeat_tail.endswith("/heartbeat")
+        and bool(task_id)
+        and "/" not in task_id
+    )
+    if task_heartbeat:
+        operation = "heartbeat_workflow_task"
     if operation is None:
         return False, None
     try:
@@ -97,6 +109,24 @@ def _backend_unavailable_refusal(exc: Exception) -> tuple[bool, int | None]:
     worker_id = submitted.get("worker_id")
     queue = submitted.get("task_queue")
     delay = body.get("retry_after_seconds")
+    if task_heartbeat:
+        lease_owner = submitted.get("lease_owner")
+        attempt = submitted.get("workflow_task_attempt")
+        if (
+            not isinstance(lease_owner, str) or not lease_owner
+            or type(attempt) is not int or attempt <= 0
+            or body.get("operation") != operation
+            or body.get("outcome") != "unknown"
+            or body.get("worker_id") != lease_owner
+            or body.get("task_queue") is not None
+            or body.get("task_id") != task_id
+            or body.get("lease_owner") != lease_owner
+            or body.get("workflow_task_attempt") != attempt
+            or body.get("retryable") is not True
+            or type(delay) is not int or delay <= 0
+        ):
+            return True, None
+        return True, delay
     if (
         not isinstance(worker_id, str) or not worker_id
         or body.get("operation") != operation

{durable_workflow-2.3.3 → durable_workflow-2.3.5/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.3.3
+Version: 2.3.5
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.3.3 → durable_workflow-2.3.5}/tests/test_client.py

@@ -791,6 +791,17 @@ class TestWorkflowRunVisibility:
 
 
 class TestWorkflowHandleControlPlane:
+    @pytest.mark.asyncio
+    async def test_history_page_token_is_encoded(self, client: Client) -> None:
+        response = _mock_response(200, {"events": [], "next_page_token": None})
+        with patch.object(client._http, "request", new_callable=AsyncMock, return_value=response) as request:
+            page = await client.get_history("wf-1", "run-1", page_size=1000, next_page_token="opaque+/=")
+
+        assert page["events"] == []
+        assert request.call_args.args[1] == (
+            "/api/workflows/wf-1/runs/run-1/history?page_size=1000&next_page_token=opaque%2B%2F%3D"
+        )
+
     @pytest.mark.asyncio
     async def test_run_visibility_delegates_to_client(self, client: Client) -> None:
         handle = WorkflowHandle(client, workflow_id="wf-1", run_id="r1", workflow_type="greeter")
@@ -3181,6 +3192,42 @@ class TestUpdateWorkflow:
 
 
 class TestGetResult:
+    @pytest.mark.asyncio
+    async def test_completed_result_on_later_history_page(self, client: Client) -> None:
+        handle = WorkflowHandle(client, workflow_id="wf-1", run_id="run-1", workflow_type="greeter")
+        client.describe_workflow = AsyncMock(
+            return_value=WorkflowExecution(
+                workflow_id="wf-1", run_id="run-1", workflow_type="greeter", status="completed",
+            )
+        )
+        client.get_history = AsyncMock(side_effect=[
+            {"events": [{"event_type": "WorkflowStarted"}], "next_page_token": "page two"},
+            {"events": [{"event_type": "WorkflowCompleted", "payload": {
+                "output": serializer.encode(42, codec="avro"), "payload_codec": "avro",
+            }}], "next_page_token": None},
+        ])
+
+        assert await client.get_result(handle) == 42
+        assert client.get_history.await_args_list[0].args == ("wf-1", "run-1")
+        assert client.get_history.await_args_list[0].kwargs == {"page_size": 1000, "next_page_token": None}
+        assert client.get_history.await_args_list[1].kwargs == {
+            "page_size": 1000, "next_page_token": "page two",
+        }
+
+    @pytest.mark.asyncio
+    async def test_repeated_history_page_token_fails(self, client: Client) -> None:
+        handle = WorkflowHandle(client, workflow_id="wf-1", run_id="run-1", workflow_type="greeter")
+        client.describe_workflow = AsyncMock(
+            return_value=WorkflowExecution(
+                workflow_id="wf-1", run_id="run-1", workflow_type="greeter", status="completed",
+            )
+        )
+        client.get_history = AsyncMock(return_value={"events": [], "next_page_token": "same"})
+
+        with pytest.raises(RuntimeError, match="repeated a page token"):
+            await client.get_result(handle)
+        assert client.get_history.await_count == 2
+
     @pytest.mark.asyncio
     async def test_completed_result_uses_event_payload_codec(self, client: Client) -> None:
         handle = WorkflowHandle(client, workflow_id="wf-1", run_id="run-1", workflow_type="greeter")

{durable_workflow-2.3.3 → durable_workflow-2.3.5}/tests/test_storage_admission.py

@@ -42,7 +42,8 @@ def pressure(poll_id: str | None = None, *, reason: str = "storage_pressure", en
 def backend_unavailable(request: httpx.Request) -> dict[str, Any]:
     submitted = json.loads(request.content)
     path = request.url.path
-    operation = {
+    task_heartbeat = "/api/worker/workflow-tasks/" in path and path.endswith("/heartbeat")
+    operation = "heartbeat_workflow_task" if task_heartbeat else {
         "/api/worker/workflow-tasks/poll": "poll_workflow_task",
         "/api/worker/activity-tasks/poll": "poll_activity_task",
         "/api/worker/query-tasks/poll": "poll_query_task",
@@ -51,9 +52,16 @@ def backend_unavailable(request: httpx.Request) -> dict[str, Any]:
     }[path]
     body: dict[str, Any] = {
         "reason": "backend_unavailable", "operation": operation, "outcome": "unknown",
-        "worker_id": submitted["worker_id"], "task_queue": submitted.get("task_queue"),
+        "worker_id": submitted.get("lease_owner") if task_heartbeat else submitted["worker_id"],
+        "task_queue": submitted.get("task_queue"),
         "retryable": True, "retry_after_seconds": 1,
     }
+    if task_heartbeat:
+        body.update({
+            "task_id": path.rpartition("/api/worker/workflow-tasks/")[2].removesuffix("/heartbeat"),
+            "lease_owner": submitted["lease_owner"],
+            "workflow_task_attempt": submitted["workflow_task_attempt"],
+        })
     if path.endswith("/poll"):
         body.update({
             "task": None, "poll_status": "backend_unavailable",
@@ -85,9 +93,9 @@ def retry_sleeps(monkeypatch: pytest.MonkeyPatch) -> list[float]:
     return sleeps
 
 
-def client_for(handler: Callable[..., Any]) -> Client:
+def client_for(handler: Callable[..., Any], base_url: str = "https://runtime.example") -> Client:
     client = Client(
-        "https://runtime.example", token="test-runtime-token",
+        base_url, token="test-runtime-token",
         retry_policy=TransportRetryPolicy(max_attempts=2, initial_backoff_seconds=0, jitter=False),
     )
     client._http = httpx.AsyncClient(base_url=client.base_url, transport=httpx.MockTransport(handler))
@@ -186,6 +194,57 @@ async def test_backend_outage_retries_worker_registration_and_heartbeat(
     assert sum(retry_sleeps) == pytest.approx(4)
 
 
+@pytest.mark.parametrize("base_url", ["https://runtime.example", "https://runtime.example/managed/namespace"])
+async def test_backend_outage_retries_workflow_task_heartbeat_with_same_fence(
+    base_url: str, retry_sleeps: list[float],
+) -> None:
+    requests: list[bytes] = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        requests.append(request.content)
+        if len(requests) <= 4:
+            return httpx.Response(503, json=backend_unavailable(request))
+        return httpx.Response(200, json={
+            "task_id": "task-1", "lease_owner": "worker-1",
+            "workflow_task_attempt": 3, "renewed": True,
+        })
+
+    async with client_for(handler, base_url) as client:
+        with worker_scope():
+            result = await client.heartbeat_workflow_task(
+                task_id="task-1", lease_owner="worker-1", workflow_task_attempt=3,
+            )
+    assert result["renewed"] is True
+    assert len(requests) == 5
+    assert len(set(requests)) == 1
+    assert sum(retry_sleeps) == pytest.approx(4)
+
+
+@pytest.mark.parametrize("override", [
+    {"task_id": "other-task"}, {"lease_owner": "other-worker"},
+    {"worker_id": "other-worker"}, {"workflow_task_attempt": 4},
+    {"operation": "heartbeat_worker"}, {"outcome": "failed"},
+    {"retryable": False}, {"retry_after_seconds": 0},
+])
+async def test_invalid_workflow_task_heartbeat_backend_response_is_not_retried(
+    override: dict[str, Any], retry_sleeps: list[float],
+) -> None:
+    calls = 0
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        nonlocal calls
+        calls += 1
+        return httpx.Response(503, json={**backend_unavailable(request), **override})
+
+    async with client_for(handler) as client:
+        with worker_scope(), pytest.raises(ServerError):
+            await client.heartbeat_workflow_task(
+                task_id="task-1", lease_owner="worker-1", workflow_task_attempt=3,
+            )
+    assert calls == 1
+    assert not retry_sleeps
+
+
 @pytest.mark.parametrize("override", [
     {"operation": "poll_activity_task"},
     {"outcome": "failed"}, {"worker_id": "other-worker"},

{durable_workflow-2.3.3 → durable_workflow-2.3.5}/tests/test_workflow_result_timeout.py

@@ -28,7 +28,9 @@ async def test_persisted_deadline_raises_typed_timeout_for_selected_history(kind
     try:
         with pytest.raises(WorkflowTimedOut, match="workflow execution timed out"):
             await client.get_result(handle, timeout=0)
-        client.get_history.assert_awaited_once_with("order", "selected-run")
+        client.get_history.assert_awaited_once_with(
+            "order", "selected-run", page_size=1000, next_page_token=None
+        )
     finally:
         await client.aclose()