cadence-python-client 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

cadence/_internal/activity/_activity_executor.py

@@ -1,12 +1,13 @@
 from concurrent.futures import ThreadPoolExecutor
 from logging import getLogger
 from traceback import format_exception
-from typing import Any, Callable, cast
+from typing import Any, Callable, Union, cast
 from google.protobuf.duration import to_timedelta
 from google.protobuf.timestamp import to_datetime
 
 from cadence._internal.activity._context import _Context, _SyncContext
 from cadence._internal.activity._definition import BaseDefinition, ExecutionStrategy
+from cadence._internal.activity._heartbeat import _HeartbeatSender
 from cadence.activity import ActivityInfo, ActivityDefinition
 from cadence.api.v1.common_pb2 import Failure
 from cadence.api.v1.service_worker_pb2 import (
@@ -46,7 +47,9 @@ class ActivityExecutor:
             _logger.exception("Activity failed")
             await self._report_failure(task, e)
 
-    def _create_context(self, task: PollForActivityTaskResponse) -> _Context:
+    def _create_context(
+        self, task: PollForActivityTaskResponse
+    ) -> Union[_Context, _SyncContext]:
         activity_type = task.activity_type.name
         try:
             activity_def = cast(BaseDefinition, self._registry(activity_type))
@@ -54,11 +57,24 @@ class ActivityExecutor:
             raise KeyError(f"Activity type not found: {activity_type}") from None
 
         info = self._create_info(task)
+        heartbeat_sender = _HeartbeatSender(
+            self._client.worker_stub,
+            self._data_converter,
+            task.task_token,
+            self._identity,
+            task.heartbeat_details,
+        )
 
         if activity_def.strategy == ExecutionStrategy.ASYNC:
-            return _Context(self._client, info, activity_def)
+            return _Context(self._client, info, activity_def, heartbeat_sender)
         else:
-            return _SyncContext(self._client, info, activity_def, self._thread_pool)
+            return _SyncContext(
+                self._client,
+                info,
+                activity_def,
+                self._thread_pool,
+                heartbeat_sender,
+            )
 
     async def _report_failure(
         self, task: PollForActivityTaskResponse, error: Exception

cadence/_internal/activity/_context.py

@@ -1,9 +1,10 @@
 import asyncio
 from concurrent.futures.thread import ThreadPoolExecutor
-from typing import Any
+from typing import Any, Type
 
 from cadence import Client
 from cadence._internal.activity._definition import BaseDefinition
+from cadence._internal.activity._heartbeat import _HeartbeatSender
 from cadence.activity import ActivityInfo, ActivityContext
 from cadence.api.v1.common_pb2 import Payload
 
@@ -14,15 +15,27 @@ class _Context(ActivityContext):
         client: Client,
         info: ActivityInfo,
         activity_def: BaseDefinition[[Any], Any],
+        heartbeat_sender: _HeartbeatSender,
     ):
         self._client = client
         self._info = info
         self._activity_def = activity_def
+        self._heartbeat_sender = heartbeat_sender
+        self._heartbeat_tasks: set[asyncio.Future[None]] = set()
 
     async def execute(self, payload: Payload) -> Any:
         params = self._to_params(payload)
-        with self._activate():
-            return await self._activity_def.impl_fn(*params)
+        try:
+            with self._activate():
+                return await self._activity_def.impl_fn(*params)
+        finally:
+            await self._wait_pending_heartbeats()
+
+    async def _wait_pending_heartbeats(self) -> None:
+        if not self._heartbeat_tasks:
+            return
+        tasks = list(self._heartbeat_tasks)
+        await asyncio.gather(*tasks, return_exceptions=True)
 
     def _to_params(self, payload: Payload) -> list[Any]:
         return self._activity_def.signature.params_from_payload(
@@ -35,6 +48,16 @@ class _Context(ActivityContext):
     def info(self) -> ActivityInfo:
         return self._info
 
+    def heartbeat(self, *details: Any) -> None:
+        heartbeat_task = asyncio.create_task(
+            self._heartbeat_sender.send_heartbeat(*details)
+        )
+        self._heartbeat_tasks.add(heartbeat_task)
+        heartbeat_task.add_done_callback(self._heartbeat_tasks.discard)
+
+    def heartbeat_details(self, *types: Type) -> list[Any]:
+        return self._heartbeat_sender.get_details(*types)
+
 
 class _SyncContext(_Context):
     def __init__(
@@ -43,14 +66,18 @@ class _SyncContext(_Context):
         info: ActivityInfo,
         activity_def: BaseDefinition[[Any], Any],
         executor: ThreadPoolExecutor,
+        heartbeat_sender: _HeartbeatSender,
     ):
-        super().__init__(client, info, activity_def)
+        super().__init__(client, info, activity_def, heartbeat_sender)
         self._executor = executor
 
     async def execute(self, payload: Payload) -> Any:
         params = self._to_params(payload)
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(self._executor, self._run, params)
+        self._loop = asyncio.get_running_loop()
+        try:
+            return await self._loop.run_in_executor(self._executor, self._run, params)
+        finally:
+            await self._wait_pending_heartbeats()
 
     def _run(self, args: list[Any]) -> Any:
         with self._activate():
@@ -58,3 +85,11 @@ class _SyncContext(_Context):
 
     def client(self) -> Client:
         raise RuntimeError("client is only supported in async activities")
+
+    def heartbeat(self, *details: Any) -> None:
+        future = asyncio.run_coroutine_threadsafe(
+            self._heartbeat_sender.send_heartbeat(*details), self._loop
+        )
+        wrapped = asyncio.wrap_future(future, loop=self._loop)
+        self._heartbeat_tasks.add(wrapped)
+        wrapped.add_done_callback(self._heartbeat_tasks.discard)

cadence/_internal/activity/_definition.py

@@ -1,4 +1,8 @@
 import abc
+import asyncio.coroutines
+import inspect
+import sys
+
 from abc import ABC
 from enum import Enum
 from functools import update_wrapper, partial
@@ -10,7 +14,9 @@ from typing import (
     ParamSpec,
     TypeVar,
     Awaitable,
+    Type,
     cast,
+    overload,
     Concatenate,
 )
 
@@ -21,6 +27,8 @@ T = TypeVar("T")
 P = ParamSpec("P")
 R = TypeVar("R")
 
+_COROUTINE_MARKER = getattr(asyncio.coroutines, "_is_coroutine")
+
 
 class ExecutionStrategy(Enum):
     ASYNC = "async"
@@ -113,10 +121,13 @@ class SyncMethodImpl(BaseDefinition[P, R], Generic[T, P, R]):
         super().__init__(name, wrapped, ExecutionStrategy.THREAD_POOL, signature)
         update_wrapper(self, wrapped)
 
-    def __get__(self, instance, owner):
+    @overload
+    def __get__(self, instance: None, owner: Type[T]) -> "SyncMethodImpl[T, P, R]": ...
+    @overload
+    def __get__(self, instance: T, owner: Type[T]) -> SyncImpl[P, R]: ...
+    def __get__(self, instance: T | None, owner: Type[T]) -> "SyncImpl[P, R] | Self":
         if instance is None:
             return self
-        # If we bound the method to an instance, then drop the self parameter. It's a normal function again
         return SyncImpl[P, R](
             partial(self._wrapped, instance), self.name, self._signature
         )
@@ -141,6 +152,13 @@ class AsyncImpl(BaseDefinition[P, R]):
     ):
         super().__init__(name, wrapped, ExecutionStrategy.ASYNC, signature)
         update_wrapper(self, wrapped)
+        if sys.version_info >= (3, 12):
+            """
+            Mark the function as a coroutine function. This is only available in python 3.12 and above
+            """
+            inspect.markcoroutinefunction(self)
+        else:
+            self._is_coroutine = _COROUTINE_MARKER
 
     async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
         if WorkflowContext.is_set():
@@ -160,11 +178,21 @@ class AsyncMethodImpl(BaseDefinition[P, R], Generic[T, P, R]):
     ):
         super().__init__(name, wrapped, ExecutionStrategy.ASYNC, signature)
         update_wrapper(self, wrapped)
