durable-workflow 2.5.2__tar.gz → 2.5.4__tar.gz

{durable_workflow-2.5.2/src/durable_workflow.egg-info → durable_workflow-2.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.2
+Version: 2.5.4
 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.2 → durable_workflow-2.5.4}/pyproject.toml

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

{durable_workflow-2.5.2 → durable_workflow-2.5.4}/src/durable_workflow/__init__.py

@@ -70,6 +70,7 @@ from .errors import (
     ChildWorkflowCancelled,
     ChildWorkflowFailed,
     ChildWorkflowTerminated,
+    DuplicateRegistrationError,
     DurableOperationCancelled,
     DurableWorkflowError,
     ExternalPayloadError,
@@ -370,6 +371,7 @@ __all__ = [
     "NexusOperationResult",
     "NexusServiceCall",
     "NonDeterministicReplayError",
+    "DuplicateRegistrationError",
     "InvalidWorkflowDefinition",
     "NoopMetrics",
     "QueryFailed",

{durable_workflow-2.5.2 → durable_workflow-2.5.4}/src/durable_workflow/errors.py

@@ -31,6 +31,30 @@ class InvalidWorkflowDefinition(DurableWorkflowError, ValueError):
     """Workflow authoring uses an unsupported entry point or result."""
 
 
+class DuplicateRegistrationError(DurableWorkflowError, ValueError):
+    """One registration scope assigns a wire name to multiple definitions."""
+
+    def __init__(
+        self, registration_kind: str, wire_name: str,
+        first_definition: object, second_definition: object,
+    ) -> None:
+        def label(definition: object) -> str:
+            if isinstance(definition, str):
+                return definition
+            module = getattr(definition, "__module__", type(definition).__module__)
+            name = getattr(definition, "__qualname__", type(definition).__qualname__)
+            return f"{module}.{name}"
+
+        self.registration_kind = registration_kind
+        self.wire_name = wire_name
+        self.first_definition = label(first_definition)
+        self.second_definition = label(second_definition)
+        super().__init__(
+            f"duplicate {registration_kind} name {wire_name!r}: "
+            f"{self.first_definition} conflicts with {self.second_definition}"
+        )
+
+
 class DurableOperationCancelled(DurableWorkflowError):
     """A durable selection member was explicitly cancelled."""
 

{durable_workflow-2.5.2 → durable_workflow-2.5.4}/src/durable_workflow/testing.py

@@ -39,7 +39,7 @@ from pathlib import Path
 from typing import Any
 
 from . import serializer
-from .errors import WorkflowCancelled, WorkflowFailed, WorkflowTerminated
+from .errors import DuplicateRegistrationError, WorkflowCancelled, WorkflowFailed, WorkflowTerminated
 from .workflow import (
     CompleteWorkflow,
     ContinueAsNew,
@@ -52,6 +52,7 @@ from .workflow import (
     StartTimer,
     UpsertSearchAttributes,
     _validate_workflow_entrypoint,
+    _workflow_handler_registries,
     registry,
     replay,
 )
@@ -136,6 +137,9 @@ class WorkflowEnvironment:
                 "decorate it with @workflow.defn(name=...) first."
             )
         _validate_workflow_entrypoint(workflow_cls)
+        _workflow_handler_registries(workflow_cls)
+        if name in self._registered_workflows and self._registered_workflows[name] is not workflow_cls:
+            raise DuplicateRegistrationError("workflow", name, self._registered_workflows[name], workflow_cls)
         self._registered_workflows[name] = workflow_cls
 
     def signal(

{durable_workflow-2.5.2 → durable_workflow-2.5.4}/src/durable_workflow/worker.py

@@ -66,9 +66,11 @@ from .errors import (
     ActivityCancelled,
     ActivityFailed,
     AvroNotInstalledError,
+    DuplicateRegistrationError,
     DurableWorkflowError,
     ExternalPayloadError,
     InvalidArgument,
+    NonDeterministicReplayError,
     NonRetryableError,
     QueryFailed,
     ServerError,
@@ -105,6 +107,7 @@ from .workflow import (
     StartChildWorkflow,
     UpsertMemo,
     _validate_workflow_entrypoint,
+    _workflow_handler_registries,
     apply_update,
     commands_to_server_commands,
     query_state,
@@ -1027,7 +1030,11 @@ class Worker:
         self.workflows: dict[str, type] = {}
         for definition in workflows:
             _validate_workflow_entrypoint(definition)
-            self.workflows[_workflow_name(definition)] = definition
+            _workflow_handler_registries(definition)
+            name = _workflow_name(definition)
+            if name in self.workflows:
+                raise DuplicateRegistrationError("workflow", name, self.workflows[name], definition)
+            self.workflows[name] = definition
         self.workflow_definition_fingerprints = {
             workflow_type: _workflow_definition_fingerprint(workflow_cls)
             for workflow_type, workflow_cls in self.workflows.items()
@@ -1036,7 +1043,12 @@ class Worker:
             workflow_type: _workflow_command_contract(workflow_cls)
             for workflow_type, workflow_cls in self.workflows.items()
         }
-        self.activities = {_activity_name(a): a for a in activities}
+        self.activities: dict[str, Callable[..., Any]] = {}
+        for activity_definition in activities:
+            name = _activity_name(activity_definition)
+            if name in self.activities:
+                raise DuplicateRegistrationError("activity", name, self.activities[name], activity_definition)
+            self.activities[name] = activity_definition
         self.capabilities = tuple(dict.fromkeys(capability.strip() for capability in capabilities))
         self._sticky_cache = StickyWorkflowCache(
             sticky_cache_capacity, sticky_cache_max_bytes, sticky_cache_ttl_seconds,
@@ -2502,20 +2514,35 @@ class Worker:
 
         update_id = task.get("workflow_update_id")
         if isinstance(update_id, str) and update_id:
-            update_command = apply_update(
-                cls,
-                history,
-                start_input,
-                update_id,
-                workflow_id=task.get("workflow_id"),
-                run_id=run_id,
-                payload_codec=codec,
-                external_storage=self.external_storage,
-                external_storage_cache=self.external_storage_cache,
-                prepare_local_activities=self._prepared_local_activities_supported,
-                prepare_local_activity_groups=self._prepared_local_activity_groups_supported,
-                local_activity_cancellation_policies=self._local_activity_cancellation_policies,
-            )
+            try:
+                update_command = apply_update(
+                    cls,
+                    history,
+                    start_input,
+                    update_id,
+                    workflow_id=task.get("workflow_id"),
+                    run_id=run_id,
+                    payload_codec=codec,
+                    external_storage=self.external_storage,
+                    external_storage_cache=self.external_storage_cache,
+                    prepare_local_activities=self._prepared_local_activities_supported,
+                    prepare_local_activity_groups=self._prepared_local_activity_groups_supported,
+                    local_activity_cancellation_policies=self._local_activity_cancellation_policies,
+                )
+            except NonDeterministicReplayError as exc:
+                log.exception("workflow update task %s replay failed for run %s", task_id, run_id)
+                try:
+                    await self.client.fail_workflow_task(
+                        task_id=task_id,
+                        lease_owner=self.worker_id,
+                        workflow_task_attempt=attempt,
+                        message=f"workflow replay failed before update {update_id!r}: {exc}",
+                        failure_type=type(exc).__name__,
+                        stack_trace=traceback.format_exc(),
+                    )
+                except Exception as failure_error:
+                    log.warning("failed to report update replay failure: %s", failure_error)
+                return None
             command = update_command.to_server_command(
                 self.task_queue,
                 payload_codec=command_codec,

{durable_workflow-2.5.2 → durable_workflow-2.5.4}/src/durable_workflow/workflow.py

@@ -58,6 +58,7 @@ from .errors import (
     ChildWorkflowCancelled,
     ChildWorkflowFailed,
     ChildWorkflowTerminated,
+    DuplicateRegistrationError,
     DurableOperationCancelled,
     InvalidWorkflowDefinition,
     NexusOperationFailed,
@@ -124,6 +125,29 @@ def _validate_workflow_result(value: Any, cls: type) -> None:
         )
 
 
+def _workflow_handler_registries(
+    cls: type,
+) -> tuple[dict[str, str], dict[str, str], dict[str, str], dict[str, str]]:
+    handlers: dict[str, dict[str, str]] = {kind: {} for kind in ("signal", "query", "update", "update_validator")}
+    for attr in dir(cls):
+        if attr.startswith("_"):
+            continue
+        member = getattr(cls, attr, None)
+        for kind, registry in handlers.items():
+            wire_name = getattr(member, f"__{kind}_name__", None)
+            if not isinstance(wire_name, str) or not wire_name:
+                continue
+            if kind == "signal" and wire_name == MESSAGE_STREAM_SIGNAL:
+                raise ValueError(f"signal name {wire_name!r} is reserved by the workflow runtime")
+            if wire_name in registry:
+                owner = f"{cls.__module__}.{cls.__qualname__}"
+                raise DuplicateRegistrationError(
+                    kind, wire_name, f"{owner}.{registry[wire_name]}", f"{owner}.{attr}",
+                )
+            registry[wire_name] = attr
+    return handlers["signal"], handlers["query"], handlers["update"], handlers["update_validator"]
+
+
 def defn(*, name: str) -> Callable[[type[_WorkflowT]], type[_WorkflowT]]:
     """Register a class as a workflow type under a language-neutral name.
 
@@ -136,28 +160,7 @@ def defn(*, name: str) -> Callable[[type[_WorkflowT]], type[_WorkflowT]]:
     def wrap(cls: type[_WorkflowT]) -> type[_WorkflowT]:
         cls.__workflow_name__ = name  # type: ignore[attr-defined]
         _validate_workflow_entrypoint(cls)
-        signals: dict[str, str] = {}
-        queries: dict[str, str] = {}
-        updates: dict[str, str] = {}
-        update_validators: dict[str, str] = {}
-        for attr in dir(cls):
-            if attr.startswith("_"):
-                continue
-            member = getattr(cls, attr, None)
-            signal_name = getattr(member, "__signal_name__", None)
-            if isinstance(signal_name, str) and signal_name:
-                if signal_name == MESSAGE_STREAM_SIGNAL:
-                    raise ValueError(f"signal name {signal_name!r} is reserved by the workflow runtime")
-                signals[signal_name] = attr
-            query_name = getattr(member, "__query_name__", None)
-            if isinstance(query_name, str) and query_name:
-                queries[query_name] = attr
-            update_name = getattr(member, "__update_name__", None)
-            if isinstance(update_name, str) and update_name:
-                updates[update_name] = attr
-            update_validator_name = getattr(member, "__update_validator_name__", None)
-            if isinstance(update_validator_name, str) and update_validator_name:
-                update_validators[update_validator_name] = attr
+        signals, queries, updates, update_validators = _workflow_handler_registries(cls)
         cls.__workflow_signals__ = signals  # type: ignore[attr-defined]
         cls.__workflow_queries__ = queries  # type: ignore[attr-defined]
         cls.__workflow_updates__ = updates  # type: ignore[attr-defined]
@@ -2578,9 +2581,12 @@ class Replayer:
     def __init__(self, *, workflows: Iterable[type]) -> None:
         self._workflows: dict[str, type] = {}
         for workflow_cls in workflows:
+            _workflow_handler_registries(workflow_cls)
             workflow_type = str(getattr(workflow_cls, "__workflow_name__", workflow_cls.__name__))
             if workflow_type in self._workflows:
-                raise ValueError(f"duplicate workflow type registered with Replayer: {workflow_type!r}")
+                raise DuplicateRegistrationError(
+                    "workflow", workflow_type, self._workflows[workflow_type], workflow_cls,
+                )
             self._workflows[workflow_type] = workflow_cls
         if not self._workflows:
             raise ValueError("Replayer requires at least one workflow class")
@@ -3067,6 +3073,8 @@ def apply_update(
             prepare_local_activity_groups=prepare_local_activity_groups,
             local_activity_cancellation_policies=local_activity_cancellation_policies,
         )
+    except NonDeterministicReplayError:
+        raise
     except Exception as exc:
         return _fail_update_from_exception(
             update_id,
@@ -5144,16 +5152,20 @@ def _replay_state(
         for _ in range(boundary):
             _apply_receiver(pending_receivers.pop(0))
 
-    def _condition_wait_mismatch(opened: Mapping[str, Any], cmd: WaitCondition) -> FailWorkflow | None:
+    def _condition_wait_mismatch(
+        opened: Mapping[str, Any], cmd: WaitCondition,
+    ) -> NonDeterministicReplayError | None:
+        step = recorded_wait_steps[wait_yield_count]
+        identity = f"condition wait {opened.get('condition_wait_id')!r}"
         opened_key = opened.get("condition_key")
         if isinstance(opened_key, str) and opened_key != (cmd.condition_key or ""):
-            return FailWorkflow(
-                message=(
-                    "wait_condition key changed during replay: "
+            return NonDeterministicReplayError(
+                step.workflow_sequence, "condition wait", step.event_types,
+                detail=(
+                    f"condition_key_changed: {identity} wait_condition key changed during replay: "
                     f"history has {opened_key!r}, workflow yielded "
                     f"{cmd.condition_key!r}"
                 ),
-                exception_type="NonDeterministicWaitCondition",
             )
 
         opened_fingerprint = opened.get("condition_definition_fingerprint")
@@ -5161,13 +5173,14 @@ def _replay_state(
             isinstance(opened_fingerprint, str)
             and cmd.condition_definition_fingerprint != opened_fingerprint
         ):
-            return FailWorkflow(
-                message=(
+            return NonDeterministicReplayError(
+                step.workflow_sequence, "condition wait", step.event_types,
+                detail=(
+                    f"condition_fingerprint_changed: {identity} "
                     "wait_condition predicate fingerprint changed during replay: "
                     f"history has {opened_fingerprint!r}, workflow yielded "
                     f"{cmd.condition_definition_fingerprint!r}"
                 ),
-                exception_type="NonDeterministicWaitCondition",
             )
 
         return None
@@ -6655,7 +6668,7 @@ def _replay_state(
                         next_value = True
                         continue
                     if next_opened_mismatch is not None:
-                        return _state([next_opened_mismatch])
+                        raise next_opened_mismatch
                     step = _next_unconsumed_recorded_step()
                     if step is not None:
                         _assert_step_matches(cmd, step)
@@ -6707,7 +6720,7 @@ def _replay_state(
                         opened = wait_opened[wait_yield_count]
                         mismatch = _condition_wait_mismatch(opened, cmd)
                         if mismatch is not None:
-                            return _state([mismatch])
+                            raise mismatch
                         opened_id = opened.get("condition_wait_id")
                         if isinstance(opened_id, str):
                             resolution = wait_resolutions.get(opened_id)

{durable_workflow-2.5.2 → durable_workflow-2.5.4/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.2
+Version: 2.5.4
 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.2 → durable_workflow-2.5.4}/src/durable_workflow.egg-info/SOURCES.txt

@@ -62,6 +62,7 @@ tests/test_committed_cancellation_scope_descendants.py
 tests/test_committed_cancellation_scope_groups.py
 tests/test_committed_cancellation_scope_history.py
 tests/test_committed_cancellation_scope_replay.py
+tests/test_condition_replay_drift.py
 tests/test_control_plane_parity_fixtures.py
 tests/test_cooperative_cancellation.py
 tests/test_cooperative_cancellation_client.py
@@ -94,6 +95,7 @@ tests/test_python_conformance.py
 tests/test_queries.py
 tests/test_readme_quickstart.py
 tests/test_redrive_replay.py
+tests/test_registration_ambiguity.py
 tests/test_release_metadata.py
 tests/test_replay.py
 tests/test_replay_conformance.py

durable_workflow-2.5.4/tests/test_condition_replay_drift.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from durable_workflow import Worker, serializer, workflow
+from durable_workflow.client import Client
+from durable_workflow.errors import NonDeterministicReplayError, QueryFailed
+from durable_workflow.workflow import WorkflowContext, apply_update, query_state, replay
+
+
+@workflow.defn(name="tests.replay.condition-identity")
+class ConditionIdentityWorkflow:
+    @workflow.query("state")
+    def state(self) -> str:
+        return "waiting"
+
+    @workflow.update("approve")
+    def approve(self) -> str:
+        return "approved"
+
+    def run(self, ctx: WorkflowContext):  # type: ignore[no-untyped-def]
+        yield ctx.wait_condition(lambda: False, key="approved")
+        return "done"
+
+
+def condition_history(field: str) -> list[dict]:
+    return [{
+        "event_type": "ConditionWaitOpened",
+        "payload": {
+            "sequence": 7,
+            "condition_wait_id": "wait-original",
+            "condition_key": "approved",
+            field: "old-key" if field == "condition_key" else "sha256:different",
+        },
+    }]
+
+
+@pytest.mark.parametrize("field", ["condition_key", "condition_definition_fingerprint"])
+@pytest.mark.parametrize("consumer", ["replay", "query", "update"])
+def test_condition_drift_is_not_a_business_failure(field: str, consumer: str) -> None:
+    history = condition_history(field)
+    error = QueryFailed if consumer == "query" else NonDeterministicReplayError
+    with pytest.raises(error) as captured:
+        if consumer == "query":
+            query_state(ConditionIdentityWorkflow, history, [], "state")
+        elif consumer == "update":
+            apply_update(ConditionIdentityWorkflow, history, [], "update-original")
+        else:
+            replay(ConditionIdentityWorkflow, history, [])
+
+    mismatch = captured.value.__cause__ if consumer == "query" else captured.value
+    assert isinstance(mismatch, NonDeterministicReplayError)
+    assert mismatch.workflow_sequence == 7
+    assert "wait-original" in str(mismatch)
+    assert "changed" in str(mismatch)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("field", ["condition_key", "condition_definition_fingerprint"])
+@pytest.mark.parametrize("consumer", ["workflow", "update"])
+async def test_worker_reports_drift_once_without_a_completion(field: str, consumer: str) -> None:
+    client = AsyncMock(spec=Client)
+    worker = Worker(client, task_queue="condition-drift", workflows=[ConditionIdentityWorkflow])
+    task = {
+        "task_id": "task-original",
+        "workflow_id": "workflow-original",
+        "run_id": "run-original",
+        "workflow_type": "tests.replay.condition-identity",
+        "workflow_task_attempt": 2,
+        "history_events": condition_history(field),
+        "arguments": serializer.envelope([], codec="avro"),
+        "payload_codec": "avro",
+    }
+    if consumer == "update":
+        task["workflow_update_id"] = "update-original"
+
+    assert await worker._run_workflow_task_core(task) is None
+
+    client.complete_workflow_task.assert_not_awaited()
+    client.fail_workflow_task.assert_awaited_once()
+    report = client.fail_workflow_task.await_args.kwargs
+    assert report["task_id"] == "task-original"
+    assert report["workflow_task_attempt"] == 2
+    assert report["lease_owner"] == worker.worker_id
+    assert report["failure_type"] == "NonDeterministicReplayError"
+    assert "wait-original" in report["message"]
+
+
+def test_application_predicate_failure_remains_terminal() -> None:
+    @workflow.defn(name="tests.condition-predicate-failure")
+    class PredicateFailure:
+        def run(self, ctx: WorkflowContext):  # type: ignore[no-untyped-def]
+            def predicate() -> bool:
+                raise ValueError("application failed")
+
+            yield ctx.wait_condition(predicate, key="approved")
+
+    outcome = replay(PredicateFailure, [], [])
+    assert len(outcome.commands) == 1
+    command = outcome.commands[0].to_server_command("condition-drift")
+    assert command["type"] == "fail_workflow"
+    assert command["exception_type"] == "ValueError"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("field", ["condition_key", "condition_definition_fingerprint"])
+async def test_query_worker_reports_unavailable_state_without_changing_the_run(field: str) -> None:
+    client = AsyncMock(spec=Client)
+    worker = Worker(client, task_queue="condition-drift", workflows=[ConditionIdentityWorkflow])
+    outcome = await worker._run_query_task({
+        "query_task_id": "query-original",
+        "query_task_attempt": 2,
+        "workflow_id": "workflow-original",
+        "run_id": "run-original",
+        "workflow_type": "tests.replay.condition-identity",
+        "query_name": "state",
+        "history_events": condition_history(field),
+        "workflow_arguments": serializer.envelope([], codec="avro"),
+        "query_arguments": serializer.envelope([], codec="avro"),
+        "payload_codec": "avro",
+    })
+
+    assert outcome == "failed"
+    client.complete_query_task.assert_not_awaited()
+    client.complete_workflow_task.assert_not_awaited()
+    client.fail_workflow_task.assert_not_awaited()
+    client.fail_query_task.assert_awaited_once()
+    report = client.fail_query_task.await_args.kwargs
+    assert report["reason"] == "query_workflow_state_unavailable"
+    assert "wait-original" in report["message"]