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

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

@@ -9,6 +9,7 @@ __pycache__/
 *$py.class
 *.egg-info/
 
+*.coverage
 /.coverage
 /.coverage.*
 /.cache
@@ -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.0a1/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.0a1/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: async-durable-execution
+Version: 2.0.0a1
+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.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.11
+Requires-Dist: boto3>=1.42.1
+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 the examples, helpers, and package direction here prioritize `async def` handlers, steps, child contexts, callback submitters, and condition checks.
+
+## ✨ Key Features
+
+- **Async-first fork** - This fork prioritizes making `async def` workflows feel natural with durable functions
+- **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 `context.logger` for structured, de-duplicated logs
+- **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 recommends writing new durable workflows with async callables by default.
+
+Install the execution SDK:
+
+```console
+pip install async-durable-execution
+```
+
+Create a durable Lambda handler:
+
+```python
+import asyncio
+
+from async_durable_execution import (
+    DurableContext,
+    StepContext,
+    durable_execution,
+    durable_step,
+)
+from async_durable_execution.config import Duration
+
+
+@durable_step
+async def validate_order(step_ctx: StepContext, order_id: str) -> dict:
+    await asyncio.sleep(0)
+    step_ctx.logger.info("Validating order", extra={"order_id": order_id})
+    return {"order_id": order_id, "valid": True}
+
+
+@durable_execution
+async def handler(event: dict, context: DurableContext) -> dict:
+    order_id = event["order_id"]
+    context.logger.info("Starting workflow", extra={"order_id": order_id})
+
+    validation = context.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)
+    context.wait(duration=Duration.from_seconds(5), name="await_confirmation")
+
+    return {"status": "approved", "order_id": order_id}
+```
+
+Async callables are supported anywhere the SDK accepts user code, including `map()` item functions, `parallel()` branches, child contexts, callback submitters, and wait-for-condition checks. The public Durable APIs stay synchronous, so async work is awaited transparently for you:
+
+```python
+import asyncio
+
+from async_durable_execution import (
+    DurableContext,
+    StepContext,
+    durable_execution,
+    durable_step,
+)
+
+
+@durable_step
+async def fetch_order(step_ctx: StepContext, order_id: str) -> dict:
+    await asyncio.sleep(0)
+    step_ctx.logger.info("Fetched order", extra={"order_id": order_id})
+    return {"order_id": order_id, "status": "ready"}
+
+
+@durable_execution
+async def handler(event: dict, context: DurableContext) -> dict:
+    order = context.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.0a1/README.md

@@ -0,0 +1,125 @@
+# 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 the examples, helpers, and package direction here prioritize `async def` handlers, steps, child contexts, callback submitters, and condition checks.
+
+## ✨ Key Features
+
+- **Async-first fork** - This fork prioritizes making `async def` workflows feel natural with durable functions
+- **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 `context.logger` for structured, de-duplicated logs
+- **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 recommends writing new durable workflows with async callables by default.
+
+Install the execution SDK:
+
+```console
+pip install async-durable-execution
+```
+
+Create a durable Lambda handler:
+
+```python
+import asyncio
+
+from async_durable_execution import (
+    DurableContext,
+    StepContext,
+    durable_execution,
+    durable_step,
+)
+from async_durable_execution.config import Duration
+
+
+@durable_step
+async def validate_order(step_ctx: StepContext, order_id: str) -> dict:
+    await asyncio.sleep(0)
+    step_ctx.logger.info("Validating order", extra={"order_id": order_id})
+    return {"order_id": order_id, "valid": True}
+
+
+@durable_execution
+async def handler(event: dict, context: DurableContext) -> dict:
+    order_id = event["order_id"]
+    context.logger.info("Starting workflow", extra={"order_id": order_id})
+
+    validation = context.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)
+    context.wait(duration=Duration.from_seconds(5), name="await_confirmation")
+
+    return {"status": "approved", "order_id": order_id}
+```
+
+Async callables are supported anywhere the SDK accepts user code, including `map()` item functions, `parallel()` branches, child contexts, callback submitters, and wait-for-condition checks. The public Durable APIs stay synchronous, so async work is awaited transparently for you:
+
+```python
+import asyncio
+
+from async_durable_execution import (
+    DurableContext,
+    StepContext,
+    durable_execution,
+    durable_step,
+)
+
+
+@durable_step
+async def fetch_order(step_ctx: StepContext, order_id: str) -> dict:
+    await asyncio.sleep(0)
+    step_ctx.logger.info("Fetched order", extra={"order_id": order_id})
+    return {"order_id": order_id, "status": "ready"}
+
+
+@durable_execution
+async def handler(event: dict, context: DurableContext) -> dict:
+    order = context.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.0a1/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.0a1"

