cadence-python-client 0.1.0__py3-none-any.whl

cadence/_internal/workflow/deterministic_event_loop.py

@@ -0,0 +1,498 @@
+from asyncio import AbstractEventLoop, Handle, TimerHandle, futures, tasks, Future, Task
+from contextvars import Context
+import logging
+import collections
+import asyncio.events as events
+import threading
+from typing import Callable, Any, TypeVar, Coroutine, Awaitable, Generator
+from typing_extensions import Unpack, TypeVarTuple
+
+logger = logging.getLogger(__name__)
+
+_Ts = TypeVarTuple("_Ts")
+_T = TypeVar("_T")
+
+
+class DeterministicEventLoop(AbstractEventLoop):
+    """
+    This is a basic FIFO implementation of event loop that does not allow I/O or timer operations.
+    As a result, it's theoretically deterministic. This event loop is not useful directly without async events processing inside the loop.
+
+    Code is mostly copied from asyncio.BaseEventLoop without I/O or timer operations.
+    """
+
+    def __init__(self) -> None:
+        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._stopping: bool = False
+        self._closed: bool = False
+
+    def run_until_yield(self):
+        """Run until stop() is called."""
+        self._run_forever_setup()
+        try:
+            while self._ready:
+                self._run_once()
+        finally:
+            self._run_forever_cleanup()
+
+    # Event Loop APIs
+    def call_soon(
+        self,
+        callback: Callable[[Unpack[_Ts]], object],
+        *args: Unpack[_Ts],
+        context: Context | None = None,
+    ) -> Handle:
+        return self._call_soon(callback, args, context)
+
+    def _call_soon(
+        self,
+        callback: Callable[..., Any],
+        args: tuple[Any, ...],
+        context: Context | None,
+    ) -> Handle:
+        handle = events.Handle(callback, args, self, context)
+        self._ready.append(handle)
+        return handle
+
+    def get_debug(self) -> bool:
+        return self._debug
+
+    def set_debug(self, enabled: bool) -> None:
+        self._debug = enabled
+
+    def run_forever(self) -> None:
+        """Run until stop() is called."""
+        self._run_forever_setup()
+        try:
+            while True:
+                self._run_once()
+                if self._stopping:
+                    break
+        finally:
+            self._run_forever_cleanup()
+
+    def run_until_complete(
+        self, future: Generator[Any, None, _T] | Awaitable[_T]
+    ) -> _T:
+        """Run until the Future is done.
+
+        If the argument is a coroutine, it is wrapped in a Task.
+
+        WARNING: It would be disastrous to call run_until_complete()
+        with the same coroutine twice -- it would wrap it in two
+        different Tasks and that can't be good.
+
+        Return the Future's result, or raise its exception.
+        """
+        self._check_closed()
+        self._check_running()
+
+        new_task = not futures.isfuture(future)
+        future = tasks.ensure_future(future, loop=self)  # type: ignore[arg-type]
+
+        future.add_done_callback(_run_until_complete_cb)
+        try:
+            self.run_forever()
+        except:
+            if new_task and future.done() and not future.cancelled():
+                # The coroutine raised a BaseException. Consume the exception
+                # to not log a warning, the caller doesn't have access to the
+                # local task.
+                future.exception()
+            raise
+        finally:
+            future.remove_done_callback(_run_until_complete_cb)
+        if not future.done():
+            raise RuntimeError("Event loop stopped before Future completed.")
+
+        return future.result()
+
+    def create_task(
+        self, coro: Generator[Any, None, _T] | Coroutine[Any, Any, _T], **kwargs: Any
+    ) -> Task[_T]:
+        """Schedule a coroutine object.
+
+        Return a task object.
+        """
+        self._check_closed()
+
+        # NOTE: eager_start is not supported for deterministic event loop
+        if kwargs.get("eager_start", False):
+            raise RuntimeError(
+                "eager_start in create_task is not supported for deterministic event loop"
+            )
+
+        task = tasks.Task(coro, loop=self, **kwargs)
+        # We intentionally destroy pending tasks when shutting down the event loop.
+        # If our asyncio implementation supports it, disable the logs
+        if hasattr(task, "_log_destroy_pending"):
+            setattr(task, "_log_destroy_pending", False)
+        return task
+
+    def create_future(self) -> Future[Any]:
+        return futures.Future(loop=self)
+
+    def _run_once(self) -> None:
+        ntodo = len(self._ready)
+        for i in range(ntodo):
+            handle = self._ready.popleft()
+            if handle._cancelled:
+                continue
+            handle._run()
+
+    def _run_forever_setup(self) -> None:
+        self._check_closed()
+        self._check_running()
+        self._thread_id = threading.get_ident()
+        events._set_running_loop(self)
+
+    def _run_forever_cleanup(self) -> None:
+        self._stopping = False
+        self._thread_id = None
+        events._set_running_loop(None)
+
+    def stop(self) -> None:
+        self._stopping = True
+
+    def _check_closed(self) -> None:
+        if self._closed:
+            raise RuntimeError("Event loop is closed")
+
+    def _check_running(self) -> None:
+        if self.is_running():
+            raise RuntimeError("This event loop is already running")
+        if events._get_running_loop() is not None:
+            raise RuntimeError(
+                "Cannot run the event loop while another loop is running"
+            )
+
+    def is_running(self) -> bool:
+        return self._thread_id is not None
+
+    def close(self) -> None:
+        """Close the event loop.
+        The event loop must not be running.
+        """
+        if self.is_running():
+            raise RuntimeError("Cannot close a running event loop")
+        if self._closed:
+            return
+        if self._debug:
+            logger.debug("Close %r", self)
+        self._closed = True
+        self._ready.clear()
+
+    def is_closed(self) -> bool:
+        """Returns True if the event loop was closed."""
+        return self._closed
+
+    # Timer operations - not supported for deterministic execution
+    def time(self) -> float:
+        raise NotImplementedError("Timers not supported in deterministic event loop")
+
+    def call_later(  # type: ignore[override]
+        self,
+        delay: float,
+        callback: Callable[..., Any],
+        *args: Any,
+        context: Context | None = None,
+    ) -> TimerHandle:
+        raise NotImplementedError("Timers not supported in deterministic event loop")
+
+    def call_at(  # type: ignore[override]
+        self,
+        when: float,
+        callback: Callable[..., Any],
+        *args: Any,
+        context: Context | None = None,
+    ) -> TimerHandle:
+        raise NotImplementedError("Timers not supported in deterministic event loop")
+
+    # Thread operations - not supported
+    def call_soon_threadsafe(  # type: ignore[override]
+        self, callback: Callable[..., Any], *args: Any, context: Context | None = None
+    ) -> Handle:
+        raise NotImplementedError(
+            "Thread operations not supported in deterministic event loop"
+        )
+
+    def run_in_executor(  # type: ignore[override]
+        self, executor: Any, func: Callable[..., Any], *args: Any
+    ) -> Future[Any]:
+        raise NotImplementedError(
+            "Executor operations not supported in deterministic event loop"
+        )
+
+    def set_default_executor(self, executor: Any) -> None:
+        raise NotImplementedError(
+            "Executor operations not supported in deterministic event loop"
+        )
+
+    # I/O operations - not supported for deterministic execution
+    def add_reader(self, fd: int, callback: Callable[..., Any], *args: Any) -> None:  # type: ignore[override]
+        raise NotImplementedError(
+            "I/O operations not supported in deterministic event loop"
+        )
+
+    def remove_reader(self, fd: int) -> bool:  # type: ignore[override]
+        raise NotImplementedError(
+            "I/O operations not supported in deterministic event loop"
+        )
+
+    def add_writer(self, fd: int, callback: Callable[..., Any], *args: Any) -> None:  # type: ignore[override]
+        raise NotImplementedError(
+            "I/O operations not supported in deterministic event loop"
+        )
+
+    def remove_writer(self, fd: int) -> bool:  # type: ignore[override]
+        raise NotImplementedError(
+            "I/O operations not supported in deterministic event loop"
+        )
+
+    # Socket operations - not supported
+    async def sock_recv(self, sock: Any, nbytes: int) -> bytes:
+        raise NotImplementedError(
+            "Socket operations not supported in deterministic event loop"
+        )
+
+    async def sock_recv_into(self, sock: Any, buf: Any) -> int:
+        raise NotImplementedError(
+            "Socket operations not supported in deterministic event loop"
+        )
+
+    async def sock_sendall(self, sock: Any, data: bytes) -> None:  # type: ignore[override]
+        raise NotImplementedError(
+            "Socket operations not supported in deterministic event loop"
+        )
+
+    async def sock_connect(self, sock: Any, address: Any) -> None:
+        raise NotImplementedError(
+            "Socket operations not supported in deterministic event loop"
+        )
+
+    async def sock_accept(self, sock: Any) -> tuple[Any, Any]:
+        raise NotImplementedError(
+            "Socket operations not supported in deterministic event loop"
+        )
+
+    async def sock_sendfile(  # type: ignore[override]
+        self,
+        sock: Any,
+        file: Any,
+        offset: int = 0,
+        count: int | None = None,
+        *,
+        fallback: bool = True,
+    ) -> int:
+        raise NotImplementedError(
+            "Socket operations not supported in deterministic event loop"
+        )
+
+    async def sock_recvfrom(self, sock: Any, bufsize: int) -> tuple[bytes, Any]:
+        raise NotImplementedError(
+            "Socket operations not supported in deterministic event loop"
+        )
+
+    async def sock_recvfrom_into(
+        self, sock: Any, buf: Any, nbytes: int = 0
+    ) -> tuple[int, Any]:
+        raise NotImplementedError(
+            "Socket operations not supported in deterministic event loop"
+        )
+
+    async def sock_sendto(self, sock: Any, data: bytes, address: Any) -> int:  # type: ignore[override]
+        raise NotImplementedError(
+            "Socket operations not supported in deterministic event loop"
+        )
+
+    # DNS operations - not supported
+    async def getaddrinfo(  # type: ignore[override]
+        self,
+        host: str | None,
+        port: int | str | None,
+        *,
+        family: int = 0,
+        type: int = 0,
+        proto: int = 0,
+        flags: int = 0,
+    ) -> list[tuple[Any, ...]]:
+        raise NotImplementedError(
+            "DNS operations not supported in deterministic event loop"
+        )
+
+    async def getnameinfo(  # type: ignore[override]
+        self, sockaddr: tuple[str, int], flags: int = 0
+    ) -> tuple[str, str]:
+        raise NotImplementedError(
+            "DNS operations not supported in deterministic event loop"
+        )
+
+    # Network connection operations - not supported
+    async def create_connection(
+        self,
+        protocol_factory: Any,
+        host: str | None = None,
+        port: int | None = None,
+        **kwargs: Any,
+    ) -> tuple[Any, Any]:
+        raise NotImplementedError(
+            "Network operations not supported in deterministic event loop"
+        )
+
+    async def create_server(  # type: ignore[override]
+        self,
+        protocol_factory: Any,
+        host: str | None = None,
+        port: int | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        raise NotImplementedError(
+            "Network operations not supported in deterministic event loop"
+        )
+
+    async def create_unix_connection(
+        self, protocol_factory: Any, path: str | None = None, **kwargs: Any
+    ) -> tuple[Any, Any]:
+        raise NotImplementedError(
+            "Unix socket operations not supported in deterministic event loop"
+        )
+
+    async def create_unix_server(  # type: ignore[override]
+        self, protocol_factory: Any, path: str | None = None, **kwargs: Any
+    ) -> Any:
+        raise NotImplementedError(
+            "Unix socket operations not supported in deterministic event loop"
+        )
+
+    async def create_datagram_endpoint(  # type: ignore[override]
+        self,
+        protocol_factory: Any,
+        local_addr: tuple[str, int] | None = None,
+        remote_addr: tuple[str, int] | None = None,
+        **kwargs: Any,
+    ) -> tuple[Any, Any]:
+        raise NotImplementedError(
+            "Datagram operations not supported in deterministic event loop"
+        )
+
+    async def sendfile(
+        self,
+        transport: Any,
+        file: Any,
+        offset: int = 0,
+        count: int | None = None,
+        *,
+        fallback: bool = True,
+    ) -> int:
+        raise NotImplementedError(
+            "Sendfile operations not supported in deterministic event loop"
+        )
+
+    async def start_tls(
+        self, transport: Any, protocol: Any, sslcontext: Any, **kwargs: Any
+    ) -> Any:
+        raise NotImplementedError(
+            "TLS operations not supported in deterministic event loop"
+        )
+
+    # Pipe operations - not supported
+    async def connect_read_pipe(
+        self, protocol_factory: Any, pipe: Any
+    ) -> tuple[Any, Any]:
+        raise NotImplementedError(
+            "Pipe operations not supported in deterministic event loop"
+        )
+
+    async def connect_write_pipe(
+        self, protocol_factory: Any, pipe: Any
+    ) -> tuple[Any, Any]:
+        raise NotImplementedError(
+            "Pipe operations not supported in deterministic event loop"
+        )
+
+    # Subprocess operations - not supported
+    async def subprocess_shell(self, cmd: str, **kwargs: Any) -> Any:  # type: ignore[override]
+        raise NotImplementedError(
+            "Subprocess operations not supported in deterministic event loop"
+        )
+
+    async def subprocess_exec(self, program: str, *args: Any, **kwargs: Any) -> Any:  # type: ignore[override]
+        raise NotImplementedError(
+            "Subprocess operations not supported in deterministic event loop"
+        )
+
+    # Signal handlers - not supported
+    def add_signal_handler(  # type: ignore[override]
+        self, sig: int, callback: Callable[..., Any], *args: Any
+    ) -> None:
+        raise NotImplementedError(
+            "Signal handlers not supported in deterministic event loop"
+        )
+
+    def remove_signal_handler(self, sig: int) -> bool:
+        raise NotImplementedError(
+            "Signal handlers not supported in deterministic event loop"
+        )
+
+    # Exception handling
+    def set_exception_handler(
+        self, handler: Callable[[Any, dict[str, Any]], Any] | None
+    ) -> None:
+        raise NotImplementedError(
+            "Custom exception handlers not supported in deterministic event loop"
+        )
+
+    def get_exception_handler(self) -> Callable[[Any, dict[str, Any]], Any] | None:
+        raise NotImplementedError(
+            "Custom exception handlers not supported in deterministic event loop"
+        )
+
+    def default_exception_handler(self, context: dict[str, Any]) -> None:
+        raise NotImplementedError(
+            "Custom exception handlers not supported in deterministic event loop"
+        )
+
+    def call_exception_handler(self, context: dict[str, Any]) -> None:
+        raise NotImplementedError(
+            "Custom exception handlers not supported in deterministic event loop"
+        )
+
+    # Task factory
+    def set_task_factory(  # type: ignore[override]
+        self, factory: Callable[[Any, Coroutine[Any, Any, Any]], Task[Any]] | None
+    ) -> None:
+        raise NotImplementedError(
+            "Custom task factory not supported in deterministic event loop"
+        )
+
+    def get_task_factory(  # type: ignore[override]
+        self,
+    ) -> Callable[[Any, Coroutine[Any, Any, Any]], Task[Any]] | None:
+        return None
+
+    # Shutdown operations
+    async def shutdown_asyncgens(self) -> None:
+        # This is a no-op for deterministic event loop
+        pass
+
+    async def shutdown_default_executor(self, timeout: float | None = None) -> None:
+        # This is a no-op for deterministic event loop
+        pass
+
+    # Accepted socket connection
+    async def connect_accepted_socket(
+        self, protocol_factory: Any, sock: Any, **kwargs: Any
+    ) -> tuple[Any, Any]:
+        raise NotImplementedError(
+            "Socket operations not supported in deterministic event loop"
+        )
+
+
+def _run_until_complete_cb(fut: Future[Any]) -> None:
+    if not fut.cancelled():
+        exc = fut.exception()
+        if isinstance(exc, (SystemExit, KeyboardInterrupt)):
+            return
+    fut.get_loop().stop()

cadence/_internal/workflow/history_event_iterator.py

@@ -0,0 +1,58 @@
+from typing import Iterator, List, Optional
+from cadence.api.v1.history_pb2 import HistoryEvent
+from cadence.api.v1.service_worker_pb2 import PollForDecisionTaskResponse
+from cadence.api.v1.service_workflow_pb2 import (
+    GetWorkflowExecutionHistoryRequest,
+    GetWorkflowExecutionHistoryResponse,
+)
+from cadence.client import Client
+
+
+async def iterate_history_events(
+    decision_task: PollForDecisionTaskResponse, client: Client
+):
+    PAGE_SIZE = 1000
+
+    current_page = decision_task.history.events
+    next_page_token = decision_task.next_page_token
+    workflow_execution = decision_task.workflow_execution
+
+    while True:
+        for event in current_page:
+            yield event
+        if not next_page_token:
+            break
+        response: GetWorkflowExecutionHistoryResponse = (
+            await client.workflow_stub.GetWorkflowExecutionHistory(
+                GetWorkflowExecutionHistoryRequest(
+                    domain=client.domain,
+                    workflow_execution=workflow_execution,
+                    next_page_token=next_page_token,
+                    page_size=PAGE_SIZE,
+                )
+            )
+        )
+        current_page = response.history.events
+        next_page_token = response.next_page_token
+
+
+class HistoryEventsIterator(Iterator[HistoryEvent]):
+    def __init__(self, events: List[HistoryEvent]):
+        self._iter = iter(events)
+        self._current = next(self._iter, None)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self) -> HistoryEvent:
+        if not self._current:
+            raise StopIteration("No more events")
+        event = self._current
+        self._current = next(self._iter, None)
+        return event
+
+    def has_next(self) -> bool:
+        return self._current is not None
+
+    def peek(self) -> Optional[HistoryEvent]:
+        return self._current

