minor fix

Author: timl3136

cadence/_internal/workflow/workflow_engine.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 from dataclasses import dataclass
-from typing import Callable, Optional, Dict, Any
+from typing import Callable, Any
 
 from cadence._internal.workflow.context import Context
 from cadence.api.v1.decision_pb2 import Decision
@@ -16,8 +16,6 @@
 @dataclass
 class DecisionResult:
     decisions: list[Decision]
-    force_create_new_decision_task: bool = False
-    query_results: Optional[Dict[str, Any]] = None
 
 class WorkflowEngine:
     def __init__(self, info: WorkflowInfo, client: Client, workflow_func: Callable[[Any], Any] | None = None):

cadence/worker/_decision_task_handler.py

@@ -136,8 +136,7 @@ async def _respond_decision_task_completed(self, task: PollForDecisionTaskRespon
                 task_token=task.task_token,
                 decisions=decision_result.decisions,
                 identity=self._identity,
-                return_new_decision_task=True,
-                force_create_new_decision_task=False
+                return_new_decision_task=True
             )
 
             await self._client.worker_stub.RespondDecisionTaskCompleted(request)

tests/cadence/_internal/workflow/test_workflow_engine_integration.py

@@ -96,8 +96,6 @@ async def test_process_decision_success(self, workflow_engine, mock_client):
             # Verify the result
             assert isinstance(result, DecisionResult)
             assert len(result.decisions) == 1
-            assert result.force_create_new_decision_task is False
-            assert result.query_results is None
 
     @pytest.mark.asyncio
     async def test_process_decision_with_history(self, workflow_engine, mock_client):
