durable-workflow 2.5.3__tar.gz → 2.5.5__tar.gz

{durable_workflow-2.5.3/src/durable_workflow.egg-info → durable_workflow-2.5.5}/PKG-INFO

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

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

{durable_workflow-2.5.3 → durable_workflow-2.5.5}/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.3 → durable_workflow-2.5.5}/src/durable_workflow/client.py

@@ -19,6 +19,7 @@ methods without repeating the id on every call.
 from __future__ import annotations
 
 import asyncio
+import copy
 import hashlib
 import json as json_module
 import math
@@ -2672,6 +2673,26 @@ class Client:
         """
         return WorkflowHandle(self, workflow_id=workflow_id, run_id=run_id, workflow_type=workflow_type)
 
+    def _nexus_target_client(self, target_namespace: str | None) -> Client:
+        if target_namespace is not None and not target_namespace.strip():
+            raise ValueError("target_namespace must be nonempty")
+        if target_namespace is None or target_namespace == self.namespace:
+            return self
+        self._auth_token(worker=False)
+        scoped = copy.copy(self)
+        scoped.namespace = target_namespace
+        # Share the HTTP pool, never the caller's namespace discovery or
+        # provider credentials. The worker keeps using the original client.
+        scoped.worker_token = None
+        scoped._cluster_info = None
+        scoped._cluster_info_lock = asyncio.Lock()
+        scoped._runtime_external_payload_transport_cache = None
+        scoped._runtime_external_payload_transport_resolved = False
+        scoped.external_storage = None
+        scoped.external_storage_threshold_bytes = None
+        scoped.external_storage_cache = ExternalPayloadCache()
+        return scoped
+
     async def execute_nexus_operation(
         self,
         endpoint_name: str,
@@ -2685,6 +2706,7 @@ class Client:
         idempotency_key: str | None = None,
         payload_codec: str | None = None,
         caller_namespace: str | None = None,
+        target_namespace: str | None = None,
         caller_workflow_instance_id: str | None = None,
         caller_workflow_run_id: str | None = None,
         service_sdk_language: str | None = None,
@@ -2708,7 +2730,11 @@ class Client:
         the worker uses this client method to make the single durable
         execute request and records the returned service-call surface into
         workflow history.
+
+        ``target_namespace`` selects the service catalog and its payload
+        storage. The caller identity and worker namespace are preserved.
         """
+        execution_client = self._nexus_target_client(target_namespace)
         request_body = nexus_request_payload(
             arguments=list(arguments) if arguments is not None else [],
             payload_codec=payload_codec,
@@ -2736,8 +2762,21 @@ class Client:
         )
         context = f"{endpoint_name}/{service_name}/{operation_name}"
 
+        wire_body = request_body
+        transport = await execution_client._runtime_external_payload_transport()
+        if transport is not None:
+            arguments_envelope = await execution_client._externalize_runtime_payloads(
+                {"codec": request_body["payload_codec"], "blob": request_body["arguments"]},
+                worker=False,
+                transport=transport,
+                uploaded={},
+                slot=("arguments",),
+            )
+            if "external_payload" in arguments_envelope:
+                wire_body = {**request_body, "arguments": arguments_envelope}
+
         try:
-            data = await self._request("POST", path, json=request_body, context=context)
+            data = await execution_client._request("POST", path, json=wire_body, context=context)
         except ServerError as exc:
             if exc.status != 409 or not isinstance(exc.body, dict):
                 raise
@@ -2747,6 +2786,7 @@ class Client:
                 service_name=service_name,
                 operation_name=operation_name,
                 request_payload=request_body,
+                target_namespace=target_namespace,
                 service_sdk_language=service_sdk_language,
                 artifact_tuple=artifact_tuple,
                 published_artifact_worker_execution=published_artifact_worker_execution,
@@ -2770,6 +2810,7 @@ class Client:
             service_name=service_name,
             operation_name=operation_name,
             request_payload=request_body,
+            target_namespace=target_namespace,
             service_sdk_language=service_sdk_language,
             artifact_tuple=artifact_tuple,
             published_artifact_worker_execution=published_artifact_worker_execution,

{durable_workflow-2.5.3 → durable_workflow-2.5.5}/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.3 → durable_workflow-2.5.5}/src/durable_workflow/nexus.py

@@ -8,6 +8,7 @@ from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field
 from typing import Any
 
+from . import serializer
 from .errors import NexusOperationFailed
 
 NEXUS_OPERATION_RESULT_SCHEMA = "durable-workflow.v2.sdk-python.nexus-operation-result"
