aws-durable-execution-sdk-python 1.1.2__py3-none-any.whl → 1.4.0__py3-none-any.whl

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.1.2"
+__version__ = "1.4.0"

aws_durable_execution_sdk_python/__init__.py

@@ -1,7 +1,12 @@
 """AWS Lambda Durable Executions Python SDK."""
 
+# Package metadata
+from aws_durable_execution_sdk_python.__about__ import __version__
+
 # Main context - used in every durable function
 # Helper decorators - commonly used for step functions
+# Concurrency
+from aws_durable_execution_sdk_python.concurrency.models import BatchResult
 from aws_durable_execution_sdk_python.context import (
     DurableContext,
     durable_step,
@@ -20,7 +25,7 @@ from aws_durable_execution_sdk_python.exceptions import (
 from aws_durable_execution_sdk_python.execution import durable_execution
 
 # Essential context types - passed to user functions
-from aws_durable_execution_sdk_python.types import BatchResult, StepContext
+from aws_durable_execution_sdk_python.types import StepContext
 
 __all__ = [
     "BatchResult",
@@ -29,6 +34,7 @@ __all__ = [
     "InvocationError",
     "StepContext",
     "ValidationError",
+    "__version__",
     "durable_execution",
     "durable_step",
     "durable_wait_for_callback",

aws_durable_execution_sdk_python/concurrency/executor.py

@@ -30,6 +30,7 @@ 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.operation.child import child_handler
 
+
 if TYPE_CHECKING:
     from collections.abc import Callable
 
@@ -196,6 +197,11 @@ class ConcurrentExecutor(ABC, Generic[CallableType, ResultType]):
             "▶️ Executing concurrent operation, items: %d", len(self.executables)
         )
 
+        # Early return for empty executables
+        if not self.executables:
+            logger.debug("No items to execute, returning empty result")
+            return self._create_result()
+
         max_workers = self.max_concurrency or len(self.executables)
 
         self.executables_with_state = [

aws_durable_execution_sdk_python/concurrency/models.py

@@ -114,6 +114,85 @@ class BatchResult(Generic[R], BatchResultProtocol[R]):  # noqa: PYI059
         completion_reason = CompletionReason(completion_reason_value)
         return cls(batch_items, completion_reason)
 
+    @staticmethod
+    def _get_completion_reason(
+        failure_count: int,
+        success_count: int,
+        completed_count: int,
+        total_count: int,
+        completion_config: CompletionConfig | None,
+    ) -> CompletionReason:
+        """
+        Determine completion reason based on completion counts.
+
+        Logic order:
+        1. Check failure tolerance FIRST (before checking if all completed)
+        2. Check if all completed
+        3. Check if minimum successful reached
+        4. Default to ALL_COMPLETED
+
+        Args:
+            failure_count: Number of failed items
+            success_count: Number of succeeded items
+            completed_count: Total completed (succeeded + failed)
+            total_count: Total number of items
+            completion_config: Optional completion configuration
+
+        Returns:
+            CompletionReason enum value
+        """
+        # STEP 1: Check tolerance first, before checking if all completed
+
+        # Handle fail-fast behavior (no completion config or empty completion config)
+        if completion_config is None:
+            if failure_count > 0:
+                return CompletionReason.FAILURE_TOLERANCE_EXCEEDED
+        else:
+            # Check if completion config has any criteria set
+            has_any_completion_criteria = (
+                completion_config.min_successful is not None
+                or completion_config.tolerated_failure_count is not None
+                or completion_config.tolerated_failure_percentage is not None
+            )
+
+            if not has_any_completion_criteria:
+                # Empty completion config - fail fast on any failure
+                if failure_count > 0:
+                    return CompletionReason.FAILURE_TOLERANCE_EXCEEDED
+            else:
+                # Check specific tolerance thresholds
+                if (
+                    completion_config.tolerated_failure_count is not None
+                    and failure_count > completion_config.tolerated_failure_count
+                ):
+                    return CompletionReason.FAILURE_TOLERANCE_EXCEEDED
+
+                if (
+                    completion_config.tolerated_failure_percentage is not None
+                    and total_count > 0
+                ):
+                    failure_percentage = (failure_count / total_count) * 100
+                    if (
+                        failure_percentage
+                        > completion_config.tolerated_failure_percentage
+                    ):
+                        return CompletionReason.FAILURE_TOLERANCE_EXCEEDED
+
+        # STEP 2: Check if all completed
+        if completed_count == total_count:
+            return CompletionReason.ALL_COMPLETED
+
+        # STEP 3: Check if minimum successful reached
+        if (
+            completion_config is not None
+            and completion_config.min_successful is not None
+            and success_count >= completion_config.min_successful
+        ):
+            return CompletionReason.MIN_SUCCESSFUL_REACHED
+
+        # STEP 4: Default
+        return CompletionReason.ALL_COMPLETED
+
     @classmethod
     def from_items(
         cls,
@@ -123,12 +202,8 @@ class BatchResult(Generic[R], BatchResultProtocol[R]):  # noqa: PYI059
         """
         Infer completion reason based on batch item statuses and completion config.
 
-        This follows the same logic as the TypeScript implementation:
-        - If all items completed: ALL_COMPLETED
-        - If minSuccessful threshold met and not all completed: MIN_SUCCESSFUL_REACHED
-        - Otherwise: FAILURE_TOLERANCE_EXCEEDED
+        This follows the same logic as the TypeScript implementation.
         """
-
         statuses = (item.status for item in items)
         counts = Counter(statuses)
         succeeded_count = counts.get(BatchItemStatus.SUCCEEDED, 0)
@@ -138,18 +213,14 @@ class BatchResult(Generic[R], BatchResultProtocol[R]):  # noqa: PYI059
         completed_count = succeeded_count + failed_count
         total_count = started_count + completed_count
 
-        # If all items completed (no started items), it's ALL_COMPLETED
-        if completed_count == total_count:
-            completion_reason = CompletionReason.ALL_COMPLETED
-        elif (  # If we have completion config and minSuccessful threshold is met
-            completion_config
-            and (min_successful := completion_config.min_successful) is not None
-            and succeeded_count >= min_successful
-        ):
-            completion_reason = CompletionReason.MIN_SUCCESSFUL_REACHED
-        else:
-            # Otherwise, assume failure tolerance was exceeded
-            completion_reason = CompletionReason.FAILURE_TOLERANCE_EXCEEDED
+        # Determine completion reason using the same logic as JavaScript SDK
+        completion_reason = cls._get_completion_reason(
+            failure_count=failed_count,
+            success_count=succeeded_count,
+            completed_count=completed_count,
+            total_count=total_count,
+            completion_config=completion_config,
+        )
 
         return cls(items, completion_reason)
 

aws_durable_execution_sdk_python/context.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import hashlib
 import logging
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Concatenate, Generic, ParamSpec, TypeVar
 
 from aws_durable_execution_sdk_python.config import (
@@ -43,21 +44,21 @@ from aws_durable_execution_sdk_python.serdes import (
 )
 from aws_durable_execution_sdk_python.state import ExecutionState  # noqa: TCH001
 from aws_durable_execution_sdk_python.threading import OrderedCounter
+from aws_durable_execution_sdk_python.types import Callback as CallbackProtocol
+from aws_durable_execution_sdk_python.types import (
+    DurableContext as DurableContextProtocol,
+)
 from aws_durable_execution_sdk_python.types import (
-    BatchResult,
     LoggerInterface,
     StepContext,
     WaitForCallbackContext,
     WaitForConditionCheckContext,
 )
-from aws_durable_execution_sdk_python.types import Callback as CallbackProtocol
-from aws_durable_execution_sdk_python.types import (
-    DurableContext as DurableContextProtocol,
-)
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
 
+    from aws_durable_execution_sdk_python.concurrency.models import BatchResult
     from aws_durable_execution_sdk_python.state import CheckpointedResult
     from aws_durable_execution_sdk_python.types import LambdaContext
     from aws_durable_execution_sdk_python.waits import WaitForConditionConfig
@@ -74,6 +75,20 @@ logger = logging.getLogger(__name__)
 PASS_THROUGH_SERDES: SerDes[Any] = PassThroughSerDes()
 
 
+@dataclass(frozen=True)
+class ExecutionContext:
+    """Readonly metadata about the current durable execution context.
+
+    This class provides immutable access to execution-level metadata.
+
+    Attributes:
+        durable_execution_arn: The Amazon Resource Name (ARN) of the current
+            durable execution.
+    """
+
+    durable_execution_arn: str
+
+
 def durable_step(
     func: Callable[Concatenate[StepContext, Params], T],
 ) -> Callable[Params, Callable[[StepContext], T]]:
@@ -218,11 +233,13 @@ class DurableContext(DurableContextProtocol):
     def __init__(
         self,
         state: ExecutionState,
+        execution_context: ExecutionContext,
         lambda_context: LambdaContext | None = None,
         parent_id: str | None = None,
         logger: Logger | None = None,
     ) -> None:
         self.state: ExecutionState = state
+        self.execution_context: ExecutionContext = execution_context
         self.lambda_context = lambda_context
         self._parent_id: str | None = parent_id
         self._step_counter: OrderedCounter = OrderedCounter()
@@ -245,6 +262,9 @@ class DurableContext(DurableContextProtocol):
     ):
         return DurableContext(
             state=state,
+            execution_context=ExecutionContext(
+                durable_execution_arn=state.durable_execution_arn
+            ),
             lambda_context=lambda_context,
             parent_id=None,
         )
@@ -254,6 +274,7 @@ class DurableContext(DurableContextProtocol):
         logger.debug("Creating child context for parent %s", parent_id)
         return DurableContext(
             state=self.state,
+            execution_context=self.execution_context,
             lambda_context=self.lambda_context,
             parent_id=parent_id,
             logger=self.logger.with_log_info(

aws_durable_execution_sdk_python/logger.py

@@ -72,7 +72,7 @@ class Logger(LoggerInterface):
             # Use 'operation_name' instead of 'name' as key because the stdlib LogRecord internally reserved 'name' parameter
             extra["operationName"] = info.name
         if info.attempt is not None:
-            extra["attempt"] = info.attempt + 1
+            extra["attempt"] = info.attempt
         if info.operation_id:
             extra["operationId"] = info.operation_id
         return cls(

aws_durable_execution_sdk_python/operation/step.py

@@ -202,9 +202,10 @@ class StepOperationExecutor(OperationExecutor[T]):
             ExecutionError: For fatal errors that should not be retried
             May raise other exceptions that will be handled by retry_handler
         """
-        attempt: int = 0
+        # Get current attempt - checkpointed attempts + 1
+        attempt: int = 1
         if checkpointed_result.operation and checkpointed_result.operation.step_details:
-            attempt = checkpointed_result.operation.step_details.attempt
+            attempt = checkpointed_result.operation.step_details.attempt + 1
 
         step_context: StepContext = StepContext(
             logger=self.context_logger.with_log_info(

aws_durable_execution_sdk_python/operation/wait_for_condition.py

@@ -170,10 +170,11 @@ class WaitForConditionOperationExecutor(OperationExecutor[T]):
         else:
             current_state = self.config.initial_state
 
-        # Get attempt number
+        # Get attempt number - current attempt is checkpointed attempts + 1
+        # The checkpoint stores completed attempts, so the current attempt being executed is one more
         attempt: int = 1
         if checkpointed_result.operation and checkpointed_result.operation.step_details:
-            attempt = checkpointed_result.operation.step_details.attempt
+            attempt = checkpointed_result.operation.step_details.attempt + 1
 
         try:
             # Execute the check function with the injected logger

aws_durable_execution_sdk_python/serdes.py

@@ -316,11 +316,7 @@ class TypeCodec(Codec):
     def decode(self, tag: TypeTag, value: Any) -> Any:
         match tag:
             case (
-                TypeTag.NONE
-                | TypeTag.STR
-                | TypeTag.BOOL
-                | TypeTag.INT
-                | TypeTag.FLOAT
+                TypeTag.NONE | TypeTag.STR | TypeTag.BOOL | TypeTag.INT | TypeTag.FLOAT
             ):
                 return self.primitive_codec.decode(tag, value)
             case TypeTag.BYTES:

aws_durable_execution_sdk_python/state.py

@@ -45,12 +45,12 @@ class CheckpointBatcherConfig:
     Attributes:
         max_batch_size_bytes: Maximum batch size in bytes (default: 750KB)
         max_batch_time_seconds: Maximum time to wait before flushing batch (default: 1.0 second)
-        max_batch_operations: Maximum number of operations per batch (default: unlimited)
+        max_batch_operations: Maximum number of operations per batch (default: 250)
     """
 
-    max_batch_size_bytes: int = 750 * 1024  # 750KB - private readonly MAX_PAYLOAD_SIZE
-    max_batch_time_seconds: float = 1.0  # 1 second default
-    max_batch_operations: int | float = float("inf")  # No operation limit by default
+    max_batch_size_bytes: int = 750 * 1024  # 750KB
+    max_batch_time_seconds: float = 1.0
+    max_batch_operations: int = 250
 
 
 @dataclass(frozen=True)
@@ -592,15 +592,21 @@ class ExecutionState:
             batch: list[QueuedOperation] = self._collect_checkpoint_batch()
 
             if batch:
-                # Extract OperationUpdates from QueuedOperations for API call
-                updates: list[OperationUpdate] = [
-                    q.operation_update for q in batch if q.operation_update is not None
-                ]
+                # Extract OperationUpdates, excluding empty checkpoints from API call
+                updates: list[OperationUpdate] = []
+                empty_count = 0
+
+                for q in batch:
+                    if q.operation_update is not None:
+                        updates.append(q.operation_update)
+                    else:
+                        empty_count += 1
 
                 logger.debug(
-                    "Processing checkpoint batch with %d operations (%d non-empty)",
-                    len(batch),
+                    "Sending %d OperationUpdates out of %d operations, excluding %d empty checkpoints",
                     len(updates),
+                    len(batch),
+                    empty_count,
                 )
 
                 try:
@@ -687,26 +693,43 @@ class ExecutionState:
         operation if queues are empty, then collects additional operations within the time
         window.
 
+        Empty checkpoints (operation_update=None) are coalesced: the first empty checkpoint
+        counts toward the batch operation limit, but subsequent empty checkpoints do not.
+        All empty checkpoints remain in the batch so their completion events are signaled.
+        This avoids unnecessary batches when many concurrent map/parallel branches resume
+        simultaneously and each queues an empty checkpoint.
+
         Returns:
             List of QueuedOperation objects ready for batch processing. Returns empty list
             if no operations are available.
         """
         batch: list[QueuedOperation] = []
+        has_empty_checkpoint = False
         total_size = 0
+        effective_operation_count = 0  # Operations that count toward batch limit
 
         # First, drain overflow queue (FIFO order preserved)
         try:
-            while len(batch) < self._batcher_config.max_batch_operations:
+            while effective_operation_count < self._batcher_config.max_batch_operations:
                 overflow_op = self._overflow_queue.get_nowait()
-                op_size = self._calculate_operation_size(overflow_op)
-
-                if total_size + op_size > self._batcher_config.max_batch_size_bytes:
-                    # Put back and stop
-                    self._overflow_queue.put(overflow_op)
-                    break
 
-                batch.append(overflow_op)
-                total_size += op_size
+                if overflow_op.operation_update is None:  # Empty checkpoint
+                    batch.append(overflow_op)
+                    if not has_empty_checkpoint:
+                        effective_operation_count += (
+                            1  # First empty counts toward limit
+                        )
+                        has_empty_checkpoint = True
+                    # Subsequent empties don't count toward limit
+                else:
+                    op_size = self._calculate_operation_size(overflow_op)
+                    if total_size + op_size > self._batcher_config.max_batch_size_bytes:
+                        # Put back and stop
+                        self._overflow_queue.put(overflow_op)
+                        break
+                    batch.append(overflow_op)
+                    total_size += op_size
+                    effective_operation_count += 1
         except queue.Empty:
             pass
 
@@ -720,7 +743,13 @@ class ExecutionState:
                     )  # Check stop signal every 100ms
                     self._checkpoint_queue.task_done()
                     batch.append(first_op)
-                    total_size += self._calculate_operation_size(first_op)
+
+                    if first_op.operation_update is None:
+                        has_empty_checkpoint = True
+                    else:
+                        total_size += self._calculate_operation_size(first_op)
+
+                    effective_operation_count = 1
                     break
                 except queue.Empty:
                     continue
@@ -735,7 +764,7 @@ class ExecutionState:
         # Collect additional operations within the time window
         while (
             time.time() < batch_deadline
-            and len(batch) < self._batcher_config.max_batch_operations
+            and effective_operation_count < self._batcher_config.max_batch_operations
             and not self._checkpointing_stopped.is_set()
         ):
             remaining_time = min(
@@ -749,26 +778,39 @@ class ExecutionState:
             try:
                 additional_op = self._checkpoint_queue.get(timeout=remaining_time)
                 self._checkpoint_queue.task_done()
-                op_size = self._calculate_operation_size(additional_op)
-
-                # Check if adding this operation would exceed size limit
-                if total_size + op_size > self._batcher_config.max_batch_size_bytes:
-                    # Put in overflow queue for next batch
-                    self._overflow_queue.put(additional_op)
-                    logger.debug(
-                        "Batch size limit reached, moving operation to overflow queue"
-                    )
-                    break
 
-                batch.append(additional_op)
-                total_size += op_size
+                if additional_op.operation_update is None:  # Empty checkpoint
+                    batch.append(additional_op)
+                    if not has_empty_checkpoint:
+                        effective_operation_count += (
+                            1  # First empty counts toward limit
+                        )
+                        has_empty_checkpoint = True
+                    # Subsequent empties don't count toward limit
+                else:
+                    op_size = self._calculate_operation_size(additional_op)
+                    # Check if adding this operation would exceed size limit
+                    if total_size + op_size > self._batcher_config.max_batch_size_bytes:
+                        # Put in overflow queue for next batch
+                        self._overflow_queue.put(additional_op)
+                        logger.debug(
+                            "Batch size limit reached, moving operation to overflow queue"
+                        )
+                        break
+                    batch.append(additional_op)
+                    total_size += op_size
+                    effective_operation_count += 1
 
             except queue.Empty:
                 break
 
+        empty_count = sum(1 for q in batch if q.operation_update is None)
         logger.debug(
-            "Collected batch of %d operations, total size: %d bytes",
+            "Collected batch of %d operations (%d effective, %d non-empty, %d empty), total size: %d bytes",
             len(batch),
+            effective_operation_count,
+            len(batch) - empty_count,
+            empty_count,
             total_size,
         )
         return batch

{aws_durable_execution_sdk_python-1.1.2.dist-info → aws_durable_execution_sdk_python-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-durable-execution-sdk-python
-Version: 1.1.2
+Version: 1.4.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

{aws_durable_execution_sdk_python-1.1.2.dist-info → aws_durable_execution_sdk_python-1.4.0.dist-info}/RECORD

@@ -1,24 +1,24 @@
 aws_durable_execution_sdk_python/.gitignore,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aws_durable_execution_sdk_python/__about__.py,sha256=7qzc63t8OUhHP9YvXrUIRIK7LxcEvXL60VN7Z4b_y4M,137
-aws_durable_execution_sdk_python/__init__.py,sha256=reI6AQTpEyeK3ev6iZJuu7A6PSoa0V1VJGOgSB2RpGM,1023
+aws_durable_execution_sdk_python/__about__.py,sha256=ZjNnP948vlNHMpNCtGcD-ZfYMICduDyvWTwaUejUdXc,137
+aws_durable_execution_sdk_python/__init__.py,sha256=LMxy0GN8uCDxLkPznYyng-6frbD_0Js7rHeSR5O8oKQ,1206
 aws_durable_execution_sdk_python/config.py,sha256=vd_8IZO5KZU3qWENbWDVtyLglqw3sa6SU-R8CYUgm9g,18938
-aws_durable_execution_sdk_python/context.py,sha256=efJIc5KrsTzcI_azMjxqrHiPt71PuiQy4vbdsUiTtLI,22467
+aws_durable_execution_sdk_python/context.py,sha256=U0ox6-QzW5dOzZb0tL-R_MITF9O5iSeH9JmnZ5pS_UQ,23217
 aws_durable_execution_sdk_python/exceptions.py,sha256=AvuXnBHAijXb3TepNTu5CVDb_cpR6Yw6x4W3jELVneQ,13631
 aws_durable_execution_sdk_python/execution.py,sha256=A20fOp6_wXdIcL1YiqJ_RGJbQ09D1lSivBQnUY0FT3Y,18571
 aws_durable_execution_sdk_python/identifier.py,sha256=0NyNTb8mTrUni7PlmFtzvJdW6lk0_XpuAaL89LNc378,324
 aws_durable_execution_sdk_python/lambda_service.py,sha256=FkkcmFxDZLA4JS7mMW2YT9BfqTNHHJtEk9kSADwu5bk,37858
-aws_durable_execution_sdk_python/logger.py,sha256=nde1fhe9uK-UmXRZI7T_sIoU-_T5PnZo16boaFQFtyw,4281
+aws_durable_execution_sdk_python/logger.py,sha256=DtPNfJS9PFUfeJqHTl34rSxYRizvVVWAtblV-5zpuY4,4277
 aws_durable_execution_sdk_python/py.typed,sha256=DbCDcAirv769HS1ibzZLXq8VPazYf7JCkKSzj3ctudM,58
 aws_durable_execution_sdk_python/retries.py,sha256=CNJ6msQHVhcdSjMuuQAvR0WvsaN7cFA7QgQTVI8pK2w,5829
-aws_durable_execution_sdk_python/serdes.py,sha256=-hzqPyAHi1rsOUwpi7RjiJBNiDc0Oe5_QVNMemYBfGY,16808
-aws_durable_execution_sdk_python/state.py,sha256=5kWSwtOCt0VkhhB2orhGyrXNg1nBt-HXfXm0T8VzAiE,33303
+aws_durable_execution_sdk_python/serdes.py,sha256=AgsvqpOLjFR1reUO3utuKt3Q52cPUbZ9_CEjWps40qk,16744
+aws_durable_execution_sdk_python/state.py,sha256=YFpi73RoGqz-cV8eWNHzxwjBAza8zhAm_8KCY_V0PxY,35464
 aws_durable_execution_sdk_python/suspend.py,sha256=PIgc6w5-diZIq58-tPv51dzBSHGW7e4oR0QFam8Vgi0,3323
 aws_durable_execution_sdk_python/threading.py,sha256=cU7vIEWHYco-qqkgoAMyPHSOQ8b_Q_r_rZGG7m1g7I4,7650
 aws_durable_execution_sdk_python/types.py,sha256=8vqwa5q2EikesX_NdhR_njin7l7uHakhWPH_ntHY_PI,5152
 aws_durable_execution_sdk_python/waits.py,sha256=ZO_SWafI0G7rWxItpnL7w4o--eDp2VAjnGZlrBJfufc,3883
 aws_durable_execution_sdk_python/concurrency/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aws_durable_execution_sdk_python/concurrency/executor.py,sha256=NkpB0gRRykhc1eMB1xGNy7VPMawIkejMuV2-T--Vnao,18156
-aws_durable_execution_sdk_python/concurrency/models.py,sha256=wPi0PEFsCFthoXlRMkomS0Tl9hZ7IVk4d-9xWH5cIJQ,15540
+aws_durable_execution_sdk_python/concurrency/executor.py,sha256=zaJsunB9YPyMZe9fAur3sZ1btm365RkyET6wCRsUL7s,18349
+aws_durable_execution_sdk_python/concurrency/models.py,sha256=5YGCr6cqgts6d_pvLe_J7PxXFWcECFHnVaJZPIXmVcQ,18158
 aws_durable_execution_sdk_python/operation/__init__.py,sha256=xjtSpukZb6sftgJ5oVPSc6TcgKgVQg4vXHeYIeKOPks,25
 aws_durable_execution_sdk_python/operation/base.py,sha256=5Ppis4xFJoXQK4f7-cF-RYmeF84nAVlepzJgHx_OBYc,7049
 aws_durable_execution_sdk_python/operation/callback.py,sha256=wSSdD7R9cOZuRxVeGqqMGirrEmKaZp8iN34uDc7avH0,6685
@@ -26,11 +26,11 @@ aws_durable_execution_sdk_python/operation/child.py,sha256=L2RMHhTt_xewAS20T1iZN
 aws_durable_execution_sdk_python/operation/invoke.py,sha256=R-31JLlazDWECe8Q242LMqiwuyg1_GzycDNKYJEoz_M,6801
 aws_durable_execution_sdk_python/operation/map.py,sha256=NMp-U3dvv2OK9kiUF1PQfkll1JKzpL7Sh_cxyda_Kyk,5024
 aws_durable_execution_sdk_python/operation/parallel.py,sha256=uzxa_XsTvimC63HpadwCjNhGoUcqxM8P4bvQLVHQTq0,4715
-aws_durable_execution_sdk_python/operation/step.py,sha256=5R-Rzmfh5uYHMQdq3WoDzwXUBwNg-ToeWW5DI7_l7zw,15567
+aws_durable_execution_sdk_python/operation/step.py,sha256=hnwiLtXNLAOl71FPduxyMYaUggQsrelLeP1W5kRXXlM,15629
 aws_durable_execution_sdk_python/operation/wait.py,sha256=P1R7-BrQ0eadFxQiGLHL3ySkuJUqPvVv7zewAzBeVT8,4193
-aws_durable_execution_sdk_python/operation/wait_for_condition.py,sha256=s33dEf5qosed_DxZiNN0A_t9DHfpHBpcfD7HqaEfbx0,11768
-aws_durable_execution_sdk_python-1.1.2.dist-info/METADATA,sha256=hYagEtD3Dl8MjSAH41gPAODHtYKb3Dyo3CNpm4mA9xs,6424
-aws_durable_execution_sdk_python-1.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-aws_durable_execution_sdk_python-1.1.2.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-aws_durable_execution_sdk_python-1.1.2.dist-info/licenses/NOTICE,sha256=1CkO1kwu3Q_OHYTj-d-yiBJA_lNN73a4zSntavaD4oc,67
-aws_durable_execution_sdk_python-1.1.2.dist-info/RECORD,,
+aws_durable_execution_sdk_python/operation/wait_for_condition.py,sha256=9t-XsfKQfg66Ys57L61VWA5_JYPvVNnGD6ddFq-h4Xg,11921
+aws_durable_execution_sdk_python-1.4.0.dist-info/METADATA,sha256=nKFN7Mr7GvfCdIfAFBLIZ1i358avvac6j-qqV4hT8ek,6424
+aws_durable_execution_sdk_python-1.4.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+aws_durable_execution_sdk_python-1.4.0.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+aws_durable_execution_sdk_python-1.4.0.dist-info/licenses/NOTICE,sha256=1CkO1kwu3Q_OHYTj-d-yiBJA_lNN73a4zSntavaD4oc,67
+aws_durable_execution_sdk_python-1.4.0.dist-info/RECORD,,

{aws_durable_execution_sdk_python-1.1.2.dist-info → aws_durable_execution_sdk_python-1.4.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: hatchling 1.29.0
 Root-Is-Purelib: true
 Tag: py3-none-any