durable-workflow 2.5.4__tar.gz → 2.6.0rc2__tar.gz

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

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

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

{durable_workflow-2.5.4 → durable_workflow-2.6.0rc2}/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
@@ -299,8 +300,8 @@ def _contains_inline_payload_envelope(value: object) -> bool:
         if set(value) == {"codec", "blob"} and isinstance(value.get("blob"), str):
             return True
         if (
-            value.get("type") == "record_side_effect"
-            and isinstance(value.get("result"), str)
+            (value.get("type") == "record_side_effect" and isinstance(value.get("result"), str))
+            or (value.get("type") == "start_service_operation" and isinstance(value.get("request_payload"), str))
         ):
             return True
         return any(_contains_inline_payload_envelope(item) for item in value.values())
@@ -2079,21 +2080,23 @@ class Client:
         slot: tuple[str | int, ...] = (),
     ) -> Any:
         if isinstance(value, dict):
-            if (
-                value.get("type") == "record_side_effect"
-                and isinstance(value.get("result"), str)
-            ):
+            command_type = value.get("type")
+            blob_key = (
+                {"record_side_effect": "result", "start_service_operation": "request_payload"}.get(command_type)
+                if isinstance(command_type, str) else None
+            )
+            if blob_key is not None and isinstance(value.get(blob_key), str):
                 normalized_command = dict(value)
                 externalized_result = await self._externalize_runtime_payloads(
-                    {"codec": serializer.AVRO_CODEC, "blob": value["result"]},
+                    {"codec": value.get("payload_codec", serializer.AVRO_CODEC), "blob": value[blob_key]},
                     worker=worker,
                     transport=transport,
                     uploaded=uploaded,
                     completion=completion,
-                    slot=(*slot, "result"),
+                    slot=(*slot, blob_key),
                 )
                 if "external_payload" in externalized_result:
-                    normalized_command["result"] = externalized_result
+                    normalized_command[blob_key] = externalized_result
                 value = normalized_command
 
             if set(value) == {"codec", "blob"} and isinstance(value.get("blob"), str):
@@ -2672,6 +2675,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 +2708,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 +2732,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 +2764,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 +2788,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 +2812,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.4 → durable_workflow-2.6.0rc2}/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.4 → durable_workflow-2.6.0rc2}/src/durable_workflow/worker.py