-
-    def __get__(self, instance, owner):
+        if sys.version_info >= (3, 12):
+            """
+            Mark the function as a coroutine function. This is only available in python 3.12 and above
+            """
+            inspect.markcoroutinefunction(self)
+        else:
+            self._is_coroutine = _COROUTINE_MARKER
+
+    @overload
+    def __get__(self, instance: None, owner: Type[T]) -> "AsyncMethodImpl[T, P, R]": ...
+    @overload
+    def __get__(self, instance: T, owner: Type[T]) -> AsyncImpl[P, R]: ...
+    def __get__(self, instance: T | None, owner: Type[T]) -> "AsyncImpl[P, R] | Self":
         if instance is None:
             return self
-        # If we bound the method to an instance, then drop the self parameter. It's a normal function again
         return AsyncImpl[P, R](
             partial(self._wrapped, instance), self.name, self._signature
         )

cadence/_internal/activity/_heartbeat.py

@@ -0,0 +1,42 @@
+from logging import getLogger
+from typing import Any, Type
+
+from cadence.api.v1.common_pb2 import Payload
+from cadence.api.v1.service_worker_pb2 import RecordActivityTaskHeartbeatRequest
+from cadence.api.v1.service_worker_pb2_grpc import WorkerAPIStub
+from cadence.data_converter import DataConverter
+
+_logger = getLogger(__name__)
+
+
+class _HeartbeatSender:
+    def __init__(
+        self,
+        worker_stub: WorkerAPIStub,
+        data_converter: DataConverter,
+        task_token: bytes,
+        identity: str,
+        previous_details: Payload,
+    ):
+        self._worker_stub = worker_stub
+        self._data_converter = data_converter
+        self._task_token = task_token
+        self._identity = identity
+        self._previous_details = previous_details
+
+    def get_details(self, *types: Type) -> list[Any]:
+        return self._data_converter.from_data(self._previous_details, list(types))
+
+    async def send_heartbeat(self, *details: Any) -> None:
+        try:
+            payload = self._data_converter.to_data(list(details))
+            await self._worker_stub.RecordActivityTaskHeartbeat(
+                RecordActivityTaskHeartbeatRequest(
+                    task_token=self._task_token,
+                    details=payload,
+                    identity=self._identity,
+                )
+            )
+            self._previous_details = payload
+        except Exception:
+            _logger.warning("Heartbeat failed", exc_info=True)

