cadence-python-client 0.1.0__tar.gz → 0.2.0__tar.gz

{cadence_python_client-0.1.0/cadence_python_client.egg-info → cadence_python_client-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cadence-python-client
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python framework for authoring Cadence workflows and activities
 Author: Cadence
 License: Apache-2.0
@@ -23,14 +23,14 @@ Requires-Python: <3.14,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
-Requires-Dist: grpcio==1.71.2
-Requires-Dist: grpcio-status>=1.71.2
+Requires-Dist: grpcio>=1.73.1
+Requires-Dist: grpcio-status>=1.73.1
 Requires-Dist: msgspec>=0.19.0
-Requires-Dist: protobuf==5.29.1
+Requires-Dist: protobuf<7.0.0,>=6.31.0
 Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: prometheus-client>=0.21.0
 Provides-Extra: dev
-Requires-Dist: grpcio-tools==1.71.2; extra == "dev"
+Requires-Dist: grpcio-tools>=1.73.1; 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"

cadence_python_client-0.2.0/cadence/_internal/activity/__init__.py

@@ -0,0 +1,10 @@
+from ._activity_executor import ActivityExecutor
+from ._definition import AsyncImpl, AsyncMethodImpl, SyncImpl, SyncMethodImpl
+
+__all__ = [
+    "ActivityExecutor",
+    "AsyncImpl",
+    "AsyncMethodImpl",
+    "SyncImpl",
+    "SyncMethodImpl",
+]

{cadence_python_client-0.1.0 → cadence_python_client-0.2.0}/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
+from typing import Any, Callable, 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.activity import ActivityInfo, ActivityDefinition, ExecutionStrategy
+from cadence._internal.activity._definition import BaseDefinition, ExecutionStrategy
+from cadence.activity import ActivityInfo, ActivityDefinition
 from cadence.api.v1.common_pb2 import Failure
 from cadence.api.v1.service_worker_pb2 import (
     PollForActivityTaskResponse,
@@ -42,12 +43,13 @@ class ActivityExecutor:
             result = await context.execute(task.input)
             await self._report_success(task, result)
         except Exception as e:
+            _logger.exception("Activity failed")
             await self._report_failure(task, e)
 
     def _create_context(self, task: PollForActivityTaskResponse) -> _Context:
         activity_type = task.activity_type.name
         try:
-            activity_def = self._registry(activity_type)
+            activity_def = cast(BaseDefinition, self._registry(activity_type))
         except KeyError:
             raise KeyError(f"Activity type not found: {activity_type}") from None
 

{cadence_python_client-0.1.0 → cadence_python_client-0.2.0}/cadence/_internal/activity/_context.py

@@ -3,7 +3,8 @@ from concurrent.futures.thread import ThreadPoolExecutor
 from typing import Any
 
 from cadence import Client
-from cadence.activity import ActivityInfo, ActivityContext, ActivityDefinition
+from cadence._internal.activity._definition import BaseDefinition
+from cadence.activity import ActivityInfo, ActivityContext
 from cadence.api.v1.common_pb2 import Payload
 
 
@@ -12,20 +13,21 @@ class _Context(ActivityContext):
         self,
         client: Client,
         info: ActivityInfo,
-        activity_fn: ActivityDefinition[[Any], Any],
+        activity_def: BaseDefinition[[Any], Any],
     ):
         self._client = client
         self._info = info
-        self._activity_fn = activity_fn
+        self._activity_def = activity_def
 
     async def execute(self, payload: Payload) -> Any:
         params = self._to_params(payload)
         with self._activate():
-            return await self._activity_fn(*params)
+            return await self._activity_def.impl_fn(*params)
 
     def _to_params(self, payload: Payload) -> list[Any]:
-        type_hints = [param.type_hint for param in self._activity_fn.params]
-        return self._client.data_converter.from_data(payload, type_hints)
+        return self._activity_def.signature.params_from_payload(
+            self._client.data_converter, payload
+        )
 
     def client(self) -> Client:
         return self._client
@@ -39,10 +41,10 @@ class _SyncContext(_Context):
         self,
         client: Client,
         info: ActivityInfo,
-        activity_fn: ActivityDefinition[[Any], Any],
+        activity_def: BaseDefinition[[Any], Any],
         executor: ThreadPoolExecutor,
     ):
-        super().__init__(client, info, activity_fn)
+        super().__init__(client, info, activity_def)
         self._executor = executor
 
     async def execute(self, payload: Payload) -> Any:
@@ -52,7 +54,7 @@ class _SyncContext(_Context):
 
     def _run(self, args: list[Any]) -> Any:
         with self._activate():
-            return self._activity_fn(*args)
+            return self._activity_def.impl_fn(*args)
 
     def client(self) -> Client:
         raise RuntimeError("client is only supported in async activities")

cadence_python_client-0.2.0/cadence/_internal/activity/_definition.py

@@ -0,0 +1,178 @@
+import abc
+from abc import ABC
+from enum import Enum
+from functools import update_wrapper, partial
+from typing import (
+    Generic,
+    Callable,
+    Unpack,
+    Self,
+    ParamSpec,
+    TypeVar,
+    Awaitable,
+    cast,
+    Concatenate,
+)
+
+from cadence._internal.fn_signature import FnSignature
+from cadence.workflow import ActivityOptions, WorkflowContext, execute_activity
+
+T = TypeVar("T")
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+class ExecutionStrategy(Enum):
+    ASYNC = "async"
+    THREAD_POOL = "thread_pool"
+
+
+class BaseDefinition(ABC, Generic[P, R]):
+    def __init__(
+        self,
+        name: str,
+        wrapped: Callable,
+        strategy: ExecutionStrategy,
+        signature: FnSignature,
+    ):
+        self._name = name
+        self._wrapped = wrapped
+        self._strategy = strategy
+        self._signature = signature
+        self._execution_options = ActivityOptions()
+
+    @property
+    def strategy(self) -> ExecutionStrategy:
+        return self._strategy
+
+    @property
+    def signature(self) -> FnSignature:
+        return self._signature
+
+    @property
+    def impl_fn(self) -> Callable:
+        return self._wrapped
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @abc.abstractmethod
+    def clone(self) -> Self: ...
+
+    def rebind(self, fn: Callable) -> Self:
+        res = self.clone()
+        res._wrapped = fn
+        return res
+
+    def with_options(self, **kwargs: Unpack[ActivityOptions]) -> Self:
+        res = self.clone()
+        new_opts = self._execution_options.copy()
+        new_opts.update(kwargs)
+        res._execution_options = new_opts
+        return res
+
+    async def execute(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        result_type = cast(type[R], self._signature.return_type)
+        return await execute_activity(
+            self._name,
+            result_type,
+            *self._signature.params_from_call(args, kwargs),
+            **self._execution_options,
+        )
+
+
+class SyncImpl(BaseDefinition[P, R]):
+    def __init__(
+        self,
+        wrapped: Callable[P, R],
+        name: str,
+        signature: FnSignature,
+    ):
+        super().__init__(name, wrapped, ExecutionStrategy.THREAD_POOL, signature)
+        update_wrapper(self, wrapped)
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        if WorkflowContext.is_set():
+            raise RuntimeError(
+                "Attempting to invoke sync function in workflow. Use execute"
+            )
+        return self._wrapped(*args, **kwargs)  # type: ignore
+
+    def clone(self) -> "SyncImpl[P, R]":
+        return SyncImpl[P, R](self._wrapped, self._name, self._signature)
+
+
+class SyncMethodImpl(BaseDefinition[P, R], Generic[T, P, R]):
+    def __init__(
+        self,
+        wrapped: Callable[Concatenate[T, P], R],
+        name: str,
+        signature: FnSignature,
+    ):
+        super().__init__(name, wrapped, ExecutionStrategy.THREAD_POOL, signature)
+        update_wrapper(self, wrapped)
+
+    def __get__(self, instance, owner):
+        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
+        )
+
+    def __call__(self, original_self: T, *args: P.args, **kwargs: P.kwargs) -> R:
+        if WorkflowContext.is_set():
+            raise RuntimeError(
+                "Attempting to invoke sync function in workflow. Use execute"
+            )
+        return self._wrapped(original_self, *args, **kwargs)  # type: ignore
+
+    def clone(self) -> "SyncMethodImpl[T, P, R]":
+        return SyncMethodImpl[T, P, R](self._wrapped, self._name, self._signature)
+
+
+class AsyncImpl(BaseDefinition[P, R]):
+    def __init__(
+        self,
+        wrapped: Callable[P, Awaitable[R]],
+        name: str,
+        signature: FnSignature,
+    ):
+        super().__init__(name, wrapped, ExecutionStrategy.ASYNC, signature)
+        update_wrapper(self, wrapped)
+
+    async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        if WorkflowContext.is_set():
+            return await self.execute(*args, **kwargs)  # type: ignore
+        return await self._wrapped(*args, **kwargs)  # type: ignore
+
+    def clone(self) -> "AsyncImpl[P, R]":
+        return AsyncImpl[P, R](self._wrapped, self._name, self._signature)
+
+
+class AsyncMethodImpl(BaseDefinition[P, R], Generic[T, P, R]):
+    def __init__(
+        self,
+        wrapped: Callable[Concatenate[T, P], Awaitable[R]],
+        name: str,
+        signature: FnSignature,
+    ):
+        super().__init__(name, wrapped, ExecutionStrategy.ASYNC, signature)
+        update_wrapper(self, wrapped)
+
+    def __get__(self, instance, owner):
+        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
+        )
+
+    async def __call__(self, original_self: T, *args: P.args, **kwargs: P.kwargs) -> R:
+        if WorkflowContext.is_set():
+            return await self.execute(*args, **kwargs)  # type: ignore
+        return await self._wrapped(original_self, *args, **kwargs)  # type: ignore
+
+    def clone(self) -> "AsyncMethodImpl[T, P, R]":
+        return AsyncMethodImpl[T, P, R](self._wrapped, self._name, self._signature)