cadence/_internal/workflow/statemachine/activity_state_machine.py

@@ -0,0 +1,106 @@
+from cadence._internal.workflow.statemachine.decision_state_machine import (
+    DecisionState,
+    DecisionType,
+    DecisionId,
+    DecisionFuture,
+    BaseDecisionStateMachine,
+)
+from cadence._internal.workflow.statemachine.event_dispatcher import EventDispatcher
+from cadence.api.v1 import decision, history
+from cadence.api.v1.common_pb2 import Payload
+from cadence.error import ActivityFailure
+
+activity_events = EventDispatcher("scheduled_event_id")
+
+
+class ActivityStateMachine(BaseDecisionStateMachine):
+    request: decision.ScheduleActivityTaskDecisionAttributes
+    completed: DecisionFuture[Payload]
+
+    def __init__(
+        self,
+        request: decision.ScheduleActivityTaskDecisionAttributes,
+        completed: DecisionFuture[Payload],
+    ) -> None:
+        super().__init__()
+        self.request = request
+        self.completed = completed
+
+    def get_id(self) -> DecisionId:
+        return DecisionId(DecisionType.ACTIVITY, self.request.activity_id)
+
+    def get_decision(self) -> decision.Decision | None:
+        if self.state is DecisionState.CREATED:
+            return decision.Decision(
+                schedule_activity_task_decision_attributes=self.request
+            )
+
+        if self.state is DecisionState.CANCELED_AFTER_INITIATED:
+            return decision.Decision(
+                request_cancel_activity_task_decision_attributes=decision.RequestCancelActivityTaskDecisionAttributes(
+                    activity_id=self.request.activity_id,
+                )
+            )
+
+        return None
+
+    def request_cancel(self) -> bool:
+        if self.state is DecisionState.CREATED:
+            self._transition(DecisionState.COMPLETED)
+            self.completed.force_cancel()
+            return True
+
+        if self.state is DecisionState.INITIATED:
+            self._transition(DecisionState.CANCELED_AFTER_INITIATED)
+            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)
+
+    @activity_events.event()
+    def handle_started(self, _: history.ActivityTaskStartedEventAttributes) -> None:
+        # Started doesn't actually do anything in the Go client.
+        # The workflow can't observe it, and it doesn't impact cancellation
+        # self._transition(DecisionState.STARTED)
+        pass
+
+    @activity_events.event()
+    def handle_completed(
+        self, event: history.ActivityTaskCompletedEventAttributes
+    ) -> None:
+        self._transition(DecisionState.COMPLETED)
+        self.completed.set_result(event.result)
+
+    @activity_events.event()
+    def handle_failed(self, event: history.ActivityTaskFailedEventAttributes) -> None:
+        self._transition(DecisionState.COMPLETED)
+        self.completed.set_exception(ActivityFailure(event.failure.reason))
+
+    @activity_events.event()
+    def handle_timeout(
+        self, event: history.ActivityTaskTimedOutEventAttributes
+    ) -> None:
+        self._transition(DecisionState.COMPLETED)
+        self.completed.set_exception(ActivityFailure(event.details.data.decode()))
+
+    @activity_events.event()
+    def handle_canceled(
+        self, event: history.ActivityTaskCanceledEventAttributes
+    ) -> None:
+        self._transition(DecisionState.COMPLETED)
+        self.completed.force_cancel(event.details.data.decode())
+
+    @activity_events.event("activity_id")
+    def handle_cancel_requested(
+        self, _: history.ActivityTaskCancelRequestedEventAttributes
+    ) -> None:
+        self._transition(DecisionState.CANCELLATION_DECISION_SENT)
+
+    @activity_events.event("activity_id")
+    def handle_cancel_failed(
+        self, _: history.RequestCancelActivityTaskFailedEventAttributes
+    ) -> None:
+        self._transition(DecisionState.INITIATED)