durable-workflow 2.5.0__tar.gz → 2.5.1__tar.gz

{durable_workflow-2.5.0/src/durable_workflow.egg-info → durable_workflow-2.5.1}/PKG-INFO

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

{durable_workflow-2.5.0 → durable_workflow-2.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.5.0"
+version = "2.5.1"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -71,9 +71,9 @@ 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.0"
-registry-version = "2.5.0"
-supported-server-versions = "2.5.0"
+product-train = "2.5.1"
+registry-version = "2.5.1"
+supported-server-versions = "2.5.16"
 worker-protocol-version = "1.19"
 control-plane-version = "2"
 durable-selection = true

{durable_workflow-2.5.0 → durable_workflow-2.5.1}/src/durable_workflow/workflow.py

@@ -5185,6 +5185,96 @@ def _replay_state(
     pending: list[Command] = []
     advanced_cmd: Any = None
     terminal_condition_reopen_cmd: WaitCondition | None = None
+    version_decisions: dict[str, tuple[int, str]] = {}
+
+    def _version_error(detail: str, step: _RecordedStep | None = None) -> NonDeterministicReplayError:
+        return NonDeterministicReplayError(
+            step.workflow_sequence if step is not None else authored_sequence,
+            "compatible version marker",
+            step.event_types if step is not None else [],
+            detail=detail,
+        )
+
+    def _recorded_version(step: _RecordedStep) -> int:
+        if step.history_index is None:
+            raise _version_error("Version marker is missing its history position.", step)
+        payload = events[step.history_index].get("payload") or {}
+        version = payload.get("version")
+        if type(version) is not int:
+            raise _version_error("Version marker must contain an integer version.", step)
+        change_id = payload.get("change_id")
+        if "change_id" in payload and (not isinstance(change_id, str) or not change_id.strip()):
+            raise _version_error("Version marker must retain a non-empty change ID.", step)
+        if "min_supported" in payload or "max_supported" in payload:
+            minimum, maximum = payload.get("min_supported"), payload.get("max_supported")
+            if (type(minimum) is not int or type(maximum) is not int
+                    or not minimum <= version <= maximum):
+                raise _version_error("Recorded version marker has an invalid supported range.", step)
+        return version
+
+    def _consume_duplicate_version_markers() -> None:
+        nonlocal result_cursor, authored_sequence
+        if not version_decisions:
+            return
+        while result_cursor < len(recorded_steps):
+            step = recorded_steps[result_cursor]
+            change_id = step.details.get("change_id")
+            if step.shape != "version marker" or change_id not in version_decisions:
+                return
+            if _next_unconsumed_recorded_step() is not step:
+                return
+            version = _recorded_version(step)
+            if version != version_decisions[change_id][0]:
+                raise _version_error(f"Conflicting recorded decisions for change ID {change_id!r}.", step)
+            # Earlier SDKs emitted a marker for every invocation. Consume these
+            # aliases while retaining their physical positions for cancellation
+            # and prepared operations. The stored history itself is unchanged.
+            result_cursor += 1
+            authored_sequence = max(authored_sequence, step.workflow_sequence + 1)
+
+    def _resolve_version(command: RecordVersionMarker) -> Any:
+        nonlocal result_cursor, authored_sequence
+        change_id = command.change_id
+        if not isinstance(change_id, str) or not change_id.strip():
+            raise _version_error("Version markers require a stable non-empty change ID.")
+        if (type(command.min_supported) is not int or type(command.max_supported) is not int
+                or command.min_supported > command.max_supported):
+            raise _version_error(f"Invalid supported range for change ID {change_id!r}.")
+        family = "version" if command.result_kind == "version" else "patch"
+        decision = version_decisions.get(change_id)
+        step = _next_unconsumed_recorded_step()
+        if decision is not None:
+            version, original_family = decision
+            if original_family != family:
+                raise _version_error(f"Change ID {change_id!r} cannot switch between version and patch helpers.", step)
+        elif step is not None and step.shape == "version marker":
+            _assert_step_matches(command, step)
+            version = _recorded_version(step)
+            result_cursor += 1
+            authored_sequence = max(authored_sequence, step.workflow_sequence + 1)
+        elif step is not None or (cancellation.delivery is not None and not cancellation_consumed) or any(
+            sequence not in consumed_scope_deliveries for sequence in committed_scopes.deliveries
+        ) or any(_history_event_type(event) in {
+            "WorkflowCompleted", "WorkflowFailed", "WorkflowCancelled", "WorkflowTerminated",
+            "WorkflowContinuedAsNew", "WorkflowTimedOut",
+        } for event in events):
+            # An unmarked recorded command proves this history passed the new
+            # patch site. Leave that command available for its original call.
+            version = -1
+        else:
+            version = command.version
+            if type(version) is not int:
+                raise _version_error(f"Invalid version for change ID {change_id!r}.")
+            ctx.logger._set_replaying(False)
+            pending.append(command)
+            authored_sequence += 1
+        if not command.min_supported <= version <= command.max_supported:
+            raise _version_error(
+                f"Recorded version {version} for change ID {change_id!r} is outside "
+                f"the supported range {command.min_supported}..{command.max_supported}.", step,
+            )
+        version_decisions.setdefault(change_id, (version, family))
+        return _version_marker_result(command, version)
 
     def _parallel_leaf_kind(command: Any) -> str:
         if isinstance(command, ScheduleActivity | RecordLocalActivity):
@@ -6064,6 +6154,7 @@ def _replay_state(
     replay_token = _ACTIVE_WORKFLOW_REPLAY.set(ctx)
     try:
         while True:
+            _consume_duplicate_version_markers()
             # Cursor-0 receivers are start-boundary events. Enter run() once
             # before applying them so workflow initialization observes the
             # same WorkflowStarted-before-Signal/Update ordering the server
@@ -6081,6 +6172,9 @@ def _replay_state(
                 first = False
             _apply_due_receivers()
             _validate_local_activity_policies(cmd)
+            if isinstance(cmd, RecordVersionMarker):
+                next_value = _resolve_version(cmd)
+                continue
             if prepare_local_activities and isinstance(cmd, list | SelectGroup) and _contains_local_activity(cmd) and (
                 not prepare_local_activity_groups or isinstance(cmd, SelectGroup)
             ):
@@ -6497,18 +6591,6 @@ def _replay_state(
                 pending.append(cmd)
                 next_value = None
                 continue
-            if isinstance(cmd, RecordVersionMarker):
-                if result_cursor < len(resolved_results):
-                    _assert_next_step_matches(cmd)
-                    val = resolved_results[result_cursor]
-                    result_cursor += 1
-                    next_value = _version_marker_result(cmd, val)
-                    continue
-                ctx.logger._set_replaying(False)
-                _assert_pending_step_matches(cmd)
-                pending.append(cmd)
-                next_value = _version_marker_result(cmd, cmd.version)
-                continue
             if isinstance(cmd, WaitCondition):
                 # A condition that is already true is not persisted. Apply
                 # receivers at the yield boundary before deciding whether the

{durable_workflow-2.5.0 → durable_workflow-2.5.1/src/durable_workflow.egg-info}/PKG-INFO

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

{durable_workflow-2.5.0 → durable_workflow-2.5.1}/src/durable_workflow.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ tests/test_metrics.py
 tests/test_order_processing_example.py
 tests/test_parallel_completion_order_replay.py
 tests/test_parallel_saga_authoring.py
+tests/test_patch_history.py
 tests/test_pending_operation_replay.py
 tests/test_prepared_local_activity_client.py
 tests/test_prepared_local_activity_groups.py

{durable_workflow-2.5.0 → durable_workflow-2.5.1}/tests/test_cooperative_remote_worker.py

@@ -47,22 +47,29 @@ def stop_receipt() -> dict[str, Any]:
             "heartbeat_recorded": False, "history_event_id": "receipt-event"}
 
 
+def write_pid_marker(marker: str) -> None:
+    target = Path(marker)
+    pending = target.with_name(target.name + ".pending")
+    pending.write_text(str(os.getpid()))
+    pending.replace(target)
+
+
 async def blocked_async(marker: str, heartbeat: bool = False) -> None:
     if heartbeat:
         await activity.context().heartbeat({"authored": True})
-    Path(marker).write_text(str(os.getpid()))
+    write_pid_marker(marker)
     await asyncio.Event().wait()
 
 
 def blocked_sync(marker: str, heartbeat: bool = False) -> None:
     if heartbeat:
         asyncio.run(activity.context().heartbeat({"authored": True}))
-    Path(marker).write_text(str(os.getpid()))
+    write_pid_marker(marker)
     time.sleep(60)
 
 
 def released_sync(marker: str) -> bytes:
-    Path(marker).write_text(str(os.getpid()))
+    write_pid_marker(marker)
     while not Path(marker + ".release").exists():
         time.sleep(0.02)
     return b"late result"

durable_workflow-2.5.1/tests/test_patch_history.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from durable_workflow import serializer, workflow
+from durable_workflow.errors import NonDeterministicReplayError, WorkflowCancelled
+from durable_workflow.workflow import CompleteWorkflow, RecordVersionMarker, ScheduleActivity, replay
+from tests.test_cooperative_cancellation import marker as cancellation_marker
+from tests.test_cooperative_cancellation import request
+
+
+def version_marker(sequence: int, change_id: str = "same", version: int = 1) -> dict[str, Any]:
+    return {"event_type": "VersionMarkerRecorded", "payload": {
+        "sequence": sequence, "change_id": change_id, "version": version,
+        "min_supported": -1, "max_supported": 1,
+    }}
+
+
+def old_activity(sequence: int, completed: bool = True) -> list[dict[str, Any]]:
+    history = [{"event_type": "ActivityScheduled", "payload": {
+        "sequence": sequence, "activity_type": "old",
+    }}]
+    if completed:
+        history.append({"event_type": "ActivityCompleted", "payload": {
+            "sequence": sequence, "activity_type": "old", "result": serializer.encode("recorded"),
+            "payload_codec": "avro",
+        }})
+    return history
+
+
+@workflow.defn(name="tests.patch.insertion")
+class PatchInsertionWorkflow:
+    def run(self, ctx):  # type: ignore[no-untyped-def]
+        if (yield ctx.patched("same")):
+            yield ctx.schedule_activity("new", [])
+        return (yield ctx.schedule_activity("old", []))
+
+
+@workflow.defn(name="tests.patch.repeated")
+class RepeatedPatchWorkflow:
+    def run(self, ctx, repeat=True):  # type: ignore[no-untyped-def]
+        first = yield ctx.patched("same")
+        second = (yield ctx.patched("same")) if repeat else first
+        result = yield ctx.schedule_activity("old", [])
+        return [first, second, result]
+
+
+@workflow.defn(name="tests.patch.interleaved")
+class InterleavedPatchWorkflow:
+    def run(self, ctx, repeat=True):  # type: ignore[no-untyped-def]
+        first = yield ctx.patched("same")
+        result = yield ctx.schedule_activity("old", [])
+        second = (yield ctx.patched("same")) if repeat else first
+        return [first, second, result]
+
+
+@workflow.defn(name="tests.patch.ranges")
+class VersionRangeWorkflow:
+    def run(self, ctx, minimum=1, mixed=False):  # type: ignore[no-untyped-def]
+        first = yield ctx.get_version("same", 1, 2)
+        second = (yield ctx.patched("same")) if mixed else (yield ctx.get_version("same", minimum, 3))
+        return [first, second]
+
+
+@workflow.defn(name="tests.patch.cancellation")
+class PatchCancellationWorkflow:
+    def run(self, ctx):  # type: ignore[no-untyped-def]
+        decisions = [(yield ctx.patched("same")), (yield ctx.patched("same"))]
+        try:
+            yield ctx.schedule_activity("old", [])
+        except WorkflowCancelled:
+            return [decisions, "cancelled"]
+
+
+@pytest.mark.parametrize("completed", [False, True])
+def test_inserted_patch_preserves_unmarked_activity(completed: bool) -> None:
+    outcome = replay(PatchInsertionWorkflow, old_activity(1, completed), [])
+    if completed:
+        assert len(outcome.commands) == 1
+        command = outcome.commands[0]
+        assert isinstance(command, CompleteWorkflow)
+        assert command.result == "recorded"
+    else:
+        # The old activity is already scheduled. Await it without duplicating
+        # that command or introducing the new patched activity.
+        assert outcome.commands == []
+
+
+def test_repeated_patch_emits_one_marker_on_new_history() -> None:
+    commands = replay(RepeatedPatchWorkflow, [], []).commands
+    assert [type(command) for command in commands] == [RecordVersionMarker, ScheduleActivity]
+
+
+@pytest.mark.parametrize("repeat", [False, True])
+@pytest.mark.parametrize("duplicates", [False, True])
+def test_old_consistent_duplicate_markers_remain_replayable(repeat: bool, duplicates: bool) -> None:
+    history = [version_marker(1)]
+    if duplicates:
+        history.append(version_marker(2))
+    history += old_activity(3 if duplicates else 2)
+    commands = replay(RepeatedPatchWorkflow, history, [repeat]).commands
+    assert len(commands) == 1
+    assert isinstance(commands[0], CompleteWorkflow)
+    assert commands[0].result == [True, True, "recorded"]
+
+
+@pytest.mark.parametrize("repeat", [False, True])
+def test_duplicate_markers_after_an_activity_remain_replayable(repeat: bool) -> None:
+    history = [version_marker(1)] + old_activity(2) + [version_marker(3)]
+    commands = replay(InterleavedPatchWorkflow, history, [repeat]).commands
+    assert len(commands) == 1
+    assert isinstance(commands[0], CompleteWorkflow)
+    assert commands[0].result == [True, True, "recorded"]
+
+
+def test_repeated_version_reuses_first_decision() -> None:
+    commands = replay(VersionRangeWorkflow, [], []).commands
+    assert [type(command) for command in commands] == [RecordVersionMarker, CompleteWorkflow]
+    assert commands[-1].result == [2, 2]
+
+
+@pytest.mark.parametrize("arguments", [[3], [1, True]])
+def test_repeated_version_rejects_incompatible_range_or_family(arguments: list[Any]) -> None:
+    with pytest.raises(NonDeterministicReplayError):
+        replay(VersionRangeWorkflow, [], arguments)
+
+
+@pytest.mark.parametrize("version", [-1, 2, True])
+def test_conflicting_duplicate_marker_is_rejected(version: Any) -> None:
+    history = [version_marker(1), version_marker(2, version=version)] + old_activity(3)
+    with pytest.raises(NonDeterministicReplayError):
+        replay(RepeatedPatchWorkflow, history, [])
+
+
+@pytest.mark.parametrize("marker_count", [0, 1, 2])
+def test_patch_decisions_preserve_committed_cancellation_sequence(marker_count: int) -> None:
+    history = [version_marker(sequence) for sequence in range(1, marker_count + 1)]
+    history += old_activity(marker_count + 1, False)
+    history += [request(), cancellation_marker(marker_count + 1)]
+    commands = replay(PatchCancellationWorkflow, history, [], run_id="run-1").commands
+    assert len(commands) == 1
+    assert isinstance(commands[0], CompleteWorkflow)
+    assert commands[0].result == [[marker_count > 0, marker_count > 0], "cancelled"]

{durable_workflow-2.5.0 → durable_workflow-2.5.1}/tests/test_replay_regression_corpus.py

@@ -24,6 +24,7 @@ from tests.test_golden_history_replay import (
     GoldenTimeoutWaitWorkflow,
     GoldenVersionMarkerWorkflow,
 )
+from tests.test_patch_history import PatchCancellationWorkflow, PatchInsertionWorkflow, RepeatedPatchWorkflow
 from tests.test_pending_operation_replay import PendingOperation
 from tests.test_update_signal_condition_replay import (
     PostConditionReceiversWorkflow,
@@ -266,6 +267,9 @@ WORKFLOWS = [
     NestedParallelPathWorkflow,
     ParallelMetadataProducerWorkflow,
     ParallelResultBindingWorkflow,
+    PatchCancellationWorkflow,
+    PatchInsertionWorkflow,
+    RepeatedPatchWorkflow,
     PendingOperation,
     PagedRecordedSideEffectsWorkflow,
     PostConditionReceiversWorkflow,