durable-workflow 2.8.0__tar.gz → 2.9.1__tar.gz

{durable_workflow-2.8.0/src/durable_workflow.egg-info → durable_workflow-2.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.8.0
+Version: 2.9.1
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -20,6 +20,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.27
+Requires-Dist: certifi>=2026.10.19
 Requires-Dist: fastavro<2,>=1.12.2
 Provides-Extra: telemetry
 Requires-Dist: opentelemetry-api<2,>=1.45.1; extra == "telemetry"

{durable_workflow-2.8.0 → durable_workflow-2.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.8.0"
+version = "2.9.1"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -34,6 +34,7 @@ classifiers = [
 ]
 dependencies = [
     "httpx>=0.27",
+    "certifi>=2026.10.19",
     "fastavro>=1.12.2,<2",
 ]
 
@@ -75,8 +76,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.8.0"
-registry-version = "2.8.0"
+product-train = "2.9.1"
+registry-version = "2.9.1"
 supported-server-versions = "2.8.0"
 worker-protocol-version = "1.20"
 control-plane-version = "2"

{durable_workflow-2.8.0 → durable_workflow-2.9.1}/src/durable_workflow/workflow.py

@@ -316,6 +316,13 @@ class ActivityRetryPolicy:
     budget for an already-scheduled activity. It is a server-side durable
     retry policy, not the SDK HTTP transport retry policy.
 
+    ``initial_interval_seconds`` and ``maximum_interval_seconds`` accept
+    fractional seconds. Each generated interval is capped first, then rounded
+    up to a whole second for the durable command. For example, an initial
+    interval of ``0.1`` becomes one second. The explicit ``backoff_seconds``
+    list instead takes integer seconds. This resolution does not guarantee
+    when a worker will start the next attempt.
+
     ``non_retryable_error_types`` names failure types that should bypass this
     retry budget. An activity worker can also report ``non_retryable=True`` on
     a failure to stop retrying that activity execution.
@@ -2056,6 +2063,16 @@ class WorkflowContext:
         self._workflow_stream_command_counter = 0
         self.logger = _ReplayLogger(_REPLAY_LOGGER)
 
+    @property
+    def workflow_id(self) -> str:
+        """Original workflow identity, retained across continue-as-new runs."""
+        return self._workflow_id
+
+    @property
+    def run_id(self) -> str:
+        """Current run identity, stable on replay and new after continue-as-new."""
+        return self._run_id
+
     def cancellation_scope(
         self, body: Callable[[], Any], *, shield_parent: bool = False,
     ) -> Generator[Any, Any, Any]:

{durable_workflow-2.8.0 → durable_workflow-2.9.1/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.8.0
+Version: 2.9.1
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -20,6 +20,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.27
+Requires-Dist: certifi>=2026.10.19
 Requires-Dist: fastavro<2,>=1.12.2
 Provides-Extra: telemetry
 Requires-Dist: opentelemetry-api<2,>=1.45.1; extra == "telemetry"

{durable_workflow-2.8.0 → durable_workflow-2.9.1}/src/durable_workflow.egg-info/SOURCES.txt

@@ -132,6 +132,7 @@ tests/test_sync_activities.py
 tests/test_telemetry.py
 tests/test_telemetry_carrier.py
 tests/test_testing_harness.py
+tests/test_threaded_heartbeat_example.py
 tests/test_update_signal_condition_replay.py
 tests/test_updates.py
 tests/test_wait_condition.py
@@ -142,6 +143,7 @@ tests/test_worker_telemetry_wire.py
 tests/test_workflow_entry_arguments.py
 tests/test_workflow_entrypoint_validation.py
 tests/test_workflow_handler_validation.py
+tests/test_workflow_identity.py
 tests/test_workflow_result_timeout.py
 tests/test_workflow_streams.py
 tests/test_workflow_updates_conformance.py

{durable_workflow-2.8.0 → durable_workflow-2.9.1}/src/durable_workflow.egg-info/requires.txt

@@ -1,4 +1,5 @@
 httpx>=0.27
+certifi>=2026.10.19
 fastavro<2,>=1.12.2
 
 [dev]

{durable_workflow-2.8.0 → durable_workflow-2.9.1}/tests/test_replay_regression_corpus.py

@@ -46,6 +46,7 @@ from tests.test_update_signal_condition_replay import (
     UpdateSignalConditionTimerWorkflow,
 )
 from tests.test_worker import compatible_cluster_info
+from tests.test_workflow_identity import IdentityAcrossReplay, IdentityContinueAsNew
 
 FIXTURE_SCHEMA = "durable-workflow.replay-regression/v1"
 FIXTURE_DIR = Path(__file__).parent / "fixtures" / "replay_regressions"
@@ -340,6 +341,8 @@ class NexusCooperativeDeliveryWorkflow:
 
 
 WORKFLOWS = [
+    IdentityAcrossReplay,
+    IdentityContinueAsNew,
     PersistedClockWorkflow,
     NexusCooperativeDeliveryWorkflow,
     NexusTerminalDeliveryWorkflow,
@@ -514,6 +517,8 @@ def _execute_fixture(fixture: dict[str, Any]) -> list[dict[str, Any]]:
             history,
             start_input,
             workflow_type=workflow_type,
+            workflow_id=workflow.get("workflow_id"),
+            run_id=workflow.get("run_id", ""),
             payload_codec=("json" if payload_codec is None else payload_codec),
         )
         commands = _command_documents(outcome.commands)

durable_workflow-2.9.1/tests/test_threaded_heartbeat_example.py

@@ -0,0 +1,125 @@
+"""Exercise the public example with real ActivityContext thread/loop behavior."""
+from __future__ import annotations
+
+import asyncio
+import importlib.util
+import unittest
+from pathlib import Path
+from threading import Event, Thread
+from threading import enumerate as threads
+from typing import Any
+
+from durable_workflow import activity
+from durable_workflow.activity import ActivityContext, ActivityInfo, _set_context
+from durable_workflow.errors import ActivityCancelled, ActivityLeaseAuthorityLost
+
+SPEC = importlib.util.spec_from_file_location(
+    "threaded_heartbeats_example",
+    Path(__file__).resolve().parents[1] / "examples" / "threaded_heartbeats.py",
+)
+assert SPEC is not None
+assert SPEC.loader is not None
+EXAMPLE = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(EXAMPLE)
+
+
+class HeartbeatClient:
+    def __init__(self, response: Any = None) -> None:
+        self.response = response if response is not None else {"can_continue": True}
+        self.calls: list[dict[str, Any]] = []
+        self.observed = Event()
+
+    async def heartbeat_activity_task(self, **request: Any) -> Any:
+        self.calls.append(request)
+        self.observed.set()
+        if isinstance(self.response, Exception):
+            raise self.response
+        return self.response
+
+
+class ThreadedHeartbeatExampleTest(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self) -> None:
+        self.client = HeartbeatClient()
+        self.ctx = ActivityContext(
+            info=ActivityInfo(
+                "task-original", "export", "attempt-original", 2, "reports", "worker-original",
+            ),
+            client=self.client,  # type: ignore[arg-type]
+        )
+        _set_context(self.ctx)
+
+    async def asyncTearDown(self) -> None:
+        _set_context(None)
+        self.assertFalse([thread for thread in threads() if thread.name == "activity-heartbeat"])
+
+    async def run_work(self, work: Any) -> Any:
+        return await asyncio.wait_for(
+            asyncio.to_thread(EXAMPLE.call_with_heartbeats, work, interval=0.01),
+            timeout=3,
+        )
+
+    async def test_new_thread_needs_the_captured_context(self) -> None:
+        errors: list[BaseException] = []
+
+        def look_up_context() -> None:
+            try:
+                activity.context()
+            except RuntimeError as error:
+                errors.append(error)
+
+        helper = Thread(target=look_up_context)
+        helper.start()
+        helper.join()
+        self.assertEqual(len(errors), 1)
+        self.assertIn("outside of an activity", str(errors[0]))
+
+    async def test_return_keeps_original_attempt_and_joins(self) -> None:
+        def work(cancelled: Event) -> dict[str, int]:
+            self.assertTrue(self.client.observed.wait(2))
+            self.assertFalse(cancelled.is_set())
+            return {"count": 7}
+
+        self.assertEqual(await self.run_work(work), {"count": 7})
+        self.assertTrue(self.client.calls)
+        for request in self.client.calls:
+            self.assertEqual(request["task_id"], "task-original")
+            self.assertEqual(request["activity_attempt_id"], "attempt-original")
+            self.assertEqual(request["lease_owner"], "worker-original")
+
+    async def test_work_error_also_joins(self) -> None:
+        original = ValueError("business call failed")
+
+        def work(cancelled: Event) -> None:
+            self.assertTrue(self.client.observed.wait(2))
+            raise original
+
+        with self.assertRaises(ValueError) as caught:
+            await self.run_work(work)
+        self.assertIs(caught.exception, original)
+
+    def cancelled_work(self, cancelled: Event) -> str:
+        self.assertTrue(cancelled.wait(2))
+        return "must not be returned"
+
+    async def test_cancellation_stops_work_and_preserves_type(self) -> None:
+        self.client.response = {"cancel_requested": True}
+        with self.assertRaises(ActivityCancelled):
+            await self.run_work(self.cancelled_work)
+
+    async def test_authority_loss_keeps_original_identity_and_reason(self) -> None:
+        self.client.response = {"can_continue": False, "reason": "activity_attempt_replaced"}
+        with self.assertRaises(ActivityLeaseAuthorityLost) as caught:
+            await self.run_work(self.cancelled_work)
+        self.assertEqual(caught.exception.task_id, "task-original")
+        self.assertEqual(caught.exception.reason, "activity_attempt_replaced")
+
+    async def test_transport_error_is_not_silently_lost(self) -> None:
+        original = OSError("transport unavailable")
+        self.client.response = original
+        with self.assertRaises(OSError) as caught:
+            await self.run_work(self.cancelled_work)
+        self.assertIs(caught.exception, original)
+
+    async def test_event_loop_call_refuses_before_work(self) -> None:
+        with self.assertRaisesRegex(RuntimeError, "synchronous activity thread"):
+            EXAMPLE.call_with_heartbeats(lambda cancelled: self.fail("must not run"))

durable_workflow-2.9.1/tests/test_workflow_identity.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import pytest
+
+from durable_workflow import serializer, workflow
+from durable_workflow.workflow import (
+    CompleteWorkflow,
+    ContinueAsNew,
+    ScheduleActivity,
+    WorkflowContext,
+    replay,
+)
+
+
+@workflow.defn(name="identity-across-replay")
+class IdentityAcrossReplay:
+    def run(self, ctx: WorkflowContext):  # type: ignore[no-untyped-def]
+        before = [ctx.workflow_id, ctx.run_id]
+        value = yield ctx.schedule_activity("identity", before)
+        return {"before": before, "after": [ctx.workflow_id, ctx.run_id], "value": value}
+
+
+@pytest.mark.parametrize("workflow_id", ["workflow-identity", "0", "17", "017"])
+def test_identity_survives_activity_suspension_and_cold_replay(workflow_id: str) -> None:
+    run_id = "original-run"
+    first = replay(IdentityAcrossReplay, [], [], workflow_id=workflow_id, run_id=run_id)
+    assert len(first.commands) == 1
+    assert isinstance(first.commands[0], ScheduleActivity)
+    assert first.commands[0].arguments == [workflow_id, run_id]
+
+    history = [{"event_type": "ActivityCompleted", "payload": {
+        "result": serializer.envelope("done", codec=serializer.AVRO_CODEC),
+    }}]
+    resumed = replay(IdentityAcrossReplay, history, [], workflow_id=workflow_id, run_id=run_id)
+    assert len(resumed.commands) == 1
+    assert isinstance(resumed.commands[0], CompleteWorkflow)
+    assert resumed.commands[0].result == {
+        "before": [workflow_id, run_id], "after": [workflow_id, run_id], "value": "done",
+    }
+
+
+@workflow.defn(name="identity-continue-as-new")
+class IdentityContinueAsNew:
+    def run(  # type: ignore[no-untyped-def]
+        self, ctx: WorkflowContext, again: bool,
+        prior_workflow_id: str | None = None, prior_run_id: str | None = None,
+    ):
+        if again:
+            return ctx.continue_as_new(False, ctx.workflow_id, ctx.run_id)
+        return {"current": [ctx.workflow_id, ctx.run_id], "prior": [prior_workflow_id, prior_run_id]}
+
+
+def test_successor_context_has_same_workflow_and_new_run_identity() -> None:
+    original = replay(IdentityContinueAsNew, [], [True], workflow_id="chain", run_id="run-one")
+    assert len(original.commands) == 1
+    command = original.commands[0]
+    assert isinstance(command, ContinueAsNew)
+    assert command.arguments == [False, "chain", "run-one"]
+
+    successor = replay(
+        IdentityContinueAsNew, [], command.arguments, workflow_id="chain", run_id="run-two",
+    )
+    assert len(successor.commands) == 1
+    assert isinstance(successor.commands[0], CompleteWorkflow)
+    assert successor.commands[0].result == {"current": ["chain", "run-two"], "prior": ["chain", "run-one"]}
+
+
+@pytest.mark.parametrize("attribute", ["workflow_id", "run_id"])
+def test_workflow_identity_is_read_only(attribute: str) -> None:
+    ctx = WorkflowContext(workflow_id="workflow", run_id="run")
+    with pytest.raises(AttributeError):
+        setattr(ctx, attribute, "replacement")