async-durable-execution-runner 2.0.0a1__py3-none-any.whl

async_durable_execution_runner/checkpoint/validators/operations/callback.py

@@ -0,0 +1,45 @@
+"""Callback operation validator."""
+
+from __future__ import annotations
+
+from async_durable_execution.lambda_service import (
+    Operation,
+    OperationAction,
+    OperationStatus,
+    OperationUpdate,
+)
+
+from async_durable_execution_runner.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+VALID_ACTIONS_FOR_CALLBACK = frozenset(
+    [
+        OperationAction.START,
+    ]
+)
+
+
+class CallbackOperationValidator:
+    """Validates CALLBACK operation transitions."""
+
+    _ALLOWED_STATUS_TO_CANCEL = frozenset(
+        [
+            OperationStatus.STARTED,
+        ]
+    )
+
+    @staticmethod
+    def validate(current_state: Operation | None, update: OperationUpdate) -> None:
+        """Validate CALLBACK operation update."""
+        match update.action:
+            case OperationAction.START:
+                if current_state is not None:
+                    msg_callback_exists: str = (
+                        "Cannot start a CALLBACK that already exist."
+                    )
+                    raise InvalidParameterValueException(msg_callback_exists)
+            case _:
+                msg: str = "Invalid action for CALLBACK operation."
+                raise InvalidParameterValueException(msg)

async_durable_execution_runner/checkpoint/validators/operations/context.py

@@ -0,0 +1,73 @@
+"""Context operation validator."""
+
+from __future__ import annotations
+
+from async_durable_execution.lambda_service import (
+    Operation,
+    OperationAction,
+    OperationStatus,
+    OperationUpdate,
+)
+
+from async_durable_execution_runner.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+VALID_ACTIONS_FOR_CONTEXT = frozenset(
+    [
+        OperationAction.START,
+        OperationAction.FAIL,
+        OperationAction.SUCCEED,
+    ]
+)
+
+
+class ContextOperationValidator:
+    """Validates CONTEXT operation transitions."""
+
+    _ALLOWED_STATUS_TO_CLOSE = frozenset(
+        [
+            OperationStatus.STARTED,
+        ]
+    )
+
+    @staticmethod
+    def validate(current_state: Operation | None, update: OperationUpdate) -> None:
+        """Validate CONTEXT operation update."""
+        match update.action:
+            case OperationAction.START:
+                if current_state is not None:
+                    msg_context_exists: str = (
+                        "Cannot start a CONTEXT that already exist."
+                    )
+
+                    raise InvalidParameterValueException(msg_context_exists)
+            case OperationAction.FAIL | OperationAction.SUCCEED:
+                if (
+                    current_state is not None
+                    and current_state.status
+                    not in ContextOperationValidator._ALLOWED_STATUS_TO_CLOSE
+                ):
+                    msg_context_close: str = "Invalid current CONTEXT state to close."
+
+                    raise InvalidParameterValueException(msg_context_close)
+                if update.action == OperationAction.FAIL and update.payload is not None:
+                    msg_context_fail_payload: str = (
+                        "Cannot provide a Payload for FAIL action."
+                    )
+
+                    raise InvalidParameterValueException(msg_context_fail_payload)
+                if (
+                    update.action == OperationAction.SUCCEED
+                    and update.error is not None
+                ):
+                    msg_context_succeed_error: str = (
+                        "Cannot provide an Error for SUCCEED action."
+                    )
+
+                    raise InvalidParameterValueException(msg_context_succeed_error)
+            case _:
+                msg_context_invalid: str = "Invalid CONTEXT action."
+
+                raise InvalidParameterValueException(msg_context_invalid)

async_durable_execution_runner/checkpoint/validators/operations/execution.py

@@ -0,0 +1,47 @@
+"""Execution operation validator."""
+
+from __future__ import annotations
+
+from async_durable_execution.lambda_service import (
+    OperationAction,
+    OperationUpdate,
+)
+
+from async_durable_execution_runner.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+VALID_ACTIONS_FOR_EXECUTION = frozenset(
+    [
+        OperationAction.SUCCEED,
+        OperationAction.FAIL,
+    ]
+)
+
+
+class ExecutionOperationValidator:
+    """Validates EXECUTION operation transitions."""
+
+    @staticmethod
+    def validate(update: OperationUpdate) -> None:
+        """Validate EXECUTION operation update."""
+        match update.action:
+            case OperationAction.SUCCEED:
+                if update.error is not None:
+                    msg_exec_succeed_error: str = (
+                        "Cannot provide an Error for SUCCEED action."
+                    )
+
+                    raise InvalidParameterValueException(msg_exec_succeed_error)
+            case OperationAction.FAIL:
+                if update.payload is not None:
+                    msg_exec_fail_payload: str = (
+                        "Cannot provide a Payload for FAIL action."
+                    )
+
+                    raise InvalidParameterValueException(msg_exec_fail_payload)
+            case _:
+                msg_exec_invalid: str = "Invalid EXECUTION action."
+
+                raise InvalidParameterValueException(msg_exec_invalid)

