async-durable-execution 0.1.0__tar.gz → 2.0.0a2__tar.gz

{async_durable_execution-0.1.0 → async_durable_execution-2.0.0a2}/.gitignore

@@ -9,6 +9,7 @@ __pycache__/
 *$py.class
 *.egg-info/
 
+*.coverage
 /.coverage
 /.coverage.*
 /.cache
@@ -20,7 +21,7 @@ __pycache__/
 /build
 
 .venv
-.venv/
+.venv*/
 
 .attach_*
 
@@ -28,4 +29,12 @@ dist/
 
 .idea
 
-.kiro/
+.kiro/
+
+**/build/
+**/*.zip
+packages/async-durable-execution-examples/template.yaml
+**/template.generated.json
+
+.env
+*.egg-info

async_durable_execution-2.0.0a2/NOTICE

@@ -0,0 +1,8 @@
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+This repository is a modified fork of software originally released by
+Amazon.com, Inc. or its affiliates under the Apache License 2.0.
+
+Fork modifications and continued maintenance:
+Copyright 2026 Zhongke Chen
+Repository: https://github.com/zhongkechen/async-durable-execution

async_durable_execution-2.0.0a2/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: async-durable-execution
+Version: 2.0.0a2
+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
+Project-URL: Source, https://github.com/zhongkechen/async-durable-execution
+Author: Zhongke Chen
+License-Expression: Apache-2.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+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 :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: boto3>=1.42.1
+Provides-Extra: typing
+Requires-Dist: boto3-stubs[lambda]>=1.42.1; extra == 'typing'
+Description-Content-Type: text/markdown
+
+# Async Durable Execution for Python
+
+[![Build](https://github.com/zhongkechen/async-durable-execution/actions/workflows/build.yml/badge.svg)](https://github.com/zhongkechen/async-durable-execution/actions/workflows/build.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/async-durable-execution.svg)](https://pypi.org/project/async-durable-execution)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/async-durable-execution.svg)](https://pypi.org/project/async-durable-execution)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/zhongkechen/async-durable-execution/badge)](https://scorecard.dev/viewer/?uri=github.com/zhongkechen/async-durable-execution)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](../../LICENSE)
+
+-----
+
+Build reliable, long-running AWS Lambda workflows with checkpointed steps, waits, callbacks, and parallel execution.
+
+This package is distributed from a community-maintained fork of the original Apache-2.0 licensed AWS project and continues under Apache License 2.0 with upstream notices preserved.
+
+This fork is specifically focused on making async Python work naturally with durable functions. The public API remains synchronous at the durable operation boundary, but user-provided durable callables must now use `async def` for handlers, steps, child contexts, callback submitters, and condition checks.
+
+## ✨ Key Features
+
+- **Async-only user callables** - Durable handlers and user-provided durable callbacks must use `async def`
+- **Automatic checkpointing** - Resume execution after Lambda pauses or restarts
+- **Durable steps** - Run work with retry strategies and deterministic replay
+- **Waits and callbacks** - Pause for time or external signals without blocking Lambda
+- **Parallel and map operations** - Fan out work with configurable completion criteria
+- **Child contexts** - Structure complex workflows into isolated subflows
+- **Replay-safe logging** - Use standard `logging` loggers enriched by the durable context filter
+- **Local and cloud testing** - Validate workflows with the testing SDK
+- **Async Python support** - Use `async def` for handlers, steps, child contexts, callback submitters, and wait-for-condition checks
+
+## 📦 Packages
+
+| Package | Description | Version |
+| --- | --- | --- |
+| `async-durable-execution` | Execution SDK for Lambda durable functions | [![PyPI - Version](https://img.shields.io/pypi/v/async-durable-execution.svg)](https://pypi.org/project/async-durable-execution) |
+| `async-durable-execution-runner` | Local/cloud test runner and pytest helpers | [![PyPI - Version](https://img.shields.io/pypi/v/async-durable-execution-runner.svg)](https://pypi.org/project/async-durable-execution-runner) |
+| `async-durable-execution-examples` | Example durable functions and integration tests for local and cloud workflows | Shared repo version |
+
+## 🚀 Quick Start
+
+This fork now requires async callables for all user-provided durable code.
+Requires Python 3.10 or newer.
+
+Install the execution SDK:
+
+```console
+pip install async-durable-execution
+```
+
+Create a durable Lambda handler:
+
+```python
+import asyncio
+import logging
+from datetime import timedelta
+
+from async_durable_execution import (
+    durable_step,
+    durable_execution,
+    step,
+    wait,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@durable_step
+async def validate_order(order_id: str) -> dict:
+    await asyncio.sleep(0)
+    logger.info("Validating order", extra={"order_id": order_id})
+    return {"order_id": order_id, "valid": True}
+
+
+@durable_execution
+async def handler(event: dict) -> dict:
+    order_id = event["order_id"]
+    logger.info("Starting workflow", extra={"order_id": order_id})
+
+    validation = await step(validate_order(order_id), name="validate_order")
+    if not validation["valid"]:
+        return {"status": "rejected", "order_id": order_id}
+
+    # simulate approval (real world: use wait_for_callback)
+    await wait(duration=timedelta(seconds=5), name="await_confirmation")
+
+    return {"status": "approved", "order_id": order_id}
+```
+
+Async callables are required anywhere the SDK accepts user code, including `map()` item functions, `parallel()` branches, child contexts, callback submitters, and wait-for-condition checks. Durable context operations are awaitable and run on the same event loop as your handler:
+
+```python
+import asyncio
+import logging
+
+from async_durable_execution import (
+    durable_step,
+    durable_execution,
+    step,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@durable_step
+async def fetch_order(order_id: str) -> dict:
+    await asyncio.sleep(0)
+    logger.info("Fetched order", extra={"order_id": order_id})
+    return {"order_id": order_id, "status": "ready"}
+
+
+@durable_execution
+async def handler(event: dict) -> dict:
+    order = await step(fetch_order(event["order_id"]), name="fetch_order")
+    return {"order": order}
+```
+
+## 📚 Documentation
+
+The complete documentation for the AWS Durable Execution SDK for Python lives on the AWS Documentation site:
+
+- **[AWS Durable Execution Documentation](https://docs.aws.amazon.com/durable-execution/)** - Concepts, getting started, core operations, advanced topics, and API reference
+- **[AWS Lambda Durable Functions Guide](https://docs.aws.amazon.com/lambda/latest/dg/durable-functions.html)** - How durable functions work on Lambda
+
+## 💬 Feedback & Support
+
+- [Bug report](https://github.com/zhongkechen/async-durable-execution/issues/new?template=bug_report.yml)
+- [Feature request](https://github.com/zhongkechen/async-durable-execution/issues/new?template=feature_request.yml)
+- [Documentation feedback](https://github.com/zhongkechen/async-durable-execution/issues/new?template=documentation.yml)
+- [Contributing guide](../../CONTRIBUTING.md)
+
+## 📄 License
+
+See the [LICENSE](../../LICENSE) file for our project's licensing.

async_durable_execution-2.0.0a2/README.md

@@ -0,0 +1,131 @@
+# Async Durable Execution for Python
+
+[![Build](https://github.com/zhongkechen/async-durable-execution/actions/workflows/build.yml/badge.svg)](https://github.com/zhongkechen/async-durable-execution/actions/workflows/build.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/async-durable-execution.svg)](https://pypi.org/project/async-durable-execution)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/async-durable-execution.svg)](https://pypi.org/project/async-durable-execution)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/zhongkechen/async-durable-execution/badge)](https://scorecard.dev/viewer/?uri=github.com/zhongkechen/async-durable-execution)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](../../LICENSE)
+
+-----
+
+Build reliable, long-running AWS Lambda workflows with checkpointed steps, waits, callbacks, and parallel execution.
+
+This package is distributed from a community-maintained fork of the original Apache-2.0 licensed AWS project and continues under Apache License 2.0 with upstream notices preserved.
+
+This fork is specifically focused on making async Python work naturally with durable functions. The public API remains synchronous at the durable operation boundary, but user-provided durable callables must now use `async def` for handlers, steps, child contexts, callback submitters, and condition checks.
+
+## ✨ Key Features
+
+- **Async-only user callables** - Durable handlers and user-provided durable callbacks must use `async def`
+- **Automatic checkpointing** - Resume execution after Lambda pauses or restarts
+- **Durable steps** - Run work with retry strategies and deterministic replay
+- **Waits and callbacks** - Pause for time or external signals without blocking Lambda
+- **Parallel and map operations** - Fan out work with configurable completion criteria
+- **Child contexts** - Structure complex workflows into isolated subflows
+- **Replay-safe logging** - Use standard `logging` loggers enriched by the durable context filter
+- **Local and cloud testing** - Validate workflows with the testing SDK
+- **Async Python support** - Use `async def` for handlers, steps, child contexts, callback submitters, and wait-for-condition checks
+
+## 📦 Packages
+
+| Package | Description | Version |
+| --- | --- | --- |
+| `async-durable-execution` | Execution SDK for Lambda durable functions | [![PyPI - Version](https://img.shields.io/pypi/v/async-durable-execution.svg)](https://pypi.org/project/async-durable-execution) |
+| `async-durable-execution-runner` | Local/cloud test runner and pytest helpers | [![PyPI - Version](https://img.shields.io/pypi/v/async-durable-execution-runner.svg)](https://pypi.org/project/async-durable-execution-runner) |
+| `async-durable-execution-examples` | Example durable functions and integration tests for local and cloud workflows | Shared repo version |
+
+## 🚀 Quick Start
+
+This fork now requires async callables for all user-provided durable code.
+Requires Python 3.10 or newer.
+
+Install the execution SDK:
+
+```console
+pip install async-durable-execution
+```
+
+Create a durable Lambda handler:
+
+```python
+import asyncio
+import logging
+from datetime import timedelta
+
+from async_durable_execution import (
+    durable_step,
+    durable_execution,
+    step,
+    wait,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@durable_step
+async def validate_order(order_id: str) -> dict:
+    await asyncio.sleep(0)
+    logger.info("Validating order", extra={"order_id": order_id})
+    return {"order_id": order_id, "valid": True}
+
+
+@durable_execution
+async def handler(event: dict) -> dict:
+    order_id = event["order_id"]
+    logger.info("Starting workflow", extra={"order_id": order_id})
+
+    validation = await step(validate_order(order_id), name="validate_order")
+    if not validation["valid"]:
+        return {"status": "rejected", "order_id": order_id}
+
+    # simulate approval (real world: use wait_for_callback)
+    await wait(duration=timedelta(seconds=5), name="await_confirmation")
+
+    return {"status": "approved", "order_id": order_id}
+```
+
+Async callables are required anywhere the SDK accepts user code, including `map()` item functions, `parallel()` branches, child contexts, callback submitters, and wait-for-condition checks. Durable context operations are awaitable and run on the same event loop as your handler:
+
+```python
+import asyncio
+import logging
+
+from async_durable_execution import (
+    durable_step,
+    durable_execution,
+    step,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@durable_step
+async def fetch_order(order_id: str) -> dict:
+    await asyncio.sleep(0)
+    logger.info("Fetched order", extra={"order_id": order_id})
+    return {"order_id": order_id, "status": "ready"}
+
+
+@durable_execution
+async def handler(event: dict) -> dict:
+    order = await step(fetch_order(event["order_id"]), name="fetch_order")
+    return {"order": order}
+```
+
+## 📚 Documentation
+
+The complete documentation for the AWS Durable Execution SDK for Python lives on the AWS Documentation site:
+
+- **[AWS Durable Execution Documentation](https://docs.aws.amazon.com/durable-execution/)** - Concepts, getting started, core operations, advanced topics, and API reference
+- **[AWS Lambda Durable Functions Guide](https://docs.aws.amazon.com/lambda/latest/dg/durable-functions.html)** - How durable functions work on Lambda
+
+## 💬 Feedback & Support
+
+- [Bug report](https://github.com/zhongkechen/async-durable-execution/issues/new?template=bug_report.yml)
+- [Feature request](https://github.com/zhongkechen/async-durable-execution/issues/new?template=feature_request.yml)
+- [Documentation feedback](https://github.com/zhongkechen/async-durable-execution/issues/new?template=documentation.yml)
+- [Contributing guide](../../CONTRIBUTING.md)
+
+## 📄 License
+
+See the [LICENSE](../../LICENSE) file for our project's licensing.

async_durable_execution-0.1.0/src/async_durable_execution/__about__.py → async_durable_execution-2.0.0a2/VERSION.py

@@ -1,4 +1,5 @@
 # SPDX-FileCopyrightText: 2025-present Amazon.com, Inc. or its affiliates.
 #
 # SPDX-License-Identifier: Apache-2.0
-__version__ = "0.1.0"
+# Modified for the async-durable-execution fork; shared version source for all packages.
+__version__ = "2.0.0a2"

async_durable_execution-2.0.0a2/pyproject.toml

@@ -0,0 +1,90 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+# Modified fork metadata for async-durable-execution; upstream Apache-2.0 notices are preserved in the repository LICENSE and NOTICE files.
+[project]
+name = "async-durable-execution"
+dynamic = ["version"]
+description = "Community-maintained durable execution SDK for AWS Lambda in Python"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+keywords = []
+authors = [{ name = "Zhongke Chen" }]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = ["boto3>=1.42.1"]
+
+[project.optional-dependencies]
+typing = ["boto3-stubs[lambda]>=1.42.1"]
+
+[project.urls]
+Documentation = "https://github.com/zhongkechen/async-durable-execution#readme"
+Issues = "https://github.com/zhongkechen/async-durable-execution/issues"
+Source = "https://github.com/zhongkechen/async-durable-execution"
+
+[tool.hatch.build.targets.sdist.force-include]
+"../../LICENSE" = "LICENSE"
+"../../NOTICE" = "NOTICE"
+"../../VERSION.py" = "VERSION.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/async_durable_execution"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"../../LICENSE" = "LICENSE"
+"../../NOTICE" = "NOTICE"
+"../../VERSION.py" = "VERSION.py"
+
+[tool.hatch.version]
+path = "../../VERSION.py"
+
+[tool.coverage.run]
+source_pkgs = ["async_durable_execution"]
+branch = true
+parallel = true
+omit = ["src/async_durable_execution/__about__.py"]
+
+[tool.coverage.paths]
+async_durable_execution = [
+  "src/async_durable_execution",
+  "*/async-durable-execution/src/async_durable_execution",
+]
+
+[tool.coverage.report]
+exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+preview = true
+select = []
+
+[tool.ruff.lint.isort]
+known-first-party = ["async_durable_execution"]
+force-single-line = false
+lines-after-imports = 2
+
+[tool.ruff.lint.per-file-ignores]
+"tests_async_durable_execution/**" = [
+  "ARG001",
+  "ARG002",
+  "ARG005",
+  "S101",
+  "PLR2004",
+  "PLR6301",
+  "SIM117",
+  "TRY301",
+]

async_durable_execution-2.0.0a2/src/async_durable_execution/__about__.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: 2025-present Amazon.com, Inc. or its affiliates.
+#
+# SPDX-License-Identifier: Apache-2.0
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+
+_DIST_NAME = "async-durable-execution"
+
+
+def _read_repo_version() -> str:
+    version_file = _find_version_file()
+    if version_file is None:
+        return "0.0.0"
+
+    namespace: dict[str, str] = {}
+    exec(version_file.read_text(encoding="utf-8"), namespace)
+    return namespace["__version__"]
+
+
+def _find_version_file() -> Path | None:
+    current = Path(__file__).resolve()
+    for parent in current.parents:
+        candidate = parent / "VERSION.py"
+        if candidate.exists():
+            return candidate
+    return None
+
+
+try:
+    __version__ = version(_DIST_NAME)
+except PackageNotFoundError:
+    __version__ = _read_repo_version()

async_durable_execution-2.0.0a2/src/async_durable_execution/__init__.py

@@ -0,0 +1,132 @@
+"""AWS Lambda Durable Executions Python SDK."""
+
+# Package metadata
+from .__about__ import __version__
+
+# Main context - used in every durable function
+# Helper decorators - commonly used for step functions
+# Concurrency
+from .models import (
+    BatchItem,
+    BatchItemStatus,
+    BatchResult,
+    CompletionReason,
+    InvocationStatus,
+    OperationType,
+    OperationStatus,
+)
+from .config import (
+    CallbackConfig,
+    CompletionConfig,
+    MapConfig,
+    NestingType,
+    ParallelBranch,
+    ParallelConfig,
+    RetryPresets,
+    RetryStrategyBuilder,
+    StepConfig,
+    StepSemantics,
+    WaitStrategyBuilder,
+    WaitForCallbackConfig,
+    WaitForConditionConfig,
+    WithRetryConfig,
+)
+from .context import (
+    get_current_context,
+)
+from .operation.with_retry import with_retry
+from .operation.map import map
+from .operation.wait_for_condition import (
+    wait_for_condition,
+    WaitForConditionCheckContext,
+)
+from .operation.invoke import invoke
+from .operation.parallel import parallel, durable_parallel_branch
+from .operation.callback import (
+    create_callback,
+    durable_wait_for_callback,
+    wait_for_callback,
+    WaitForCallbackContext,
+    Callback,
+)
+from .operation.child import durable_child_context, run_in_child_context, DurableContext
+from .operation.step import step, durable_step, StepContext, get_attempt
+from .models import (
+    ErrorObject,
+    OperationIdentifier,
+    RetryDecision,
+    WaitDecision,
+    WaitForConditionDecision,
+)
+
+# Most common exceptions - users need to handle these exceptions
+from .exceptions import (
+    DurableExecutionsError,
+    InvocationError,
+    ValidationError,
+)
+
+# Core decorator - used in every durable function
+from .execution import durable_execution
+from .operation.wait import wait
+from .plugin import DurableInstrumentationPlugin
+from .serdes import JsonSerDes, SerDes, SerDesContext
+
+__all__ = [
+    "BatchItem",
+    "BatchItemStatus",
+    "BatchResult",
+    "Callback",
+    "CallbackConfig",
+    "CompletionConfig",
+    "CompletionReason",
+    "DurableContext",
+    "DurableInstrumentationPlugin",
+    "DurableExecutionsError",
+    "ErrorObject",
+    "InvocationError",
+    "JsonSerDes",
+    "MapConfig",
+    "NestingType",
+    "OperationIdentifier",
+    "ParallelBranch",
+    "ParallelConfig",
+    "RetryDecision",
+    "RetryPresets",
+    "RetryStrategyBuilder",
+    "SerDes",
+    "SerDesContext",
+    "StepConfig",
+    "StepContext",
+    "StepSemantics",
+    "ValidationError",
+    "WaitForCallbackConfig",
+    "WaitForCallbackContext",
+    "WaitDecision",
+    "WaitForConditionCheckContext",
+    "WaitForConditionConfig",
+    "WaitForConditionDecision",
+    "WaitStrategyBuilder",
+    "WithRetryConfig",
+    "__version__",
+    "create_callback",
+    "durable_execution",
+    "durable_parallel_branch",
+    "durable_step",
+    "durable_wait_for_callback",
+    "get_attempt",
+    "get_current_context",
+    "invoke",
+    "map",
+    "parallel",
+    "run_in_child_context",
+    "step",
+    "wait",
+    "wait_for_callback",
+    "wait_for_condition",
+    "with_retry",
+    "InvocationStatus",
+    "OperationType",
+    "OperationStatus",
+    "durable_child_context",
+]

async_durable_execution-2.0.0a2/src/async_durable_execution/async_tools.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import functools
+import inspect
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, TypeVar, cast
+
+from .context import reset_current_context, set_current_context
+from .exceptions import ValidationError
+
+if TYPE_CHECKING:
+    from . import DurableContext
+
+T = TypeVar("T")
+_CONTEXT_PARAM_NAMES = {
+    "context",
+    "ctx",
+    "child_context",
+    "child_ctx",
+    "durable_context",
+    "durable_ctx",
+}
+
+
+def is_async_callable(func: Callable[..., object]) -> bool:
+    if inspect.iscoroutinefunction(func):
+        return True
+    if isinstance(func, functools.partial):
+        return is_async_callable(func.func)
+
+    call = getattr(func, "__call__", None)
+    return call is not None and inspect.iscoroutinefunction(call)
+
+
+def get_callable_name(
+    func: Callable[..., object],
+    *,
+    include_original_name: bool = True,
+) -> str | None:
+    if isinstance(func, functools.partial):
+        return get_callable_name(
+            func.func,
+            include_original_name=include_original_name,
+        )
+
+    if include_original_name:
+        original_name = getattr(func, "_original_name", None)
+        if original_name is not None:
+            return original_name
+
+    if inspect.isfunction(func) or inspect.ismethod(func):
+        return getattr(func, "__name__", None)
+
+    return None
+
+
+def assert_async_callable(
+    func: Callable[..., object],
+    *,
+    label: str = "func",
+) -> None:
+    if is_async_callable(func):
+        return
+
+    name = get_callable_name(func)
+    if name is None:
+        name = type(func).__name__
+
+    msg = (
+        f"`{label}` must be an async function. "
+        f"Non-async callables are no longer supported: {name}."
+    )
+    raise ValidationError(msg)
+
+
+async def invoke_callable(func: Callable[..., Awaitable[T]], *args, **kwargs) -> T:
+    assert_async_callable(func)
+    return await func(*args, **kwargs)
+
+
+async def invoke_user_callable(
+    context: DurableContext,
+    func: Callable[..., Awaitable[T]],
+    *args,
+    **kwargs,
+) -> T:
+    token = set_current_context(context)
+    try:
+        return await invoke_callable(
+            func,
+            *args,
+            **kwargs,
+        )
+    finally:
+        reset_current_context(token)