cadence-python-client 0.2.3__tar.gz → 0.3.0__tar.gz

{cadence_python_client-0.2.3 → cadence_python_client-0.3.0}/.cursorrules

@@ -32,7 +32,7 @@ pip install -e ".[dev]"
 
 ## Code Generation
 - Use `uv run python scripts/generate_proto.py` for protobuf generation
-- Use `uv run python scripts/dev.py` for development tasks
+- Use `make` targets for development tasks
 
 ## Code Quality
 - **ALWAYS run linter and type checker after making code changes**

{cadence_python_client-0.2.3 → cadence_python_client-0.3.0}/.github/workflows/ci_checks.yml

@@ -97,6 +97,6 @@ jobs:
       - name: Install dependencies
         run: |
           uv sync --extra dev
-      - name: Run unit tests
+      - name: Run integration tests
         run: |
-          uv run pytest -v --integration-tests
+          uv run pytest -v tests/integration_tests --integration-tests

{cadence_python_client-0.2.3 → cadence_python_client-0.3.0}/Makefile

@@ -33,11 +33,11 @@ test:
 # Run integration tests
 integration-test:
 	@echo "Running integration tests..."
-	uv run pytest -v --integration-tests
+	uv run pytest -v tests/integration_tests --integration-tests
 
 integration-test-keep:
 	@echo "Running integration tests with cadence alive..."
-	uv run pytest -v --integration-tests --keep-cadence-alive
+	uv run pytest -v tests/integration_tests --integration-tests --keep-cadence-alive
 
 # Clean generated files and caches
 clean:

{cadence_python_client-0.2.3 → cadence_python_client-0.3.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cadence-python-client
-Version: 0.2.3
-Summary: Python framework for authoring Cadence workflows and activities
+Version: 0.3.0
+Summary: Python SDK for authoring Cadence workflows and activities
 Author: Cadence
 License: Apache-2.0
 Project-URL: Homepage, https://cadenceworkflow.io/
@@ -9,7 +9,7 @@ Project-URL: Documentation, https://cadenceworkflow.io/docs/get-started
 Project-URL: Repository, https://github.com/cadence-workflow/cadence-python-client
 Project-URL: Bug Tracker, https://github.com/cadence-workflow/cadence-python-client/issues
 Keywords: workflow,orchestration,distributed,async,cadence
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
@@ -35,11 +35,7 @@ Requires-Dist: grpc-stubs>=1.53.0.6; extra == "dev"
 Requires-Dist: pytest>=8.4.1; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
-Requires-Dist: isort>=5.12.0; extra == "dev"
-Requires-Dist: flake8>=6.0.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
-Requires-Dist: pre-commit>=3.0.0; extra == "dev"
 Requires-Dist: pytest-docker>=3.2.3; extra == "dev"
 Requires-Dist: opentelemetry-instrumentation-grpc==0.60b1; extra == "dev"
 Requires-Dist: opentelemetry-sdk>=1.39.1; extra == "dev"
@@ -57,19 +53,13 @@ Requires-Dist: openai>=0.27.10; extra == "openai"
 Requires-Dist: openai-agents>=0.12.5; extra == "openai"
 Dynamic: license-file
 
-# Python framework for Cadence
+# Cadence Python SDK
 
 [Cadence](https://github.com/uber/cadence) is a distributed, scalable, durable, and highly available orchestration engine we developed at Uber Engineering to execute asynchronous long-running business logic in a scalable and resilient way.
 
 If you'd like to propose a new feature, first join the [CNCF Slack workspace](https://communityinviter.com/apps/cloud-native/cncf) in the **#cadence-users** channel to start a discussion.
 
-`cadence-python-client` is the Python framework for authoring workflows and activities.
-
-## Disclaimer
-**This SDK is currently an early work-in-progress (WIP) and is NOT ready for production use.**
-
-- This project is still in active development
-- APIs and interfaces are subject to change without notice
+The Cadence Python SDK is the framework for authoring workflows and activities using the Python programming language.
 
 ## Installation
 
@@ -87,6 +77,8 @@ uv add cadence-python-client
 
 The core package supports Python `>=3.11,<3.14`.
 
+The SDK is ready for production use using PYPI. To build from source, clone the repository and install the development dependencies.
+
 Clone the repository if you want to develop locally:
 
 ```bash

{cadence_python_client-0.2.3 → cadence_python_client-0.3.0}/README.md

@@ -1,16 +1,10 @@
-# Python framework for Cadence
+# Cadence Python SDK
 
 [Cadence](https://github.com/uber/cadence) is a distributed, scalable, durable, and highly available orchestration engine we developed at Uber Engineering to execute asynchronous long-running business logic in a scalable and resilient way.
 
 If you'd like to propose a new feature, first join the [CNCF Slack workspace](https://communityinviter.com/apps/cloud-native/cncf) in the **#cadence-users** channel to start a discussion.
 
-`cadence-python-client` is the Python framework for authoring workflows and activities.
-
-## Disclaimer
-**This SDK is currently an early work-in-progress (WIP) and is NOT ready for production use.**
-
-- This project is still in active development
-- APIs and interfaces are subject to change without notice
+The Cadence Python SDK is the framework for authoring workflows and activities using the Python programming language.
 
 ## Installation
 
@@ -28,6 +22,8 @@ uv add cadence-python-client
 
 The core package supports Python `>=3.11,<3.14`.
 
+The SDK is ready for production use using PYPI. To build from source, clone the repository and install the development dependencies.
+
 Clone the repository if you want to develop locally:
 
 ```bash

cadence_python_client-0.3.0/cadence/_internal/workflow/context.py

@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from asyncio import get_running_loop
+from datetime import timedelta
+from math import ceil
+from typing import Iterator, Optional, Any, Unpack, Type, cast, Callable
+
+from cadence._internal.workflow.deterministic_event_loop import DeterministicEventLoop
+from cadence._internal.workflow.memo import memo_to_proto
+from cadence._internal.workflow.retry_policy import retry_policy_to_proto
+from cadence._internal.workflow.statemachine.decision_manager import DecisionManager
+from cadence.api.v1 import workflow_pb2
+from cadence.api.v1.common_pb2 import ActivityType, WorkflowType, WorkflowExecution
+from cadence.api.v1.decision_pb2 import (
+    ScheduleActivityTaskDecisionAttributes,
+    SignalExternalWorkflowExecutionDecisionAttributes,
+    StartChildWorkflowExecutionDecisionAttributes,
+    StartTimerDecisionAttributes,
+)
+from cadence.api.v1.tasklist_pb2 import TaskList, TaskListKind
+from cadence.data_converter import DataConverter
+from cadence.workflow import (
+    ActivityOptions,
+    ChildWorkflowFuture,
+    ChildWorkflowOptions,
+    ResultType,
+    WorkflowContext,
+    WorkflowInfo,
+)
+
+_DEFAULT_ACTIVITY_OPTIONS: ActivityOptions = {
+    "schedule_to_close_timeout": timedelta(hours=1),
+    "schedule_to_start_timeout": timedelta(seconds=10),
+}
+
+
+class Context(WorkflowContext):
+    def __init__(
+        self,
+        info: WorkflowInfo,
+        decision_manager: DecisionManager,
+    ):
+        self._info = info
+        self._replay_mode = True
+        self._replay_current_time_milliseconds: Optional[int] = None
+        self._decision_manager = decision_manager
+
+    def info(self) -> WorkflowInfo:
+        return self._info
+
+    def data_converter(self) -> DataConverter:
+        return self.info().data_converter
+
+    async def execute_activity(
+        self,
+        activity: str,
+        result_type: Type[ResultType],
+        *args: Any,
+        **kwargs: Unpack[ActivityOptions],
+    ) -> ResultType:
+        opts: ActivityOptions = {**_DEFAULT_ACTIVITY_OPTIONS, **kwargs}
+        if "schedule_to_close_timeout" not in opts and (
+            "schedule_to_start_timeout" not in opts
+            or "start_to_close_timeout" not in opts
+        ):
+            raise ValueError(
+                "Either schedule_to_close_timeout or both schedule_to_start_timeout and start_to_close_timeout must be specified"
+            )
+
+        schedule_to_close = opts.get("schedule_to_close_timeout", None)
+        schedule_to_start = opts.get("schedule_to_start_timeout", None)
+        start_to_close = opts.get("start_to_close_timeout", None)
+        heartbeat = opts.get("heartbeat_timeout", None)
+
+        if schedule_to_close is None:
+            schedule_to_close = schedule_to_start + start_to_close  # type: ignore
+
+        if start_to_close is None:
+            start_to_close = schedule_to_close
+
+        if schedule_to_start is None:
+            schedule_to_start = schedule_to_close
+
+        if heartbeat is None:
+            heartbeat = schedule_to_close
+
+        task_list = (
+            opts["task_list"]
+            if opts.get("task_list", None)
+            else self._info.workflow_task_list
+        )
+
+        activity_input = self.data_converter().to_data(list(args))
+        schedule_attributes = ScheduleActivityTaskDecisionAttributes(
+            activity_type=ActivityType(name=activity),
+            domain=self.info().workflow_domain,
+            task_list=TaskList(kind=TaskListKind.TASK_LIST_KIND_NORMAL, name=task_list),
+            input=activity_input,
+            schedule_to_close_timeout=_round_to_nearest_second(schedule_to_close),
+            schedule_to_start_timeout=_round_to_nearest_second(schedule_to_start),
+            start_to_close_timeout=_round_to_nearest_second(start_to_close),
+            heartbeat_timeout=_round_to_nearest_second(heartbeat),
+            retry_policy=retry_policy_to_proto(opts.get("retry_policy")),
+            header=None,
+            request_local_dispatch=False,
+        )
+
+        future = self._decision_manager.schedule_activity(schedule_attributes)
+        result_payload = await future
+
+        result = self.data_converter().from_data(result_payload, [result_type])[0]
+
+        return cast(ResultType, result)
+
+    async def execute_child_workflow(
+        self,
+        workflow_type: str,
+        result_type: Type[ResultType],
+        *args: Any,
+        **kwargs: Unpack[ChildWorkflowOptions],
+    ) -> ResultType:
+        future = await self.start_child_workflow(
+            workflow_type, result_type, *args, **kwargs
+        )
+        return await future
+
+    async def start_child_workflow(
+        self,
+        workflow_type: str,
+        result_type: Type[ResultType],
+        *args: Any,
+        **kwargs: Unpack[ChildWorkflowOptions],
+    ) -> ChildWorkflowFuture[ResultType]:
+        schedule_attributes = self._build_child_workflow_attrs(
+            workflow_type, *args, **kwargs
+        )
+        execution_future, result_future = (
+            self._decision_manager.schedule_child_workflow(
+                schedule_attributes,
+                parent_workflow_run_id=self._info.workflow_run_id,
+            )
+        )
+        workflow_execution = await execution_future
+        return ChildWorkflowFuture(
+            workflow_id=workflow_execution.workflow_id,
+            run_id=workflow_execution.run_id,
+            result_future=result_future,
+            result_type=result_type,
+            data_converter=self.data_converter(),
+        )
+
+    def _build_child_workflow_attrs(
+        self,
+        workflow_type: str,
+        *args: Any,
+        **kwargs: Unpack[ChildWorkflowOptions],
+    ) -> StartChildWorkflowExecutionDecisionAttributes:
+        execution_timeout = kwargs.get("execution_start_to_close_timeout")
+        if execution_timeout is None:
+            raise ValueError(
+                "execution_start_to_close_timeout is required for child workflow execution"
+            )
+        if execution_timeout <= timedelta(0):
+            raise ValueError("execution_start_to_close_timeout must be greater than 0")
+
+        task_timeout = kwargs.get("task_start_to_close_timeout", timedelta(seconds=10))
+        if task_timeout <= timedelta(0):
+            raise ValueError("task_start_to_close_timeout must be greater than 0")
+
+        domain = kwargs.get("domain") or self._info.workflow_domain
+        task_list = kwargs.get("task_list") or self._info.workflow_task_list
+
+        workflow_id = kwargs.get("workflow_id") or ""
+
+        parent_close_policy = kwargs.get(
+            "parent_close_policy",
+            workflow_pb2.PARENT_CLOSE_POLICY_TERMINATE,
+        )
+        workflow_id_reuse_policy = kwargs.get(
+            "workflow_id_reuse_policy",
+            workflow_pb2.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY,
+        )
+        if workflow_id_reuse_policy == workflow_pb2.WORKFLOW_ID_REUSE_POLICY_INVALID:
+            raise ValueError(
+                "workflow_id_reuse_policy cannot be WORKFLOW_ID_REUSE_POLICY_INVALID"
+            )
+
+        child_input = self.data_converter().to_data(list(args))
+        schedule_attributes = StartChildWorkflowExecutionDecisionAttributes(
+            domain=domain,
+            workflow_id=workflow_id,
+            workflow_type=WorkflowType(name=workflow_type),
+            task_list=TaskList(kind=TaskListKind.TASK_LIST_KIND_NORMAL, name=task_list),
+            input=child_input,
+            execution_start_to_close_timeout=_round_to_nearest_second(
+                execution_timeout
+            ),
+            task_start_to_close_timeout=_round_to_nearest_second(task_timeout),
+            parent_close_policy=parent_close_policy,
+            workflow_id_reuse_policy=workflow_id_reuse_policy,
+            retry_policy=retry_policy_to_proto(kwargs.get("retry_policy")),
+        )
+
+        cron_schedule = kwargs.get("cron_schedule")
+        if cron_schedule:
+            schedule_attributes.cron_schedule = cron_schedule
+
+        memo_proto = memo_to_proto(self.data_converter(), kwargs.get("memo"))
+        if memo_proto is not None:
+            schedule_attributes.memo.CopyFrom(memo_proto)
+
+        return schedule_attributes
+
+    async def signal_child_workflow(
+        self,
+        child_workflow_id: str,
+        signal_name: str,
+        *args: Any,
+    ) -> None:
+        if not child_workflow_id:
+            raise ValueError("child_workflow_id must not be empty")
+        await self._signal_workflow(
+            child_workflow_id, signal_name, args, child_workflow_only=True
+        )
+
+    async def signal_external_workflow(
+        self,
+        workflow_id: str,
+        signal_name: str,
+        *args: Any,
+        run_id: str = "",
+        domain: str = "",
+    ) -> None:
+        if not workflow_id:
+            raise ValueError("workflow_id must not be empty")
+        await self._signal_workflow(
+            workflow_id, signal_name, args, run_id=run_id, domain=domain
+        )
+
+    async def start_timer(self, duration: timedelta):
+        if duration.total_seconds() <= 0:  # shortcut
+            return
+        future = self._decision_manager.start_timer(
+            StartTimerDecisionAttributes(
+                start_to_fire_timeout=duration,
+            )
+        )
+        await future
+
+    def set_replay_mode(self, replay: bool) -> None:
+        """Set whether the workflow is currently in replay mode."""
+        self._replay_mode = replay
+
+    def is_replay_mode(self) -> bool:
+        """Check if the workflow is currently in replay mode."""
+        return self._replay_mode
+
+    def set_replay_current_time_milliseconds(self, time_millis: int) -> None:
+        """Set the current replay time in milliseconds."""
+        self._replay_current_time_milliseconds = time_millis
+
+    def get_replay_current_time_milliseconds(self) -> Optional[int]:
+        """Get the current replay time in milliseconds."""
+        return self._replay_current_time_milliseconds
+
+    async def wait_condition(self, predicate: Callable[[], bool]) -> None:
+        loop = cast(DeterministicEventLoop, get_running_loop())
+        await loop.create_waiter(predicate)
+
+    @contextmanager
+    def _activate(self) -> Iterator["Context"]:
+        token = WorkflowContext._var.set(self)
+        try:
+            yield self
+        finally:
+            WorkflowContext._var.reset(token)
+
+    async def _signal_workflow(
+        self,
+        workflow_id: str,
+        signal_name: str,
+        args: tuple,
+        *,
+        run_id: str = "",
+        domain: str = "",
+        child_workflow_only: bool = False,
+    ) -> None:
+        if not signal_name:
+            raise ValueError("signal_name must not be empty")
+        attrs = SignalExternalWorkflowExecutionDecisionAttributes(
+            domain=domain or self._info.workflow_domain,
+            workflow_execution=WorkflowExecution(
+                workflow_id=workflow_id,
+                run_id=run_id,
+            ),
+            signal_name=signal_name,
+            input=self.data_converter().to_data(list(args)),
+            child_workflow_only=child_workflow_only,
+        )
+        await self._decision_manager.signal_external_workflow(attrs)
+
+
+def _round_to_nearest_second(delta: timedelta) -> timedelta:
+    return timedelta(seconds=ceil(delta.total_seconds()))

cadence_python_client-0.3.0/cadence/_internal/workflow/memo.py

@@ -0,0 +1,40 @@
+"""Convert user memo maps to/from protobuf :class:`cadence.api.v1.common_pb2.Memo`."""
+
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from cadence.api.v1 import common_pb2
+from cadence.data_converter import DataConverter
+
+
+def memo_to_proto(
+    data_converter: DataConverter,
+    memo: Mapping[str, Any] | None,
+) -> common_pb2.Memo | None:
+    """Serialize ``memo`` to protobuf, or ``None`` if no memo was provided.
+
+    Each value is encoded as a single-element list via the data converter,
+    matching Go/Java SDK behavior (one :class:`Payload` per key).
+    """
+    if not memo:
+        return None
+    out = common_pb2.Memo()
+    for key, value in memo.items():
+        out.fields[key].CopyFrom(data_converter.to_data([value]))
+    return out
+
+
+def memo_from_proto(
+    data_converter: DataConverter,
+    memo: common_pb2.Memo,
+) -> dict[str, Any]:
+    """Deserialize a protobuf ``Memo`` back to a plain dict.
+
+    Each field payload was encoded as a single-element list; we unwrap that
+    first element to recover the original value.
+    """
+    return {
+        key: data_converter.from_data(payload, [None])[0]
+        for key, payload in memo.fields.items()
+    }

cadence_python_client-0.3.0/cadence/_internal/workflow/statemachine/child_workflow_execution_state_machine.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+from cadence._internal.workflow.statemachine.decision_state_machine import (
+    BaseDecisionStateMachine,
+    DecisionFuture,
+    DecisionId,
+    DecisionState,
+    DecisionType,
+)
+from cadence._internal.workflow.statemachine.event_dispatcher import EventDispatcher
+from cadence._internal.workflow.statemachine.nondeterminism import (
+    record_immediate_cancel,
+)
+from cadence.api.v1 import decision, history
+from cadence.api.v1.common_pb2 import Payload, WorkflowExecution
+from cadence.error import (
+    ChildWorkflowExecutionCanceled,
+    ChildWorkflowExecutionFailed,
+    ChildWorkflowExecutionTerminated,
+    ChildWorkflowExecutionTimedOut,
+    StartChildWorkflowExecutionFailed,
+)
+
+child_workflow_events = EventDispatcher("initiated_event_id")
+
+
+class ChildWorkflowExecutionStateMachine(BaseDecisionStateMachine):
+    """State machine for StartChildWorkflowExecution and child close events."""
+
+    request: decision.StartChildWorkflowExecutionDecisionAttributes
+    execution: DecisionFuture[WorkflowExecution]
+    result: DecisionFuture[Payload]
+    _run_id: str | None
+
+    def __init__(
+        self,
+        request: decision.StartChildWorkflowExecutionDecisionAttributes,
+        execution: DecisionFuture[WorkflowExecution],
+        result: DecisionFuture[Payload],
+    ) -> None:
+        super().__init__()
+        self.request = request
+        self.execution = execution
+        self.result = result
+        self._run_id = None
+
+    def get_id(self) -> DecisionId:
+        return DecisionId(DecisionType.CHILD_WORKFLOW, self.request.workflow_id)
+
+    def get_decision(self) -> decision.Decision | None:
+        match self.state:
+            case DecisionState.REQUESTED:
+                return decision.Decision(
+                    start_child_workflow_execution_decision_attributes=self.request
+                )
+            case DecisionState.CANCELED_AFTER_REQUESTED:
+                return record_immediate_cancel(self.request)
+            case (
+                DecisionState.CANCELED_AFTER_RECORDED
+                | DecisionState.CANCELED_AFTER_STARTED
+            ):
+                return decision.Decision(
+                    request_cancel_external_workflow_execution_decision_attributes=decision.RequestCancelExternalWorkflowExecutionDecisionAttributes(
+                        domain=self.request.domain,
+                        workflow_execution=WorkflowExecution(
+                            workflow_id=self.request.workflow_id,
+                            run_id=self._run_id or "",
+                        ),
+                        child_workflow_only=True,
+                    )
+                )
+            case _:
+                return None
+
+    def request_cancel(self) -> bool:
+        match self.state:
+            case DecisionState.REQUESTED:
+                self._transition(DecisionState.CANCELED_AFTER_REQUESTED)
+                self.execution.force_cancel()
+                self.result.force_cancel()
+                return True
+            case DecisionState.RECORDED:
+                self._transition(DecisionState.CANCELED_AFTER_RECORDED)
+                self.execution.force_cancel()
+                return True
+            case DecisionState.STARTED:
+                self._transition(DecisionState.CANCELED_AFTER_STARTED)
+                return True
+            case _:
+                return False
+
+    @child_workflow_events.event("workflow_id", event_id_is_alias=True)
+    def handle_initiated(
+        self, _: history.StartChildWorkflowExecutionInitiatedEventAttributes
+    ) -> None:
+        self._transition(DecisionState.RECORDED)
+
+    @child_workflow_events.event()
+    def handle_initiation_failed(
+        self, event: history.StartChildWorkflowExecutionFailedEventAttributes
+    ) -> None:
+        self._transition(DecisionState.COMPLETED)
+        exc = StartChildWorkflowExecutionFailed(
+            f"start child failed: {event.cause}",
+            cause=event.cause,
+            workflow_id=event.workflow_id,
+        )
+        self.execution.set_exception(exc)
+        self.result.set_exception(exc)
+
+    @child_workflow_events.event()
+    def handle_started(
+        self, event: history.ChildWorkflowExecutionStartedEventAttributes
+    ) -> None:
+        self._run_id = event.workflow_execution.run_id
+        if self.state is DecisionState.CANCELED_AFTER_RECORDED:
+            self._transition(DecisionState.CANCELED_AFTER_STARTED)
+        else:
+            self._transition(DecisionState.STARTED)
+        if not self.execution.done():
+            self.execution.set_result(event.workflow_execution)
+
+    @child_workflow_events.event()
+    def handle_completed(
+        self, event: history.ChildWorkflowExecutionCompletedEventAttributes
+    ) -> None:
+        self._transition(DecisionState.COMPLETED)
+        self.result.set_result(event.result)
+
+    @child_workflow_events.event()
+    def handle_failed(
+        self, event: history.ChildWorkflowExecutionFailedEventAttributes
+    ) -> None:
+        self._transition(DecisionState.COMPLETED)
+        self.result.set_exception(
+            ChildWorkflowExecutionFailed(
+                event.failure.reason,
+                failure=event.failure,
+            )
+        )
+
+    @child_workflow_events.event()
+    def handle_canceled(
+        self, event: history.ChildWorkflowExecutionCanceledEventAttributes
+    ) -> None:
+        self._transition(DecisionState.COMPLETED)
+        self.result.set_exception(
+            ChildWorkflowExecutionCanceled(
+                "child workflow canceled", details=event.details
+            )
+        )
+
+    @child_workflow_events.event()
+    def handle_timed_out(
+        self, event: history.ChildWorkflowExecutionTimedOutEventAttributes
+    ) -> None:
+        self._transition(DecisionState.COMPLETED)
+        self.result.set_exception(
+            ChildWorkflowExecutionTimedOut(
+                f"child workflow timed out: {event.timeout_type}",
+                timeout_type=int(event.timeout_type),
+            )
+        )
+
+    @child_workflow_events.event()
+    def handle_terminated(
+        self, event: history.ChildWorkflowExecutionTerminatedEventAttributes
+    ) -> None:
+        self._transition(DecisionState.COMPLETED)
+        self.result.set_exception(ChildWorkflowExecutionTerminated())
+
+    @child_workflow_events.event(
+        "workflow_execution.workflow_id", event_id_is_alias=True
+    )
+    def handle_cancel_initiated(
+        self, _: history.RequestCancelExternalWorkflowExecutionInitiatedEventAttributes
+    ) -> None:
+        self._transition(DecisionState.CANCELLATION_RECORDED)
+
+    @child_workflow_events.event()
+    def handle_cancel_failed(
+        self, _: history.RequestCancelExternalWorkflowExecutionFailedEventAttributes
+    ) -> None:
+        self._transition(DecisionState.STARTED)