cadence/_internal/fn_signature.py

@@ -53,8 +53,20 @@ class FnSignature:
     def params_from_payload(
         self, data_converter: DataConverter, payload: Payload
     ) -> list[Any]:
+        if not self.params:
+            return []
         type_hints = [param.type_hint for param in self.params]
-        return data_converter.from_data(payload, type_hints)
+        decoded = _decode_provided_values(data_converter, payload, type_hints)
+        for i, param in enumerate(self.params):
+            if i < len(decoded):
+                continue
+            if param.has_default:
+                decoded.append(param.default_value)
+            else:
+                raise ValueError(
+                    f"required parameter '{param.name}' (position {i}) not provided in payload"
+                )
+        return decoded
 
     @staticmethod
     def of(fn: Callable) -> "FnSignature":
@@ -88,3 +100,21 @@ class FnSignature:
         return_type = hints.get("return", Any)
 
         return FnSignature(params, return_type)
+
+
+def _decode_provided_values(
+    data_converter: DataConverter,
+    payload: Payload,
+    type_hints: Sequence[Type | None],
+) -> list[Any]:
+    decoder = getattr(data_converter, "_decode_provided_values", None)
+    if callable(decoder):
+        return list(decoder(payload, type_hints))
+
+    counter = getattr(data_converter, "_payload_value_count", None)
+    if callable(counter):
+        provided_count = int(counter(payload, len(type_hints)))
+        return data_converter.from_data(payload, list(type_hints[:provided_count]))
+
+    # Backward compatibility
+    return data_converter.from_data(payload, list(type_hints))

cadence/_internal/rpc/retry.py

