aws-durable-execution-sdk-python 1.5.0__tar.gz → 1.6.0__tar.gz

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/.gitignore

@@ -9,6 +9,7 @@ __pycache__/
 *$py.class
 *.egg-info/
 
+*.coverage
 /.coverage
 /.coverage.*
 /.cache
@@ -30,7 +31,7 @@ dist/
 
 .kiro/
 
-/examples/build/*
-/examples/*.zip
+**/build/
+**/*.zip
 
 .env

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/PKG-INFO

@@ -1,14 +1,12 @@
 Metadata-Version: 2.4
 Name: aws-durable-execution-sdk-python
-Version: 1.5.0
+Version: 1.6.0
 Summary: AWS Durable Execution SDK for Python
 Project-URL: Documentation, https://github.com/aws/aws-durable-execution-sdk-python#readme
 Project-URL: Issues, https://github.com/aws/aws-durable-execution-sdk-python/issues
 Project-URL: Source, https://github.com/aws/aws-durable-execution-sdk-python
 Author-email: AWS durable-execution-dev <durable-execution-dev@amazon.com>
 License-Expression: Apache-2.0
-License-File: LICENSE
-License-File: NOTICE
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.11
@@ -27,7 +25,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Version](https://img.shields.io/pypi/v/aws-durable-execution-sdk-python.svg)](https://pypi.org/project/aws-durable-execution-sdk-python)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aws-durable-execution-sdk-python.svg)](https://pypi.org/project/aws-durable-execution-sdk-python)
 [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/aws/aws-durable-execution-sdk-python/badge)](https://scorecard.dev/viewer/?uri=github.com/aws/aws-durable-execution-sdk-python)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/aws/aws-durable-execution-sdk-python/blob/main/LICENSE)
 
 -----
 
@@ -105,4 +103,4 @@ The complete documentation for the AWS Durable Execution SDK for Python lives on
 
 ## 📄 License
 
-See the [LICENSE](LICENSE) file for our project's licensing.
+See the [LICENSE](https://github.com/aws/aws-durable-execution-sdk-python/blob/main/LICENSE) file for our project's licensing.

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/README.md

@@ -4,7 +4,7 @@
 [![PyPI - Version](https://img.shields.io/pypi/v/aws-durable-execution-sdk-python.svg)](https://pypi.org/project/aws-durable-execution-sdk-python)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aws-durable-execution-sdk-python.svg)](https://pypi.org/project/aws-durable-execution-sdk-python)
 [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/aws/aws-durable-execution-sdk-python/badge)](https://scorecard.dev/viewer/?uri=github.com/aws/aws-durable-execution-sdk-python)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/aws/aws-durable-execution-sdk-python/blob/main/LICENSE)
 
 -----
 
@@ -82,4 +82,4 @@ The complete documentation for the AWS Durable Execution SDK for Python lives on
 
 ## 📄 License
 
-See the [LICENSE](LICENSE) file for our project's licensing.
+See the [LICENSE](https://github.com/aws/aws-durable-execution-sdk-python/blob/main/LICENSE) file for our project's licensing.

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/pyproject.toml

@@ -28,49 +28,20 @@ Documentation = "https://github.com/aws/aws-durable-execution-sdk-python#readme"
 Issues = "https://github.com/aws/aws-durable-execution-sdk-python/issues"
 Source = "https://github.com/aws/aws-durable-execution-sdk-python"
 
+[tool.hatch.build.targets.sdist.force-include]
+"../../LICENSE" = "LICENSE"
+"../../NOTICE" = "NOTICE"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/aws_durable_execution_sdk_python"]
 
+[tool.hatch.build.targets.wheel.force-include]
+"../../LICENSE" = "aws_durable_execution_sdk_python/LICENSE"
+"../../NOTICE" = "aws_durable_execution_sdk_python/NOTICE"
+
 [tool.hatch.version]
 path = "src/aws_durable_execution_sdk_python/__about__.py"
 
-[tool.hatch.envs.test]
-dependencies = [
-  "coverage[toml]",
-  "pytest",
-  "pytest-cov",
-  "aws-durable-execution-sdk-python-testing>=1.0.0",
-]
-
-[tool.hatch.envs.test.scripts]
-examples = "pytest --runner-mode=local -m example examples/test/ -v"
-examples-integration = "pytest --runner-mode=cloud -m example examples/test/ -v {args}"
-cov = "pytest --cov-report=term-missing --cov-config=pyproject.toml --cov=src/aws_durable_execution_sdk_python --cov-fail-under=98"
-
-[tool.hatch.envs.types]
-extra-dependencies = ["mypy>=1.0.0", "pytest", "boto3-stubs[lambda]"]
-
-[tool.hatch.envs.types.scripts]
-check = "mypy --install-types --non-interactive {args:src/aws_durable_execution_sdk_python tests}"
-
-[tool.hatch.envs.examples]
-dependencies = [
-  "aws-durable-execution-sdk-python-testing>=1.0.0",
-]
-
-[tool.hatch.envs.examples.scripts]
-cli = "python examples/cli.py {args}"
-bootstrap = "python examples/cli.py bootstrap"
-generate-sam-template = "python examples/scripts/generate_sam_template.py"
-build = "python examples/cli.py build"
-deploy = "python examples/cli.py deploy {args}"
-invoke = "python examples/cli.py invoke {args}"
-get = "python examples/cli.py get {args}"
-history = "python examples/cli.py history {args}"
-policy = "python examples/cli.py policy {args}"
-list = "python examples/cli.py list"
-clean = "rm -rf examples/build examples/.aws-sam examples/*.zip"
-
 [tool.coverage.run]
 source_pkgs = ["aws_durable_execution_sdk_python"]
 branch = true
@@ -110,25 +81,3 @@ lines-after-imports = 2
   "SIM117",
   "TRY301",
 ]
-"examples/test/**" = [
-  "ARG001",
-  "ARG002",
-  "ARG005",
-  "S101",
-  "PLR2004",
-  "SIM117",
-  "TRY301",
-]
-
-[tool.pytest.ini_options]
-# Declare custom markers to avoid warnings with --strict-markers
-markers = [
-  # Used for test selection with -m example
-  "example: marks tests as example tests (deselect with '-m \"not example\"')",
-  # Used for configuration - passes handler and lambda_function_name to durable_runner fixture
-  "durable_execution: marks tests that use the durable_runner fixture (not used for test selection)",
-]
-# Default test discovery paths
-testpaths = ["tests"]
-# Default options for all test runs
-addopts = "-v --strict-markers"

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/src/aws_durable_execution_sdk_python/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Amazon.com, Inc. or its affiliates.
 #
 # SPDX-License-Identifier: Apache-2.0
-__version__ = "1.5.0"
+__version__ = "1.6.0"

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/src/aws_durable_execution_sdk_python/__init__.py

@@ -25,6 +25,7 @@ from aws_durable_execution_sdk_python.exceptions import (
 
 # Core decorator - used in every durable function
 from aws_durable_execution_sdk_python.execution import durable_execution
+from aws_durable_execution_sdk_python.retries import WithRetryConfig, with_retry
 
 # Essential context types - passed to user functions
 from aws_durable_execution_sdk_python.types import StepContext
@@ -38,10 +39,12 @@ __all__ = [
     "ParallelBranch",
     "StepContext",
     "ValidationError",
+    "WithRetryConfig",
     "__version__",
     "durable_execution",
     "durable_parallel_branch",
     "durable_step",
     "durable_wait_for_callback",
     "durable_with_child_context",
+    "with_retry",
 ]

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/src/aws_durable_execution_sdk_python/concurrency/executor.py

@@ -30,7 +30,7 @@ from aws_durable_execution_sdk_python.exceptions import (
     TimedSuspendExecution,
 )
 from aws_durable_execution_sdk_python.identifier import OperationIdentifier
-from aws_durable_execution_sdk_python.lambda_service import ErrorObject
+from aws_durable_execution_sdk_python.lambda_service import ErrorObject, OperationType
 from aws_durable_execution_sdk_python.operation.child import child_handler
 
 
@@ -59,7 +59,7 @@ class TimerScheduler:
     """Manage timed suspend tasks with a background timer thread."""
 
     def __init__(
-        self, resubmit_callback: Callable[[ExecutableWithState], None]
+        self, resubmit_callback: Callable[[list[ExecutableWithState]], None]
     ) -> None:
         self.resubmit_callback = resubmit_callback
         self._pending_resumes: list[tuple[float, int, ExecutableWithState]] = []
@@ -114,18 +114,31 @@ class TimerScheduler:
 
             current_time = time.time()
             if current_time >= next_resume_time:
-                # Time to resume
+                # Drain every due resume under the lock, transitioning each to
+                # PENDING atomically with the pop. Keeping pop+reset_to_pending
+                # together is required: should_execution_suspend reads branch
+                # status without this lock, so an item that is removed from the
+                # heap but still SUSPENDED_WITH_TIMEOUT could trigger a spurious
+                # parent suspend.
+                ready: list[ExecutableWithState] = []
                 with self._lock:
-                    # no branch cover because hard to test reliably - this is a double-safety check if heap mutated
-                    # since the first peek on next_resume_time further up
-                    if (  # pragma: no branch
+                    while (
                         self._pending_resumes
                         and self._pending_resumes[0][0] <= current_time
                     ):
                         _, _, exe_state = heapq.heappop(self._pending_resumes)
                         if exe_state.can_resume:
                             exe_state.reset_to_pending()
-                            self.resubmit_callback(exe_state)
+                            ready.append(exe_state)
+                # Resubmit outside the lock. Only the heap pop and the PENDING
+                # transition need the lock. The checkpoint refresh is a blocking
+                # network call and the submit hands work to the pool, so running
+                # them off the lock keeps timed resumes from serializing behind
+                # the network round trip and keeps the timer thread from
+                # re-entering this non-reentrant lock when a submitted future
+                # completes inline and its done-callback calls schedule_resume.
+                if ready:
+                    self.resubmit_callback(ready)
             else:
                 # Wait until next resume time
                 wait_time = min(next_resume_time - current_time, 0.1)
@@ -169,6 +182,7 @@ class ConcurrentExecutor(ABC, Generic[CallableType, ResultType]):
         # Event-driven state tracking for when the executor is done
         self._completion_event = threading.Event()
         self._suspend_exception: SuspendExecution | None = None
+        self._resume_error: Exception | None = None
 
         # ExecutionCounters will keep track of completion criteria and on-going counters
         min_successful = self.completion_config.min_successful or len(self.executables)
@@ -222,11 +236,32 @@ class ConcurrentExecutor(ABC, Generic[CallableType, ResultType]):
         ]
         self._completion_event.clear()
         self._suspend_exception = None
-
-        def resubmitter(executable_with_state: ExecutableWithState) -> None:
-            """Resubmit a timed suspended task."""
-            execution_state.create_checkpoint()
-            submit_task(executable_with_state)
+        self._resume_error = None
+
+        def resubmitter(ready: list[ExecutableWithState]) -> None:
+            """Resubmit a wave of timed-suspended tasks.
+
+            One checkpoint refresh serves the whole due wave: the fetch returns
+            all operations, so every resumed branch reads fresh state. The
+            refresh only raises when the background checkpoint subsystem has
+            failed, which is terminal for the whole execution, so record the
+            error and wake the parent to re-raise it. Catching here keeps the
+            single timer thread alive so a failure does not strand the other
+            pending resumes.
+            """
+            try:
+                execution_state.create_checkpoint()
+            except Exception as exc:  # noqa: BLE001
+                # resubmitter runs only on the single timer thread, so this
+                # check-then-set needs no lock. First error wins: keep the
+                # earliest failure if several waves fail before execute() reads
+                # it (they are the same terminal checkpoint failure anyway).
+                if self._resume_error is None:  # pragma: no branch
+                    self._resume_error = exc
+                self._completion_event.set()
+                return
+            for executable_with_state in ready:
+                submit_task(executable_with_state)
 
         thread_executor = ThreadPoolExecutor(max_workers=max_workers)
         try:
@@ -259,6 +294,12 @@ class ConcurrentExecutor(ABC, Generic[CallableType, ResultType]):
                 for future in futures:
                     future.cancel()
 
+                # A timed resume failed to refresh state (terminal checkpoint
+                # subsystem failure). Re-raise so the invocation fails and the
+                # backend retries from the last durable checkpoint.
+                if self._resume_error is not None:
+                    raise self._resume_error
+
                 # Suspend execution if everything done and at least one of the tasks raised a suspend exception.
                 if self._suspend_exception:
                     raise self._suspend_exception
@@ -428,9 +469,10 @@ class ConcurrentExecutor(ABC, Generic[CallableType, ResultType]):
         # For FLAT `child_handler` skips checkpoints, so not used.
         # Construct it unconditionally to keep the call simple.
         operation_identifier = OperationIdentifier(
-            operation_id,
-            executor_context._parent_id,  # noqa: SLF001
-            name,
+            operation_id=operation_id,
+            sub_type=self.sub_type_iteration,
+            parent_id=executor_context._parent_id,  # noqa: SLF001
+            name=name,
         )
 
         def run_in_child_handler() -> ResultType:

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/src/aws_durable_execution_sdk_python/config.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import math
 import random
 from dataclasses import dataclass, field
 from enum import Enum, StrEnum
@@ -589,5 +590,16 @@ class JitterStrategy(StrEnum):
                 # Full jitter: random(0, delay)
                 return random.random() * delay  # noqa: S311
 
+    def finalize_delay(self, base_delay: float) -> int:
+        """Apply jitter, round up, and clamp to a minimum of 1 second.
+
+        Args:
+            base_delay: The base delay value before jitter is applied
+
+        Returns:
+            The final delay in whole seconds, at least 1
+        """
+        return max(1, math.ceil(self.apply_jitter(base_delay)))
+
 
 # endregion Jitter

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/src/aws_durable_execution_sdk_python/context.py

@@ -23,7 +23,10 @@ from aws_durable_execution_sdk_python.exceptions import (
     ValidationError,
 )
 from aws_durable_execution_sdk_python.identifier import OperationIdentifier
-from aws_durable_execution_sdk_python.lambda_service import OperationSubType
+from aws_durable_execution_sdk_python.lambda_service import (
+    OperationSubType,
+    OperationType,
+)
 from aws_durable_execution_sdk_python.logger import Logger, LogInfo
 from aws_durable_execution_sdk_python.operation.callback import (
     CallbackOperationExecutor,
@@ -443,6 +446,7 @@ class DurableContext(DurableContextProtocol):
             state=self.state,
             operation_identifier=OperationIdentifier(
                 operation_id=operation_id,
+                sub_type=OperationSubType.CALLBACK,
                 parent_id=self._parent_id,
                 name=name,
             ),
@@ -485,6 +489,7 @@ class DurableContext(DurableContextProtocol):
             state=self.state,
             operation_identifier=OperationIdentifier(
                 operation_id=operation_id,
+                sub_type=OperationSubType.CHAINED_INVOKE,
                 parent_id=self._parent_id,
                 name=name,
             ),
@@ -507,6 +512,7 @@ class DurableContext(DurableContextProtocol):
         operation_id = self._create_step_id()
         operation_identifier = OperationIdentifier(
             operation_id=operation_id,
+            sub_type=OperationSubType.MAP,
             parent_id=self._parent_id,
             name=map_name,
         )
@@ -553,7 +559,10 @@ class DurableContext(DurableContextProtocol):
         operation_id = self._create_step_id()
         parallel_context = self.create_child_context(operation_id=operation_id)
         operation_identifier = OperationIdentifier(
-            operation_id=operation_id, parent_id=self._parent_id, name=name
+            operation_id=operation_id,
+            sub_type=OperationSubType.PARALLEL,
+            parent_id=self._parent_id,
+            name=name,
         )
 
         def parallel_in_child_context() -> BatchResult[T]:
@@ -606,6 +615,11 @@ class DurableContext(DurableContextProtocol):
         step_name: str | None = self._resolve_step_name(name, func)
         # _create_step_id() is thread-safe. rest of method is safe, since using local copy of parent id
         operation_id = self._create_step_id()
+        sub_type = (
+            config.sub_type
+            if config and config.sub_type
+            else OperationSubType.RUN_IN_CHILD_CONTEXT
+        )
 
         is_virtual: bool = config.is_virtual if config else False
 
@@ -621,6 +635,7 @@ class DurableContext(DurableContextProtocol):
             state=self.state,
             operation_identifier=OperationIdentifier(
                 operation_id=operation_id,
+                sub_type=sub_type,
                 parent_id=self._parent_id,
                 name=step_name,
             ),
@@ -646,6 +661,7 @@ class DurableContext(DurableContextProtocol):
             state=self.state,
             operation_identifier=OperationIdentifier(
                 operation_id=operation_id,
+                sub_type=OperationSubType.STEP,
                 parent_id=self._parent_id,
                 name=step_name,
             ),
@@ -673,6 +689,7 @@ class DurableContext(DurableContextProtocol):
             state=self.state,
             operation_identifier=OperationIdentifier(
                 operation_id=operation_id,
+                sub_type=OperationSubType.WAIT,
                 parent_id=self._parent_id,
                 name=name,
             ),
@@ -695,6 +712,7 @@ class DurableContext(DurableContextProtocol):
         return self.run_in_child_context(
             wait_in_child_context,
             step_name,
+            ChildConfig(sub_type=OperationSubType.WAIT_FOR_CALLBACK),
         )
 
     def wait_for_condition(
@@ -728,6 +746,7 @@ class DurableContext(DurableContextProtocol):
                 state=self.state,
                 operation_identifier=OperationIdentifier(
                     operation_id=operation_id,
+                    sub_type=OperationSubType.WAIT_FOR_CONDITION,
                     parent_id=self._parent_id,
                     name=name,
                 ),

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/src/aws_durable_execution_sdk_python/execution.py

@@ -4,9 +4,9 @@ import contextlib
 import functools
 import json
 import logging
+import warnings
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
-from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 from aws_durable_execution_sdk_python.context import DurableContext
@@ -20,15 +20,22 @@ from aws_durable_execution_sdk_python.exceptions import (
     SuspendExecution,
 )
 from aws_durable_execution_sdk_python.lambda_service import (
+    DurableExecutionInvocationOutput,
     DurableServiceClient,
     ErrorObject,
+    InvocationStatus,
     LambdaClient,
     Operation,
     OperationType,
     OperationUpdate,
 )
+from aws_durable_execution_sdk_python.plugin import (
+    DurableInstrumentationPlugin,
+    PluginExecutor,
+)
 from aws_durable_execution_sdk_python.state import ExecutionState, ReplayStatus
 
+
 if TYPE_CHECKING:
     from collections.abc import Callable, MutableMapping
 
@@ -149,62 +156,6 @@ class DurableExecutionInvocationInputWithClient(DurableExecutionInvocationInput)
         )
 
 
-class InvocationStatus(Enum):
-    SUCCEEDED = "SUCCEEDED"
-    FAILED = "FAILED"
-    PENDING = "PENDING"
-
-
-@dataclass(frozen=True)
-class DurableExecutionInvocationOutput:
-    """Representation the DurableExecutionInvocationOutput. This is what the Durable lambda handler returns.
-
-    If the execution has been already completed via an update to the EXECUTION operation via CheckpointDurableExecution,
-    payload must be empty for SUCCEEDED/FAILED status.
-    """
-
-    status: InvocationStatus
-    result: str | None = None
-    error: ErrorObject | None = None
-
-    @classmethod
-    def from_dict(
-        cls, data: MutableMapping[str, Any]
-    ) -> DurableExecutionInvocationOutput:
-        """Create an instance from a dictionary.
-
-        Args:
-            data: Dictionary with camelCase keys matching the original structure
-
-        Returns:
-            A DurableExecutionInvocationOutput instance
-        """
-        status = InvocationStatus(data.get("Status"))
-        error = ErrorObject.from_dict(data["Error"]) if data.get("Error") else None
-        return cls(status=status, result=data.get("Result"), error=error)
-
-    def to_dict(self) -> MutableMapping[str, Any]:
-        """Convert to a dictionary with the original field names.
-
-        Returns:
-            Dictionary with the original camelCase keys
-        """
-        result: MutableMapping[str, Any] = {"Status": self.status.value}
-
-        if self.result is not None:
-            # large payloads return "", because checkpointed already
-            result["Result"] = self.result
-        if self.error:
-            result["Error"] = self.error.to_dict()
-
-        return result
-
-    @classmethod
-    def create_succeeded(cls, result: str) -> DurableExecutionInvocationOutput:
-        """Create a succeeded invocation output."""
-        return cls(status=InvocationStatus.SUCCEEDED, result=result)
-
-
 # endregion Invocation models
 
 
@@ -212,14 +163,36 @@ def durable_execution(
     func: Callable[[Any, DurableContext], Any] | None = None,
     *,
     boto3_client: Boto3LambdaClient | None = None,
+    plugins: list[DurableInstrumentationPlugin] | None = None,
 ) -> Callable[[Any, LambdaContext], Any]:
+    """
+    Decorator to create a durable execution handler.
+
+    Args:
+        func: The user function to decorate
+        boto3_client: Optional boto3 Lambda client to use
+        plugins: Optional list of plugins to use (EXPERIMENTAL: This
+            feature has known issues and this parameter may change or be removed.)
+    """
     # Decorator called with parameters
     if func is None:
         logger.debug("Decorator called with parameters")
-        return functools.partial(durable_execution, boto3_client=boto3_client)
+        return functools.partial(
+            durable_execution, boto3_client=boto3_client, plugins=plugins
+        )
 
     logger.debug("Starting durable execution handler...")
 
+    if plugins:
+        warnings.warn(
+            "The 'plugins' parameter is provisional and may be altered or removed.",
+            category=FutureWarning,
+            stacklevel=2,  # point the warning to the caller of durable_execution
+        )
+
+    plugin_executor = PluginExecutor(plugins)
+
+    @plugin_executor.handle_durable_output
     def wrapper(event: Any, context: LambdaContext) -> MutableMapping[str, Any]:
         invocation_input: DurableExecutionInvocationInput
         service_client: DurableServiceClient
@@ -255,6 +228,7 @@ def durable_execution(
             operations={},
             service_client=service_client,
             replay_status=ReplayStatus.NEW,
+            plugin_executor=plugin_executor,
         )
 
         try:
@@ -306,6 +280,19 @@ def durable_execution(
             ) as executor,
             contextlib.closing(execution_state) as execution_state,
         ):
+            execution_operation = execution_state.get_execution_operation()
+
+            # execute the plugins
+            plugin_executor.on_invocation_start(
+                execution_arn=invocation_input.durable_execution_arn,
+                lambda_context=context,
+                execution_start_time=(
+                    execution_operation.start_timestamp
+                    if execution_operation is not None
+                    else None
+                ),
+                is_first_invocation=not execution_state.is_replaying(),
+            )
             # Thread 1: Run background checkpoint processing
             executor.submit(execution_state.checkpoint_batches_forever)
 

{aws_durable_execution_sdk_python-1.5.0 → aws_durable_execution_sdk_python-1.6.0}/src/aws_durable_execution_sdk_python/identifier.py

@@ -4,11 +4,21 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from aws_durable_execution_sdk_python.lambda_service import (
+    OperationType,
+    OperationSubType,
+)
+
 
 @dataclass(frozen=True)
 class OperationIdentifier:
     """Container for operation id, parent id, and name."""
 
     operation_id: str
+    sub_type: OperationSubType
     parent_id: str | None = None
     name: str | None = None
+
+    @property
+    def type(self) -> OperationType:
+        return OperationType.from_sub_type(self.sub_type)