durable-workflow 0.4.63__tar.gz → 0.4.65__tar.gz

{durable_workflow-0.4.63/src/durable_workflow.egg-info → durable_workflow-0.4.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 0.4.63
+Version: 0.4.65
 Summary: Python SDK for the Durable Workflow server (language-neutral HTTP protocol)
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-0.4.63 → durable_workflow-0.4.65}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "0.4.63"
+version = "0.4.65"
 description = "Python SDK for the Durable Workflow server (language-neutral HTTP protocol)"
 readme = "README.md"
 requires-python = ">=3.10"

{durable_workflow-0.4.63 → durable_workflow-0.4.65}/src/durable_workflow/client.py

@@ -148,6 +148,7 @@ class NamespaceDescription:
     status: str | None = None
     created_at: str | None = None
     updated_at: str | None = None
+    deleted: dict[str, int] | None = None
     external_payload_storage: ExternalPayloadStoragePolicy | None = None
 
     @classmethod
@@ -155,6 +156,13 @@ class NamespaceDescription:
         external_payload_storage = None
         if isinstance(data.get("external_payload_storage"), dict):
             external_payload_storage = ExternalPayloadStoragePolicy.from_dict(data)
+        deleted = None
+        if isinstance(data.get("deleted"), dict):
+            deleted = {
+                str(key): value
+                for key, value in data["deleted"].items()
+                if isinstance(value, int)
+            }
 
         return cls(
             name=str(data.get("name", "")),
@@ -163,6 +171,7 @@ class NamespaceDescription:
             status=data.get("status"),
             created_at=data.get("created_at"),
             updated_at=data.get("updated_at"),
+            deleted=deleted,
             external_payload_storage=external_payload_storage,
         )
 
@@ -1572,6 +1581,19 @@ class Client:
             )
         return NamespaceDescription.from_dict(data)
 