@@ -60,6 +60,8 @@ class RetryInterceptor(UnaryUnaryClientInterceptor):
     ) -> Any:
         loop = asyncio.get_running_loop()
         expiration_interval = client_call_details.timeout
+        if expiration_interval is None:
+            expiration_interval = float("inf")
         start_time = loop.time()
         deadline = start_time + expiration_interval
 
@@ -68,11 +70,16 @@ class RetryInterceptor(UnaryUnaryClientInterceptor):
             remaining = deadline - loop.time()
             # Namedtuple methods start with an underscore to avoid conflicts and aren't actually private
             # noinspection PyProtectedMember
-            call_details = client_call_details._replace(timeout=remaining)
+            call_details = client_call_details._replace(  # type: ignore[attr-defined]
+                timeout=remaining
+            )
             rpc_call = await continuation(call_details, request)
             try:
-                # Return the result directly if success. GRPC will wrap it back into a UnaryUnaryCall
-                return await rpc_call
+                await rpc_call
+                # Return the call object (not the raw response) so outer interceptors
+                # that rely on UnaryUnaryCall methods like add_done_callback still work
+                # (e.g. opentelemetry-instrumentation-grpc).
+                return rpc_call
             except CadenceRpcError as e:
                 err = e
 
@@ -92,8 +99,9 @@ class RetryInterceptor(UnaryUnaryClientInterceptor):
 
 def is_retryable(err: CadenceRpcError, call_details: ClientCallDetails) -> bool:
     # Handle requests to the passive side, matching the Go and Java Clients
