async-durable-execution 2.2.0__tar.gz → 2.3.0__tar.gz

{async_durable_execution-2.2.0 → async_durable_execution-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: async-durable-execution
-Version: 2.2.0
+Version: 2.3.0
 Summary: Community-maintained durable execution SDK for AWS Lambda in Python
 Project-URL: Documentation, https://github.com/zhongkechen/async-durable-execution#readme
 Project-URL: Issues, https://github.com/zhongkechen/async-durable-execution/issues
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
@@ -72,6 +73,7 @@ composition, and APIs designed for modern Python applications.
 
 - **[Async-first durable code](https://zhongkechen.github.io/async-durable-execution/official-python-sdk-comparison.html#programming-model)** - Compared with the official AWS SDK, user-provided durable handlers, steps, child contexts, `flow` nodes, callback submitters, map item functions, parallel branches, and wait-for-condition checks are written with `async def`.
 - **[Operations not available in the official SDK](https://zhongkechen.github.io/async-durable-execution/api/extension/replay_safe.html)** - This SDK adds [replay-safe helpers](https://zhongkechen.github.io/async-durable-execution/api/extension/replay_safe.html) (`random()`, `now()`, `timestamp()`, and `uuid()`) and [durable self-invocation](https://zhongkechen.github.io/async-durable-execution/api/extension/recurse.html) (`recurse()`).
+- **[Stable custom operation SPI](https://zhongkechen.github.io/async-durable-execution/custom-operations.html)** - Third-party packages can reserve opaque deterministic primitive identities, use custom subtypes, and build stateful replay-safe operations without importing SDK internals.
 - **[Declarative DAG workflows](https://zhongkechen.github.io/async-durable-execution/api/extension/flow.html#quick-start)** - Define acyclic workflows with typed node inputs, inferred or conditional dependencies, failure routes, and durable operations inside each node. The SDK validates the graph before execution and skips nodes that are not required by the selected outputs.
 - **[Background operation tasks](https://zhongkechen.github.io/async-durable-execution/advanced-usage.html#background-operation-tasks)** - Durable operations such as `step(...)`, `wait(...)`, `invoke(...)`, `recurse(...)`, `run_in_child_context(...)`, and `flow(...)` return `asyncio.Task` objects, so independent operations can run in the background and be awaited together with `asyncio.gather` without using `parallel()` or `map()`.
 - **[Pythonic operation parameters](https://zhongkechen.github.io/async-durable-execution/migrating-from-official-python-sdk.html#api-mapping)** - Operations use direct keyword arguments, standard Python types such as `datetime.timedelta`, and keyword-only names instead of configuration wrapper objects.
@@ -247,6 +249,7 @@ For the developer workflow to run or deploy example integration tests, see the [
 - **[Deploy and Invoke](https://zhongkechen.github.io/async-durable-execution/deployment.html)** - Configure IAM, qualified function identifiers, invocations, CloudFormation, and SAM
 - **[Using Synchronous Code](https://zhongkechen.github.io/async-durable-execution/using-synchronous-code.html)** - Wrap existing synchronous business logic and blocking clients safely
 - **[Advanced Usage](https://zhongkechen.github.io/async-durable-execution/advanced-usage.html)** - Explore background operation tasks, batch completion conditions, Lambda clients, and Lambda layers
+- **[Custom Durable Operations](https://zhongkechen.github.io/async-durable-execution/custom-operations.html)** - Build third-party durable operation libraries on the stable extension-author interface
 - **[Runner Architecture](https://zhongkechen.github.io/async-durable-execution/runner-architecture.html)** - Local and cloud runner execution flow, components, and diagrams
 - **[Contributing Guide](https://github.com/zhongkechen/async-durable-execution/blob/main/CONTRIBUTING.md)** - Development workflow, Hatch commands, testing, and pull request guidance
 

{async_durable_execution-2.2.0 → async_durable_execution-2.3.0}/README.md

@@ -43,6 +43,7 @@ composition, and APIs designed for modern Python applications.
 
 - **[Async-first durable code](https://zhongkechen.github.io/async-durable-execution/official-python-sdk-comparison.html#programming-model)** - Compared with the official AWS SDK, user-provided durable handlers, steps, child contexts, `flow` nodes, callback submitters, map item functions, parallel branches, and wait-for-condition checks are written with `async def`.
 - **[Operations not available in the official SDK](https://zhongkechen.github.io/async-durable-execution/api/extension/replay_safe.html)** - This SDK adds [replay-safe helpers](https://zhongkechen.github.io/async-durable-execution/api/extension/replay_safe.html) (`random()`, `now()`, `timestamp()`, and `uuid()`) and [durable self-invocation](https://zhongkechen.github.io/async-durable-execution/api/extension/recurse.html) (`recurse()`).
+- **[Stable custom operation SPI](https://zhongkechen.github.io/async-durable-execution/custom-operations.html)** - Third-party packages can reserve opaque deterministic primitive identities, use custom subtypes, and build stateful replay-safe operations without importing SDK internals.
 - **[Declarative DAG workflows](https://zhongkechen.github.io/async-durable-execution/api/extension/flow.html#quick-start)** - Define acyclic workflows with typed node inputs, inferred or conditional dependencies, failure routes, and durable operations inside each node. The SDK validates the graph before execution and skips nodes that are not required by the selected outputs.
 - **[Background operation tasks](https://zhongkechen.github.io/async-durable-execution/advanced-usage.html#background-operation-tasks)** - Durable operations such as `step(...)`, `wait(...)`, `invoke(...)`, `recurse(...)`, `run_in_child_context(...)`, and `flow(...)` return `asyncio.Task` objects, so independent operations can run in the background and be awaited together with `asyncio.gather` without using `parallel()` or `map()`.
 - **[Pythonic operation parameters](https://zhongkechen.github.io/async-durable-execution/migrating-from-official-python-sdk.html#api-mapping)** - Operations use direct keyword arguments, standard Python types such as `datetime.timedelta`, and keyword-only names instead of configuration wrapper objects.
@@ -218,6 +219,7 @@ For the developer workflow to run or deploy example integration tests, see the [
 - **[Deploy and Invoke](https://zhongkechen.github.io/async-durable-execution/deployment.html)** - Configure IAM, qualified function identifiers, invocations, CloudFormation, and SAM
 - **[Using Synchronous Code](https://zhongkechen.github.io/async-durable-execution/using-synchronous-code.html)** - Wrap existing synchronous business logic and blocking clients safely
 - **[Advanced Usage](https://zhongkechen.github.io/async-durable-execution/advanced-usage.html)** - Explore background operation tasks, batch completion conditions, Lambda clients, and Lambda layers
+- **[Custom Durable Operations](https://zhongkechen.github.io/async-durable-execution/custom-operations.html)** - Build third-party durable operation libraries on the stable extension-author interface
 - **[Runner Architecture](https://zhongkechen.github.io/async-durable-execution/runner-architecture.html)** - Local and cloud runner execution flow, components, and diagrams
 - **[Contributing Guide](https://github.com/zhongkechen/async-durable-execution/blob/main/CONTRIBUTING.md)** - Development workflow, Hatch commands, testing, and pull request guidance
 

{async_durable_execution-2.2.0 → async_durable_execution-2.3.0}/async_durable_execution/__about__.py

@@ -2,4 +2,4 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-__version__ = "2.2.0"
+__version__ = "2.3.0"

{async_durable_execution-2.2.0 → async_durable_execution-2.3.0}/async_durable_execution/__init__.py

@@ -36,13 +36,13 @@ from ._core import (
 )
 
 # Durable operations
-from ._extension.with_retry import (
+from ._operation.with_retry import (
     WithRetryContext,
     get_with_retry_context,
     with_retry,
 )
-from ._extension.map import MapItemContext, get_map_item_context, map
-from ._extension.flow import (
+from ._operation.map import MapItemContext, get_map_item_context, map
+from ._operation.flow import (
     FlowDefinitionError,
     FlowExecutionError,
     FlowNode,
@@ -56,7 +56,7 @@ from ._extension.flow import (
     get_node_context,
     node,
 )
-from ._extension.parallel import (
+from ._operation.parallel import (
     BatchItem,
     BatchItemStatus,
     BatchResult,
@@ -66,38 +66,46 @@ from ._extension.parallel import (
     CompletionStatus,
     NestingType,
 )
-from ._extension.wait_for_condition import (
+from ._operation.wait_for_condition import (
     PollingStrategy,
     WaitForConditionCheckContext,
     WaitForConditionError,
     get_wait_for_condition_check_context,
     wait_for_condition,
 )
-from ._primitive.invoke import invoke
-from ._extension.recurse import recurse
-from ._extension.parallel import (
+from ._operation.invoke import invoke
+from ._operation.recurse import recurse
+from ._operation.parallel import (
     parallel,
 )
-from ._primitive.callback import (
+from ._operation.callback import (
     Callback,
     CallbackError,
     create_callback,
 )
-from ._extension.wait_for_callback import (
+from ._operation.wait_for_callback import (
     WaitForCallbackContext,
     get_wait_for_callback_context,
     wait_for_callback,
 )
-from ._primitive.child import SummaryGenerator, run_in_child_context
-from ._primitive.step import (
+from ._operation.child import SummaryGenerator, run_in_child_context
+from ._operation.step import (
     StepContext,
     StepInterruptedError,
     StepSemantics,
     get_step_context,
     step,
 )
-from ._extension.replay_safe import now, random, timestamp, uuid
-from ._primitive.wait import wait
+from ._operation.replay_safe import now, random, timestamp, uuid
+from ._operation.wait import wait
+from .extension import (
+    ExtensionContext,
+    ExtensionOperation,
+    ExtensionStepFunction,
+    ExtensionStepResult,
+    ExtensionStepRetryStrategy,
+    get_extension_context,
+)
 from ._runner import (
     DurableFunctionCloudTestRunner,
     DurableFunctionLocalTestRunner,
@@ -119,6 +127,7 @@ __all__ = [
     "flow",
     "get_current_context",
     "get_durable_context",
+    "get_extension_context",
     "get_map_item_context",
     "get_node_context",
     "get_serdes_context",
@@ -159,6 +168,11 @@ __all__ = [
     "DurableExecutionsError",
     "ErrorObject",
     "ExecutionError",
+    "ExtensionContext",
+    "ExtensionOperation",
+    "ExtensionStepFunction",
+    "ExtensionStepResult",
+    "ExtensionStepRetryStrategy",
     "ExtendedTypeSerDes",
     "FlowDefinitionError",
     "FlowExecutionError",

{async_durable_execution-2.2.0 → async_durable_execution-2.3.0}/async_durable_execution/_core/__init__.py

@@ -15,6 +15,7 @@ from .config import (
 from .context import (
     DurableContext,
     OperationContext,
+    SerDesContext,
     bind_current_context,
     bind_durable_definition,
     ensure_durable_operations_allowed,
@@ -50,6 +51,7 @@ from .execution import (
     durable_execution,
 )
 from .models import (
+    BotoSerializableModel,
     CallbackDetails,
     CallbackOptions,
     CallbackTimeoutType,
@@ -64,21 +66,21 @@ from .models import (
     ExecutionDetails,
     InvocationStatus,
     LambdaContext,
+    MappingModel,
     Operation,
     OperationAction,
     OperationIdentifier,
     OperationPayload,
     OperationStatus,
     OperationSubType,
+    OperationSubTypeValue,
     OperationType,
     OperationUpdate,
-    SerializableModel,
     StateOutput,
     StepDetails,
     TimestampConverter,
     WaitDetails,
     WaitOptions,
-    _metadata,
 )
 from .serdes import (
     DEFAULT_JSON_SERDES,
@@ -87,7 +89,6 @@ from .serdes import (
     JsonSerDes,
     PassThroughSerDes,
     SerDes,
-    SerDesContext,
     TypeCodecExtension,
     TypeTag,
     deserialize,

{async_durable_execution-2.2.0 → async_durable_execution-2.3.0}/async_durable_execution/_core/client.py

@@ -25,13 +25,9 @@ logger = logging.getLogger(__name__)
 class LambdaApiClient(Protocol):
     """Minimal Lambda client surface needed by durable execution."""
 
-    def checkpoint_durable_execution(
-        self, **kwargs: Any
-    ) -> Mapping[str, Any]: ...  # pragma: no cover
+    def checkpoint_durable_execution(self, **kwargs: Any) -> Mapping[str, Any]: ...
 
-    def get_durable_execution_state(
-        self, **kwargs: Any
-    ) -> Mapping[str, Any]: ...  # pragma: no cover
+    def get_durable_execution_state(self, **kwargs: Any) -> Mapping[str, Any]: ...
 
 
 class AsyncLambdaApiClient(Protocol):
@@ -39,11 +35,11 @@ class AsyncLambdaApiClient(Protocol):
 
     def checkpoint_durable_execution(
         self, **kwargs: Any
-    ) -> Awaitable[Mapping[str, Any]]: ...  # pragma: no cover
+    ) -> Awaitable[Mapping[str, Any]]: ...
 
     def get_durable_execution_state(
         self, **kwargs: Any
-    ) -> Awaitable[Mapping[str, Any]]: ...  # pragma: no cover
+    ) -> Awaitable[Mapping[str, Any]]: ...
 
 
 class DurableServiceClient(Protocol):
@@ -55,7 +51,7 @@ class DurableServiceClient(Protocol):
         checkpoint_token: str,
         updates: list[OperationUpdate],
         client_token: str | None,
-    ) -> CheckpointOutput: ...  # pragma: no cover
+    ) -> CheckpointOutput: ...
 
     async def get_execution_state(
         self,
@@ -63,7 +59,7 @@ class DurableServiceClient(Protocol):
         checkpoint_token: str,
         next_marker: str,
         max_items: int = 1000,
-    ) -> StateOutput: ...  # pragma: no cover
+    ) -> StateOutput: ...
 
 
 def _create_client_config() -> Config:

{async_durable_execution-2.2.0 → async_durable_execution-2.3.0}/async_durable_execution/_core/config.py

@@ -85,7 +85,7 @@ class _DelayStrategy:
     jitter_strategy: JitterStrategy = field(default=JitterStrategy.FULL)
     increment: Duration | None = None
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         self.initial_delay = duration_to_seconds(self.initial_delay, "initial_delay")
         self.max_delay = duration_to_seconds(self.max_delay, "max_delay")
         if self.increment is not None:

{async_durable_execution-2.2.0 → async_durable_execution-2.3.0}/async_durable_execution/_core/context.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import functools
 import hashlib
 import logging
+from collections.abc import Iterator
 from contextlib import contextmanager
 from contextvars import ContextVar, Token
 from dataclasses import dataclass
@@ -18,19 +19,32 @@ from .models import (
 
 if TYPE_CHECKING:
     from .models import LambdaContext
-    from .serdes import SerDesContext
     from .state import ExecutionState
 
 
 logger = logging.getLogger(__name__)
 
 
+@dataclass(frozen=True)
+class SerDesContext:
+    """Context for serialization operations."""
+
+    operation_id: str = ""
+    durable_execution_arn: str = ""
+    recursive_level: int = 0
+
+
 class OperationIdGenerator:
     """Generate deterministic operation ids within a durable execution scope."""
 
     def __init__(self, prefix: str | None) -> None:
         self._prefix = prefix
         self._counter = 0
+        self._claimed_local_ids: set[str] = set()
+        self._unconsumed_reservations: dict[str, bool] = {}
+        self._unconsumed_checkpoint_count = 0
+        self._reservation_selection_started = False
+        self._replay_frontier_pending = False
 
     def increment(self) -> int:
         self._counter += 1
@@ -39,16 +53,89 @@ class OperationIdGenerator:
     def get_current(self) -> int:
         return self._counter
 
-    def _create_step_id_for_logical_step(self, step: int) -> str:
-        """Generate the stable operation id for a logical step."""
+    def _create_id(self, value: str) -> str:
+        """Hash one context-local identity value."""
         prefix = self._prefix
-        step_id = f"{prefix}-{step}" if prefix else str(step)
+        step_id = f"{prefix}-{value}" if prefix else value
         return hashlib.blake2b(step_id.encode()).hexdigest()[:64]
 
+    def _create_id_for_local_id(self, local_id: str) -> str:
+        """Generate an id in the caller-provided local-id namespace."""
+        return self._create_id(f"local:{local_id}")
+
+    def _create_step_id_for_logical_step(self, step: int) -> str:
+        """Generate the stable operation id for a logical step."""
+        return self._create_id(str(step))
+
     def create_step_id(self) -> str:
         """Generate an operation id and advance the logical step counter."""
         return self._create_step_id_for_logical_step(self.increment())
 
+    def create_step_id_for_local_id(self, local_id: str) -> str:
+        """Generate an operation id from a stable caller-provided local id."""
+        if not isinstance(local_id, str):
+            msg = "local_operation_id must be a string"
+            raise TypeError(msg)
+        if not local_id.strip():
+            msg = "local_operation_id must not be blank"
+            raise ValueError(msg)
+        if self._reservation_selection_started:
+            msg = (
+                "local_operation_id reservations must be created before any "
+                "reserved operation is selected"
+            )
+            raise RuntimeError(msg)
+        if local_id in self._claimed_local_ids:
+            msg = f"local_operation_id is already reserved: {local_id}"
+            raise ValueError(msg)
+
+        self._claimed_local_ids.add(local_id)
+        return self._create_id_for_local_id(local_id)
+
+    def _register_reservation(
+        self,
+        operation_id: str,
+        *,
+        has_checkpoint: bool,
+    ) -> None:
+        """Track an allocated reservation until workflow code selects it."""
+        previous = self._unconsumed_reservations.get(operation_id)
+        if operation_id in self._unconsumed_reservations:
+            if previous == has_checkpoint:
+                return
+            if previous:
+                self._unconsumed_checkpoint_count -= 1
+        self._unconsumed_reservations[operation_id] = has_checkpoint
+        if has_checkpoint:
+            self._unconsumed_checkpoint_count += 1
+
+    def _consume_reservation(self, operation_id: str) -> None:
+        """Discard a reservation after workflow code selects it."""
+        self._mark_reservation_selected()
+        has_checkpoint = self._unconsumed_reservations.pop(operation_id, False)
+        if has_checkpoint:
+            self._unconsumed_checkpoint_count -= 1
+
+    def _mark_reservation_selected(self) -> None:
+        """Prevent explicit local ids from being registered after selection."""
+        self._reservation_selection_started = True
+
+    def _has_unconsumed_checkpoint(self) -> bool:
+        """Return whether any allocated reservation still has replay history."""
+        return self._unconsumed_checkpoint_count > 0
+
+    def _mark_replay_frontier(self) -> None:
+        """Remember that replay ended immediately before a virtual scope."""
+        self._replay_frontier_pending = True
+
+    def _clear_replay_frontier(self) -> None:
+        """Clear a replay frontier after the next operation boundary is known."""
+        self._replay_frontier_pending = False
+
+    def _is_replay_frontier_pending(self) -> bool:
+        """Return whether a virtual scope may still contain flattened history."""
+        return self._replay_frontier_pending
+
 
 @dataclass(frozen=True)
 class OperationContext:
@@ -113,7 +200,11 @@ class DurableContext(OperationContext):
         )
 
     def create_child_context(
-        self, operation_id: str, *, is_virtual: bool = False
+        self,
+        operation_id: str,
+        *,
+        is_virtual: bool = False,
+        replaying: bool | None = None,
     ) -> DurableContext:
         """Create a child context for the given operation."""
         child_parent_id = self.parent_id if is_virtual else operation_id
@@ -130,7 +221,7 @@ class DurableContext(OperationContext):
                 parent_id=child_parent_id,
             ),
             step_id_prefix=operation_id,
-            replaying=self.is_replaying(),
+            replaying=self.is_replaying() if replaying is None else replaying,
         )
 
     def is_replaying(self) -> bool:
@@ -139,6 +230,18 @@ class DurableContext(OperationContext):
 
     def _set_replay_status_new(self) -> None:
         object.__setattr__(self, "replaying", False)
+        self.step_counter._clear_replay_frontier()  # noqa: SLF001
+
+    def _set_replay_status_frontier(self) -> None:
+        """End parent replay while retaining a snapshot for a virtual child."""
+        object.__setattr__(self, "replaying", False)
+        self.step_counter._mark_replay_frontier()  # noqa: SLF001
+
+    def _virtual_child_replay_snapshot(self) -> bool:
+        """Return replay state including flattened history past the frontier."""
+        return (
+            self.is_replaying() or self.step_counter._is_replay_frontier_pending()  # noqa: SLF001
+        )
 
     def _peek_next_operation_id(self) -> str:
         return self.step_counter._create_step_id_for_logical_step(  # noqa: SLF001
@@ -146,13 +249,24 @@ class DurableContext(OperationContext):
         )
 
     def _next_operation_result(self) -> Operation | None:
-        return self.execution_state.operations.get(self._peek_next_operation_id())
+        return self._operation_result(self._peek_next_operation_id())
+
+    def _operation_result(self, operation_id: str) -> Operation | None:
+        return self.execution_state.operations.get(operation_id)
 
     def _next_operation_exists(self) -> bool:
         return self._next_operation_result() is not None
 
+    def _next_reserved_or_sequential_operation_exists(self) -> bool:
+        if self.step_counter._has_unconsumed_checkpoint():  # noqa: SLF001
+            return True
+        return self._next_operation_exists()
+
     def _next_operation_is_terminal_checkpoint(self) -> bool:
-        operation = self._next_operation_result()
+        return self._operation_is_terminal_checkpoint(self._peek_next_operation_id())
+
+    def _operation_is_terminal_checkpoint(self, operation_id: str) -> bool:
+        operation = self._operation_result(operation_id)
         if operation is None:
             return False
         return operation.status in {
@@ -164,20 +278,39 @@ class DurableContext(OperationContext):
         }
 
     @contextmanager
-    def _replay_aware(self, *, executes_user_code: bool = False):
-        """Update this context's replay status around one durable operation."""
+    def _replay_aware(
+        self,
+        *,
+        operation_id: str | None = None,
+        executes_user_code: bool = False,
+        consume_reservation: bool = True,
+    ) -> Iterator[None]:
+        """Update replay status around one durable operation.
+
+        `operation_id` identifies an operation that was allocated before entering
+        this scope. Pre-allocated reservations are tracked independently from the
+        sequential counter so launch order does not end replay prematurely.
+        """
         was_replaying = self.is_replaying()
-        next_exists = was_replaying and self._next_operation_exists()
-        next_terminal = was_replaying and self._next_operation_is_terminal_checkpoint()
+        self.step_counter._clear_replay_frontier()  # noqa: SLF001
+        current_operation_id = operation_id or self._peek_next_operation_id()
+        if operation_id is not None and consume_reservation:
+            self.step_counter._consume_reservation(operation_id)  # noqa: SLF001
+        current_exists = was_replaying and (
+            self._operation_result(current_operation_id) is not None
+        )
+        current_terminal = was_replaying and self._operation_is_terminal_checkpoint(
+            current_operation_id
+        )
         flip_after = (
             was_replaying
             and not executes_user_code
-            and next_exists
-            and not next_terminal
+            and current_exists
+            and not current_terminal
         )
 
         if was_replaying and (
-            not next_exists or (executes_user_code and not next_terminal)
+            not current_exists or (executes_user_code and not current_terminal)
         ):
             self._set_replay_status_new()
 
@@ -185,9 +318,15 @@ class DurableContext(OperationContext):
             yield
         finally:
             if flip_after:
-                self._set_replay_status_new()
-            elif self.is_replaying() and not self._next_operation_exists():
-                self._set_replay_status_new()
+                self._set_replay_status_frontier()
+            elif self.is_replaying():
+                next_operation_exists = (
+                    self._next_reserved_or_sequential_operation_exists()
+                    if operation_id is not None
+                    else self._next_operation_exists()
+                )
+                if not next_operation_exists:
+                    self._set_replay_status_frontier()
 
 
 _current_context: ContextVar = ContextVar(
@@ -215,7 +354,7 @@ def ensure_durable_operations_allowed(operation_name: str) -> None:
 
 
 @contextmanager
-def bind_durable_definition(operation_name: str):
+def bind_durable_definition(operation_name: str) -> Iterator[None]:
     """Mark a synchronous definition phase in the current context."""
     token = _durable_definition_operation.set(operation_name)
     try:
@@ -234,7 +373,7 @@ def reset_current_context(token: Token) -> None:
     _current_context.reset(token)
 
 
-def get_current_context():
+def get_current_context() -> OperationContext | SerDesContext:
     """Return the currently active durable execution context.
 
     Raises:
@@ -271,7 +410,9 @@ def get_durable_context() -> DurableContext:
 
 
 @contextmanager
-def bind_current_context(context: OperationContext | SerDesContext):
+def bind_current_context(
+    context: OperationContext | SerDesContext,
+) -> Iterator[None]:
     """Temporarily bind the supplied durable context while invoking user code."""
     token = set_current_context(context)
     try:

{async_durable_execution-2.2.0 → async_durable_execution-2.3.0}/async_durable_execution/_core/exceptions.py

@@ -238,7 +238,7 @@ class DurableExecutionsError(Exception):
 class UnrecoverableError(DurableExecutionsError):
     """Base class for errors that terminate execution."""
 
-    def __init__(self, message: str, termination_reason: TerminationReason):
+    def __init__(self, message: str, termination_reason: TerminationReason) -> None:
         super().__init__(message)
         self.termination_reason = termination_reason
 
@@ -250,7 +250,7 @@ class ExecutionError(UnrecoverableError):
         self,
         message: str,
         termination_reason: TerminationReason = TerminationReason.EXECUTION_ERROR,
-    ):
+    ) -> None:
         super().__init__(message, termination_reason)
 
 
@@ -263,7 +263,7 @@ class _RestoredExecutionError(ExecutionError):
         *,
         original_error_type: str,
         termination_reason: TerminationReason,
-    ):
+    ) -> None:
         super().__init__(message, termination_reason)
         self.original_error_type = original_error_type
 
@@ -275,7 +275,7 @@ class InvocationError(UnrecoverableError):
         self,
         message: str,
         termination_reason: TerminationReason = TerminationReason.INVOCATION_ERROR,
-    ):
+    ) -> None:
         super().__init__(message, termination_reason)
 
     def is_retryable(self) -> bool:
@@ -318,7 +318,7 @@ class BotoClientError(InvocationError):
         error: AwsErrorObj | None = None,
         response_metadata: AwsErrorMetadata | None = None,
         termination_reason=TerminationReason.INVOCATION_ERROR,
-    ):
+    ) -> None:
         super().__init__(message=message, termination_reason=termination_reason)
         self.error: AwsErrorObj | None = error
         self.response_metadata: AwsErrorMetadata | None = response_metadata
@@ -409,7 +409,7 @@ class _RestoredInvocationError(InvocationError):
         error_category: DurableApiErrorCategory | None = None,
         error: AwsErrorObj | None = None,
         response_metadata: AwsErrorMetadata | None = None,
-    ):
+    ) -> None:
         super().__init__(message, termination_reason)
         self.original_error_type = original_error_type
         self.retryable = retryable
@@ -643,7 +643,7 @@ def _restore_sdk_control_error(
 class NonDeterministicExecutionError(ExecutionError):
     """Error when execution is non-deterministic."""
 
-    def __init__(self, message: str, step_id: str | None = None):
+    def __init__(self, message: str, step_id: str | None = None) -> None:
         super().__init__(message, TerminationReason.NON_DETERMINISTIC_EXECUTION)
         self.step_id = step_id
 
@@ -657,7 +657,7 @@ class CheckpointError(BotoClientError):
         error_category: DurableApiErrorCategory = DurableApiErrorCategory.INVOCATION,
         error: AwsErrorObj | None = None,
         response_metadata: AwsErrorMetadata | None = None,
-    ):
+    ) -> None:
         super().__init__(
             message,
             error_category,
@@ -680,7 +680,7 @@ class GetExecutionStateError(BotoClientError):
         error_category: DurableApiErrorCategory = DurableApiErrorCategory.INVOCATION,
         error: AwsErrorObj | None = None,
         response_metadata: AwsErrorMetadata | None = None,
-    ):
+    ) -> None:
         super().__init__(
             message,
             error_category,
@@ -740,7 +740,7 @@ class BackgroundThreadError(BaseException):
         source_exception: The original exception from the background thread
     """
 
-    def __init__(self, message: str, source_exception: Exception):
+    def __init__(self, message: str, source_exception: Exception) -> None:
         super().__init__(message)
         self.source_exception = source_exception
 
@@ -752,7 +752,7 @@ class OrphanedChildException(BaseException):
     with broad exception handlers like ``except Exception``.
     """
 
-    def __init__(self, message: str, operation_id: str):
+    def __init__(self, message: str, operation_id: str) -> None:
         super().__init__(message)
         self.operation_id = operation_id
 
@@ -764,7 +764,7 @@ class SuspendExecution(BaseException):
     KeyboardInterrupt or SystemExit.
     """
 
-    def __init__(self, message: str):
+    def __init__(self, message: str) -> None:
         super().__init__(message)
 
 
@@ -777,7 +777,7 @@ class TimedSuspendExecution(SuspendExecution):
         scheduled_timestamp (float): Unix timestamp in seconds at which to resume.
     """
 
-    def __init__(self, message: str, scheduled_timestamp: float):
+    def __init__(self, message: str, scheduled_timestamp: float) -> None:
         super().__init__(message)
         self.scheduled_timestamp = scheduled_timestamp