@@ -98,10 +98,8 @@ from .workflow import (
     Command,
     FailWorkflow,
     LocalActivityExecutionAborted,
-    NexusServiceCall,
     PreparedLocalActivityCall,
     RecordLocalActivity,
-    RecordSideEffect,
     ReplayOutcome,
     ScheduleActivity,
     StartChildWorkflow,
@@ -166,7 +164,6 @@ _WORKFLOW_TASK_COMPLETION_AMBIGUOUS_REJECTION_REASONS = {
 }
 _WORKFLOW_TASK_COMPLETION_MAX_ATTEMPTS = 3
 _WORKFLOW_TASK_COMPLETION_RETRY_DELAYS = (0.05, 0.2)
-_WORKFLOW_TASK_NEXUS_RESOLUTION_LIMIT = 100
 _LOCAL_ACTIVITY_REPORT_LIMIT = 1000
 _WORKER_WORKFLOW_FINGERPRINTS: dict[tuple[str, str], str] = {}
 _P = ParamSpec("_P")
@@ -1428,85 +1425,6 @@ class Worker:
 
         return await handler(context)
 
-    async def _resolve_workflow_nexus_commands(
-        self,
-        workflow_cls: type,
-        history: list[dict[str, Any]],
-        start_input: list[Any],
-        task: dict[str, Any],
-        *,
-        payload_codec: str | None,
-        command_codec: str,
-        initial_commands: list[Command],
-    ) -> list[Command]:
-        events = list(history)
-        commands: list[Command] = list(initial_commands)
-        recorded_commands: list[RecordSideEffect] = []
-
-        for _ in range(_WORKFLOW_TASK_NEXUS_RESOLUTION_LIMIT):
-            nexus_commands = [command for command in commands if isinstance(command, NexusServiceCall)]
-            if not nexus_commands:
-                return recorded_commands + commands
-            if len(nexus_commands) != len(commands):
-                raise RuntimeError("Nexus service calls must be yielded one at a time")
-
-            for command in nexus_commands:
-                result = await self.client.execute_nexus_operation(
-                    command.endpoint_name,
-                    command.service_name,
-                    command.operation_name,
-                    command.arguments,
-                    mode=command.mode,
-                    wait_for=command.wait_for,
-                    wait_timeout_seconds=command.wait_timeout_seconds,
-                    idempotency_key=command.idempotency_key,
-                    payload_codec=command.payload_codec,
-                    caller_namespace=command.caller_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,
-                    artifact_tuple=command.artifact_tuple,
-                    published_artifact_worker_execution=command.published_artifact_worker_execution,
-                    target_workflow_instance_id=command.target_workflow_instance_id,
-                    target_workflow_run_id=command.target_workflow_run_id,
-                    connection=command.connection,
-                    queue=command.queue,
-                    business_key=command.business_key,
-                    labels=command.labels,
-                    memo=command.memo,
-                    search_attributes=command.search_attributes,
-                    duplicate_start_policy=command.duplicate_start_policy,
-                    raise_on_failure=False,
-                )
-                recorded_payload = result.to_recorded_payload()
-                recorded_commands.append(RecordSideEffect(recorded_payload))
-                events.append({
-                    "event_type": "SideEffectRecorded",
-                    "payload": {
-                        "payload_codec": command_codec,
-                        "result": serializer.encode(recorded_payload, codec=command_codec),
-                    },
-                })
-
-            outcome = replay(
-                workflow_cls,
-                events,
-                start_input,
-                workflow_id=task.get("workflow_id"),
-                run_id=_string_or_none(task.get("run_id")) or "",
-                workflow_command_id=(
-                    _string_or_none(task.get("workflow_command_id"))
-                    or _string_or_none(task.get("task_id"))
-                ),
-                payload_codec=payload_codec,
-                external_storage=self.external_storage,
-                external_storage_cache=self.external_storage_cache,
-                cancel_requested=bool(task.get("cancel_requested", False)),
-            )
-            commands = list(outcome.commands)
-
-        raise RuntimeError("workflow yielded too many consecutive Nexus service calls")
-
     async def _renew_local_workflow_lease(self, task: dict[str, Any]) -> None:
         if self._cooperative_cancellation_supported and self._local_activity_shutdown.is_set():
             raise LocalActivityExecutionAborted("worker shutdown abandoned its local workflow claim")
@@ -2628,45 +2546,7 @@ class Worker:
                 log.warning("failed to report replay failure: %s", fe)
             return None
 
-        try:
-            workflow_commands = await self._resolve_workflow_nexus_commands(
-                cls,
-                list(history),
-                start_input,
-                task,
-                payload_codec=codec,
-                command_codec=command_codec,
-                initial_commands=list(outcome.commands),
-            )
-        except Exception as e:
-            log.exception("workflow Nexus service call resolution failed")
-            last_local = max(
-                (index for index, command in enumerate(outcome.commands)
-                 if isinstance(command, RecordLocalActivity) and command.outcome is not None),
-                default=-1,
-            )
-            if last_local >= 0:
-                workflow_commands = [
-                    *outcome.commands[:last_local + 1],
-                    FailWorkflow(
-                        f"Nexus resolution after local activity failed: {e}",
-                        exception_type=type(e).__name__,
-                        non_retryable=True,
-                    ),
-                ]
-            else:
-                try:
-                    await self.client.fail_workflow_task(
-                        task_id=task_id,
-                        lease_owner=self.worker_id,
-                        workflow_task_attempt=attempt,
-                        message=f"workflow Nexus service call resolution failed: {e}",
-                        failure_type=type(e).__name__,
-                        stack_trace=traceback.format_exc(),
-                    )
-                except Exception as fe:
-                    log.warning("failed to report workflow Nexus resolution failure: %s", fe)
-                return None
+        workflow_commands = list(outcome.commands)
 
         if (
             any(isinstance(command, UpsertMemo) for command in workflow_commands)