-    if call_details.method == GET_WORKFLOW_HISTORY and isinstance(
-        err, EntityNotExistsError
+    if (
+        call_details.method == GET_WORKFLOW_HISTORY  # type: ignore[comparison-overlap]
+        and isinstance(err, EntityNotExistsError)
     ):
         return (
             err.active_cluster is not None

cadence/_internal/rpc/yarpc.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable
+from typing import Any, Callable, cast
 
 from grpc.aio import Metadata
 from grpc.aio import UnaryUnaryClientInterceptor, ClientCallDetails
@@ -40,6 +40,9 @@ class YarpcMetadataInterceptor(UnaryUnaryClientInterceptor):
 
         # Namedtuple methods start with an underscore to avoid conflicts and aren't actually private
         # noinspection PyProtectedMember
-        return client_call_details._replace(
-            metadata=metadata, timeout=client_call_details.timeout or 60.0
+        return cast(
+            ClientCallDetails,
+            client_call_details._replace(  # type: ignore[attr-defined]
+                metadata=metadata, timeout=client_call_details.timeout or 60.0
+            ),
         )

cadence/_internal/workflow/active_cluster_selection_policy.py

@@ -0,0 +1,32 @@
+"""Adapt :class:`cadence.workflow.ActiveClusterSelectionPolicy` (TypedDict) to its protobuf wire form."""
+
+from __future__ import annotations
+
+from typing import Mapping, cast
+
+from cadence.api.v1 import common_pb2
+from cadence.workflow import ActiveClusterSelectionPolicy
+
+
+def active_cluster_selection_policy_to_proto(
+    policy: ActiveClusterSelectionPolicy | Mapping[str, object] | None,
+) -> common_pb2.ActiveClusterSelectionPolicy | None:
+    """Convert a user active-cluster selection policy to protobuf, or ``None`` if empty.
+
+    ``None`` and an empty mapping both map to ``None``.
+    """
+    if policy is None or (isinstance(policy, Mapping) and len(policy) == 0):
+        return None
+
+    out = common_pb2.ActiveClusterSelectionPolicy()
+
+    if (ca := policy.get("cluster_attribute")) is not None:
+        ca_map = cast(Mapping[str, str], ca)
+        out.cluster_attribute.CopyFrom(
+            common_pb2.ClusterAttribute(
+                scope=ca_map.get("scope", ""),
+                name=ca_map.get("name", ""),
+            )
+        )
+
+    return out

cadence/_internal/workflow/context.py

@@ -1,14 +1,30 @@
 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
+from typing import Iterator, Optional, Any, Unpack, Type, cast, Callable
 
+from cadence._internal.workflow.deterministic_event_loop import DeterministicEventLoop
+from cadence._internal.workflow.retry_policy import retry_policy_to_proto
 from cadence._internal.workflow.statemachine.decision_manager import DecisionManager
 from cadence.api.v1.common_pb2 import ActivityType
-from cadence.api.v1.decision_pb2 import ScheduleActivityTaskDecisionAttributes
+from cadence.api.v1.decision_pb2 import (
+    ScheduleActivityTaskDecisionAttributes,
+    StartTimerDecisionAttributes,
+)
 from cadence.api.v1.tasklist_pb2 import TaskList, TaskListKind
 from cadence.data_converter import DataConverter
-from cadence.workflow import WorkflowContext, WorkflowInfo, ResultType, ActivityOptions
+from cadence.workflow import (
+    ActivityOptions,
+    ResultType,
+    WorkflowContext,
+    WorkflowInfo,
+)
+
+_DEFAULT_ACTIVITY_OPTIONS: ActivityOptions = {
+    "schedule_to_close_timeout": timedelta(hours=1),
+    "schedule_to_start_timeout": timedelta(seconds=10),
+}
 
 
 class Context(WorkflowContext):
@@ -35,7 +51,7 @@ class Context(WorkflowContext):
         *args: Any,
         **kwargs: Unpack[ActivityOptions],
     ) -> ResultType:
-        opts = ActivityOptions(**kwargs)
+        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
@@ -77,19 +93,28 @@ class Context(WorkflowContext):
             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=None,
+            retry_policy=retry_policy_to_proto(opts.get("retry_policy")),
             header=None,
             request_local_dispatch=False,
         )
 
-        result_payload = await self._decision_manager.schedule_activity(
-            schedule_attributes
-        )
+        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 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
@@ -106,11 +131,17 @@ class Context(WorkflowContext):
         """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)
-        yield self
-        WorkflowContext._var.reset(token)
+        try:
+            yield self
+        finally:
+            WorkflowContext._var.reset(token)
 
 
 def _round_to_nearest_second(delta: timedelta) -> timedelta:

cadence/_internal/workflow/deterministic_event_loop.py

@@ -8,6 +8,8 @@ import threading
 from typing import Callable, Any, TypeVar, Coroutine, Awaitable, Generator
 from typing_extensions import Unpack, TypeVarTuple
 
+from cadence._internal.workflow.waiter import Waiter
+
 logger = logging.getLogger(__name__)
 
 
@@ -32,6 +34,7 @@ class DeterministicEventLoop(AbstractEventLoop):
         self._thread_id: int | None = None  # indicate if the event loop is running
         self._debug: bool = False
         self._ready: collections.deque[events.Handle] = collections.deque()
+        self._waiters: list[Waiter] = []
         self._stopping: bool = False
         self._closed: bool = False
 
@@ -141,6 +144,13 @@ class DeterministicEventLoop(AbstractEventLoop):
     def create_future(self) -> Future[Any]:
         return futures.Future(loop=self)
 
+    def create_waiter(self, predicate: Callable[[], bool]) -> Waiter:
+        """Register a predicate-driven awaitable."""
+        waiter = Waiter(predicate, self)
+        if not waiter.poll():
+            self._waiters.append(waiter)
+        return waiter
+
     def _run_once(self) -> None:
         ntodo = len(self._ready)
         for i in range(ntodo):
@@ -149,6 +159,19 @@ class DeterministicEventLoop(AbstractEventLoop):
                 continue
             handle._run()
 
+        # Poll waiters; only stop early if settling one schedules new work,
+        # so remaining waiters are not skipped.
+        i = 0
+        while i < len(self._waiters):
+            w = self._waiters[i]
+            ready_before = len(self._ready)
+            if w.poll():
+                del self._waiters[i]
+                if len(self._ready) > ready_before:
+                    return
+            else:
+                i += 1
+
     def _run_forever_setup(self) -> None:
         self._check_closed()
         self._check_running()
@@ -190,6 +213,7 @@ class DeterministicEventLoop(AbstractEventLoop):
             logger.debug("Close %r", self)
         self._closed = True
         self._ready.clear()
+        self._waiters.clear()
 
     def is_closed(self) -> bool:
         """Returns True if the event loop was closed."""
@@ -462,13 +486,12 @@ class DeterministicEventLoop(AbstractEventLoop):
         )
 
     def call_exception_handler(self, context: dict[str, Any]) -> None:
-        # This is called if a task has an unhandled exception. Short term, it's helpful to log these for debugging.
-        # Long term, we need some combination of failing decision tasks or workflows based on these errors.
         message = context.get("message")
         if not message:
             message = "Unhandled exception in event loop"
 
         exception = context.get("exception")
+
         if isinstance(exception, BaseException):
             exc_info = exception
         else:

cadence/_internal/workflow/retry_policy.py

@@ -0,0 +1,62 @@
+"""Adapt :class:`cadence.workflow.RetryPolicy` (TypedDict) to its protobuf wire form."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+from math import ceil
+from typing import Mapping, cast
+
+from google.protobuf.duration_pb2 import Duration
+
+from cadence.api.v1 import common_pb2
+from cadence.workflow import RetryPolicy
+
+
+def _round_to_whole_seconds(delta: timedelta) -> timedelta:
+    """Ceil-round a ``timedelta`` to whole seconds."""
+    return timedelta(seconds=ceil(delta.total_seconds()))
+
+
+def _set_duration_field(target: Duration, delta: timedelta) -> None:
+    """Write ``delta``, ceil-rounded to whole seconds, into a proto ``Duration`` field."""
+    d = Duration()
+    d.FromTimedelta(_round_to_whole_seconds(delta))
+    target.CopyFrom(d)
+
+
+def retry_policy_to_proto(
+    policy: RetryPolicy | Mapping[str, object] | None,
+) -> common_pb2.RetryPolicy | None:
+    """Convert a user retry policy to protobuf, or ``None`` if no policy was provided.
+
+    ``None`` and an empty mapping both map to ``None`` so that the server applies its
+    own defaults instead of receiving an explicit empty policy. Durations are ceiled
+    to whole seconds to match the server's resolution and the Go/Java SDKs.
+    """
+    if policy is None or (isinstance(policy, Mapping) and len(policy) == 0):
+        return None
+
+    out = common_pb2.RetryPolicy()
+
+    if (ii := policy.get("initial_interval")) is not None:
+        _set_duration_field(out.initial_interval, cast(timedelta, ii))
+
+    if (coef := policy.get("backoff_coefficient")) is not None:
+        coef_f = cast(float, coef)
+        if coef_f < 1.0:
+            raise ValueError("backoff_coefficient must be >= 1.0 when provided")
+        out.backoff_coefficient = coef_f
+
+    if (mi := policy.get("maximum_interval")) is not None:
+        _set_duration_field(out.maximum_interval, cast(timedelta, mi))
+
+    if (ma := policy.get("maximum_attempts")) is not None:
+        out.maximum_attempts = int(cast(int, ma))
+
+    if (reasons := policy.get("non_retryable_error_reasons")) is not None:
+        out.non_retryable_error_reasons.extend(cast(list[str], reasons))
+
+    if (ei := policy.get("expiration_interval")) is not None:
+        _set_duration_field(out.expiration_interval, cast(timedelta, ei))
+
+    return out

cadence/_internal/workflow/statemachine/event_dispatcher.py

@@ -21,7 +21,7 @@ class Action:
 class EventDispatcher:
     handlers: dict[Type, Action]
 
-    def __init__(self, default_id_attr: str) -> None:
+    def __init__(self, default_id_attr: str = "") -> None:
         self._default_id_attr = default_id_attr
         self.handlers = {}
 
@@ -32,7 +32,8 @@ class EventDispatcher:
             event_type = _find_event_type(func)
             event_id_attr = id_attr if id_attr else self._default_id_attr
 
-            _validate_field(func, event_type, event_id_attr)
+            if event_id_attr:
+                _validate_field(func, event_type, event_id_attr)
             if event_type in self.handlers:
                 raise ValueError(
                     f"Duplicate handler for {event_type}: {func.__qualname__} and {self.handlers[event_type].fn.__qualname__}"