cadence_python_client-0.2.0/cadence/_internal/fn_signature.py

@@ -0,0 +1,90 @@
+from dataclasses import dataclass
+from inspect import signature, Parameter
+from typing import (
+    Type,
+    Any,
+    Callable,
+    Sequence,
+    get_type_hints,
+)
+
+from cadence.api.v1.common_pb2 import Payload
+from cadence.data_converter import DataConverter
+
+
+@dataclass(frozen=True)
+class FnParameter:
+    name: str
+    type_hint: Type | None
+    has_default: bool = False
+    default_value: Any = None
+
+
+@dataclass(frozen=True)
+class FnSignature:
+    params: list[FnParameter]
+    return_type: Type
+
+    def params_from_call(
+        self, args: Sequence[Any], kwargs: dict[str, Any]
+    ) -> list[Any]:
+        result: list[Any] = []
+        if len(args) > len(self.params):
+            raise ValueError(f"Too many positional arguments: {args}")
+
+        for value, param_spec in zip(args, self.params):
+            result.append(value)
+
+        i = len(result)
+        while i < len(self.params):
+            param = self.params[i]
+            if param.name not in kwargs and not param.has_default:
+                raise ValueError(f"Missing parameter: {param.name}")
+
+            value = kwargs.pop(param.name, param.default_value)
+            result.append(value)
+            i = i + 1
+
+        if len(kwargs) > 0:
+            raise ValueError(f"Unexpected keyword arguments: {kwargs}")
+
+        return result
+
+    def params_from_payload(
+        self, data_converter: DataConverter, payload: Payload
+    ) -> list[Any]:
+        type_hints = [param.type_hint for param in self.params]
+        return data_converter.from_data(payload, type_hints)
+
+    @staticmethod
+    def of(fn: Callable) -> "FnSignature":
+        sig = signature(fn)
+        args = sig.parameters
+        hints = get_type_hints(fn)
+        params = []
+        for name, param in args.items():
+            # "unbound functions" aren't a thing in the Python spec. We don't have a way to determine whether the function
+            # is part of a class or is standalone.
+            # Filter out the self parameter and hope they followed the convention.
+            if param.name == "self":
+                continue
+            default = None
+            has_default = False
+            if param.default != Parameter.empty:
+                default = param.default
+                has_default = param.default is not None
+            if param.kind in (
+                Parameter.POSITIONAL_ONLY,
+                Parameter.POSITIONAL_OR_KEYWORD,
+            ):
+                type_hint = hints.get(name, None)
+                params.append(FnParameter(name, type_hint, has_default, default))
+            else:
+                raise ValueError(
+                    f"Parameters must be positional. {name} is {param.kind}, and not valid"
+                )
+
+        # Treat unspecified return type as Any
+        return_type = hints.get("return", Any)
+
+        return FnSignature(params, return_type)

{cadence_python_client-0.1.0 → cadence_python_client-0.2.0}/cadence/_internal/rpc/yarpc.py

@@ -8,6 +8,8 @@ SERVICE_KEY = "rpc-service"
 CALLER_KEY = "rpc-caller"
 ENCODING_KEY = "rpc-encoding"
 ENCODING_PROTO = "proto"
+CALLER_TYPE_KEY = "cadence-caller-type"
+CALLER_TYPE_VALUE = "sdk"
 
 
 class YarpcMetadataInterceptor(UnaryUnaryClientInterceptor):