@@ -49,6 +50,7 @@ def stable_nexus_idempotency_key(
     service_name: str,
     operation_name: str,
     arguments: Sequence[Any],
+    target_namespace: str | None = None,
 ) -> str:
     """Return a deterministic idempotency key for one workflow-side Nexus call."""
     source = {
@@ -61,6 +63,8 @@ def stable_nexus_idempotency_key(
         "operation_name": operation_name,
         "arguments": list(arguments),
     }
+    if target_namespace is not None:
+        source["target_namespace"] = target_namespace
     encoded = json.dumps(source, sort_keys=True, separators=(",", ":"), default=_json_default)
     return f"dw-py-nexus-{hashlib.sha256(encoded.encode()).hexdigest()}"
 
@@ -87,9 +91,10 @@ def nexus_request_payload(
     duplicate_start_policy: str | None = None,
 ) -> dict[str, Any]:
     """Build the server execute-operation request body."""
+    codec = payload_codec or serializer.AVRO_CODEC
     return _clean_dict({
-        "arguments": list(arguments),
-        "payload_codec": payload_codec,
+        "arguments": serializer.encode(list(arguments), codec=codec),
+        "payload_codec": codec,
         "mode_override": mode,
         "wait_for": wait_for,
         "wait_timeout_seconds": wait_timeout_seconds,
@@ -134,6 +139,7 @@ class NexusOperationResult:
     caller_observed_error_type: str | None = None
     typed_error_message: str | None = None
     result: Any = None
+    target_namespace: str | None = None
 
     @classmethod
     def from_response(
@@ -147,6 +153,7 @@ class NexusOperationResult:
         service_sdk_language: str | None = None,
         artifact_tuple: Mapping[str, Any] | None = None,
         published_artifact_worker_execution: bool | None = None,
+        target_namespace: str | None = None,
     ) -> NexusOperationResult:
         call = data.get("service_call")
         source = call if isinstance(call, Mapping) else data
@@ -188,6 +195,7 @@ class NexusOperationResult:
             typed_error_message=_optional_str(source.get("typed_error_message"))
             or _optional_str(data.get("typed_error_message")),
             result=response_value,
+            target_namespace=target_namespace,
         )
 
     @classmethod
@@ -199,6 +207,9 @@ class NexusOperationResult:
         if value.get("version") != NEXUS_OPERATION_RESULT_VERSION:
             raise ValueError("recorded Nexus operation result version is not supported")
 
+        if value.get("target_namespace") != expected.get("target_namespace"):
+            raise ValueError("recorded Nexus target namespace does not match the current workflow command")
+
         for key in ("endpoint_name", "service_name", "operation_name", "idempotency_key"):
             expected_value = expected.get(key)
             recorded_value = value.get(key)
@@ -235,6 +246,7 @@ class NexusOperationResult:
             caller_observed_error_type=_optional_str(value.get("caller_observed_error_type")),
             typed_error_message=_optional_str(value.get("typed_error_message")),
             result=value.get("result"),
+            target_namespace=_optional_str(value.get("target_namespace")),
         )
         if result.is_failure:
             raise result.to_failure()
@@ -287,6 +299,7 @@ class NexusOperationResult:
             "endpoint_name": self.endpoint_name,
             "service_name": self.service_name,
             "operation_name": self.operation_name,
+            "target_namespace": self.target_namespace,
             "idempotency_key": self.request_payload.get("idempotency_key"),
             "caller_workflow_instance_id": self.caller_workflow_instance_id,
             "caller_workflow_run_id": self.caller_workflow_run_id,

{durable_workflow-2.5.3 → durable_workflow-2.5.5}/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.3 → durable_workflow-2.5.5}/src/durable_workflow/worker.py