async_durable_execution-2.0.0a1/pyproject.toml

@@ -0,0 +1,86 @@
+[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.11"
+license = "Apache-2.0"
+keywords = []
+authors = [{ name = "Zhongke Chen" }]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "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.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 = "py311"
+
+[tool.ruff.lint]
+preview = true
+select = ["TID252"]  # Enforce absolute imports (ban relative imports)
+
+[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/**" = [
+  "ARG001",
+  "ARG002",
+  "ARG005",
+  "S101",
+  "PLR2004",
+  "PLR6301",
+  "SIM117",
+  "TRY301",
+]

async_durable_execution-2.0.0a1/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-0.1.0 → async_durable_execution-2.0.0a1}/src/async_durable_execution/__init__.py

@@ -1,42 +1,50 @@
 """AWS Lambda Durable Executions Python SDK."""
 
 # Package metadata
-from .__about__ import __version__
+from async_durable_execution.__about__ import __version__
 
 # Main context - used in every durable function
 # Helper decorators - commonly used for step functions
 # Concurrency
-from .concurrency.models import BatchResult
-from .context import (
+from async_durable_execution.concurrency.models import BatchResult
+from async_durable_execution.config import ParallelBranch
+from async_durable_execution.context import (
     DurableContext,
+    durable_parallel_branch,
     durable_step,
     durable_wait_for_callback,
     durable_with_child_context,
 )
 
 # Most common exceptions - users need to handle these exceptions
-from .exceptions import (
+from async_durable_execution.exceptions import (
     DurableExecutionsError,
     InvocationError,
     ValidationError,
 )
 
 # Core decorator - used in every durable function
-from .execution import durable_execution
+from async_durable_execution.execution import durable_execution
+from async_durable_execution.retries import WithRetryConfig, with_retry
 
 # Essential context types - passed to user functions
-from .types import StepContext
+from async_durable_execution.types import StepContext
+
 
 __all__ = [
     "BatchResult",
     "DurableContext",
     "DurableExecutionsError",
     "InvocationError",
+    "ParallelBranch",
     "StepContext",
     "ValidationError",
+    "WithRetryConfig",
     "__version__",
     "durable_execution",
+    "durable_parallel_branch",
     "durable_step",
     "durable_wait_for_callback",
     "durable_with_child_context",
+    "with_retry",
 ]

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

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import queue
+import threading
+from collections.abc import Awaitable, Callable
+from typing import Any, TypeVar, cast
+
+
+T = TypeVar("T")
+
+
+def resolve_awaitable(value: T | Awaitable[T]) -> T:
+    if inspect.isawaitable(value):
+        return run_awaitable(cast(Awaitable[T], value))
+    return value
+
+
+def invoke_callable(func: Callable[..., T | Awaitable[T]], *args, **kwargs) -> T:
+    return resolve_awaitable(func(*args, **kwargs))
+
+
+def run_awaitable(awaitable: Awaitable[T]) -> T:
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(awaitable)
+
+    return _run_awaitable_in_thread(awaitable)
+
+
+def _run_awaitable_in_thread(awaitable: Awaitable[T]) -> T:
+    result_queue: queue.Queue[tuple[bool, T | BaseException]] = queue.Queue(maxsize=1)
+
+    def runner() -> None:
+        try:
+            result_queue.put((True, asyncio.run(awaitable)))
+        except BaseException as exc:  # noqa: BLE001
+            result_queue.put((False, exc))
+
+    thread = threading.Thread(target=runner, name="dex-async-user-code", daemon=True)
+    thread.start()
+    success, payload = result_queue.get()
+    thread.join()
+
+    if success:
+        return cast(T, payload)
+    raise cast(BaseException, payload)