aws-durable-execution-sdk-python 1.0.0__py3-none-any.whl

aws_durable_execution_sdk_python/operation/parallel.py

@@ -0,0 +1,122 @@
+"""Implementation for Durable Parallel operation."""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, TypeVar
+
+from aws_durable_execution_sdk_python.concurrency.executor import ConcurrentExecutor
+from aws_durable_execution_sdk_python.concurrency.models import Executable
+from aws_durable_execution_sdk_python.config import ParallelConfig
+from aws_durable_execution_sdk_python.lambda_service import OperationSubType
+
+if TYPE_CHECKING:
+    from aws_durable_execution_sdk_python.concurrency.models import BatchResult
+    from aws_durable_execution_sdk_python.context import DurableContext
+    from aws_durable_execution_sdk_python.identifier import OperationIdentifier
+    from aws_durable_execution_sdk_python.serdes import SerDes
+    from aws_durable_execution_sdk_python.state import ExecutionState
+    from aws_durable_execution_sdk_python.types import SummaryGenerator
+
+logger = logging.getLogger(__name__)
+
+# Result type
+R = TypeVar("R")
+
+
+class ParallelExecutor(ConcurrentExecutor[Callable, R]):
+    def __init__(
+        self,
+        executables: list[Executable[Callable]],
+        max_concurrency: int | None,
+        completion_config,
+        top_level_sub_type: OperationSubType,
+        iteration_sub_type: OperationSubType,
+        name_prefix: str,
+        serdes: SerDes | None,
+        summary_generator: SummaryGenerator | None = None,
+        item_serdes: SerDes | None = None,
+    ):
+        super().__init__(
+            executables=executables,
+            max_concurrency=max_concurrency,
+            completion_config=completion_config,
+            sub_type_top=top_level_sub_type,
+            sub_type_iteration=iteration_sub_type,
+            name_prefix=name_prefix,
+            serdes=serdes,
+            summary_generator=summary_generator,
+            item_serdes=item_serdes,
+        )
+
+    @classmethod
+    def from_callables(
+        cls,
+        callables: Sequence[Callable],
+        config: ParallelConfig,
+    ) -> ParallelExecutor:
+        """Create ParallelExecutor from a sequence of callables."""
+        executables: list[Executable[Callable]] = [
+            Executable(index=i, func=func) for i, func in enumerate(callables)
+        ]
+        return cls(
+            executables=executables,
+            max_concurrency=config.max_concurrency,
+            completion_config=config.completion_config,
+            top_level_sub_type=OperationSubType.PARALLEL,
+            iteration_sub_type=OperationSubType.PARALLEL_BRANCH,
+            name_prefix="parallel-branch-",
+            serdes=config.serdes,
+            summary_generator=config.summary_generator,
+            item_serdes=config.item_serdes,
+        )
+
+    def execute_item(self, child_context, executable: Executable[Callable]) -> R:  # noqa: PLR6301
+        logger.debug("🔀 Processing parallel branch: %s", executable.index)
+        result: R = executable.func(child_context)
+        logger.debug("✅ Processed parallel branch: %s", executable.index)
+        return result
+
+
+def parallel_handler(
+    callables: Sequence[Callable],
+    config: ParallelConfig | None,
+    execution_state: ExecutionState,
+    parallel_context: DurableContext,
+    operation_identifier: OperationIdentifier,
+) -> BatchResult[R]:
+    """Execute multiple operations in parallel."""
+    # Summary Generator Construction (matches TypeScript implementation):
+    # Construct the summary generator at the handler level, just like TypeScript does in parallel-handler.ts.
+    # This matches the pattern where handlers are responsible for configuring operation-specific behavior.
+    #
+    # See TypeScript reference: aws-durable-execution-sdk-js/src/handlers/parallel-handler/parallel-handler.ts (~line 112)
+
+    executor = ParallelExecutor.from_callables(
+        callables,
+        config or ParallelConfig(summary_generator=ParallelSummaryGenerator()),
+    )
+
+    checkpoint = execution_state.get_checkpoint_result(
+        operation_identifier.operation_id
+    )
+    if checkpoint.is_succeeded():
+        return executor.replay(execution_state, parallel_context)
+    return executor.execute(execution_state, executor_context=parallel_context)
+
+
+class ParallelSummaryGenerator:
+    def __call__(self, result: BatchResult) -> str:
+        fields = {
+            "totalCount": result.total_count,
+            "successCount": result.success_count,
+            "failureCount": result.failure_count,
+            "completionReason": result.completion_reason.value,
+            "status": result.status.value,
+            "startedCount": result.started_count,
+            "type": "ParallelResult",
+        }
+
+        return json.dumps(fields)

