durable-workflow 2.6.0rc3__tar.gz → 2.6.2__tar.gz

{durable_workflow-2.6.0rc3/src/durable_workflow.egg-info → durable_workflow-2.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.6.0rc3
+Version: 2.6.2
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -139,6 +139,7 @@ for the complete cross-SDK contract.
 - [Python SDK guide](https://durable-workflow.com/docs/2.0/polyglot/python/)
 - [Complete SDK reference](docs/sdk-reference.md)
 - [Runnable examples](examples/)
+- [Separate workflow and activity worker processes](docs/guides/separate-workers.md)
 - [Symmetric SDK playground](https://github.com/durable-workflow/sample-app#symmetric-sdk-playground)
 
 ## Runtime choices

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2}/README.md

@@ -99,6 +99,7 @@ for the complete cross-SDK contract.
 - [Python SDK guide](https://durable-workflow.com/docs/2.0/polyglot/python/)
 - [Complete SDK reference](docs/sdk-reference.md)
 - [Runnable examples](examples/)
+- [Separate workflow and activity worker processes](docs/guides/separate-workers.md)
 - [Symmetric SDK playground](https://github.com/durable-workflow/sample-app#symmetric-sdk-playground)
 
 ## Runtime choices

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.6.0-rc.3"
+version = "2.6.2"
 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.6.0-rc.3"
-registry-version = "2.6.0rc3"
+product-train = "2.6.2"
+registry-version = "2.6.2"
 supported-server-versions = "2.8.0"
 worker-protocol-version = "1.20"
 control-plane-version = "2"

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2}/src/durable_workflow/__init__.py

@@ -103,6 +103,7 @@ from .errors import (
     UpdateValidationFailed,
     WorkflowAlreadyStarted,
     WorkflowCancelled,
+    WorkflowEntryArgumentsMismatchError,
     WorkflowFailed,
     WorkflowNotFound,
     WorkflowPayloadDecodeError,
@@ -319,6 +320,7 @@ __all__ = [
     "WorkflowHandle",
     "WorkflowList",
     "WorkflowPayloadDecodeError",
+    "WorkflowEntryArgumentsMismatchError",
     "WorkflowRun",
     "WorkflowRunList",
     "WorkflowStreamAppendItem",

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2}/src/durable_workflow/activity.py

@@ -1,6 +1,7 @@
 """Activity decorator, registry, and execution context."""
 from __future__ import annotations
 
+import asyncio
 import contextvars
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
@@ -44,6 +45,10 @@ class ActivityContext:
         self._client = client
         self._heartbeat_callback = heartbeat_callback
         self._cancel_requested = False
+        try:
+            self._event_loop: asyncio.AbstractEventLoop | None = asyncio.get_running_loop()
+        except RuntimeError:
+            self._event_loop = None
 
     @property
     def info(self) -> ActivityInfo:
@@ -55,6 +60,29 @@ class ActivityContext:
         """``True`` once the server has signalled that the owning workflow cancelled this activity."""
         return self._cancel_requested
 
+    def heartbeat_sync(self, details: dict[str, Any] | None = None) -> None:
+        """Heartbeat from a synchronous activity thread and observe cancellation.
+
+        The request runs on the worker's event loop using the original attempt
+        and client. Async handlers must use ``await heartbeat()`` instead.
+        """
+        loop = self._event_loop
+        if loop is None or not loop.is_running():
+            raise RuntimeError("heartbeat_sync requires a running worker event loop")
+        try:
+            caller_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            caller_loop = None
+        if caller_loop is loop:
+            raise RuntimeError("use await activity.context().heartbeat() on the worker event loop")
+        heartbeat = self.heartbeat(details)
+        try:
+            pending = asyncio.run_coroutine_threadsafe(heartbeat, loop)
+        except RuntimeError:
+            heartbeat.close()
+            raise
+        pending.result()
+
     async def heartbeat(self, details: dict[str, Any] | None = None) -> None:
         """Report liveness to the server and check for a cancellation request.
 

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2}/src/durable_workflow/client.py

@@ -3527,9 +3527,18 @@ class Client:
         ``workflow_type`` is the language-neutral type key registered via
         :func:`durable_workflow.workflow.defn`. ``task_queue`` selects which
         worker pool picks up the workflow. ``workflow_id`` is the
-        caller-supplied instance id — if it collides with an existing
-        workflow, behavior depends on ``duplicate_policy``
-        (``reject`` | ``allow`` | ``terminate_existing``).
+        caller-supplied instance ID. The PHP Server start contract accepts
+        ``duplicate_policy="fail"`` (also the default when omitted) or
+        ``"use-existing"``. ``fail`` raises :class:`WorkflowAlreadyStarted`
+        if the ID already exists. ``use-existing`` returns the original run
+        only while it is pending, running or waiting. Both policies reject
+        a closed instance. Neither replaces a run or changes its input or
+        deadlines. Use a new workflow ID for a new independent execution.
+
+        The SDK forwards the policy unchanged. ``reject``, ``allow`` and
+        ``terminate_existing`` are not supported wire values. A resource-keyed
+        workflow ID coordinates start admission; it does not revoke work
+        already running in an external system.
 
         ``input`` is a list of positional arguments passed to the workflow's
         ``run`` method; the SDK encodes the list with the default payload
@@ -5303,15 +5312,20 @@ class Client:
         message: str,
         failure_type: str | None = None,
         stack_trace: str | None = None,
+        failure_reason: str | None = None,
     ) -> Any:
-        """Report a workflow task failure so the server can schedule a retry.
+        """Report a workflow task failure without closing the run.
 
         Worker-plane endpoint. Task failures (e.g. non-determinism) are
         distinct from workflow failures (``FailWorkflow`` commands).
+        The runtime may block incompatible replay until compatible code and
+        a supported repair are available instead of automatically retrying it.
         """
         failure: dict[str, Any] = {"message": message}
         if failure_type is not None:
             failure["type"] = failure_type
+        if failure_reason is not None:
+            failure["reason"] = failure_reason
         if stack_trace is not None:
             failure["stack_trace"] = stack_trace
         body: dict[str, Any] = {

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2}/src/durable_workflow/errors.py

@@ -312,8 +312,10 @@ class WorkflowNotFound(DurableWorkflowError):
 class WorkflowAlreadyStarted(DurableWorkflowError):
     """A start request collided with an existing instance id.
 
-    Raised when duplicate-start policy is ``reject`` (the default) and the
-    caller-supplied ``workflow_id`` is already in use.
+    The PHP Server raises this for an existing ``workflow_id`` when the
+    duplicate policy is ``fail`` (the default), or when ``use-existing``
+    addresses a closed instance. ``use-existing`` returns a handle only
+    while the original run is pending, running or waiting.
     """
 
     def __init__(self, workflow_id: str) -> None:
@@ -463,6 +465,21 @@ class WorkflowPayloadDecodeError(DurableWorkflowError):
         self.exception_type = exception_type
 
 
+class WorkflowEntryArgumentsMismatchError(DurableWorkflowError):
+    """Recorded input cannot bind to the deployed entry method before it runs."""
+
+    reason = "workflow_entry_arguments_mismatch"
+
+    def __init__(self, workflow_type: str, binding_reason: str) -> None:
+        self.workflow_type = workflow_type
+        self.entry_method = "run"
+        self.binding_reason = binding_reason
+        super().__init__(
+            f"{self.reason}: {workflow_type}.run cannot bind the recorded arguments "
+            f"({binding_reason}). Restore compatible code and repair the workflow task."
+        )
+
+
 class NonDeterministicReplayError(DurableWorkflowError):
     """Current workflow code yielded a command shape that does not match history."""
 
@@ -874,7 +891,7 @@ def _raise_for_status(status: int, body: object, *, context: str = "") -> None:
     if status == 409:
         if reason == "schedule_already_exists":
             raise ScheduleAlreadyExists(context)
-        if reason == "duplicate_not_allowed":
+        if reason in ("duplicate_not_allowed", "instance_already_started"):
             raise WorkflowAlreadyStarted(context)
         if reason == "run_not_active":
             if operation == "signal":

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2}/src/durable_workflow/worker.py

@@ -79,6 +79,7 @@ from .errors import (
     ServerError,
     UpdateRejected,
     UpdateValidationFailed,
+    WorkflowEntryArgumentsMismatchError,
 )
 from .external_storage import ExternalPayloadCache, ExternalStorageDriver, store_external_payload
 from .interceptors import (
@@ -108,12 +109,13 @@ from .workflow import (
     StartChildWorkflow,
     UpsertMemo,
     _prepare_query_state,
+    _prepare_update_validation,
+    _UpdateValidationReplayOptions,
     _validate_workflow_entrypoint,
     _workflow_handler_registries,
     apply_update,
     commands_to_server_commands,
     replay,
-    validate_update,
 )
 
 log = logging.getLogger("durable_workflow.worker")
@@ -136,6 +138,7 @@ _WORKFLOW_COMMAND_CAPABILITIES = (
     TYPED_SEARCH_ATTRIBUTES_CAPABILITY,
     DURABLE_SELECTION_CAPABILITY,
     LOCAL_ACTIVITIES_CAPABILITY,
+    "workflow_entry_arguments_validation",
 )
 
 _WORKFLOW_WORK_TASK_KINDS = ("workflow", "update_validation")
@@ -2619,6 +2622,9 @@ class Worker:
             return None
         except Exception as e:
             log.exception("replay failed")
+            failure_details = (
+                {"failure_reason": e.reason} if isinstance(e, WorkflowEntryArgumentsMismatchError) else {}
+            )
             try:
                 await self.client.fail_workflow_task(
                     task_id=task_id,
@@ -2627,6 +2633,7 @@ class Worker:
                     message=f"replay failed: {e}",
                     failure_type=type(e).__name__,
                     stack_trace=traceback.format_exc(),
+                    **failure_details,
                 )
             except Exception as fe:
                 log.warning("failed to report replay failure: %s", fe)
@@ -3065,7 +3072,9 @@ class Worker:
             if self._cooperative_cancellation_supported:
                 result = await self._execute_cooperative_remote_callable(task, fn, tuple(args), act_ctx.info)
             else:
-                result = await self._execute_activity_callable(task, activity_type, tuple(args), fn)
+                result = await self._execute_activity_callable(
+                    task, activity_type, tuple(args), fn, run_sync_in_thread=True, remote=True,
+                )
         except _RemoteActivityExecutionAborted as error:
             log.warning("remote activity %s claim abandoned: %s", task_id, error)
             return "claim_aborted"
@@ -3859,21 +3868,24 @@ class Worker:
                 codec=codec,
                 context="workflow update validation arguments",
             )
-            result = validate_update(
+            invoke = _prepare_update_validation(
                 workflow_cls,
                 history,
                 start_input,
                 update_name,
                 update_args,
-                workflow_id=task.get("workflow_id"),
-                run_id=task.get("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,
+                replay_options=_UpdateValidationReplayOptions(
+                    workflow_id=task.get("workflow_id"),
+                    run_id=task.get("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,
+                ),
             )
+            result = invoke()
             if inspect.isawaitable(result):
                 result = await result
             if result is False:
@@ -4506,6 +4518,17 @@ class Worker:
                 )
             await asyncio.gather(*in_flight, return_exceptions=True)
 
+        # Cancelling the asyncio await cannot stop a running Python thread.
+        # Keep registration and capacity until the actual callback has returned.
+        while any(not future.done() for future in self._remote_activity_threads):
+            remaining = self._remaining_shutdown_time(deadline)
+            if remaining <= 0:
+                raise RuntimeError(
+                    "worker shutdown has unconfirmed activity thread stop(s); "
+                    "the worker registration remains active"
+                )
+            await asyncio.sleep(min(0.01, remaining))
+
         if self._local_activity_executor is not None:
             self._local_activity_executor.shutdown(wait=False, cancel_futures=True)
         if self._remote_activity_executor is not None:

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2}/src/durable_workflow/workflow.py

@@ -66,6 +66,7 @@ from .errors import (
     QueryFailed,
     SagaCompensationFailed,
     WorkflowCancelled,
+    WorkflowEntryArgumentsMismatchError,
     WorkflowPayloadDecodeError,
 )
 from .external_storage import ExternalPayloadCache, ExternalStorageDriver
@@ -137,6 +138,21 @@ def _workflow_handler_registries(
             wire_name = getattr(member, f"__{kind}_name__", None)
             if not isinstance(wire_name, str) or not wire_name:
                 continue
+            if not callable(member):
+                raise InvalidWorkflowDefinition(f"workflow {cls.__qualname__}.{attr} handler must be callable")
+            target = inspect.unwrap(member)
+            if not inspect.isroutine(target) and callable(target):
+                target = inspect.unwrap(target.__call__)
+            if (
+                (inspect.iscoroutinefunction(target) and kind not in {"query", "update_validator"})
+                or inspect.isasyncgenfunction(target)
+                or inspect.isgeneratorfunction(target)
+            ):
+                name = getattr(cls, "__workflow_name__", cls.__name__)
+                raise InvalidWorkflowDefinition(
+                    f"unsupported_workflow_handler: workflow {name!r} ({cls.__qualname__}.{attr}) "
+                    f"{kind} handler {wire_name!r} must be synchronous; yield durable commands from run()."
+                )
             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:
@@ -148,6 +164,28 @@ def _workflow_handler_registries(
     return handlers["signal"], handlers["query"], handlers["update"], handlers["update_validator"]
 
 
+def _invoke_workflow_handler(
+    handler: Callable[..., Any], args: list[Any], cls: type, method: str, *, allow_async: bool = False,
+) -> Any:
+    return _validate_workflow_handler_result(handler(*args), cls, method, allow_async=allow_async)
+
+
+def _validate_workflow_handler_result(result: Any, cls: type, method: str, *, allow_async: bool = False) -> Any:
+    if (
+        (inspect.isawaitable(result) and not allow_async)
+        or inspect.isasyncgen(result)
+        or inspect.isgenerator(result)
+    ):
+        if inspect.iscoroutine(result) or inspect.isgenerator(result):
+            result.close()
+        name = getattr(cls, "__workflow_name__", cls.__name__)
+        raise InvalidWorkflowDefinition(
+            f"unsupported_workflow_handler_result: workflow {name!r} ({cls.__qualname__}.{method}) "
+            "returned an async or generator value; handlers must return synchronous values."
+        )
+    return result
+
+
 def defn(*, name: str) -> Callable[[type[_WorkflowT]], type[_WorkflowT]]:
     """Register a class as a workflow type under a language-neutral name.
 
@@ -3132,7 +3170,9 @@ def _prepare_query_state(
 
     def invoke() -> Any:
         try:
-            return handler(*(list(args) if args is not None else []))
+            return _invoke_workflow_handler(
+                handler, list(args) if args is not None else [], workflow_cls, method_name, allow_async=True,
+            )
         except QueryFailed:
             raise
         except Exception as exc:
@@ -3162,7 +3202,7 @@ def query_state(
     Server-routed Worker execution separately checks its original query claim
     between replay and handler invocation. Direct local use has no Server lease.
     """
-    return _prepare_query_state(
+    result = _prepare_query_state(
         workflow_cls, history_events, start_input, query_name, args,
         workflow_id=workflow_id, run_id=run_id, payload_codec=payload_codec,
         external_storage=external_storage, external_storage_cache=external_storage_cache,
@@ -3170,6 +3210,11 @@ def query_state(
         prepare_local_activity_groups=prepare_local_activity_groups,
         local_activity_cancellation_policies=local_activity_cancellation_policies,
     )()
+    try:
+        registry: dict[str, str] = getattr(workflow_cls, "__workflow_queries__", {}) or {}
+        return _validate_workflow_handler_result(result, workflow_cls, registry.get(query_name, query_name))
+    except InvalidWorkflowDefinition as exc:
+        raise QueryFailed(str(exc)) from exc
 
 
 def apply_update(
@@ -3275,11 +3320,24 @@ def apply_update(
         )
 
     try:
-        return CompleteUpdate(update_id=update_id, result=handler(*args))
+        result = _invoke_workflow_handler(handler, args, workflow_cls, method_name)
+        return CompleteUpdate(update_id=update_id, result=result)
     except Exception as exc:
         return _fail_update_from_exception(update_id, "update handler failed", exc)
 
 
+@dataclass(frozen=True)
+class _UpdateValidationReplayOptions:
+    workflow_id: str | None = None
+    run_id: str = ""
+    payload_codec: str | None = None
+    external_storage: ExternalStorageDriver | None = None
+    external_storage_cache: ExternalPayloadCache | None = None
+    prepare_local_activities: bool = False
+    prepare_local_activity_groups: bool = False
+    local_activity_cancellation_policies: tuple[str, ...] = ()
+
+
 def validate_update(
     workflow_cls: type,
     history_events: Iterable[dict[str, Any]],
@@ -3296,13 +3354,42 @@ def validate_update(
     prepare_local_activity_groups: bool = False,
     local_activity_cancellation_policies: tuple[str, ...] = (),
 ) -> Any:
+    """Replay and invoke a validator synchronously, refusing asynchronous results."""
+    from .errors import UpdateRejected
+
+    result = _prepare_update_validation(
+        workflow_cls, history_events, start_input, update_name, args,
+        replay_options=_UpdateValidationReplayOptions(
+            workflow_id=workflow_id, run_id=run_id, payload_codec=payload_codec,
+            external_storage=external_storage, external_storage_cache=external_storage_cache,
+            prepare_local_activities=prepare_local_activities,
+            prepare_local_activity_groups=prepare_local_activity_groups,
+            local_activity_cancellation_policies=local_activity_cancellation_policies,
+        ),
+    )()
+    try:
+        registry: dict[str, str] = getattr(workflow_cls, "__workflow_update_validators__", {}) or {}
+        return _validate_workflow_handler_result(result, workflow_cls, registry.get(update_name, update_name))
+    except InvalidWorkflowDefinition as exc:
+        raise UpdateRejected(str(exc), exception_type=type(exc).__name__) from exc
+
+
+def _prepare_update_validation(
+    workflow_cls: type,
+    history_events: Iterable[dict[str, Any]],
+    start_input: list[Any],
+    update_name: str,
+    args: list[Any],
+    *,
+    replay_options: _UpdateValidationReplayOptions,
+) -> Callable[[], Any]:
     """Replay state and invoke only the declared pre-accept update validator.
 
     The replayed instance is discarded after validation. This helper does not
     run the update handler and does not emit workflow commands, so the server
     remains the sole authority that can cross the accepted-state boundary.
     """
-    from .errors import InvalidArgument, UpdateRejected, UpdateValidationFailed
+    from .errors import UpdateValidationFailed
 
     events = list(history_events)
     try:
@@ -3310,14 +3397,14 @@ def validate_update(
             workflow_cls,
             events,
             start_input,
-            workflow_id=workflow_id,
-            run_id=run_id,
-            payload_codec=payload_codec,
-            external_storage=external_storage,
-            external_storage_cache=external_storage_cache,
-            prepare_local_activities=prepare_local_activities,
-            prepare_local_activity_groups=prepare_local_activity_groups,
-            local_activity_cancellation_policies=local_activity_cancellation_policies,
+            workflow_id=replay_options.workflow_id,
+            run_id=replay_options.run_id,
+            payload_codec=replay_options.payload_codec,
+            external_storage=replay_options.external_storage,
+            external_storage_cache=replay_options.external_storage_cache,
+            prepare_local_activities=replay_options.prepare_local_activities,
+            prepare_local_activity_groups=replay_options.prepare_local_activity_groups,
+            local_activity_cancellation_policies=replay_options.local_activity_cancellation_policies,
         )
     except Exception as exc:
         raise UpdateValidationFailed(
@@ -3348,8 +3435,20 @@ def validate_update(
     if validator is None:
         raise UpdateValidationFailed(f"update validator {update_name!r} is not available")
 
+    return lambda: _invoke_update_validator(validator, args, workflow_cls, validator_name, update_name)
+
+
+def _invoke_update_validator(
+    validator: Callable[..., Any],
+    args: list[Any],
+    workflow_cls: type,
+    validator_name: str,
+    update_name: str,
+) -> Any:
+    from .errors import InvalidArgument, UpdateRejected
+
     try:
-        result = validator(*list(args))
+        result = _invoke_workflow_handler(validator, list(args), workflow_cls, validator_name, allow_async=True)
         if result is False:
             raise ValueError(f"update validator {update_name!r} returned false")
         return result
@@ -4239,6 +4338,7 @@ def _replay_state(
     allow_cancellation_scope_delivery: bool = False,
 ) -> _ReplayState:
     _validate_workflow_entrypoint(workflow_cls)
+    _workflow_handler_registries(workflow_cls)
     if allow_cancellation_scope_delivery and not allow_cancellation_scope_authoring:
         raise LocalActivityExecutionAborted("scope delivery requires canonical scope authoring")
     if prepare_local_activity_groups and not prepare_local_activities:
@@ -5284,7 +5384,7 @@ def _replay_state(
                 return
             raise TypeError(f"update handler {receiver.name!r} is not available")
         ctx.logger._set_replaying(True)
-        handler(*receiver.args)
+        _invoke_workflow_handler(handler, receiver.args, workflow_cls, method_name)
 
     def _receiver_due(receiver: _PendingReceiver, *, before_consuming_result: bool) -> bool:
         if receiver.after_cancellation_delivery and not cancellation_consumed:
@@ -5386,8 +5486,21 @@ def _replay_state(
     result_cursor = 0
     pending_step_cursor = 0
     wait_yield_count = 0
+    entry = instance.run
+    workflow_type = str(getattr(workflow_cls, "__workflow_name__", workflow_cls.__name__))
+    try:
+        entry_signature = inspect.signature(entry)
+    except (TypeError, ValueError):
+        raise WorkflowEntryArgumentsMismatchError(workflow_type, "signature_unavailable") from None
+    try:
+        entry_signature.bind(ctx, *start_input)
+    except TypeError:
+        raise WorkflowEntryArgumentsMismatchError(workflow_type, "argument_binding_failed") from None
+
+    # Binding happens outside the application-error path. A TypeError raised
+    # by a successfully bound body is still an actual workflow failure.
     try:
-        gen = instance.run(ctx, *start_input)
+        gen = entry(ctx, *start_input)
     except NonDeterministicReplayError:
         raise
     except LocalActivityExecutionAborted:

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.6.0rc3
+Version: 2.6.2
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -139,6 +139,7 @@ for the complete cross-SDK contract.
 - [Python SDK guide](https://durable-workflow.com/docs/2.0/polyglot/python/)
 - [Complete SDK reference](docs/sdk-reference.md)
 - [Runnable examples](examples/)
+- [Separate workflow and activity worker processes](docs/guides/separate-workers.md)
 - [Symmetric SDK playground](https://github.com/durable-workflow/sample-app#symmetric-sdk-playground)
 
 ## Runtime choices

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2}/src/durable_workflow.egg-info/SOURCES.txt

@@ -120,6 +120,7 @@ tests/test_standalone_activity_client.py
 tests/test_sticky_execution.py
 tests/test_storage_admission.py
 tests/test_sync.py
+tests/test_sync_activities.py
 tests/test_testing_harness.py
 tests/test_update_signal_condition_replay.py
 tests/test_updates.py
@@ -127,7 +128,9 @@ tests/test_wait_condition.py
 tests/test_worker.py
 tests/test_worker_observation.py
 tests/test_worker_session.py
+tests/test_workflow_entry_arguments.py
 tests/test_workflow_entrypoint_validation.py
+tests/test_workflow_handler_validation.py
 tests/test_workflow_result_timeout.py
 tests/test_workflow_streams.py
 tests/test_workflow_updates_conformance.py

{durable_workflow-2.6.0rc3 → durable_workflow-2.6.2}/tests/test_errors.py

@@ -57,9 +57,11 @@ class TestRaiseForStatus:
         with pytest.raises(ServerError):
             _raise_for_status(404, {"reason": "other"})
 
-    def test_409_duplicate(self) -> None:
-        with pytest.raises(WorkflowAlreadyStarted):
-            _raise_for_status(409, {"reason": "duplicate_not_allowed"}, context="wf-1")
+    @pytest.mark.parametrize("reason", ["duplicate_not_allowed", "instance_already_started"])
+    def test_409_duplicate(self, reason: str) -> None:
+        with pytest.raises(WorkflowAlreadyStarted) as duplicate:
+            _raise_for_status(409, {"reason": reason}, context="resource-017")
+        assert duplicate.value.workflow_id == "resource-017"
 
     def test_409_query_rejected(self) -> None:
         with pytest.raises(QueryFailed):