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

cadence/_internal/workflow/decision_events_iterator.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+Decision Events Iterator for Cadence workflow orchestration.
+
+This module provides functionality to iterate through workflow history events,
+particularly focusing on decision-related events for replay and execution.
+"""
+
+from dataclasses import dataclass
+from typing import Iterator, List, Optional
+
+from cadence._internal.workflow.history_event_iterator import HistoryEventsIterator
+from cadence.api.v1.history_pb2 import HistoryEvent
+
+
+@dataclass
+class DecisionEvents:
+    """
+    Represents events for a single decision iteration.
+    """
+
+    input: List[HistoryEvent]
+    output: List[HistoryEvent]
+    markers: List[HistoryEvent]
+    replay: bool
+    replay_current_time_milliseconds: int
+    next_decision_event_id: int
+
+    def get_output_event_by_id(self, event_id: int) -> Optional[HistoryEvent]:
+        for event in self.input:
+            if hasattr(event, "event_id") and event.event_id == event_id:
+                return event
+        return None
+
+
+class DecisionEventsIterator(Iterator[DecisionEvents]):
+    """
+    Iterator for processing decision events from workflow history.
+
+    This is the main class that processes workflow history events and groups them
+    into decision iterations for proper workflow replay and execution.
+    """
+
+    def __init__(
+        self,
+        events: List[HistoryEvent],
+    ):
+        self._events: HistoryEventsIterator = HistoryEventsIterator(events)
+        self._next_decision_event_id: Optional[int] = None
+        self._replay_current_time_milliseconds: Optional[int] = None
+
+    def __iter__(self):
+        return self
+
+    def __next__(self) -> DecisionEvents:
+        """
+        Process the next decision batch.
+        1. Find the next valid decision task started event during replay or last scheduled decision task events for non-replay
+        2. Collect the decision input events before the decision task
+        3. Collect the decision output events after the decision task
+
+        Relay mode is determined by checking if the decision task is completed or not
+        """
+        decision_input_events: List[HistoryEvent] = []
+        decision_output_events: List[HistoryEvent] = []
+        decision_event: Optional[HistoryEvent] = None
+        for event in self._events:
+            match event.WhichOneof("attributes"):
+                case "decision_task_started_event_attributes":
+                    next_event = self._events.peek()
+
+                    # latest event, not replay, assign started event as decision event insteaad
+                    if next_event is None:
+                        decision_event = event
+                        break
+
+                    match next_event.WhichOneof("attributes"):
+                        case (
+                            "decision_task_failed_event_attributes"
+                            | "decision_task_timed_out_event_attributes"
+                        ):
+                            # skip failed / timed out decision tasks and continue searching
+                            next(self._events)
+                            continue
+                        case "decision_task_completed_event_attributes":
+                            # found decision task completed event, stop
+                            decision_event = next(self._events)
+                            break
+                        case _:
+                            raise ValueError(
+                                f"unexpected event type after decision task started event: {next_event}"
+                            )
+
+                case _:
+                    decision_input_events.append(event)
+
+        if not decision_event:
+            raise StopIteration("no decision event found")
+
+        # collect decision output events
+        while self._events.has_next():
+            nxt = self._events.peek() if self._events.has_next() else None
+            if nxt and not is_decision_event(nxt):
+                break
+            decision_output_events.append(next(self._events))
+
+        replay_current_time_milliseconds = decision_event.event_time.ToMilliseconds()
+
+        replay: bool
+        next_decision_event_id: int
+        if (
+            decision_event.WhichOneof("attributes")
+            == "decision_task_completed_event_attributes"
+        ):  # completed decision task
+            replay = True
+            next_decision_event_id = decision_event.event_id + 1
+        else:
+            replay = False
+            next_decision_event_id = decision_event.event_id + 2
+
+        # collect marker events
+        markers = [m for m in decision_output_events if is_marker_event(m)]
+
+        return DecisionEvents(
+            input=decision_input_events,
+            output=decision_output_events,
+            markers=markers,
+            replay=replay,
+            replay_current_time_milliseconds=replay_current_time_milliseconds,
+            next_decision_event_id=next_decision_event_id,
+        )
+
+
+def is_decision_event(event: HistoryEvent) -> bool:
+    """Check if an event is a decision output event."""
+    return event is not None and event.WhichOneof("attributes") in set(
+        [
+            "activity_task_scheduled_event_attributes",
+            "start_child_workflow_execution_initiated_event_attributes",
+            "timer_started_event_attributes",
+            "workflow_execution_completed_event_attributes",
+            "workflow_execution_failed_event_attributes",
+            "workflow_execution_canceled_event_attributes",
+            "workflow_execution_continued_as_new_event_attributes",
+            "activity_task_cancel_requested_event_attributes",
+            "request_cancel_activity_task_failed_event_attributes",
+            "timer_canceled_event_attributes",
+            "cancel_timer_failed_event_attributes",
+            "request_cancel_external_workflow_execution_initiated_event_attributes",
+            "marker_recorded_event_attributes",
+            "signal_external_workflow_execution_initiated_event_attributes",
+            "upsert_workflow_search_attributes_event_attributes",
+        ]
+    )
+
+
+def is_marker_event(event: HistoryEvent) -> bool:
+    return bool(
+        event is not None
+        and event.WhichOneof("attributes") == "marker_recorded_event_attributes"
+    )

cadence/_internal/workflow/decisions_helper.py

@@ -0,0 +1,312 @@
+"""
+DecisionsHelper manages the next decision ID which is used for tracking decision state machines.
+
+This helper ensures that decision IDs are properly assigned and tracked to maintain
+consistency in the workflow execution state.
+"""
+
+import logging
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+from cadence._internal.workflow.statemachine.decision_state_machine import (
+    DecisionId,
+    DecisionType,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DecisionTracker:
+    """Tracks a decision with its ID and current state."""
+
+    decision_id: DecisionId
+    scheduled_event_id: Optional[int] = None
+    initiated_event_id: Optional[int] = None
+    started_event_id: Optional[int] = None
+    is_completed: bool = False
+
+
+class DecisionsHelper:
+    """
+    Helper class to manage decision IDs and work with DecisionManager state machines.
+
+    This class generates unique decision IDs and integrates with the DecisionManager
+    state machines for proper decision lifecycle tracking.
+    """
+
+    def __init__(self):
+        """
+        Initialize the DecisionsHelper with a DecisionManager reference.
+        """
+        self._next_decision_counters: Dict[DecisionType, int] = {}
+        self._tracked_decisions: Dict[str, DecisionTracker] = {}
+        self._decision_id_to_key: Dict[str, str] = {}
+        logger.debug("DecisionsHelper initialized with DecisionManager integration")
+
+    def _get_next_counter(self, decision_type: DecisionType) -> int:
+        """
+        Get the next counter value for a given decision type.
+
+        Args:
+            decision_type: The type of decision
+
+        Returns:
+            The next counter value
+        """
+        if decision_type not in self._next_decision_counters:
+            self._next_decision_counters[decision_type] = 1
+        else:
+            self._next_decision_counters[decision_type] += 1
+
+        return self._next_decision_counters[decision_type]
+
+    def generate_activity_id(self, activity_name: str) -> str:
+        """
+        Generate a unique activity ID.
+
+        Args:
+            activity_name: The name of the activity
+
+        Returns:
+            A unique activity ID
+        """
+        counter = self._get_next_counter(DecisionType.ACTIVITY)
+        activity_id = f"{activity_name}_{counter}"
+
+        # Track this decision
+        decision_id = DecisionId(DecisionType.ACTIVITY, activity_id)
+        tracker = DecisionTracker(decision_id)
+        self._tracked_decisions[activity_id] = tracker
+        self._decision_id_to_key[str(decision_id)] = activity_id
+
+        logger.debug(f"Generated activity ID: {activity_id}")
+        return activity_id
+
+    def generate_timer_id(self, timer_name: str = "timer") -> str:
+        """
+        Generate a unique timer ID.
+
+        Args:
+            timer_name: The name/prefix for the timer
+
+        Returns:
+            A unique timer ID
+        """
+        counter = self._get_next_counter(DecisionType.TIMER)
+        timer_id = f"{timer_name}_{counter}"
+
+        # Track this decision
+        decision_id = DecisionId(DecisionType.TIMER, timer_id)
+        tracker = DecisionTracker(decision_id)
+        self._tracked_decisions[timer_id] = tracker
+        self._decision_id_to_key[str(decision_id)] = timer_id
+
+        logger.debug(f"Generated timer ID: {timer_id}")
+        return timer_id
+
+    def generate_child_workflow_id(self, workflow_name: str) -> str:
+        """
+        Generate a unique child workflow ID.
+
+        Args:
+            workflow_name: The name of the child workflow
+
+        Returns:
+            A unique child workflow ID
+        """
+        counter = self._get_next_counter(DecisionType.CHILD_WORKFLOW)
+        workflow_id = f"{workflow_name}_{counter}"
+
+        # Track this decision
+        decision_id = DecisionId(DecisionType.CHILD_WORKFLOW, workflow_id)
+        tracker = DecisionTracker(decision_id)
+        self._tracked_decisions[workflow_id] = tracker
+        self._decision_id_to_key[str(decision_id)] = workflow_id
+
+        logger.debug(f"Generated child workflow ID: {workflow_id}")
+        return workflow_id
+
+    def generate_marker_id(self, marker_name: str) -> str:
+        """
+        Generate a unique marker ID.
+
+        Args:
+            marker_name: The name of the marker
+
+        Returns:
+            A unique marker ID
+        """
+        counter = self._get_next_counter(DecisionType.MARKER)
+        marker_id = f"{marker_name}_{counter}"
+
+        # Track this decision
+        decision_id = DecisionId(DecisionType.MARKER, marker_id)
+        tracker = DecisionTracker(decision_id)
+        self._tracked_decisions[marker_id] = tracker
+        self._decision_id_to_key[str(decision_id)] = marker_id
+
+        logger.debug(f"Generated marker ID: {marker_id}")
+        return marker_id
+
+    def get_decision_tracker(self, decision_key: str) -> Optional[DecisionTracker]:
+        """
+        Get the decision tracker for a given decision key.
+
+        Args:
+            decision_key: The decision key (activity_id, timer_id, etc.)
+
+        Returns:
+            The DecisionTracker if found, None otherwise
+        """
+        return self._tracked_decisions.get(decision_key)
+
+    def update_decision_scheduled(
+        self, decision_key: str, scheduled_event_id: int
+    ) -> None:
+        """
+        Update a decision tracker when it gets scheduled.
+
+        Args:
+            decision_key: The decision key
+            scheduled_event_id: The event ID when the decision was scheduled
+        """
+        tracker = self._tracked_decisions.get(decision_key)
+        if tracker:
+            tracker.scheduled_event_id = scheduled_event_id
+            logger.debug(
+                f"Updated decision {decision_key} with scheduled event ID {scheduled_event_id}"
+            )
+        else:
+            logger.warning(f"No tracker found for decision key: {decision_key}")
+
+    def update_decision_initiated(
+        self, decision_key: str, initiated_event_id: int
+    ) -> None:
+        """
+        Update a decision tracker when it gets initiated.
+
+        Args:
+            decision_key: The decision key
+            initiated_event_id: The event ID when the decision was initiated
+        """
+        tracker = self._tracked_decisions.get(decision_key)
+        if tracker:
+            tracker.initiated_event_id = initiated_event_id
+            logger.debug(
+                f"Updated decision {decision_key} with initiated event ID {initiated_event_id}"
+            )
+        else:
+            logger.warning(f"No tracker found for decision key: {decision_key}")
+
+    def update_decision_started(self, decision_key: str, started_event_id: int) -> None:
+        """
+        Update a decision tracker when it gets started.
+
+        Args:
+            decision_key: The decision key
+            started_event_id: The event ID when the decision was started
+        """
+        tracker = self._tracked_decisions.get(decision_key)
+        if tracker:
+            tracker.started_event_id = started_event_id
+            logger.debug(
+                f"Updated decision {decision_key} with started event ID {started_event_id}"
+            )
+        else:
+            logger.warning(f"No tracker found for decision key: {decision_key}")
+
+    def update_decision_completed(self, decision_key: str) -> None:
+        """
+        Mark a decision as completed.
+
+        Args:
+            decision_key: The decision key
+        """
+        tracker = self._tracked_decisions.get(decision_key)
+        if tracker:
+            tracker.is_completed = True
+            logger.debug(f"Marked decision {decision_key} as completed")
+        else:
+            logger.warning(f"No tracker found for decision key: {decision_key}")
+
+    def _find_decision_by_scheduled_event_id(
+        self, scheduled_event_id: int
+    ) -> Optional[str]:
+        """Find a decision key by its scheduled event ID."""
+        for key, tracker in self._tracked_decisions.items():
+            if tracker.scheduled_event_id == scheduled_event_id:
+                return key
+        return None
+
+    def _find_decision_by_initiated_event_id(
+        self, initiated_event_id: int
+    ) -> Optional[str]:
+        """Find a decision key by its initiated event ID."""
+        for key, tracker in self._tracked_decisions.items():
+            if tracker.initiated_event_id == initiated_event_id:
+                return key
+        return None
+
+    def _find_decision_by_started_event_id(
+        self, started_event_id: int
+    ) -> Optional[str]:
+        """Find a decision key by its started event ID."""
+        for key, tracker in self._tracked_decisions.items():
+            if tracker.started_event_id == started_event_id:
+                return key
+        return None
+
+    def get_pending_decisions_count(self) -> int:
+        """
+        Get the count of decisions that are not yet completed.
+
+        Returns:
+            The number of pending decisions
+        """
+        return sum(
+            1
+            for tracker in self._tracked_decisions.values()
+            if not tracker.is_completed
+        )
+
+    def get_completed_decisions_count(self) -> int:
+        """
+        Get the count of decisions that have been completed.
+
+        Returns:
+            The number of completed decisions
+        """
+        return sum(
+            1 for tracker in self._tracked_decisions.values() if tracker.is_completed
+        )
+
+    def reset(self) -> None:
+        """Reset all decision tracking state."""
+        self._next_decision_counters.clear()
+        self._tracked_decisions.clear()
+        self._decision_id_to_key.clear()
+        logger.debug("DecisionsHelper reset")
+
+    def get_stats(self) -> Dict[str, int]:
+        """
+        Get statistics about tracked decisions.
+
+        Returns:
+            Dictionary with decision statistics
+        """
+        stats = {
+            "total_decisions": len(self._tracked_decisions),
+            "pending_decisions": self.get_pending_decisions_count(),
+            "completed_decisions": self.get_completed_decisions_count(),
+        }
+
+        # Add per-type counts
+        for decision_type in DecisionType:
+            type_name = decision_type.name.lower()
+            stats[f"{type_name}_count"] = self._next_decision_counters.get(
+                decision_type, 0
+            )
+
+        return stats