aws_durable_execution_sdk_python/operation/step.py

@@ -0,0 +1,269 @@
+"""Implement the Durable step operation."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, TypeVar
+
+from aws_durable_execution_sdk_python.config import (
+    StepConfig,
+    StepSemantics,
+)
+from aws_durable_execution_sdk_python.exceptions import (
+    ExecutionError,
+    StepInterruptedError,
+)
+from aws_durable_execution_sdk_python.lambda_service import (
+    ErrorObject,
+    OperationUpdate,
+)
+from aws_durable_execution_sdk_python.logger import Logger, LogInfo
+from aws_durable_execution_sdk_python.retries import RetryDecision, RetryPresets
+from aws_durable_execution_sdk_python.serdes import deserialize, serialize
+from aws_durable_execution_sdk_python.suspend import (
+    suspend_with_optional_resume_delay,
+    suspend_with_optional_resume_timestamp,
+)
+from aws_durable_execution_sdk_python.types import StepContext
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from aws_durable_execution_sdk_python.identifier import OperationIdentifier
+    from aws_durable_execution_sdk_python.state import (
+        CheckpointedResult,
+        ExecutionState,
+    )
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+def step_handler(
+    func: Callable[[StepContext], T],
+    state: ExecutionState,
+    operation_identifier: OperationIdentifier,
+    config: StepConfig | None,
+    context_logger: Logger,
+) -> T:
+    logger.debug(
+        "▶️ Executing step for id: %s, name: %s",
+        operation_identifier.operation_id,
+        operation_identifier.name,
+    )
+
+    if not config:
+        config = StepConfig()
+
+    checkpointed_result: CheckpointedResult = state.get_checkpoint_result(
+        operation_identifier.operation_id
+    )
+    if checkpointed_result.is_succeeded():
+        logger.debug(
+            "Step already completed, skipping execution for id: %s, name: %s",
+            operation_identifier.operation_id,
+            operation_identifier.name,
+        )
+        if checkpointed_result.result is None:
+            return None  # type: ignore
+
+        return deserialize(
+            serdes=config.serdes,
+            data=checkpointed_result.result,
+            operation_id=operation_identifier.operation_id,
+            durable_execution_arn=state.durable_execution_arn,
+        )
+
+    if checkpointed_result.is_failed():
+        # have to throw the exact same error on replay as the checkpointed failure
+        checkpointed_result.raise_callable_error()
+
+    if checkpointed_result.is_pending():
+        scheduled_timestamp = checkpointed_result.get_next_attempt_timestamp()
+        # normally, we'd ensure that a suspension here would be for > 0 seconds;
+        # however, this is coming from a checkpoint, and we can trust that it is a correct target timestamp.
+        suspend_with_optional_resume_timestamp(
+            msg=f"Retry scheduled for {operation_identifier.name or operation_identifier.operation_id} will retry at timestamp {scheduled_timestamp}",
+            datetime_timestamp=scheduled_timestamp,
+        )
+
+    if (
+        checkpointed_result.is_started()
+        and config.step_semantics is StepSemantics.AT_MOST_ONCE_PER_RETRY
+    ):
+        # step was previously interrupted
+        msg = f"Step operation_id={operation_identifier.operation_id} name={operation_identifier.name} was previously interrupted"
+        retry_handler(
+            StepInterruptedError(msg),
+            state,
+            operation_identifier,
+            config,
+            checkpointed_result,
+        )
+
+        checkpointed_result.raise_callable_error()
+
+    if not (
+        checkpointed_result.is_started()
+        and config.step_semantics is StepSemantics.AT_LEAST_ONCE_PER_RETRY
+    ):
+        # Do not checkpoint start for started & AT_LEAST_ONCE execution
+        # Checkpoint start for the other
+        start_operation: OperationUpdate = OperationUpdate.create_step_start(
+            identifier=operation_identifier,
+        )
+        # Checkpoint START operation with appropriate synchronization:
+        # - AtMostOncePerRetry: Use blocking checkpoint (is_sync=True) to prevent duplicate execution.
+        #   The step must not execute until the START checkpoint is persisted, ensuring exactly-once semantics.
+        # - AtLeastOncePerRetry: Use non-blocking checkpoint (is_sync=False) for performance optimization.
+        #   The step can execute immediately without waiting for checkpoint persistence, allowing at-least-once semantics.
+        is_sync: bool = config.step_semantics is StepSemantics.AT_MOST_ONCE_PER_RETRY
+        state.create_checkpoint(operation_update=start_operation, is_sync=is_sync)
+
+    attempt: int = 0
+    if checkpointed_result.operation and checkpointed_result.operation.step_details:
+        attempt = checkpointed_result.operation.step_details.attempt
+
+    step_context = StepContext(
+        logger=context_logger.with_log_info(
+            LogInfo.from_operation_identifier(
+                execution_state=state,
+                op_id=operation_identifier,
+                attempt=attempt,
+            )
+        )
+    )
+    try:
+        # this is the actual code provided by the caller to execute durably inside the step
+        raw_result: T = func(step_context)
+        serialized_result: str = serialize(
+            serdes=config.serdes,
+            value=raw_result,
+            operation_id=operation_identifier.operation_id,
+            durable_execution_arn=state.durable_execution_arn,
+        )
+
+        success_operation: OperationUpdate = OperationUpdate.create_step_succeed(
+            identifier=operation_identifier,
+            payload=serialized_result,
+        )
+
+        # Checkpoint SUCCEED operation with blocking (is_sync=True, default).
+        # Must ensure the success state is persisted before returning the result to the caller.
+        # This guarantees the step result is durable and won't be lost if Lambda terminates.
+        state.create_checkpoint(operation_update=success_operation)
+
+        logger.debug(
+            "✅ Successfully completed step for id: %s, name: %s",
+            operation_identifier.operation_id,
+            operation_identifier.name,
+        )
+        return raw_result  # noqa: TRY300
+    except Exception as e:
+        if isinstance(e, ExecutionError):
+            # no retry on fatal - e.g checkpoint exception
+            logger.debug(
+                "💥 Fatal error for id: %s, name: %s",
+                operation_identifier.operation_id,
+                operation_identifier.name,
+            )
+            # this bubbles up to execution.durable_execution, where it will exit with FAILED
+            raise
+
+        logger.exception(
+            "❌ failed step for id: %s, name: %s",
+            operation_identifier.operation_id,
+            operation_identifier.name,
+        )
+
+        retry_handler(e, state, operation_identifier, config, checkpointed_result)
+        # if we've failed to raise an exception from the retry_handler, then we are in a
+        # weird state, and should crash terminate the execution
+        msg = "retry handler should have raised an exception, but did not."
+        raise ExecutionError(msg) from None
+
+
+# TODO: I don't much like this func, needs refactor. Messy grab-bag of args, refine.
+def retry_handler(
+    error: Exception,
+    state: ExecutionState,
+    operation_identifier: OperationIdentifier,
+    config: StepConfig,
+    checkpointed_result: CheckpointedResult,
+):
+    """Checkpoint and suspend for replay if retry required, otherwise raise error."""
+    error_object = ErrorObject.from_exception(error)
+
+    retry_strategy = config.retry_strategy or RetryPresets.default()
+
+    retry_attempt: int = (
+        checkpointed_result.operation.step_details.attempt
+        if (
+            checkpointed_result.operation and checkpointed_result.operation.step_details
+        )
+        else 0
+    )
+    retry_decision: RetryDecision = retry_strategy(error, retry_attempt + 1)
+
+    if retry_decision.should_retry:
+        logger.debug(
+            "Retrying step for id: %s, name: %s, attempt: %s",
+            operation_identifier.operation_id,
+            operation_identifier.name,
+            retry_attempt + 1,
+        )
+
+        # because we are issuing a retry and create an OperationUpdate
+        # we enforce a minimum delay second of 1, to match model behaviour.
+        # we localize enforcement and keep it outside suspension methods as:
+        # a) those are used throughout the codebase, e.g. in wait(..) <- enforcement is done in context
+        # b) they shouldn't know model specific details <- enforcement is done above
+        # and c) this "issue" arises from retry-decision and we shouldn't push it down
+        delay_seconds = retry_decision.delay_seconds
+        if delay_seconds < 1:
+            logger.warning(
+                (
+                    "Retry delay_seconds step for id: %s, name: %s,"
+                    "attempt: %s is %d < 1. Setting to minimum of 1 seconds."
+                ),
+                operation_identifier.operation_id,
+                operation_identifier.name,
+                retry_attempt + 1,
+                delay_seconds,
+            )
+            delay_seconds = 1
+
+        retry_operation: OperationUpdate = OperationUpdate.create_step_retry(
+            identifier=operation_identifier,
+            error=error_object,
+            next_attempt_delay_seconds=delay_seconds,
+        )
+
+        # Checkpoint RETRY operation with blocking (is_sync=True, default).
+        # Must ensure retry state is persisted before suspending execution.
+        # This guarantees the retry attempt count and next attempt timestamp are durable.
+        state.create_checkpoint(operation_update=retry_operation)
+
+        suspend_with_optional_resume_delay(
+            msg=(
+                f"Retry scheduled for {operation_identifier.operation_id}"
+                f"in {retry_decision.delay_seconds} seconds"
+            ),
+            delay_seconds=delay_seconds,
+        )
+
+    # no retry
+    fail_operation: OperationUpdate = OperationUpdate.create_step_fail(
+        identifier=operation_identifier, error=error_object
+    )
+
+    # Checkpoint FAIL operation with blocking (is_sync=True, default).
+    # Must ensure the failure state is persisted before raising the exception.
+    # This guarantees the error is durable and the step won't be retried on replay.
+    state.create_checkpoint(operation_update=fail_operation)
+
+    if isinstance(error, StepInterruptedError):
+        raise error
+
+    raise error_object.to_callable_runtime_error()

aws_durable_execution_sdk_python/operation/wait.py

@@ -0,0 +1,53 @@
+"""Implement the durable wait operation."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from aws_durable_execution_sdk_python.lambda_service import OperationUpdate, WaitOptions
+from aws_durable_execution_sdk_python.suspend import suspend_with_optional_resume_delay
+
+if TYPE_CHECKING:
+    from aws_durable_execution_sdk_python.identifier import OperationIdentifier
+    from aws_durable_execution_sdk_python.state import (
+        CheckpointedResult,
+        ExecutionState,
+    )
+
+logger = logging.getLogger(__name__)
+
+
+def wait_handler(
+    seconds: int, state: ExecutionState, operation_identifier: OperationIdentifier
+) -> None:
+    logger.debug(
+        "Wait requested for id: %s, name: %s",
+        operation_identifier.operation_id,
+        operation_identifier.name,
+    )
+
+    checkpointed_result: CheckpointedResult = state.get_checkpoint_result(
+        operation_identifier.operation_id
+    )
+
+    if checkpointed_result.is_succeeded():
+        logger.debug(
+            "Wait already completed, skipping wait for id: %s, name: %s",
+            operation_identifier.operation_id,
+            operation_identifier.name,
+        )
+        return
+
+    if not checkpointed_result.is_existent():
+        operation = OperationUpdate.create_wait_start(
+            identifier=operation_identifier,
+            wait_options=WaitOptions(wait_seconds=seconds),
+        )
+        # Checkpoint wait START with blocking (is_sync=True, default).
+        # Must ensure the wait operation and scheduled timestamp are persisted before suspending.
+        # This guarantees the wait will resume at the correct time on the next invocation.
+        state.create_checkpoint(operation_update=operation)
+
+    msg = f"Wait for {seconds} seconds"
+    suspend_with_optional_resume_delay(msg, seconds)  # throws suspend

