small change to match java

Signed-off-by: Tim Li <[email protected]>

Author: timl3136

cadence/_internal/workflow/decision_events_iterator.py

@@ -21,7 +21,6 @@ class DecisionEvents:
     Represents events for a single decision iteration.
     """
     events: List[HistoryEvent] = field(default_factory=list)
-    decision_events: List[HistoryEvent] = field(default_factory=list)
     markers: List[HistoryEvent] = field(default_factory=list)
     replay: bool = False
     replay_current_time_milliseconds: Optional[int] = None
@@ -31,9 +30,6 @@ def get_events(self) -> List[HistoryEvent]:
         """Return all events in this decision iteration."""
         return self.events
 
-    def get_decision_events(self) -> List[HistoryEvent]:
-        """Return decision-related events."""
-        return self.decision_events
 
     def get_markers(self) -> List[HistoryEvent]:
         """Return marker events."""
@@ -43,9 +39,9 @@ def is_replay(self) -> bool:
         """Check if this decision is in replay mode."""
         return self.replay
 
-    def get_optional_decision_event(self, event_id: int) -> Optional[HistoryEvent]:
-        """Retrieve a specific decision event by ID."""
-        for event in self.decision_events:
+    def get_event_by_id(self, event_id: int) -> Optional[HistoryEvent]:
+        """Retrieve a specific event by ID, returns None if not found."""
+        for event in self.events:
             if hasattr(event, 'event_id') and event.event_id == event_id:
                 return event
         return None
@@ -181,9 +177,6 @@ async def next_decision_events(self) -> DecisionEvents:
                 self._process_decision_completion_event(event, decision_events)
                 current_index += 1  # Move past this event
                 break
-            else:
-                # Other events that are part of this decision
-                decision_events.decision_events.append(event)
 
             current_index += 1
 
@@ -213,14 +206,6 @@ async def next_decision_events(self) -> DecisionEvents:
 
     def _process_decision_completion_event(self, event: HistoryEvent, decision_events: DecisionEvents):
         """Process the decision completion event and update state."""
-        if self._is_decision_task_completed(event):
-            # Extract decisions from the completed event if available
-            if hasattr(event, 'decision_task_completed_event_attributes'):
-                completed_attrs = event.decision_task_completed_event_attributes
-                if hasattr(completed_attrs, 'decisions'):
-                    # Process decisions - they represent what the workflow decided to do
-                    for decision in completed_attrs.decisions:
-                        decision_events.decision_events.append(decision)
 
         # Check if we're still in replay mode
         # This is determined by comparing event IDs with the current decision task's started event ID

tests/cadence/_internal/workflow/test_decision_events_iterator.py

@@ -88,44 +88,40 @@ def test_decision_events_initialization(self):
         decision_events = DecisionEvents()
 
         assert decision_events.get_events() == []
-        assert decision_events.get_decision_events() == []
         assert decision_events.get_markers() == []
         assert not decision_events.is_replay()
         assert decision_events.replay_current_time_milliseconds is None
         assert decision_events.next_decision_event_id is None
 
     def test_decision_events_with_data(self):
         """Test DecisionEvents with actual data."""
-        events = [create_mock_history_event(1, "decision_task_started")]
-        decision_events = [create_mock_history_event(2, "decision_task_completed")]
+        events = [create_mock_history_event(1, "decision_task_started"), create_mock_history_event(2, "decision_task_completed")]
         markers = [create_mock_history_event(3, "marker_recorded")]
 
         decision_events_obj = DecisionEvents(
             events=events,
-            decision_events=decision_events,
             markers=markers,
             replay=True,
             replay_current_time_milliseconds=123456,
             next_decision_event_id=4
         )
 
         assert decision_events_obj.get_events() == events
-        assert decision_events_obj.get_decision_events() == decision_events
         assert decision_events_obj.get_markers() == markers
         assert decision_events_obj.is_replay()
         assert decision_events_obj.replay_current_time_milliseconds == 123456
         assert decision_events_obj.next_decision_event_id == 4
 
-    def test_get_optional_decision_event(self):
-        """Test retrieving optional decision event by ID."""
+    def test_get_event_by_id(self):
+        """Test retrieving event by ID."""
         event1 = create_mock_history_event(1, "decision_task_started")
         event2 = create_mock_history_event(2, "decision_task_completed")
 
-        decision_events = DecisionEvents(decision_events=[event1, event2])
+        decision_events = DecisionEvents(events=[event1, event2])
 
-        assert decision_events.get_optional_decision_event(1) == event1
-        assert decision_events.get_optional_decision_event(2) == event2
-        assert decision_events.get_optional_decision_event(999) is None
+        assert decision_events.get_event_by_id(1) == event1
+        assert decision_events.get_event_by_id(2) == event2
+        assert decision_events.get_event_by_id(999) is None
 
 
 
@@ -374,10 +370,8 @@ async def test_complex_workflow_scenario(self, mock_client):
         first_decision = all_decisions[0]
         assert len(first_decision.get_events()) == 6  # Events 1-6
         assert len(first_decision.get_markers()) == 1  # Event 4
-        assert len(first_decision.get_decision_events()) == 3  # Events 2, 3, 5
 
         # Second decision should be simpler
         second_decision = all_decisions[1]
         assert len(second_decision.get_events()) == 2  # Events 7-8
-        assert len(second_decision.get_markers()) == 0
-        assert len(second_decision.get_decision_events()) == 0
+        assert len(second_decision.get_markers()) == 0