@@ -305,5 +303,4 @@ async def test_process_decision_with_query_results(self, workflow_engine, mock_c
             # Verify the result
             assert isinstance(result, DecisionResult)
             assert len(result.decisions) == 1
-            assert result.force_create_new_decision_task is False
-            assert result.query_results is None  # Not set in this test
+  # Not set in this test

tests/cadence/worker/test_decision_task_handler.py

@@ -87,8 +87,6 @@ async def test_handle_task_implementation_success(self, handler, sample_decision
         mock_engine = Mock(spec=WorkflowEngine)
         mock_decision_result = Mock(spec=DecisionResult)
         mock_decision_result.decisions = [Decision()]
-        mock_decision_result.force_create_new_decision_task = False
-        mock_decision_result.query_results = {}
         mock_engine.process_decision = AsyncMock(return_value=mock_decision_result)
 
         with patch('cadence.worker._decision_task_handler.WorkflowEngine', return_value=mock_engine):
@@ -147,8 +145,6 @@ async def test_handle_task_implementation_creates_new_engines(self, handler, sam
         mock_engine = Mock(spec=WorkflowEngine)
         mock_decision_result = Mock(spec=DecisionResult)
         mock_decision_result.decisions = []
-        mock_decision_result.force_create_new_decision_task = False
-        mock_decision_result.query_results = {}
         mock_engine.process_decision = AsyncMock(return_value=mock_decision_result)
 
         with patch('cadence.worker._decision_task_handler.WorkflowEngine', return_value=mock_engine) as mock_engine_class:
@@ -231,8 +227,6 @@ async def test_respond_decision_task_completed_success(self, handler, sample_dec
         """Test successful decision task completion response."""
         decision_result = Mock(spec=DecisionResult)
         decision_result.decisions = [Decision(), Decision()]
-        decision_result.force_create_new_decision_task = False
-        decision_result.query_results = None
 
         await handler._respond_decision_task_completed(sample_decision_task, decision_result)
 
@@ -242,31 +236,25 @@ async def test_respond_decision_task_completed_success(self, handler, sample_dec
         assert call_args.task_token == sample_decision_task.task_token
         assert call_args.identity == handler._identity
         assert call_args.return_new_decision_task
-        assert not call_args.force_create_new_decision_task
         assert len(call_args.decisions) == 2
 
     @pytest.mark.asyncio
     async def test_respond_decision_task_completed_no_query_results(self, handler, sample_decision_task):
         """Test decision task completion response without query results."""
         decision_result = Mock(spec=DecisionResult)
         decision_result.decisions = []
-        decision_result.force_create_new_decision_task = False
-        decision_result.query_results = None
 
         await handler._respond_decision_task_completed(sample_decision_task, decision_result)
 
         call_args = handler._client.worker_stub.RespondDecisionTaskCompleted.call_args[0][0]
         assert call_args.return_new_decision_task
-        assert not call_args.force_create_new_decision_task
         assert len(call_args.decisions) == 0
 
     @pytest.mark.asyncio
     async def test_respond_decision_task_completed_error(self, handler, sample_decision_task):
         """Test decision task completion response error handling."""
         decision_result = Mock(spec=DecisionResult)
         decision_result.decisions = []
-        decision_result.force_create_new_decision_task = False
-        decision_result.query_results = None
 
         handler._client.worker_stub.RespondDecisionTaskCompleted.side_effect = Exception("Respond failed")
 
@@ -283,8 +271,6 @@ async def test_workflow_engine_creation_with_workflow_info(self, handler, sample
         mock_engine = Mock(spec=WorkflowEngine)
         mock_decision_result = Mock(spec=DecisionResult)
         mock_decision_result.decisions = []
-        mock_decision_result.force_create_new_decision_task = False
-        mock_decision_result.query_results = {}
         mock_engine.process_decision = AsyncMock(return_value=mock_decision_result)
 
         with patch('cadence.worker._decision_task_handler.WorkflowEngine', return_value=mock_engine) as mock_workflow_engine_class:

tests/cadence/worker/test_decision_task_handler_integration.py

@@ -98,8 +98,6 @@ async def test_handle_decision_task_success(self, decision_task_handler, mock_cl
         decision = Decision()
         mock_engine.process_decision = AsyncMock(return_value=Mock(
             decisions=[decision],  # Proper Decision object
-            force_create_new_decision_task=False,
-            query_results=None
         ))
 
         with patch('cadence.worker._decision_task_handler.WorkflowEngine', return_value=mock_engine):
@@ -155,8 +153,6 @@ async def test_workflow_engine_creation_each_task(self, decision_task_handler, m
             mock_engine = Mock()
             mock_engine.process_decision = AsyncMock(return_value=Mock(
                 decisions=[],
-                force_create_new_decision_task=False,
-                query_results=None
             ))
             mock_engine_class.return_value = mock_engine
 
@@ -201,8 +197,6 @@ async def test_respond_decision_task_completed(self, decision_task_handler, mock
         # Create mock decision result
         decision_result = Mock()
         decision_result.decisions = [Decision()]  # Proper Decision object
-        decision_result.force_create_new_decision_task = False
-        decision_result.query_results = None
 
         # Call the response method
         await decision_task_handler._respond_decision_task_completed(decision_task, decision_result)

tests/cadence/worker/test_task_handler_integration.py

@@ -66,8 +66,6 @@ async def test_full_task_handling_flow_success(self, handler, sample_decision_ta
         mock_engine = Mock(spec=WorkflowEngine)
         mock_decision_result = Mock(spec=DecisionResult)
         mock_decision_result.decisions = []
-        mock_decision_result.force_create_new_decision_task = False
-        mock_decision_result.query_results = None
         mock_engine.process_decision = AsyncMock(return_value=mock_decision_result)
 
         with patch('cadence.worker._decision_task_handler.WorkflowEngine', return_value=mock_engine):
@@ -111,8 +109,6 @@ async def test_context_activation_integration(self, handler, sample_decision_tas
         mock_engine = Mock(spec=WorkflowEngine)
         mock_decision_result = Mock(spec=DecisionResult)
         mock_decision_result.decisions = []
-        mock_decision_result.force_create_new_decision_task = False
-        mock_decision_result.query_results = None
         mock_engine.process_decision = AsyncMock(return_value=mock_decision_result)
 
         # Track if context is activated
@@ -162,8 +158,6 @@ async def test_multiple_workflow_executions(self, handler, mock_registry):
 
         mock_decision_result = Mock(spec=DecisionResult)
         mock_decision_result.decisions = []
-        mock_decision_result.force_create_new_decision_task = False
-        mock_decision_result.query_results = None
 
         mock_engine.process_decision = AsyncMock(return_value=mock_decision_result)
 
@@ -189,8 +183,6 @@ async def test_workflow_engine_creation_integration(self, handler, sample_decisi
         mock_engine = Mock(spec=WorkflowEngine)
         mock_decision_result = Mock(spec=DecisionResult)
         mock_decision_result.decisions = []
-        mock_decision_result.force_create_new_decision_task = False
-        mock_decision_result.query_results = None
         mock_engine.process_decision = AsyncMock(return_value=mock_decision_result)
 
         with patch('cadence.worker._decision_task_handler.WorkflowEngine', return_value=mock_engine) as mock_engine_class:
@@ -258,8 +250,6 @@ async def test_concurrent_task_handling(self, handler, mock_registry):
         mock_engine = Mock(spec=WorkflowEngine)
         mock_decision_result = Mock(spec=DecisionResult)
         mock_decision_result.decisions = []
-        mock_decision_result.force_create_new_decision_task = False
-        mock_decision_result.query_results = None
         mock_engine.process_decision = AsyncMock(return_value=mock_decision_result)
 
         with patch('cadence.worker._decision_task_handler.WorkflowEngine', return_value=mock_engine):