async_durable_execution_runner/checkpoint/validators/operations/invoke.py

@@ -0,0 +1,56 @@
+"""Invoke operation validator."""
+
+from __future__ import annotations
+
+from async_durable_execution.lambda_service import (
+    Operation,
+    OperationAction,
+    OperationStatus,
+    OperationUpdate,
+)
+
+from async_durable_execution_runner.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+VALID_ACTIONS_FOR_INVOKE = frozenset(
+    [
+        OperationAction.START,
+        OperationAction.CANCEL,
+    ]
+)
+
+
+class ChainedInvokeOperationValidator:
+    """Validates INVOKE operation transitions."""
+
+    _ALLOWED_STATUS_TO_CANCEL = frozenset(
+        [
+            OperationStatus.STARTED,
+        ]
+    )
+
+    @staticmethod
+    def validate(current_state: Operation | None, update: OperationUpdate) -> None:
+        """Validate INVOKE operation update."""
+        match update.action:
+            case OperationAction.START:
+                if current_state is not None:
+                    msg_invoke_exists: str = (
+                        "Cannot start an INVOKE that already exist."
+                    )
+
+                    raise InvalidParameterValueException(msg_invoke_exists)
+            case OperationAction.CANCEL:
+                if (
+                    current_state is None
+                    or current_state.status
+                    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)
+            case _:
+                msg_invoke_invalid: str = "Invalid INVOKE action."
+
+                raise InvalidParameterValueException(msg_invoke_invalid)

async_durable_execution_runner/checkpoint/validators/operations/step.py

@@ -0,0 +1,106 @@
+"""Step operation validator."""
+
+from __future__ import annotations
+
+from async_durable_execution.lambda_service import (
+    Operation,
+    OperationAction,
+    OperationStatus,
+    OperationUpdate,
+)
+
+from async_durable_execution_runner.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+VALID_ACTIONS_FOR_STEP = frozenset(
+    [
+        OperationAction.START,
+        OperationAction.FAIL,
+        OperationAction.RETRY,
+        OperationAction.SUCCEED,
+    ]
+)
+
+
+class StepOperationValidator:
+    """Validates STEP operation transitions."""
+
+    _ALLOWED_STATUS_TO_CLOSE = frozenset(
+        [
+            OperationStatus.STARTED,
+            OperationStatus.READY,
+        ]
+    )
+
+    _ALLOWED_STATUS_TO_START = frozenset(
+        [
+            OperationStatus.READY,
+        ]
+    )
+
+    _ALLOWED_STATUS_TO_REATTEMPT = frozenset(
+        [
+            OperationStatus.STARTED,
+            OperationStatus.READY,
+        ]
+    )
+
+    @staticmethod
+    def validate(current_state: Operation | None, update: OperationUpdate) -> None:
+        """Validate STEP operation update."""
+        if current_state is None:
+            return
+
+        match update.action:
+            case OperationAction.START:
+                if (
+                    current_state.status
+                    not in StepOperationValidator._ALLOWED_STATUS_TO_START
+                ):
+                    msg_step_start: str = "Invalid current STEP state to start."
+
+                    raise InvalidParameterValueException(msg_step_start)
+            case OperationAction.FAIL | OperationAction.SUCCEED:
+                if (
+                    current_state.status
+                    not in StepOperationValidator._ALLOWED_STATUS_TO_CLOSE
+                ):
+                    msg_step_close: str = "Invalid current STEP state to close."
+
+                    raise InvalidParameterValueException(msg_step_close)
+                if update.action == OperationAction.FAIL and update.payload is not None:
+                    msg_fail_payload: str = "Cannot provide a Payload for FAIL action."
+
+                    raise InvalidParameterValueException(msg_fail_payload)
+                if (
+                    update.action == OperationAction.SUCCEED
+                    and update.error is not None
+                ):
+                    msg_succeed_error: str = (
+                        "Cannot provide an Error for SUCCEED action."
+                    )
+
+                    raise InvalidParameterValueException(msg_succeed_error)
+            case OperationAction.RETRY:
+                if (
+                    current_state.status
+                    not in StepOperationValidator._ALLOWED_STATUS_TO_REATTEMPT
+                ):
+                    msg_step_retry: str = "Invalid current STEP state to re-attempt."
+
+                    raise InvalidParameterValueException(msg_step_retry)
+                if update.step_options is None:
+                    msg_step_options: str = "Invalid StepOptions for the given action."
+
+                    raise InvalidParameterValueException(msg_step_options)
+                if update.error is not None and update.payload is not None:
+                    msg_retry_both: str = (
+                        "Cannot provide both error and payload to RETRY a STEP."
+                    )
+                    raise InvalidParameterValueException(msg_retry_both)
+            case _:
+                msg_step_invalid: str = "Invalid STEP action."
+
+                raise InvalidParameterValueException(msg_step_invalid)

