[Chore] Model updates (#66)

- Updates InvokeOptions -> ChainedInvokeOptions
- Invoke<Status>Details -> ChainedInvoke<Status>Details

This pr matches the changes done in aws/aws-durable-execution-sdk-python#67

Author: Astraea Quinn S

src/aws_durable_execution_sdk_python_testing/checkpoint/processors/base.py

@@ -8,9 +8,9 @@
 
 from aws_durable_execution_sdk_python.lambda_service import (
     CallbackDetails,
+    ChainedInvokeDetails,
     ContextDetails,
     ExecutionDetails,
-    InvokeDetails,
     Operation,
     OperationStatus,
     OperationType,
@@ -105,16 +105,15 @@ def _create_callback_details(
             else None
         )
 
-    def _create_invoke_details(self, update: OperationUpdate) -> InvokeDetails | None:
-        """Create InvokeDetails from OperationUpdate."""
-        if update.operation_type == OperationType.INVOKE and update.invoke_options:
-            # Create a basic ARN using the function name
-            # In a real implementation, this would need more context about the execution
-            # TODO: To confirm how or if this works
-            arn = f"arn:aws:lambda:us-west-2:123456789012:durable-execution:{update.invoke_options.function_name}:execution-name"
-            return InvokeDetails(
-                durable_execution_arn=arn, result=update.payload, error=update.error
-            )
+    def _create_invoke_details(
+        self, update: OperationUpdate
+    ) -> ChainedInvokeDetails | None:
+        """Create ChainedInvokeDetails from OperationUpdate."""
+        if (
+            update.operation_type == OperationType.CHAINED_INVOKE
+            and update.chained_invoke_options
+        ):
+            return ChainedInvokeDetails(result=update.payload, error=update.error)
         return None
 
     def _create_wait_details(
@@ -165,6 +164,6 @@ def _translate_update_to_operation(
             context_details=context_details,
             step_details=step_details,
             callback_details=callback_details,
-            invoke_details=invoke_details,
+            chained_invoke_details=invoke_details,
             wait_details=wait_details,
         )

src/aws_durable_execution_sdk_python_testing/checkpoint/processors/step.py

@@ -94,7 +94,9 @@ def process(
                     callback_details=current_op.callback_details
                     if current_op
                     else None,
-                    invoke_details=current_op.invoke_details if current_op else None,
+                    chained_invoke_details=current_op.chained_invoke_details
+                    if current_op
+                    else None,
                 )
 
                 # Schedule step retry timer to fire after delay

src/aws_durable_execution_sdk_python_testing/checkpoint/processors/wait.py

@@ -63,7 +63,7 @@ def process(
                     step_details=None,
                     wait_details=wait_details,
                     callback_details=None,
-                    invoke_details=None,
+                    chained_invoke_details=None,
                 )
 
                 # Schedule wait timer to complete after delay

src/aws_durable_execution_sdk_python_testing/checkpoint/validators/checkpoint.py

@@ -20,7 +20,7 @@
     ExecutionOperationValidator,
 )
 from aws_durable_execution_sdk_python_testing.checkpoint.validators.operations.invoke import (
-    InvokeOperationValidator,
+    ChainedInvokeOperationValidator,
 )
 from aws_durable_execution_sdk_python_testing.checkpoint.validators.operations.step import (
     StepOperationValidator,
@@ -118,8 +118,8 @@ def _validate_operation_status_transition(
                 WaitOperationValidator.validate(current_state, update)
             case OperationType.CALLBACK:
                 CallbackOperationValidator.validate(current_state, update)
-            case OperationType.INVOKE:
-                InvokeOperationValidator.validate(current_state, update)
+            case OperationType.CHAINED_INVOKE:
+                ChainedInvokeOperationValidator.validate(current_state, update)
             case OperationType.EXECUTION:
                 ExecutionOperationValidator.validate(update)
             case _:  # pragma: no cover

src/aws_durable_execution_sdk_python_testing/checkpoint/validators/operations/invoke.py

@@ -22,7 +22,7 @@
 )
 
 
-class InvokeOperationValidator:
+class ChainedInvokeOperationValidator:
     """Validates INVOKE operation transitions."""
 
     _ALLOWED_STATUS_TO_CANCEL = frozenset(
@@ -46,7 +46,7 @@ def validate(current_state: Operation | None, update: OperationUpdate) -> None:
                 if (
                     current_state is None
                     or current_state.status
-                    not in InvokeOperationValidator._ALLOWED_STATUS_TO_CANCEL
+                    not in ChainedInvokeOperationValidator._ALLOWED_STATUS_TO_CANCEL
                 ):
                     msg_invoke_cancel: str = "Cannot cancel an INVOKE that does not exist or has already completed."
                     raise InvalidParameterValueException(msg_invoke_cancel)

src/aws_durable_execution_sdk_python_testing/checkpoint/validators/transitions.py

@@ -42,7 +42,7 @@ class ValidActionsByOperationTypeValidator:
         OperationType.CONTEXT: VALID_ACTIONS_FOR_CONTEXT,
         OperationType.WAIT: VALID_ACTIONS_FOR_WAIT,
         OperationType.CALLBACK: VALID_ACTIONS_FOR_CALLBACK,
-        OperationType.INVOKE: VALID_ACTIONS_FOR_INVOKE,
+        OperationType.CHAINED_INVOKE: VALID_ACTIONS_FOR_INVOKE,
         OperationType.EXECUTION: VALID_ACTIONS_FOR_EXECUTION,
     }
 

src/aws_durable_execution_sdk_python_testing/execution.py

@@ -173,7 +173,11 @@ def has_pending_operations(self, execution: Execution) -> bool:
                 and operation.status == OperationStatus.PENDING
             ) or (
                 operation.operation_type
-                in [OperationType.WAIT, OperationType.CALLBACK, OperationType.INVOKE]
+                in [
+                    OperationType.WAIT,
+                    OperationType.CALLBACK,
+                    OperationType.CHAINED_INVOKE,
+                ]
                 and operation.status == OperationStatus.STARTED
             ):
                 return True

src/aws_durable_execution_sdk_python_testing/model.py

@@ -8,9 +8,9 @@
 # Import existing types from the main SDK - REUSE EVERYTHING POSSIBLE
 from aws_durable_execution_sdk_python.lambda_service import (
     CallbackOptions,
+    ChainedInvokeOptions,
     ContextOptions,
     ErrorObject,
-    InvokeOptions,
     Operation,
     OperationAction,
     OperationSubType,
@@ -801,15 +801,15 @@ def to_dict(self) -> dict[str, Any]:
 
 
 @dataclass(frozen=True)
-class InvokeStartedDetails:
+class ChainedInvokeStartedDetails:
     """Invoke started event details."""
 
     input: EventInput | None = None
     function_arn: str | None = None
     durable_execution_arn: str | None = None
 
     @classmethod
-    def from_dict(cls, data: dict) -> InvokeStartedDetails:
+    def from_dict(cls, data: dict) -> ChainedInvokeStartedDetails:
         input_data = None
         if input_dict := data.get("Input"):
             input_data = EventInput.from_dict(input_dict)
@@ -832,13 +832,13 @@ def to_dict(self) -> dict[str, Any]:
 
 
 @dataclass(frozen=True)
-class InvokeSucceededDetails:
+class ChainedInvokeSucceededDetails:
     """Invoke succeeded event details."""
 
     result: EventResult | None = None
 
     @classmethod
-    def from_dict(cls, data: dict) -> InvokeSucceededDetails:
+    def from_dict(cls, data: dict) -> ChainedInvokeSucceededDetails:
         result_data = None
         if result_dict := data.get("Result"):
             result_data = EventResult.from_dict(result_dict)
@@ -853,13 +853,13 @@ def to_dict(self) -> dict[str, Any]:
 
 
 @dataclass(frozen=True)
-class InvokeFailedDetails:
+class ChainedInvokeFailedDetails:
     """Invoke failed event details."""
 
     error: EventError | None = None
 
     @classmethod
-    def from_dict(cls, data: dict) -> InvokeFailedDetails:
+    def from_dict(cls, data: dict) -> ChainedInvokeFailedDetails:
         error_data = None
         if error_dict := data.get("Error"):
             error_data = EventError.from_dict(error_dict)
@@ -874,13 +874,13 @@ def to_dict(self) -> dict[str, Any]:
 
 
 @dataclass(frozen=True)
-class InvokeTimedOutDetails:
+class ChainedInvokeTimedOutDetails:
     """Invoke timed out event details."""
 
     error: EventError | None = None
 
     @classmethod
-    def from_dict(cls, data: dict) -> InvokeTimedOutDetails:
+    def from_dict(cls, data: dict) -> ChainedInvokeTimedOutDetails:
         error_data = None
         if error_dict := data.get("Error"):
             error_data = EventError.from_dict(error_dict)
@@ -895,13 +895,13 @@ def to_dict(self) -> dict[str, Any]:
 
 
 @dataclass(frozen=True)
-class InvokeStoppedDetails:
+class ChainedInvokeStoppedDetails:
     """Invoke stopped event details."""
 
     error: EventError | None = None
 
     @classmethod
-    def from_dict(cls, data: dict) -> InvokeStoppedDetails:
+    def from_dict(cls, data: dict) -> ChainedInvokeStoppedDetails:
         error_data = None
         if error_dict := data.get("Error"):
             error_data = EventError.from_dict(error_dict)
@@ -1030,11 +1030,11 @@ class Event:
     step_started_details: StepStartedDetails | None = None
     step_succeeded_details: StepSucceededDetails | None = None
     step_failed_details: StepFailedDetails | None = None
-    invoke_started_details: InvokeStartedDetails | None = None
-    invoke_succeeded_details: InvokeSucceededDetails | None = None
-    invoke_failed_details: InvokeFailedDetails | None = None
-    invoke_timed_out_details: InvokeTimedOutDetails | None = None
-    invoke_stopped_details: InvokeStoppedDetails | None = None
+    chained_invoke_started_details: ChainedInvokeStartedDetails | None = None
+    chained_invoke_succeeded_details: ChainedInvokeSucceededDetails | None = None
+    chained_invoke_failed_details: ChainedInvokeFailedDetails | None = None
+    chained_invoke_timed_out_details: ChainedInvokeTimedOutDetails | None = None
+    chained_invoke_stopped_details: ChainedInvokeStoppedDetails | None = None
     callback_started_details: CallbackStartedDetails | None = None
     callback_succeeded_details: CallbackSucceededDetails | None = None
     callback_failed_details: CallbackFailedDetails | None = None
@@ -1103,25 +1103,35 @@ def from_dict(cls, data: dict) -> Event:
         if details_data := data.get("StepFailedDetails"):
             step_failed_details = StepFailedDetails.from_dict(details_data)
 
-        invoke_started_details = None
-        if details_data := data.get("InvokeStartedDetails"):
-            invoke_started_details = InvokeStartedDetails.from_dict(details_data)
+        chained_invoke_started_details = None
+        if details_data := data.get("ChainedInvokeStartedDetails"):
+            chained_invoke_started_details = ChainedInvokeStartedDetails.from_dict(
+                details_data
+            )
 
-        invoke_succeeded_details = None
-        if details_data := data.get("InvokeSucceededDetails"):
-            invoke_succeeded_details = InvokeSucceededDetails.from_dict(details_data)
+        chained_invoke_succeeded_details = None
+        if details_data := data.get("ChainedInvokeSucceededDetails"):
+            chained_invoke_succeeded_details = ChainedInvokeSucceededDetails.from_dict(
+                details_data
+            )
 
-        invoke_failed_details = None
-        if details_data := data.get("InvokeFailedDetails"):
-            invoke_failed_details = InvokeFailedDetails.from_dict(details_data)
+        chained_invoke_failed_details = None
+        if details_data := data.get("ChainedInvokeFailedDetails"):
+            chained_invoke_failed_details = ChainedInvokeFailedDetails.from_dict(
+                details_data
+            )
 
-        invoke_timed_out_details = None
-        if details_data := data.get("InvokeTimedOutDetails"):
-            invoke_timed_out_details = InvokeTimedOutDetails.from_dict(details_data)
+        chained_invoke_timed_out_details = None
+        if details_data := data.get("ChainedInvokeTimedOutDetails"):
+            chained_invoke_timed_out_details = ChainedInvokeTimedOutDetails.from_dict(
+                details_data
+            )
 
-        invoke_stopped_details = None
-        if details_data := data.get("InvokeStoppedDetails"):
-            invoke_stopped_details = InvokeStoppedDetails.from_dict(details_data)
+        chained_invoke_stopped_details = None
+        if details_data := data.get("ChainedInvokeStoppedDetails"):
+            chained_invoke_stopped_details = ChainedInvokeStoppedDetails.from_dict(
+                details_data
+            )
 
         callback_started_details = None
         if details_data := data.get("CallbackStartedDetails"):
@@ -1163,11 +1173,11 @@ def from_dict(cls, data: dict) -> Event:
             step_started_details=step_started_details,
             step_succeeded_details=step_succeeded_details,
             step_failed_details=step_failed_details,
-            invoke_started_details=invoke_started_details,
-            invoke_succeeded_details=invoke_succeeded_details,
-            invoke_failed_details=invoke_failed_details,
-            invoke_timed_out_details=invoke_timed_out_details,
-            invoke_stopped_details=invoke_stopped_details,
+            chained_invoke_started_details=chained_invoke_started_details,
+            chained_invoke_succeeded_details=chained_invoke_succeeded_details,
+            chained_invoke_failed_details=chained_invoke_failed_details,
+            chained_invoke_timed_out_details=chained_invoke_timed_out_details,
+            chained_invoke_stopped_details=chained_invoke_stopped_details,
             callback_started_details=callback_started_details,
             callback_succeeded_details=callback_succeeded_details,
             callback_failed_details=callback_failed_details,
@@ -1220,16 +1230,26 @@ def to_dict(self) -> dict[str, Any]:
             result["StepSucceededDetails"] = self.step_succeeded_details.to_dict()
         if self.step_failed_details is not None:
             result["StepFailedDetails"] = self.step_failed_details.to_dict()
-        if self.invoke_started_details is not None:
-            result["InvokeStartedDetails"] = self.invoke_started_details.to_dict()
-        if self.invoke_succeeded_details is not None:
-            result["InvokeSucceededDetails"] = self.invoke_succeeded_details.to_dict()
-        if self.invoke_failed_details is not None:
-            result["InvokeFailedDetails"] = self.invoke_failed_details.to_dict()
-        if self.invoke_timed_out_details is not None:
-            result["InvokeTimedOutDetails"] = self.invoke_timed_out_details.to_dict()
-        if self.invoke_stopped_details is not None:
-            result["InvokeStoppedDetails"] = self.invoke_stopped_details.to_dict()
+        if self.chained_invoke_started_details is not None:
+            result["ChainedInvokeStartedDetails"] = (
+                self.chained_invoke_started_details.to_dict()
+            )
+        if self.chained_invoke_succeeded_details is not None:
+            result["ChainedInvokeSucceededDetails"] = (
+                self.chained_invoke_succeeded_details.to_dict()
+            )
+        if self.chained_invoke_failed_details is not None:
+            result["ChainedInvokeFailedDetails"] = (
+                self.chained_invoke_failed_details.to_dict()
+            )
+        if self.chained_invoke_timed_out_details is not None:
+            result["ChainedInvokeTimedOutDetails"] = (
+                self.chained_invoke_timed_out_details.to_dict()
+            )
+        if self.chained_invoke_stopped_details is not None:
+            result["ChainedInvokeStoppedDetails"] = (
+                self.chained_invoke_stopped_details.to_dict()
+            )
         if self.callback_started_details is not None:
             result["CallbackStartedDetails"] = self.callback_started_details.to_dict()
         if self.callback_succeeded_details is not None:
@@ -1522,8 +1542,10 @@ def from_dict(
                     callback_options=CallbackOptions(**update_data["CallbackOptions"])
                     if update_data.get("CallbackOptions")
                     else None,
-                    invoke_options=InvokeOptions(**update_data["InvokeOptions"])
-                    if update_data.get("InvokeOptions")
+                    chained_invoke_options=ChainedInvokeOptions(
+                        **update_data["ChainedInvokeOptions"]
+                    )
+                    if update_data.get("ChainedInvokeOptions")
                     else None,
                 )
                 updates.append(operation_update)