@@ -16,6 +18,7 @@ class YarpcMetadataInterceptor(UnaryUnaryClientInterceptor):
             (SERVICE_KEY, service),
             (CALLER_KEY, caller),
             (ENCODING_KEY, ENCODING_PROTO),
+            (CALLER_TYPE_KEY, CALLER_TYPE_VALUE),
         )
 
     async def intercept_unary_unary(

{cadence_python_client-0.1.0 → cadence_python_client-0.2.0}/cadence/_internal/workflow/context.py

@@ -4,7 +4,6 @@ from math import ceil
 from typing import Iterator, Optional, Any, Unpack, Type, cast
 
 from cadence._internal.workflow.statemachine.decision_manager import DecisionManager
-from cadence._internal.workflow.decisions_helper import DecisionsHelper
 from cadence.api.v1.common_pb2 import ActivityType
 from cadence.api.v1.decision_pb2 import ScheduleActivityTaskDecisionAttributes
 from cadence.api.v1.tasklist_pb2 import TaskList, TaskListKind
@@ -21,7 +20,6 @@ class Context(WorkflowContext):
         self._info = info
         self._replay_mode = True
         self._replay_current_time_milliseconds: Optional[int] = None
-        self._decision_helper = DecisionsHelper()
         self._decision_manager = decision_manager
 
     def info(self) -> WorkflowInfo:
@@ -70,9 +68,7 @@ class Context(WorkflowContext):
         )
 
         activity_input = self.data_converter().to_data(list(args))
-        activity_id = self._decision_helper.generate_activity_id(activity)
         schedule_attributes = ScheduleActivityTaskDecisionAttributes(
-            activity_id=activity_id,
             activity_type=ActivityType(name=activity),
             domain=self.info().workflow_domain,
             task_list=TaskList(kind=TaskListKind.TASK_LIST_KIND_NORMAL, name=task_list),

{cadence_python_client-0.1.0 → cadence_python_client-0.2.0}/cadence/_internal/workflow/deterministic_event_loop.py

@@ -1,3 +1,4 @@
+import traceback
 from asyncio import AbstractEventLoop, Handle, TimerHandle, futures, tasks, Future, Task
 from contextvars import Context
 import logging
@@ -9,6 +10,12 @@ from typing_extensions import Unpack, TypeVarTuple
 
 logger = logging.getLogger(__name__)
 
+
+class FatalDecisionError(Exception):
+    def __init__(self, *args) -> None:
+        super().__init__(*args)
+
+
 _Ts = TypeVarTuple("_Ts")
 _T = TypeVar("_T")
 
@@ -455,9 +462,36 @@ class DeterministicEventLoop(AbstractEventLoop):
         )
 
     def call_exception_handler(self, context: dict[str, Any]) -> None:
-        raise NotImplementedError(
-            "Custom exception handlers not supported in deterministic event loop"
-        )
+        # 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:
+            exc_info = None
+
+        log_lines = [message]
+        for key in sorted(context):
+            if key in {"message", "exception"}:
+                continue
+            value = context[key]
+            if key == "source_traceback":
+                tb = "".join(traceback.format_list(value))
+                value = "Object created at (most recent call last):\n"
+                value += tb.rstrip()
+            elif key == "handle_traceback":
+                tb = "".join(traceback.format_list(value))
+                value = "Handle created at (most recent call last):\n"
+                value += tb.rstrip()
+            else:
+                value = repr(value)
+            log_lines.append(f"{key}: {value}")
+
+        logger.error("\n".join(log_lines), exc_info=exc_info)
 
     # Task factory
     def set_task_factory(  # type: ignore[override]

{cadence_python_client-0.1.0 → cadence_python_client-0.2.0}/cadence/_internal/workflow/statemachine/activity_state_machine.py

@@ -6,6 +6,9 @@ from cadence._internal.workflow.statemachine.decision_state_machine import (
     BaseDecisionStateMachine,
 )
 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
 from cadence.error import ActivityFailure
@@ -30,12 +33,14 @@ class ActivityStateMachine(BaseDecisionStateMachine):
         return DecisionId(DecisionType.ACTIVITY, self.request.activity_id)
 
     def get_decision(self) -> decision.Decision | None:
-        if self.state is DecisionState.CREATED:
+        if self.state is DecisionState.REQUESTED:
             return decision.Decision(
                 schedule_activity_task_decision_attributes=self.request
             )
+        if self.state is DecisionState.CANCELED_AFTER_REQUESTED:
+            return record_immediate_cancel(self.request)
 
-        if self.state is DecisionState.CANCELED_AFTER_INITIATED:
+        if self.state is DecisionState.CANCELED_AFTER_RECORDED:
             return decision.Decision(
                 request_cancel_activity_task_decision_attributes=decision.RequestCancelActivityTaskDecisionAttributes(
                     activity_id=self.request.activity_id,
@@ -45,20 +50,20 @@ class ActivityStateMachine(BaseDecisionStateMachine):
         return None
 
     def request_cancel(self) -> bool:
-        if self.state is DecisionState.CREATED:
-            self._transition(DecisionState.COMPLETED)
+        if self.state is DecisionState.REQUESTED:
+            self._transition(DecisionState.CANCELED_AFTER_REQUESTED)
             self.completed.force_cancel()
             return True
 
-        if self.state is DecisionState.INITIATED:
-            self._transition(DecisionState.CANCELED_AFTER_INITIATED)
+        if self.state is DecisionState.RECORDED:
+            self._transition(DecisionState.CANCELED_AFTER_RECORDED)
             return True
 
         return False
 
     @activity_events.event(id_attr="activity_id", event_id_is_alias=True)
     def handle_scheduled(self, _: history.ActivityTaskScheduledEventAttributes) -> None:
-        self._transition(DecisionState.INITIATED)
+        self._transition(DecisionState.RECORDED)
 
     @activity_events.event()
     def handle_started(self, _: history.ActivityTaskStartedEventAttributes) -> None:
@@ -97,10 +102,10 @@ class ActivityStateMachine(BaseDecisionStateMachine):
     def handle_cancel_requested(
         self, _: history.ActivityTaskCancelRequestedEventAttributes
     ) -> None:
-        self._transition(DecisionState.CANCELLATION_DECISION_SENT)
+        self._transition(DecisionState.CANCELLATION_RECORDED)
 
     @activity_events.event("activity_id")
     def handle_cancel_failed(
         self, _: history.RequestCancelActivityTaskFailedEventAttributes
     ) -> None:
-        self._transition(DecisionState.INITIATED)
+        self._transition(DecisionState.RECORDED)

cadence_python_client-0.2.0/cadence/_internal/workflow/statemachine/cancellation.py

@@ -0,0 +1,36 @@
+from typing import Dict, Any, Tuple
+
+from cadence._internal.workflow.statemachine.decision_state_machine import (
+    DecisionId,
+    DecisionType,
+)
+
+from cadence.api.v1 import decision, history
+from cadence.api.v1.common_pb2 import Payload
+from msgspec import json
+
+
+MARKER_PREFIX = "Cancel_"
+
+
+def is_immediate_cancel(marker: history.MarkerRecordedEventAttributes) -> bool:
+    return marker.marker_name.startswith(MARKER_PREFIX)
+
+
+def to_marker(
+    decision_id: DecisionId, props: Dict[str, Any]
+) -> decision.RecordMarkerDecisionAttributes:
+    data = props | {"type": decision_id.decision_type.name}
+    return decision.RecordMarkerDecisionAttributes(
+        marker_name=MARKER_PREFIX + decision_id.id,
+        details=Payload(data=json.encode(data)),
+    )
+
+
+def from_marker(
+    marker: history.MarkerRecordedEventAttributes,
+) -> Tuple[DecisionId, Dict[str, Any]]:
+    decision_id = marker.marker_name.replace(MARKER_PREFIX, "")
+    props = json.decode(marker.details.data)
+    decision_type = DecisionType[props.pop("type")]
+    return DecisionId(decision_type, decision_id), props

cadence_python_client-0.2.0/cadence/_internal/workflow/statemachine/completion_state_machine.py

@@ -0,0 +1,25 @@
+from cadence._internal.workflow.statemachine.decision_state_machine import (
+    DecisionStateMachine,
+    DecisionId,
+    DecisionType,
+)
+from cadence.api.v1 import decision
+
+COMPLETE = "complete"
+
+COMPLETION_ID = DecisionId(DecisionType.WORKFLOW_COMPLETE, COMPLETE)
+
+
+class CompletionStateMachine(DecisionStateMachine):
+    def __init__(self, outcome: decision.Decision) -> None:
+        super().__init__()
+        self.outcome = outcome
+
+    def get_id(self) -> DecisionId:
+        return COMPLETION_ID
+
+    def get_decision(self) -> decision.Decision | None:
+        return self.outcome
+
+    def request_cancel(self) -> bool:
+        return False