@@ -66,6 +66,7 @@ from .errors import (
     ActivityCancelled,
     ActivityFailed,
     AvroNotInstalledError,
+    DuplicateRegistrationError,
     DurableWorkflowError,
     ExternalPayloadError,
     InvalidArgument,
@@ -106,6 +107,7 @@ from .workflow import (
     StartChildWorkflow,
     UpsertMemo,
     _validate_workflow_entrypoint,
+    _workflow_handler_registries,
     apply_update,
     commands_to_server_commands,
     query_state,
@@ -1028,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()
@@ -1037,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,
@@ -1451,6 +1462,7 @@ class Worker:
                     idempotency_key=command.idempotency_key,
                     payload_codec=command.payload_codec,
                     caller_namespace=command.caller_namespace,
+                    target_namespace=command.target_namespace,
                     caller_workflow_instance_id=_string_or_none(task.get("workflow_id")),
                     caller_workflow_run_id=_string_or_none(task.get("run_id")),
                     service_sdk_language=command.service_sdk_language,

{durable_workflow-2.5.3 → durable_workflow-2.5.5}/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]
@@ -1193,6 +1196,7 @@ class NexusServiceCall:
     memo: dict[str, Any] | None = None
     search_attributes: dict[str, Any] | None = None
     duplicate_start_policy: str | None = None
+    target_namespace: str | None = None
 
     def to_server_command(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
         raise RuntimeError(
@@ -1206,6 +1210,7 @@ class NexusServiceCall:
             "service_name": self.service_name,
             "operation_name": self.operation_name,
             "idempotency_key": self.idempotency_key,
+            "target_namespace": self.target_namespace,
         }
 
     def recorded_result(self, value: Any) -> NexusOperationResult:
@@ -2399,6 +2404,7 @@ class WorkflowContext:
         wait_for: str | None = "completed",
         wait_timeout_seconds: int | None = None,
         caller_namespace: str | None = None,
+        target_namespace: str | None = None,
         service_sdk_language: str | None = None,
         artifact_tuple: Mapping[str, Any] | None = None,
         published_artifact_worker_execution: bool | None = None,
@@ -2417,7 +2423,12 @@ class WorkflowContext:
         If the service reports a typed failure, replay raises
         :class:`~durable_workflow.errors.NexusOperationFailed` at the yield
         point so workflow code can compensate or let the workflow fail.
+
+        ``target_namespace`` addresses a service in another namespace and
+        participates in the durable call identity and replay checks.
         """
+        if target_namespace is not None and not target_namespace.strip():
+            raise ValueError("target_namespace must be nonempty")
         args = list(arguments) if arguments is not None else []
         if idempotency_key is None:
             idempotency_key = stable_nexus_idempotency_key(
@@ -2428,6 +2439,7 @@ class WorkflowContext:
                 service_name=service_name,
                 operation_name=operation_name,
                 arguments=args,
+                target_namespace=target_namespace,
             )
         self._nexus_call_counter += 1
         return NexusServiceCall(
@@ -2441,6 +2453,7 @@ class WorkflowContext:
             wait_for=wait_for,
             wait_timeout_seconds=wait_timeout_seconds,
             caller_namespace=caller_namespace,
+            target_namespace=target_namespace,
             service_sdk_language=service_sdk_language,
             artifact_tuple=dict(artifact_tuple) if artifact_tuple is not None else None,
             published_artifact_worker_execution=published_artifact_worker_execution,
@@ -2578,9 +2591,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")
@@ -6583,6 +6599,14 @@ def _replay_state(
                 if result_cursor < len(resolved_results):
                     _assert_next_step_matches(cmd)
                     recorded_value = resolved_results[result_cursor]
+                    if (
+                        isinstance(recorded_value, Mapping)
+                        and recorded_value.get("target_namespace") != cmd.target_namespace
+                    ):
+                        raise NonDeterministicReplayError(
+                            current_call_sequence, "NexusServiceCall", ["SideEffectRecorded"],
+                            detail="nexus_target_namespace_changed: recorded target differs from the workflow command",
+                        )
                     result_cursor += 1
                     try:
                         next_value = cmd.recorded_result(recorded_value)

{durable_workflow-2.5.3 → durable_workflow-2.5.5/src/durable_workflow.egg-info}/PKG-INFO

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

@@ -80,6 +80,8 @@ tests/test_history_event_contract.py
 tests/test_invocable.py
 tests/test_message_streams.py
 tests/test_metrics.py
+tests/test_nexus_namespace.py
+tests/test_nexus_wire.py
 tests/test_order_processing_example.py
 tests/test_parallel_completion_order_replay.py
 tests/test_parallel_saga_authoring.py
@@ -95,6 +97,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.3 → durable_workflow-2.5.5}/tests/test_client.py

@@ -289,7 +289,8 @@ class TestNexusOperations:
             "/api/service-endpoints/greeter/services/shared/operations/greet/execute",
         )
         body = mock.call_args.kwargs["json"]
-        assert body["arguments"] == ["Ada"]
+        assert body["payload_codec"] == "avro"
+        assert serializer.decode(body["arguments"], codec=body["payload_codec"]) == ["Ada"]
         assert body["mode_override"] == "sync"
         assert body["wait_for"] == "completed"
         assert body["idempotency_key"] == "idem-1"
@@ -303,7 +304,7 @@ class TestNexusOperations:
         assert recorded["caller_sdk_language"] == "sdk-python"
         assert recorded["service_sdk_language"] == "workflow-php"
         assert recorded["operation_name"] == "greet"
-        assert recorded["request_payload"]["arguments"] == ["Ada"]
+        assert serializer.decode(recorded["request_payload"]["arguments"], codec="avro") == ["Ada"]
         assert recorded["response_or_failure_surface"]["result"] == {"greeting": "hello Ada"}
         assert recorded["service_call_id"] == "svc-call-1"
         assert recorded["artifact_tuple"]["sdk-python"] == "0.4.95"