aws_durable_execution_sdk_python/operation/wait_for_condition.py

@@ -0,0 +1,235 @@
+"""Implement the durable wait_for_condition operation."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, TypeVar
+
+from aws_durable_execution_sdk_python.exceptions import (
+    ExecutionError,
+)
+from aws_durable_execution_sdk_python.lambda_service import (
+    ErrorObject,
+    OperationUpdate,
+)
+from aws_durable_execution_sdk_python.logger import LogInfo
+from aws_durable_execution_sdk_python.serdes import deserialize, serialize
+from aws_durable_execution_sdk_python.suspend import (
+    suspend_with_optional_resume_delay,
+    suspend_with_optional_resume_timestamp,
+)
+from aws_durable_execution_sdk_python.types import WaitForConditionCheckContext
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from aws_durable_execution_sdk_python.identifier import OperationIdentifier
+    from aws_durable_execution_sdk_python.logger import Logger
+    from aws_durable_execution_sdk_python.state import (
+        CheckpointedResult,
+        ExecutionState,
+    )
+    from aws_durable_execution_sdk_python.waits import (
+        WaitForConditionConfig,
+        WaitForConditionDecision,
+    )
+
+
+T = TypeVar("T")
+
+logger = logging.getLogger(__name__)
+
+
+def wait_for_condition_handler(
+    check: Callable[[T, WaitForConditionCheckContext], T],
+    config: WaitForConditionConfig[T],
+    state: ExecutionState,
+    operation_identifier: OperationIdentifier,
+    context_logger: Logger,
+) -> T:
+    """Handle wait_for_condition operation.
+
+    wait_for_condition creates a STEP checkpoint.
+    """
+    logger.debug(
+        "▶️ Executing wait_for_condition for id: %s, name: %s",
+        operation_identifier.operation_id,
+        operation_identifier.name,
+    )
+
+    checkpointed_result: CheckpointedResult = state.get_checkpoint_result(
+        operation_identifier.operation_id
+    )
+
+    # Check if already completed
+    if checkpointed_result.is_succeeded():
+        logger.debug(
+            "wait_for_condition already completed for id: %s, name: %s",
+            operation_identifier.operation_id,
+            operation_identifier.name,
+        )
+        if checkpointed_result.result is None:
+            return None  # type: ignore
+        return deserialize(
+            serdes=config.serdes,
+            data=checkpointed_result.result,
+            operation_id=operation_identifier.operation_id,
+            durable_execution_arn=state.durable_execution_arn,
+        )
+
+    if checkpointed_result.is_failed():
+        checkpointed_result.raise_callable_error()
+
+    if checkpointed_result.is_pending():
+        scheduled_timestamp = checkpointed_result.get_next_attempt_timestamp()
+        suspend_with_optional_resume_timestamp(
+            msg=f"wait_for_condition {operation_identifier.name or operation_identifier.operation_id} will retry at timestamp {scheduled_timestamp}",
+            datetime_timestamp=scheduled_timestamp,
+        )
+
+    attempt: int = 1
+    if checkpointed_result.is_started_or_ready():
+        # This is a retry - get state from previous checkpoint
+        if checkpointed_result.result:
+            try:
+                current_state = deserialize(
+                    serdes=config.serdes,
+                    data=checkpointed_result.result,
+                    operation_id=operation_identifier.operation_id,
+                    durable_execution_arn=state.durable_execution_arn,
+                )
+            except Exception:
+                # default to initial state if there's an error getting checkpointed state
+                logger.exception(
+                    "⚠️ wait_for_condition failed to deserialize state for id: %s, name: %s. Using initial state.",
+                    operation_identifier.operation_id,
+                    operation_identifier.name,
+                )
+                current_state = config.initial_state
+        else:
+            current_state = config.initial_state
+
+        # at this point operation has to exist. Nonetheless, just in case somehow it's not there.
+        if checkpointed_result.operation and checkpointed_result.operation.step_details:
+            attempt = checkpointed_result.operation.step_details.attempt
+    else:
+        # First execution
+        current_state = config.initial_state
+
+    # Checkpoint START for observability.
+    if not checkpointed_result.is_started():
+        start_operation: OperationUpdate = (
+            OperationUpdate.create_wait_for_condition_start(
+                identifier=operation_identifier,
+            )
+        )
+        # Checkpoint wait_for_condition START with non-blocking (is_sync=False).
+        # This is purely for observability - we don't need to wait for persistence before
+        # executing the check function. The START checkpoint just records that polling began.
+        state.create_checkpoint(operation_update=start_operation, is_sync=False)
+
+    try:
+        # Execute the check function with the injected logger
+        check_context = WaitForConditionCheckContext(
+            logger=context_logger.with_log_info(
+                LogInfo.from_operation_identifier(
+                    execution_state=state,
+                    op_id=operation_identifier,
+                    attempt=attempt,
+                )
+            )
+        )
+
+        new_state = check(current_state, check_context)
+
+        # Check if condition is met with the wait strategy
+        decision: WaitForConditionDecision = config.wait_strategy(new_state, attempt)
+
+        serialized_state = serialize(
+            serdes=config.serdes,
+            value=new_state,
+            operation_id=operation_identifier.operation_id,
+            durable_execution_arn=state.durable_execution_arn,
+        )
+
+        logger.debug(
+            "wait_for_condition check completed: %s, name: %s, attempt: %s",
+            operation_identifier.operation_id,
+            operation_identifier.name,
+            attempt,
+        )
+
+        if not decision.should_continue:
+            # Condition is met - complete successfully
+            success_operation = OperationUpdate.create_wait_for_condition_succeed(
+                identifier=operation_identifier,
+                payload=serialized_state,
+            )
+            # Checkpoint SUCCEED operation with blocking (is_sync=True, default).
+            # Must ensure the final state is persisted before returning to the caller.
+            # This guarantees the condition result is durable and won't be re-evaluated on replay.
+            state.create_checkpoint(operation_update=success_operation)
+
+            logger.debug(
+                "✅ wait_for_condition completed for id: %s, name: %s",
+                operation_identifier.operation_id,
+                operation_identifier.name,
+            )
+            return new_state
+
+        # Condition not met - schedule retry
+        # we enforce a minimum delay second of 1, to match model behaviour.
+        # we localize enforcement and keep it outside suspension methods as:
+        # a) those are used throughout the codebase, e.g. in wait(..) <- enforcement is done in context
+        # b) they shouldn't know model specific details <- enforcement is done above
+        # and c) this "issue" arises from retry-decision and shouldn't be chased deeper.
+        delay_seconds = decision.delay_seconds
+        if delay_seconds is not None and delay_seconds < 1:
+            logger.warning(
+                (
+                    "WaitDecision delay_seconds step for id: %s, name: %s,"
+                    "is %d < 1. Setting to minimum of 1 seconds."
+                ),
+                operation_identifier.operation_id,
+                operation_identifier.name,
+                delay_seconds,
+            )
+            delay_seconds = 1
+
+        retry_operation = OperationUpdate.create_wait_for_condition_retry(
+            identifier=operation_identifier,
+            payload=serialized_state,
+            next_attempt_delay_seconds=delay_seconds,
+        )
+
+        # Checkpoint RETRY operation with blocking (is_sync=True, default).
+        # Must ensure the current state and next attempt timestamp are persisted before suspending.
+        # This guarantees the polling state is durable and will resume correctly on the next invocation.
+        state.create_checkpoint(operation_update=retry_operation)
+
+        suspend_with_optional_resume_delay(
+            msg=f"wait_for_condition {operation_identifier.name or operation_identifier.operation_id} will retry in {decision.delay_seconds} seconds",
+            delay_seconds=decision.delay_seconds,
+        )
+
+    except Exception as e:
+        # Mark as failed - waitForCondition doesn't have its own retry logic for errors
+        # If the check function throws, it's considered a failure
+        logger.exception(
+            "❌ wait_for_condition failed for id: %s, name: %s",
+            operation_identifier.operation_id,
+            operation_identifier.name,
+        )
+
+        fail_operation = OperationUpdate.create_wait_for_condition_fail(
+            identifier=operation_identifier,
+            error=ErrorObject.from_exception(e),
+        )
+        # Checkpoint FAIL operation with blocking (is_sync=True, default).
+        # Must ensure the failure state is persisted before raising the exception.
+        # This guarantees the error is durable and the condition won't be re-evaluated on replay.
+        state.create_checkpoint(operation_update=fail_operation)
+        raise
+
+    msg: str = "wait_for_condition should never reach this point"  # pragma: no cover
+    raise ExecutionError(msg)  # pragma: no cover

aws_durable_execution_sdk_python/py.typed

@@ -0,0 +1 @@
+# Marker file that indicates this package supports typing