async_durable_execution_runner/checkpoint/validators/operations/wait.py

@@ -0,0 +1,54 @@
+"""Wait operation validator."""
+
+from __future__ import annotations
+
+from async_durable_execution.lambda_service import (
+    Operation,
+    OperationAction,
+    OperationStatus,
+    OperationUpdate,
+)
+
+from async_durable_execution_runner.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+VALID_ACTIONS_FOR_WAIT = frozenset(
+    [
+        OperationAction.START,
+        OperationAction.CANCEL,
+    ]
+)
+
+
+class WaitOperationValidator:
+    """Validates WAIT operation transitions."""
+
+    _ALLOWED_STATUS_TO_CANCEL = frozenset(
+        [
+            OperationStatus.STARTED,
+        ]
+    )
+
+    @staticmethod
+    def validate(current_state: Operation | None, update: OperationUpdate) -> None:
+        """Validate WAIT operation update."""
+        match update.action:
+            case OperationAction.START:
+                if current_state is not None:
+                    msg_wait_exists: str = "Cannot start a WAIT that already exist."
+
+                    raise InvalidParameterValueException(msg_wait_exists)
+            case OperationAction.CANCEL:
+                if (
+                    current_state is None
+                    or current_state.status
+                    not in WaitOperationValidator._ALLOWED_STATUS_TO_CANCEL
+                ):
+                    msg_wait_cancel: str = "Cannot cancel a WAIT that does not exist or has already completed."
+                    raise InvalidParameterValueException(msg_wait_cancel)
+            case _:
+                msg_wait_invalid: str = "Invalid WAIT action."
+
+                raise InvalidParameterValueException(msg_wait_invalid)

async_durable_execution_runner/checkpoint/validators/transitions.py

@@ -0,0 +1,66 @@
+"""Validator for valid actions by operation type."""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from async_durable_execution.lambda_service import (
+    OperationAction,
+    OperationType,
+)
+
+from async_durable_execution_runner.checkpoint.validators.operations.callback import (
+    VALID_ACTIONS_FOR_CALLBACK,
+)
+from async_durable_execution_runner.checkpoint.validators.operations.context import (
+    VALID_ACTIONS_FOR_CONTEXT,
+)
+from async_durable_execution_runner.checkpoint.validators.operations.execution import (
+    VALID_ACTIONS_FOR_EXECUTION,
+)
+from async_durable_execution_runner.checkpoint.validators.operations.invoke import (
+    VALID_ACTIONS_FOR_INVOKE,
+)
+from async_durable_execution_runner.checkpoint.validators.operations.step import (
+    VALID_ACTIONS_FOR_STEP,
+)
+from async_durable_execution_runner.checkpoint.validators.operations.wait import (
+    VALID_ACTIONS_FOR_WAIT,
+)
+from async_durable_execution_runner.exceptions import (
+    InvalidParameterValueException,
+)
+
+
+class ValidActionsByOperationTypeValidator:
+    """Validates that the given action is valid for the given operation type."""
+
+    _VALID_ACTIONS_BY_OPERATION_TYPE: ClassVar[
+        dict[OperationType, frozenset[OperationAction]]
+    ] = {
+        OperationType.STEP: VALID_ACTIONS_FOR_STEP,
+        OperationType.CONTEXT: VALID_ACTIONS_FOR_CONTEXT,
+        OperationType.WAIT: VALID_ACTIONS_FOR_WAIT,
+        OperationType.CALLBACK: VALID_ACTIONS_FOR_CALLBACK,
+        OperationType.CHAINED_INVOKE: VALID_ACTIONS_FOR_INVOKE,
+        OperationType.EXECUTION: VALID_ACTIONS_FOR_EXECUTION,
+    }
+
+    @staticmethod
+    def validate(operation_type: OperationType, action: OperationAction) -> None:
+        """Validate that the action is valid for the operation type."""
+        valid_actions = (
+            ValidActionsByOperationTypeValidator._VALID_ACTIONS_BY_OPERATION_TYPE.get(
+                operation_type
+            )
+        )
+
+        if valid_actions is None:
+            msg_unknown_op: str = "Unknown operation type."
+
+            raise InvalidParameterValueException(msg_unknown_op)
+
+        if action not in valid_actions:
+            msg_invalid_action: str = "Invalid action for the given operation type."
+
+            raise InvalidParameterValueException(msg_invalid_action)