+    async def delete_namespace(self, name: str) -> NamespaceDescription:
+        """Delete a namespace through the server lifecycle surface."""
+        data = await self._request("DELETE", f"/namespaces/{quote(name, safe='')}", context=name)
+        if not isinstance(data, dict):
+            raise ServerError(
+                200,
+                {
+                    "reason": "invalid_namespace_response",
+                    "message": f"expected JSON object, got {type(data).__name__}",
+                },
+            )
+        return NamespaceDescription.from_dict(data)
+
     async def set_namespace_external_storage(
         self,
         name: str | None = None,

{durable_workflow-0.4.63 → durable_workflow-0.4.65}/src/durable_workflow/workflow.py

@@ -2296,7 +2296,7 @@ def _replay_state(
             if _is_external_receiver_event(event_type):
                 explicit_sequence = _workflow_sequence(payload) is not None
                 if current_wait_id is None:
-                    if not explicit_sequence:
+                    if prefix_can_bind_to_first_wait or not explicit_sequence:
                         prefix_receivers.append(index)
                     continue
 
@@ -2562,9 +2562,31 @@ def _replay_state(
     first = True
     pending: list[Command] = []
     advanced_cmd: Any = None
+    terminal_condition_reopen_cmd: WaitCondition | None = None
+
+    def _condition_wait_has_pending_receivers(condition_wait_id: str | None) -> bool:
+        if condition_wait_id is None:
+            return False
+        return any(receiver.condition_wait_id == condition_wait_id for receiver in pending_receivers)
+
+    def _consume_terminal_condition_reopens() -> None:
+        nonlocal wait_yield_count
+        if terminal_condition_reopen_cmd is None:
+            return
+        while wait_yield_count < len(wait_opened):
+            opened = wait_opened[wait_yield_count]
+            if not _same_logical_condition_wait(opened, terminal_condition_reopen_cmd):
+                break
+            opened_id = opened.get("condition_wait_id")
+            if not isinstance(opened_id, str):
+                break
+            if opened_id in wait_resolutions or _condition_wait_has_pending_receivers(opened_id):
+                break
+            wait_yield_count += 1
 
     def _terminal_state(value: Any, *, include_pending: bool) -> _ReplayState:
         _apply_due_receivers()
+        _consume_terminal_condition_reopens()
         commands = list(pending) if include_pending else []
         if isinstance(value, ContinueAsNew):
             _assert_no_unconsumed_history("continue as new")
@@ -2652,6 +2674,9 @@ def _replay_state(
                     step = _next_unconsumed_recorded_step()
                     if step is not None:
                         _assert_step_matches(cmd, step)
+                # Terminal cleanup may only skip a later open after this
+                # yielded wait has already replayed at least one false reopen.
+                consumed_reopen_for_current_wait = False
                 while True:
                     resolution: str | None = None
                     opened: dict[str, Any] | None = None
@@ -2666,7 +2691,15 @@ def _replay_state(
                         if isinstance(opened_id, str):
                             resolution = wait_resolutions.get(opened_id)
                             _apply_condition_wait_receivers(opened_id)
+                    next_wait_index = wait_yield_count + 1
+                    has_reopened_same_wait = (
+                        opened is not None
+                        and next_wait_index < len(wait_opened)
+                        and _same_logical_condition_wait(wait_opened[next_wait_index], cmd)
+                    )
+
                     if resolution == "timed_out":
+                        terminal_condition_reopen_cmd = None
                         next_value = False
                         wait_yield_count += 1
                         break
@@ -2677,21 +2710,27 @@ def _replay_state(
                             message=f"wait_condition predicate raised: {exc}",
                             exception_type=type(exc).__name__,
                         )])
-                    if satisfied or resolution == "satisfied":
+                    if resolution == "satisfied":
+                        terminal_condition_reopen_cmd = None
+                        next_value = True
+                        wait_yield_count += 1
+                        break
+                    if satisfied:
+                        terminal_condition_reopen_cmd = (
+                            cmd
+                            if has_reopened_same_wait and consumed_reopen_for_current_wait
+                            else None
+                        )
                         next_value = True
                         wait_yield_count += 1
                         break
 
-                    next_wait_index = wait_yield_count + 1
                     # A single logical wait can be re-opened in history after
                     # non-satisfying signals. Consume repeated physical opens
                     # with the same key/fingerprint before declaring the
                     # logical wait still pending.
-                    if (
-                        opened is not None
-                        and next_wait_index < len(wait_opened)
-                        and _same_logical_condition_wait(wait_opened[next_wait_index], cmd)
-                    ):
+                    if has_reopened_same_wait:
+                        consumed_reopen_for_current_wait = True
                         wait_yield_count = next_wait_index
                         continue
 

{durable_workflow-0.4.63 → durable_workflow-0.4.65/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 0.4.63
+Version: 0.4.65
 Summary: Python SDK for the Durable Workflow server (language-neutral HTTP protocol)
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-0.4.63 → durable_workflow-0.4.65}/tests/test_client.py

@@ -1080,6 +1080,21 @@ class TestNamespaces:
         assert result.description == fixture["semantic_body"]["description"]
         assert result.retention_days == fixture["semantic_body"]["retention_days"]
 
+    @pytest.mark.asyncio
+    async def test_delete_namespace_matches_polyglot_fixture(self, client: Client) -> None:
+        fixture_path = Path(__file__).parent / "fixtures" / "control-plane" / "namespace-delete-parity.json"
+        fixture = json.loads(fixture_path.read_text())
+        resp = _mock_response(200, fixture["response_body"])
+
+        with patch.object(client._http, "request", new_callable=AsyncMock, return_value=resp) as mock:
+            result = await client.delete_namespace(**fixture["sdk_python"]["args"])
+
+        assert mock.call_args.args[:2] == (fixture["request"]["method"], f"/api{fixture['request']['path']}")
+        assert result.name == fixture["semantic_body"]["name"]
+        assert result.status == fixture["semantic_body"]["status"]
+        assert result.deleted is not None
+        assert sorted(result.deleted) == sorted(fixture["semantic_body"]["deleted_keys"])
+
     @pytest.mark.asyncio
     async def test_set_namespace_external_storage_matches_polyglot_fixture(self, client: Client) -> None:
         fixture_path = Path(__file__).parent / "fixtures" / "control-plane" / "namespace-set-storage-driver-parity.json"

{durable_workflow-0.4.63 → durable_workflow-0.4.65}/tests/test_wait_condition.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+import pytest
+
 from durable_workflow import serializer, workflow
+from durable_workflow.errors import NonDeterministicReplayError
 from durable_workflow.workflow import (
     CompleteWorkflow,
     FailWorkflow,
@@ -169,6 +172,40 @@ class SignalCounterUntilFinished:
         return self.current()
 
 
+@workflow.defn(name="two-same-key-signal-waits")
+class TwoSameKeySignalWaits:
+    def __init__(self) -> None:
+        self.ready = False
+        self.stage = "booting"
+        self.events: list[str] = []
+
+    @workflow.signal("release")
+    def release(self, label: str) -> None:
+        self.ready = True
+        self.events.append(f"signal:{label}")
+
+    @workflow.query("state")
+    def state(self) -> dict[str, object]:
+        return {
+            "ready": self.ready,
+            "stage": self.stage,
+            "events": list(self.events),
+        }
+
+    def run(self, ctx: WorkflowContext):  # type: ignore[no-untyped-def]
+        self.stage = "first"
+        yield ctx.wait_condition(lambda: self.ready, key="gate")
+        self.events.append("passed:first")
+
+        self.ready = False
+        self.stage = "second"
+        yield ctx.wait_condition(lambda: self.ready, key="gate")
+        self.events.append("passed:second")
+
+        self.stage = "completed"
+        return self.state()
+
+
 class TestCtxWaitCondition:
     def test_wait_condition_returns_dataclass_with_predicate_and_key(self) -> None:
         ctx = WorkflowContext(run_id="x")
@@ -562,6 +599,341 @@ class TestReplayWaitCondition:
         assert outcome.commands[0].result == expected
         assert query_state(SignalCounterUntilFinished, history, [], "current") == expected
 
+    def test_stale_sequence_after_condition_resolution_binds_to_next_wait(self) -> None:
+        history = [
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-advance",
+                    "condition_key": "advance",
+                    "sequence": 21,
+                },
+            },
+            _signal_received_event("advance", ["Ada"], workflow_sequence=21),
+            {
+                "event_type": "ConditionWaitSatisfied",
+                "payload": {
+                    "condition_wait_id": "wait-advance",
+                    "condition_key": "advance",
+                    "sequence": 21,
+                },
+            },
+            _signal_received_event("finish", [], workflow_sequence=21),
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-finish",
+                    "condition_key": "finish",
+                    "sequence": 22,
+                },
+            },
+        ]
+
+        expected = {
+            "stage": "completed",
+            "name": "Ada",
+            "finished": True,
+            "events": ["started", "signal:Ada", "advanced:Ada", "signal:finish", "finish"],
+        }
+
+        outcome = replay(TwoStageSignalWait, history, [])
+
+        assert len(outcome.commands) == 1
+        assert isinstance(outcome.commands[0], CompleteWorkflow)
+        assert outcome.commands[0].result == expected
+        assert query_state(TwoStageSignalWait, history, [], "state") == expected
+
+    def test_terminal_pending_same_key_wait_without_prior_reopen_remains_history(self) -> None:
+        history = [
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-before-finish",
+                    "condition_key": "done",
+                    "sequence": 21,
+                    "timeout_seconds": 30,
+                },
+            },
+            {
+                "event_type": "TimerScheduled",
+                "payload": {
+                    "timer_kind": "condition_timeout",
+                    "condition_wait_id": "wait-before-finish",
+                    "condition_key": "done",
+                    "sequence": 21,
+                    "delay_seconds": 30,
+                },
+            },
+            _signal_received_event("finish", [], workflow_sequence=21),
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-after-finish",
+                    "condition_key": "done",
+                    "sequence": 22,
+                    "timeout_seconds": 30,
+                },
+            },
+            {
+                "event_type": "TimerScheduled",
+                "payload": {
+                    "timer_kind": "condition_timeout",
+                    "condition_wait_id": "wait-after-finish",
+                    "condition_key": "done",
+                    "sequence": 22,
+                    "delay_seconds": 30,
+                },
+            },
+        ]
+
+        with pytest.raises(NonDeterministicReplayError) as exc_info:
+            replay(SignalCounterUntilFinished, history, [])
+
+        assert exc_info.value.workflow_sequence == 22
+        assert exc_info.value.expected_shape == "complete workflow"
+        assert "ConditionWaitOpened" in exc_info.value.recorded_event_types
+        assert "TimerScheduled" in exc_info.value.recorded_event_types
+
+    def test_terminal_stale_reopened_wait_after_false_reopen_is_consumed(self) -> None:
+        history = [
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-count-3",
+                    "condition_key": "done",
+                    "sequence": 20,
+                    "timeout_seconds": 30,
+                },
+            },
+            {
+                "event_type": "TimerScheduled",
+                "payload": {
+                    "timer_kind": "condition_timeout",
+                    "condition_wait_id": "wait-count-3",
+                    "condition_key": "done",
+                    "sequence": 20,
+                    "delay_seconds": 30,
+                },
+            },
+            _signal_received_event("increment", [3], workflow_sequence=20),
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-before-finish",
+                    "condition_key": "done",
+                    "sequence": 21,
+                    "timeout_seconds": 30,
+                },
+            },
+            {
+                "event_type": "TimerScheduled",
+                "payload": {
+                    "timer_kind": "condition_timeout",
+                    "condition_wait_id": "wait-before-finish",
+                    "condition_key": "done",
+                    "sequence": 21,
+                    "delay_seconds": 30,
+                },
+            },
+            _signal_received_event("finish", [], workflow_sequence=21),
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-after-finish",
+                    "condition_key": "done",
+                    "sequence": 22,
+                    "timeout_seconds": 30,
+                },
+            },
+            {
+                "event_type": "TimerScheduled",
+                "payload": {
+                    "timer_kind": "condition_timeout",
+                    "condition_wait_id": "wait-after-finish",
+                    "condition_key": "done",
+                    "sequence": 22,
+                    "delay_seconds": 30,
+                },
+            },
+        ]
+
+        expected = {
+            "count": 3,
+            "done": True,
+            "events": [
+                {"signal": "increment", "amount": 3, "count": 3},
+                {"signal": "finish", "count": 3},
+            ],
+        }
+
+        outcome = replay(SignalCounterUntilFinished, history, [])
+
+        assert len(outcome.commands) == 1
+        assert isinstance(outcome.commands[0], CompleteWorkflow)
+        assert outcome.commands[0].result == expected
+        assert query_state(SignalCounterUntilFinished, history, [], "current") == expected
+
+    @pytest.mark.parametrize(
+        ("resolution_event_type", "resolution_payload"),
+        [
+            (
+                "ConditionWaitTimedOut",
+                {
+                    "condition_wait_id": "wait-after-finish",
+                    "condition_key": "done",
+                    "sequence": 22,
+                },
+            ),
+            (
+                "ConditionWaitSatisfied",
+                {
+                    "condition_wait_id": "wait-after-finish",
+                    "condition_key": "done",
+                    "sequence": 22,
+                },
+            ),
+            (
+                "TimerFired",
+                {
+                    "timer_kind": "condition_timeout",
+                    "condition_wait_id": "wait-after-finish",
+                    "condition_key": "done",
+                    "sequence": 22,
+                },
+            ),
+        ],
+    )
+    def test_terminal_reopened_wait_with_resolution_remains_replay_history(
+        self,
+        resolution_event_type: str,
+        resolution_payload: dict[str, object],
+    ) -> None:
+        history = [
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-before-finish",
+                    "condition_key": "done",
+                    "sequence": 21,
+                    "timeout_seconds": 30,
+                },
+            },
+            {
+                "event_type": "TimerScheduled",
+                "payload": {
+                    "timer_kind": "condition_timeout",
+                    "condition_wait_id": "wait-before-finish",
+                    "condition_key": "done",
+                    "sequence": 21,
+                    "delay_seconds": 30,
+                },
+            },
+            _signal_received_event("finish", [], workflow_sequence=21),
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-after-finish",
+                    "condition_key": "done",
+                    "sequence": 22,
+                    "timeout_seconds": 30,
+                },
+            },
+            {
+                "event_type": "TimerScheduled",
+                "payload": {
+                    "timer_kind": "condition_timeout",
+                    "condition_wait_id": "wait-after-finish",
+                    "condition_key": "done",
+                    "sequence": 22,
+                    "delay_seconds": 30,
+                },
+            },
+            {
+                "event_type": resolution_event_type,
+                "payload": resolution_payload,
+            },
+        ]
+
+        with pytest.raises(NonDeterministicReplayError) as exc_info:
+            replay(SignalCounterUntilFinished, history, [])
+
+        assert exc_info.value.workflow_sequence == 22
+        assert exc_info.value.expected_shape == "complete workflow"
+        assert "ConditionWaitOpened" in exc_info.value.recorded_event_types
+        assert resolution_event_type in exc_info.value.recorded_event_types
+
+    def test_sequential_same_key_waits_do_not_consume_second_wait_as_reopen(self) -> None:
+        history = [
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-first",
+                    "condition_key": "gate",
+                    "sequence": 21,
+                },
+            },
+            _signal_received_event("release", ["first"], workflow_sequence=21),
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-second",
+                    "condition_key": "gate",
+                    "sequence": 22,
+                },
+            },
+            _signal_received_event("release", ["second"], workflow_sequence=22),
+        ]
+
+        expected = {
+            "ready": True,
+            "stage": "completed",
+            "events": [
+                "signal:first",
+                "passed:first",
+                "signal:second",
+                "passed:second",
+            ],
+        }
+
+        outcome = replay(TwoSameKeySignalWaits, history, [])
+
+        assert len(outcome.commands) == 1
+        assert isinstance(outcome.commands[0], CompleteWorkflow)
+        assert outcome.commands[0].result == expected
+        assert query_state(TwoSameKeySignalWaits, history, [], "state") == expected
+
+    def test_pending_sequential_same_key_wait_replays_as_pending_wait(self) -> None:
+        history = [
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-first",
+                    "condition_key": "gate",
+                    "sequence": 21,
+                },
+            },
+            _signal_received_event("release", ["first"], workflow_sequence=21),
+            {
+                "event_type": "ConditionWaitOpened",
+                "payload": {
+                    "condition_wait_id": "wait-second",
+                    "condition_key": "gate",
+                    "sequence": 22,
+                },
+            },
+        ]
+
+        outcome = replay(TwoSameKeySignalWaits, history, [])
+
+        assert len(outcome.commands) == 1
+        assert isinstance(outcome.commands[0], WaitCondition)
+        assert outcome.commands[0].condition_key == "gate"
+        assert query_state(TwoSameKeySignalWaits, history, [], "state") == {
+            "ready": False,
+            "stage": "second",
+            "events": ["signal:first", "passed:first"],
+        }
+
     def test_repeated_wait_after_activity_can_be_satisfied_by_later_signal(self) -> None:
         history = [
             {