dex-python-sdk 0.1.4__tar.gz → 0.1.5__tar.gz

{dex_python_sdk-0.1.4 → dex_python_sdk-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dex-python-sdk
-Version: 0.1.4
+Version: 0.1.5
 Requires-Dist: grpcio>=1.83.0
 Requires-Dist: grpcio-status>=1.83.0
 Requires-Dist: protobuf>=7.35.1
@@ -137,6 +137,65 @@ attempts, total duration, and 1-based attempt numbers. Fallback starts
 immediately; later regular retries continue the backoff sequence at the
 cumulative attempt.
 
+### Canceling Step executions
+
+A successful Step can cancel queued or active executions while continuing with
+its normal decision:
+
+```python
+return (
+    dex.go_to(self.record_quote, quote)
+    .with_canceling_sibling_steps(self.carrier_a, self.carrier_b)
+    .with_canceling_steps(self.global_quote_timeout)
+)
+```
+
+`with_canceling_steps` selects every current execution of each registered Step
+type. `with_canceling_sibling_steps` selects only executions with the same
+`Context.from_step_execution_id` as the current execution. Decisions are
+immutable; repeated calls form a union, and Flow-wide selection wins for the
+same Step type. Unregistered selectors produce an invalid Step result.
+
+Dex resolves one snapshot after the current execution succeeds. Completed,
+already-canceled, and absent targets are no-ops. Next Steps created by the same
+decision are outside the snapshot. Dex immediately applies the next or close
+action; late decisions, writes, retries, and recovery Steps are discarded.
+
+Set `StepOptions.heartbeat_timeout` on long-running regular Steps so
+cancellation reaches the Worker promptly. It applies to `wait_for` and
+`execute`; local activities ignore it, while an ASYNC fallback uses it. `None`
+and zero disable heartbeats, and positive values must be whole seconds in the
+signed int32 range. `AsyncWorker` cancels the handler's asyncio task. A handler
+may catch `asyncio.CancelledError` for cleanup; synchronous CPU-bound handlers
+may check `Context.is_cancellation_requested()` at natural boundaries.
+
+`RPCResult.with_canceling_steps` provides the Flow-wide selector for RPCs.
+RPCs do not support sibling selection because they have no Step execution
+lineage.
+
+### Soft Flow timeout
+
+Override `Flow.handle_timeout` to make a positive timeout use handler policy
+by default. Both synchronous and async Workers support the hook:
+
+```python
+class Orders(dex.Flow[str]):
+    async def handle_timeout(self, context: dex.Context) -> dex.StepDecision:
+        await notify_expiration(context)
+        return dex.force_complete("expired")
+
+options = dex.StartFlowOptions(
+    timeout=timedelta(minutes=30),
+    timeout_policy=dex.FlowTimeoutPolicy.HANDLER,
+)
+```
+
+Register async hooks with `allow_async_handlers=True` and run them with
+`AsyncWorker`. `FAIL` produces `FlowErrorType.FLOW_TIMEOUT` and permits Flow
+retry; `CANCEL` cancels without retry. Continue-as-new preserves the deadline,
+while retry and cron runs receive a fresh budget. A zero or absent timeout
+disables the feature.
+
 `Registry` validates every Flow, Step, RPC signature, durable name, lock, and
 codec before Client or Worker startup. `Client` methods use these typed objects
 instead of raw Flow, Step, or RPC strings.
@@ -156,7 +215,7 @@ include buffered publishes, and omit empty instances. Keys are decoded and
 sorted. Use `force_complete_if_channels_empty(...)` for conditional completion.
 
 `Client.wait_for_flow` and `AsyncClient.wait_for_flow` return a
-`WaitForFlowResult` after hydrating every output-bearing completion. Use
+`FlowResult` after hydrating every output-bearing completion. Use
 `single_output` only when the Flow contract produces exactly one output:
 
 ```python
@@ -171,13 +230,30 @@ for completion in result.completions:
 `completions` is an immutable tuple in server collection order. Parallel branch
 order is not deterministic, so select by `step_type` or `step_execution_id`.
 No-output Flows return an empty tuple; `single_output` raises `ValueError` for
-zero or multiple completions. `FlowUncompletedError.completions` uses the same
-hydrated model for partial outputs.
+zero or multiple completions. Every terminal status returns a `FlowResult`; inspect
+`status`, `error_type`, and `error_message` for unsuccessful completion.
+
+SubFlows are normal, independently addressable Flows used as durable Conditions:
+
+```python
+def wait_for(self, context: Context, input: ChargeInput) -> Wait:
+    return Wait.until(SubFlow.run(self.charge_flow, input))
+
+def execute(self, context: Context, input: ChargeInput) -> StepDecision:
+    del input
+    receipt = SubFlow.get_condition_results(context).single_output(Receipt)
+    return graceful_complete(receipt)
+```
+
+`SubFlow.get_flow_id(context, index=0)` remains available for a running `any_of`
+loser. `SubFlowOptions` configures timing, timeout policy, retry, initial target
+Attributes, Flow config, Condition ID, and reuse. Parent completion does not cancel an unfinished
+SubFlow.
 
 ### Errors
 
 Client calls raise concrete `DexServiceError` subclasses. Existing-Flow reads
-(`get_attribute`, `describe_flow`, `wait_for_flow`, and `reset_flow`) raise
+(`get_attribute`, `describe_flow`, `wait_for_flow`, and `time_travel`) raise
 `FlowNotFoundError` when the Flow does not exist. Mutations, RPCs, timer/Step
 waits, config updates, and continue-as-new triggers raise
 `FlowNotActiveError` when no running Flow can accept the operation.

{dex_python_sdk-0.1.4 → dex_python_sdk-0.1.5}/README.md

@@ -121,6 +121,65 @@ attempts, total duration, and 1-based attempt numbers. Fallback starts
 immediately; later regular retries continue the backoff sequence at the
 cumulative attempt.
 
+### Canceling Step executions
+
+A successful Step can cancel queued or active executions while continuing with
+its normal decision:
+
+```python
+return (
+    dex.go_to(self.record_quote, quote)
+    .with_canceling_sibling_steps(self.carrier_a, self.carrier_b)
+    .with_canceling_steps(self.global_quote_timeout)
+)
+```
+
+`with_canceling_steps` selects every current execution of each registered Step
+type. `with_canceling_sibling_steps` selects only executions with the same
+`Context.from_step_execution_id` as the current execution. Decisions are
+immutable; repeated calls form a union, and Flow-wide selection wins for the
+same Step type. Unregistered selectors produce an invalid Step result.
+
+Dex resolves one snapshot after the current execution succeeds. Completed,
+already-canceled, and absent targets are no-ops. Next Steps created by the same
+decision are outside the snapshot. Dex immediately applies the next or close
+action; late decisions, writes, retries, and recovery Steps are discarded.
+
+Set `StepOptions.heartbeat_timeout` on long-running regular Steps so
+cancellation reaches the Worker promptly. It applies to `wait_for` and
+`execute`; local activities ignore it, while an ASYNC fallback uses it. `None`
+and zero disable heartbeats, and positive values must be whole seconds in the
+signed int32 range. `AsyncWorker` cancels the handler's asyncio task. A handler
+may catch `asyncio.CancelledError` for cleanup; synchronous CPU-bound handlers
+may check `Context.is_cancellation_requested()` at natural boundaries.
+
+`RPCResult.with_canceling_steps` provides the Flow-wide selector for RPCs.
+RPCs do not support sibling selection because they have no Step execution
+lineage.
+
+### Soft Flow timeout
+
+Override `Flow.handle_timeout` to make a positive timeout use handler policy
+by default. Both synchronous and async Workers support the hook:
+
+```python
+class Orders(dex.Flow[str]):
+    async def handle_timeout(self, context: dex.Context) -> dex.StepDecision:
+        await notify_expiration(context)
+        return dex.force_complete("expired")
+
+options = dex.StartFlowOptions(
+    timeout=timedelta(minutes=30),
+    timeout_policy=dex.FlowTimeoutPolicy.HANDLER,
+)
+```
+
+Register async hooks with `allow_async_handlers=True` and run them with
+`AsyncWorker`. `FAIL` produces `FlowErrorType.FLOW_TIMEOUT` and permits Flow
+retry; `CANCEL` cancels without retry. Continue-as-new preserves the deadline,
+while retry and cron runs receive a fresh budget. A zero or absent timeout
+disables the feature.
+
 `Registry` validates every Flow, Step, RPC signature, durable name, lock, and
 codec before Client or Worker startup. `Client` methods use these typed objects
 instead of raw Flow, Step, or RPC strings.
@@ -140,7 +199,7 @@ include buffered publishes, and omit empty instances. Keys are decoded and
 sorted. Use `force_complete_if_channels_empty(...)` for conditional completion.
 
 `Client.wait_for_flow` and `AsyncClient.wait_for_flow` return a
-`WaitForFlowResult` after hydrating every output-bearing completion. Use
+`FlowResult` after hydrating every output-bearing completion. Use
 `single_output` only when the Flow contract produces exactly one output:
 
 ```python
@@ -155,13 +214,30 @@ for completion in result.completions:
 `completions` is an immutable tuple in server collection order. Parallel branch
 order is not deterministic, so select by `step_type` or `step_execution_id`.
 No-output Flows return an empty tuple; `single_output` raises `ValueError` for
-zero or multiple completions. `FlowUncompletedError.completions` uses the same
-hydrated model for partial outputs.
+zero or multiple completions. Every terminal status returns a `FlowResult`; inspect
+`status`, `error_type`, and `error_message` for unsuccessful completion.
+
+SubFlows are normal, independently addressable Flows used as durable Conditions:
+
+```python
+def wait_for(self, context: Context, input: ChargeInput) -> Wait:
+    return Wait.until(SubFlow.run(self.charge_flow, input))
+
+def execute(self, context: Context, input: ChargeInput) -> StepDecision:
+    del input
+    receipt = SubFlow.get_condition_results(context).single_output(Receipt)
+    return graceful_complete(receipt)
+```
+
+`SubFlow.get_flow_id(context, index=0)` remains available for a running `any_of`
+loser. `SubFlowOptions` configures timing, timeout policy, retry, initial target
+Attributes, Flow config, Condition ID, and reuse. Parent completion does not cancel an unfinished
+SubFlow.
 
 ### Errors
 
 Client calls raise concrete `DexServiceError` subclasses. Existing-Flow reads
-(`get_attribute`, `describe_flow`, `wait_for_flow`, and `reset_flow`) raise
+(`get_attribute`, `describe_flow`, `wait_for_flow`, and `time_travel`) raise
 `FlowNotFoundError` when the Flow does not exist. Mutations, RPCs, timer/Step
 waits, config updates, and continue-as-new triggers raise
 `FlowNotActiveError` when no running Flow can accept the operation.

{dex_python_sdk-0.1.4 → dex_python_sdk-0.1.5}/dex/__init__.py

@@ -45,14 +45,18 @@ from dex.flow_info import (
     SearchFlowsPage,
 )
 from dex.flow_options import (
+    FlowTimeoutPolicy,
     IdReusePolicy,
-    ResetFlowOptions,
-    ResetType,
+    TimeTravelOptions,
+    TimeTravelStepMethod,
+    TimeTravelType,
     StartFlowOptions,
+    SubFlowOptions,
+    SubFlowReusePolicy,
     StopFlowOptions,
     StopType,
 )
-from dex.flow_result import StepCompletion, WaitForFlowResult
+from dex.flow_result import FlowResult, StepCompletion
 from dex.runtime_errors import (
     DexServiceError,
     ErrorSubStatus,
@@ -61,7 +65,6 @@ from dex.runtime_errors import (
     FlowErrorType,
     FlowNotActiveError,
     FlowNotFoundError,
-    FlowUncompletedError,
     InvalidStepResultError,
     LongPollTimeoutError,
     RpcLockConflictError,
@@ -87,6 +90,7 @@ from dex.step import (
 )
 from dex.step_execution import StepExecutionId, TimerId
 from dex.timer import Timer
+from dex.subflow import SubFlow
 from dex.wait import Wait
 from dex.worker import Worker
 from dex.worker_options import WorkerOptions, WorkerTarget
@@ -122,10 +126,11 @@ __all__ = [
     "FlowDefinitionError",
     "FlowErrorType",
     "FlowInfo",
+    "FlowResult",
     "FlowNotActiveError",
     "FlowNotFoundError",
     "FlowStatus",
-    "FlowUncompletedError",
+    "FlowTimeoutPolicy",
     "HealthInfo",
     "IdReusePolicy",
     "InvalidStepResultError",
@@ -136,13 +141,17 @@ __all__ = [
     "RPCResult",
     "RpcLockConflictError",
     "Registry",
-    "ResetFlowOptions",
-    "ResetType",
+    "TimeTravelOptions",
+    "TimeTravelStepMethod",
+    "TimeTravelType",
     "RetryPolicy",
     "SearchFlowEntry",
     "SearchFlowsPage",
     "StepCompletion",
     "StartFlowOptions",
+    "SubFlow",
+    "SubFlowOptions",
+    "SubFlowReusePolicy",
     "StepExecutionId",
     "StepDecision",
     "Step",
@@ -158,7 +167,6 @@ __all__ = [
     "ValueMappingError",
     "Wait",
     "WaitForFailurePolicy",
-    "WaitForFlowResult",
     "WireKind",
     "Worker",
     "WorkerInvocationError",

{dex_python_sdk-0.1.4 → dex_python_sdk-0.1.5}/dex/_async_value_hydrator.py

@@ -88,13 +88,15 @@ class AsyncValueHydrator:
     ) -> pb.InvokeExecuteMethodRequest:
         result = pb.InvokeExecuteMethodRequest()
         result.CopyFrom(request)
-        values = [request.step_input]
+        has_step_input = request.HasField("step_input")
+        values = [request.step_input] if has_step_input else []
         values.extend(entry.value for entry in request.attributes)
         values.extend(entry.value for entry in request.step_exe_locals)
         for channel_result in request.condition_results.channel_results:
             values.extend(channel_result.values)
         hydrated = iter(await self.hydrate_all(values))
-        result.step_input.CopyFrom(next(hydrated))
+        if has_step_input:
+            result.step_input.CopyFrom(next(hydrated))
         for entry in result.attributes:
             entry.value.CopyFrom(next(hydrated))
         for entry in result.step_exe_locals:

{dex_python_sdk-0.1.4 → dex_python_sdk-0.1.5}/dex/_async_worker_dispatcher.py

@@ -9,14 +9,14 @@
 from __future__ import annotations
 
 from inspect import isawaitable
-from typing import Any
+from typing import Any, Callable
 
 from dex._async_value_hydrator import AsyncValueHydrator
 from dex._invocation_context import InvocationContext, InvocationMethod
 from dex._value_mapper import ValueMapper
-from dex._worker_dispatcher import WorkerDispatcher
+from dex._worker_dispatcher import _TIMEOUT_HANDLER_STEP_TYPE, WorkerDispatcher
 from dex.dexpb import dex_pb2 as pb
-from dex.flow import RPCResult, Registry
+from dex.flow import Registry, RPCResult
 from dex.runtime_errors import InvalidStepResultError, ValueMappingError
 from dex.step import StepDecision
 from dex.wait import Wait
@@ -36,6 +36,7 @@ class AsyncWorkerDispatcher(WorkerDispatcher):
     async def invoke_wait_for(  # type: ignore[override]
         self,
         original: pb.InvokeWaitForMethodRequest,
+        is_active: Callable[[], bool] | None = None,
     ) -> pb.InvokeWaitForMethodResponse:
         request = await self._async_hydrator.wait_for_request(original)
         flow = self._registry._flow_by_type(request.flow_type)
@@ -46,6 +47,7 @@ class AsyncWorkerDispatcher(WorkerDispatcher):
             request.context,
             self._values,
             request.attributes,
+            is_active=is_active,
         )
         input = self._values.decode(request.step_input, step.input_codec)
         wait = step.step.wait_for(context, input)
@@ -72,9 +74,12 @@ class AsyncWorkerDispatcher(WorkerDispatcher):
     async def invoke_execute(  # type: ignore[override]
         self,
         original: pb.InvokeExecuteMethodRequest,
+        is_active: Callable[[], bool] | None = None,
     ) -> pb.InvokeExecuteMethodResponse:
         request = await self._async_hydrator.execute_request(original)
         flow = self._registry._flow_by_type(request.flow_type)
+        if request.step_type == _TIMEOUT_HANDLER_STEP_TYPE:
+            return await self._invoke_timeout_handler_async(request, flow)
         step = flow.step(request.step_type)
         condition_results = (
             request.condition_results if request.HasField("condition_results") else None
@@ -87,6 +92,7 @@ class AsyncWorkerDispatcher(WorkerDispatcher):
             request.attributes,
             request.step_exe_locals,
             condition_results,
+            is_active=is_active,
         )
         input = self._values.decode(request.step_input, step.input_codec)
         decision: Any = step.step.execute(context, input)
@@ -107,9 +113,56 @@ class AsyncWorkerDispatcher(WorkerDispatcher):
                 flow.name, step.name, "execute", str(error)
             ) from error
 
+    async def _invoke_timeout_handler_async(
+        self,
+        request: pb.InvokeExecuteMethodRequest,
+        flow: Any,
+    ) -> pb.InvokeExecuteMethodResponse:
+        if request.HasField("step_input"):
+            raise InvalidStepResultError(
+                flow.name, _TIMEOUT_HANDLER_STEP_TYPE, "execute", "input must be absent"
+            )
+        if not flow.has_timeout_handler:
+            raise InvalidStepResultError(
+                flow.name,
+                _TIMEOUT_HANDLER_STEP_TYPE,
+                "execute",
+                "handler is not registered",
+            )
+        condition_results = (
+            request.condition_results if request.HasField("condition_results") else None
+        )
+        context = InvocationContext(
+            InvocationMethod.EXECUTE,
+            flow,
+            request.context,
+            self._values,
+            request.attributes,
+            request.step_exe_locals,
+            condition_results,
+        )
+        decision: Any = flow.flow.handle_timeout(context)
+        if isawaitable(decision):
+            decision = await decision
+        try:
+            if not isinstance(decision, StepDecision):
+                raise TypeError("handle_timeout must return StepDecision")
+            return pb.InvokeExecuteMethodResponse(
+                step_decision=self._map_decision(flow, decision),
+                upsert_attributes=list(context.attribute_writes.values()),
+                record_events=context.events,
+                upsert_step_exe_locals=list(context.local_writes.values()),
+                publish_to_channel=context.publications,
+            )
+        except (TypeError, ValueError) as error:
+            raise InvalidStepResultError(
+                flow.name, _TIMEOUT_HANDLER_STEP_TYPE, "execute", str(error)
+            ) from error
+
     async def invoke_rpc(  # type: ignore[override]
         self,
         original: pb.InvokeWorkerRPCRequest,
+        is_active: Callable[[], bool] | None = None,
     ) -> pb.InvokeWorkerRPCResponse:
         request = await self._async_hydrator.rpc_request(original)
         flow = self._registry._flow_by_type(request.flow_type)
@@ -121,6 +174,7 @@ class AsyncWorkerDispatcher(WorkerDispatcher):
             self._values,
             request.attributes,
             channel_infos=dict(request.channel_infos),
+            is_active=is_active,
         )
         arguments: list[object] = [context]
         if rpc.input_codec is not None:
@@ -144,6 +198,11 @@ class AsyncWorkerDispatcher(WorkerDispatcher):
                     response.step_decision.next_steps.extend(
                         self._map_movements(flow, returned.next_steps)
                     )
+                response.step_decision.cancel_step_types.extend(
+                    self._map_cancellation_steps(flow, returned.canceling_steps)
+                )
+                if not returned.next_steps and not returned.canceling_steps:
+                    response.ClearField("step_decision")
             elif returned is None and rpc.output_codec is None:
                 response.output.CopyFrom(self._values.encode_dynamic(None))
             else:

{dex_python_sdk-0.1.4 → dex_python_sdk-0.1.5}/dex/_async_worker_service.py

@@ -9,8 +9,9 @@
 from __future__ import annotations
 
 import logging
+from asyncio import CancelledError, current_task
 from collections.abc import Awaitable, Callable
-from typing import TypeVar
+from typing import Any, TypeVar
 
 import grpc
 
@@ -27,39 +28,71 @@ class AsyncWorkerService(dex_pb2_grpc.WorkerServiceServicer):
     def __init__(self, dispatcher: AsyncWorkerDispatcher) -> None:
         self._dispatcher = dispatcher
 
-    async def InvokeWaitForMethod(  # type: ignore[override]
+    async def InvokeWaitForMethod(
         self,
         request: pb.InvokeWaitForMethodRequest,
-        context: grpc.aio.ServicerContext,
+        context: grpc.aio.ServicerContext[
+            pb.InvokeWaitForMethodRequest,
+            pb.InvokeWaitForMethodResponse,
+        ],
     ) -> pb.InvokeWaitForMethodResponse:
         return await self._invoke(
-            context, lambda: self._dispatcher.invoke_wait_for(request)
+            context,
+            lambda: self._dispatcher.invoke_wait_for(
+                request, lambda: self._is_active(context)
+            ),
         )
 
-    async def InvokeExecuteMethod(  # type: ignore[override]
+    async def InvokeExecuteMethod(
         self,
         request: pb.InvokeExecuteMethodRequest,
-        context: grpc.aio.ServicerContext,
+        context: grpc.aio.ServicerContext[
+            pb.InvokeExecuteMethodRequest,
+            pb.InvokeExecuteMethodResponse,
+        ],
     ) -> pb.InvokeExecuteMethodResponse:
         return await self._invoke(
-            context, lambda: self._dispatcher.invoke_execute(request)
+            context,
+            lambda: self._dispatcher.invoke_execute(
+                request, lambda: self._is_active(context)
+            ),
         )
 
-    async def InvokeWorkerRPC(  # type: ignore[override]
+    async def InvokeWorkerRPC(
         self,
         request: pb.InvokeWorkerRPCRequest,
-        context: grpc.aio.ServicerContext,
+        context: grpc.aio.ServicerContext[
+            pb.InvokeWorkerRPCRequest,
+            pb.InvokeWorkerRPCResponse,
+        ],
     ) -> pb.InvokeWorkerRPCResponse:
-        return await self._invoke(context, lambda: self._dispatcher.invoke_rpc(request))
+        return await self._invoke(
+            context,
+            lambda: self._dispatcher.invoke_rpc(
+                request, lambda: self._is_active(context)
+            ),
+        )
+
+    @staticmethod
+    def _is_active(context: grpc.aio.ServicerContext[Any, Any]) -> bool:
+        task = current_task()
+        return not context.cancelled() and (task is None or task.cancelling() == 0)
 
     @staticmethod
     async def _invoke(
-        context: grpc.aio.ServicerContext,
+        context: grpc.aio.ServicerContext[Any, Any],
         invocation: Callable[[], Awaitable[ResponseT]],
     ) -> ResponseT:
         try:
             return await invocation()
+        except CancelledError:
+            raise
         except BaseException as error:
+            if not AsyncWorkerService._is_active(context):
+                await context.abort(
+                    grpc.StatusCode.CANCELLED,
+                    "Python AsyncWorker invocation canceled",
+                )
             _LOGGER.exception("Python AsyncWorker invocation failed")
             await async_abort_worker_error(context, error)
             raise RuntimeError("gRPC abort returned unexpectedly") from error

{dex_python_sdk-0.1.4 → dex_python_sdk-0.1.5}/dex/_invocation_context.py

@@ -9,7 +9,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any, Sequence, TypeVar, cast
+from typing import Any, Callable, Sequence, TypeVar, cast
 from urllib.parse import unquote
 
 from dex._utils import require_name
@@ -19,6 +19,7 @@ from dex.channel import Channel, ChannelMap
 from dex.codec import Codec
 from dex.dexpb import dex_pb2 as pb
 from dex.flow import Registry, _RegisteredFlow
+from dex.flow_result import FlowResult, flow_result_from_proto
 
 ValueT = TypeVar("ValueT")
 _Definition = Attribute[Any] | AttributeMap[Any] | Channel[Any] | ChannelMap[Any]
@@ -41,6 +42,7 @@ class InvocationContext:
         locals: Sequence[pb.KV] = (),
         condition_results: pb.ConditionResults | None = None,
         channel_infos: dict[str, pb.ChannelInfo] | None = None,
+        is_active: Callable[[], bool] | None = None,
     ) -> None:
         self._method = method
         self._flow = flow
@@ -50,6 +52,7 @@ class InvocationContext:
         self._locals = self._map_values("step-execution local", locals)
         self._condition_results = condition_results
         self._channel_infos = dict(channel_infos or {})
+        self._is_active = is_active or _always_active
         self.attribute_writes: dict[str, pb.AttributeWrite] = {}
         self.local_writes: dict[str, pb.KV] = {}
         self.events: list[pb.KV] = []
@@ -96,6 +99,29 @@ class InvocationContext:
             and self._condition_results.wait_for_failed
         )
 
+    def sub_flow_result(self, index: int = 0) -> FlowResult:
+        if self._method is not InvocationMethod.EXECUTE:
+            raise ValueError("SubFlow results are available only during execute")
+        if (
+            self._condition_results is None
+            or index < 0
+            or index >= len(self._condition_results.sub_flow_results)
+        ):
+            raise ValueError(f"SubFlow result index is unavailable: {index}")
+        return flow_result_from_proto(
+            self._condition_results.sub_flow_results[index],
+            lambda value, output_type: self._values.decode(
+                value, self._values.codec(output_type)
+            ),
+        )
+
+    def sub_flow_id(self, index: int = 0) -> str:
+        self.sub_flow_result(index)
+        return f"SubFlow:{self.flow_id}-{self.step_execution_id}-{index}"
+
+    def is_cancellation_requested(self) -> bool:
+        return not self._is_active()
+
     def set_step_execution_local(self, key: str, value: object) -> None:
         require_name(key)
         self.local_writes[key] = pb.KV(
@@ -302,3 +328,7 @@ class InvocationContext:
         if value_type is float:
             return 0.0
         return None
+
+
+def _always_active() -> bool:
+    return True

{dex_python_sdk-0.1.4 → dex_python_sdk-0.1.5}/dex/_value_hydrator.py

@@ -88,13 +88,19 @@ class ValueHydrator:
     ) -> pb.InvokeExecuteMethodRequest:
         result = pb.InvokeExecuteMethodRequest()
         result.CopyFrom(request)
-        values = [request.step_input]
+        has_step_input = request.HasField("step_input")
+        values = [request.step_input] if has_step_input else []
         values.extend(entry.value for entry in request.attributes)
         values.extend(entry.value for entry in request.step_exe_locals)
         for channel_result in request.condition_results.channel_results:
             values.extend(channel_result.values)
+        for flow_result in request.condition_results.sub_flow_results:
+            values.extend(
+                completion.completed_step_output for completion in flow_result.results
+            )
         hydrated = iter(self.hydrate_all(values))
-        result.step_input.CopyFrom(next(hydrated))
+        if has_step_input:
+            result.step_input.CopyFrom(next(hydrated))
         for entry in result.attributes:
             entry.value.CopyFrom(next(hydrated))
         for entry in result.step_exe_locals:
@@ -102,6 +108,9 @@ class ValueHydrator:
         for channel_result in result.condition_results.channel_results:
             for value in channel_result.values:
                 value.CopyFrom(next(hydrated))
+        for flow_result in result.condition_results.sub_flow_results:
+            for completion in flow_result.results:
+                completion.completed_step_output.CopyFrom(next(hydrated))
         return result
 
     def rpc_request(