async-durable-execution-runner 2.0.0a1__tar.gz → 2.0.0a2__tar.gz

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/.gitignore

@@ -21,7 +21,7 @@ __pycache__/
 /build
 
 .venv
-.venv/
+.venv*/
 
 .attach_*
 

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-durable-execution-runner
-Version: 2.0.0a1
+Version: 2.0.0a2
 Summary: Community-maintained durable execution local and cloud test runner for Python
 Project-URL: Documentation, https://github.com/zhongkechen/async-durable-execution#readme
 Project-URL: Issues, https://github.com/zhongkechen/async-durable-execution/issues
@@ -11,17 +11,20 @@ License-File: LICENSE
 License-File: NOTICE
 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.11
-Requires-Dist: async-durable-execution>=1.0.0
+Requires-Python: >=3.10
+Requires-Dist: async-durable-execution>=2.0.0a2
 Requires-Dist: boto3>=1.42.1
 Description-Content-Type: text/markdown
 
+from async_durable_execution.operation import child
+
 # Async Durable Execution Runner for Python
 
 [![PyPI - Version](https://img.shields.io/pypi/v/async-durable-execution-runner.svg)](https://pypi.org/project/async-durable-execution-runner)
@@ -43,6 +46,8 @@ Description-Content-Type: text/markdown
 
 ## Installation
 
+Requires Python 3.10 or newer.
+
 ```console
 pip install async-durable-execution-runner
 ```
@@ -62,58 +67,54 @@ before you deploy it.
 
 ```python
 import asyncio
+from datetime import timedelta
+from functools import partial
 from typing import Any
 
 from async_durable_execution import (
-    DurableContext,
     durable_execution,
-    durable_step,
-    durable_with_child_context,
+    get_current_context,
 )
-from async_durable_execution.config import Duration
 
 
-@durable_step
 async def one(a: int, b: int) -> str:
     await asyncio.sleep(0)
     return f"{a} {b}"
 
 
-@durable_step
 async def two_1(a: int, b: int) -> str:
     await asyncio.sleep(0)
     return f"{a} {b}"
 
 
-@durable_step
 async def two_2(a: int, b: int) -> str:
     await asyncio.sleep(0)
     return f"{b} {a}"
 
 
-@durable_with_child_context
-async def two(ctx: DurableContext, a: int, b: int) -> str:
+async def two(a: int, b: int) -> str:
+    ctx = get_current_context()
     two_1_result: str = ctx.step(two_1(a, b))
     two_2_result: str = ctx.step(two_2(a, b))
     return f"{two_1_result} {two_2_result}"
 
 
-@durable_step
 async def three(a: int, b: int) -> str:
     await asyncio.sleep(0)
     return f"{a} {b}"
 
 
 @durable_execution
-async def function_under_test(event: Any, context: DurableContext) -> list[str]:
+async def function_under_test(event: Any) -> list[str]:
+    context = get_current_context()
     results: list[str] = []
 
     result_one: str = context.step(one(1, 2))
     results.append(result_one)
 
-    context.wait(duration=Duration.from_seconds(1))
+    context.wait(duration=timedelta(seconds=1))
 
-    result_two: str = context.run_in_child_context(two(3, 4))
+    result_two: str = child.run_in_child_context(partial(two, 3, 4), name="two")
     results.append(result_two)
 
     result_three: str = context.step(three(5, 6))
@@ -125,18 +126,25 @@ async def function_under_test(event: Any, context: DurableContext) -> list[str]:
 ### Your test code
 
 ```python
-from async_durable_execution.execution import InvocationStatus
-from async_durable_execution_runner.runner import (
+import asyncio
+
+from async_durable_execution import InvocationStatus
+from async_durable_execution_runner import (
     ContextOperation,
+    create_runner,
     DurableFunctionTestResult,
-    DurableFunctionTestRunner,
     StepOperation,
 )
 
 
 def test_my_durable_functions():
-    with DurableFunctionTestRunner(handler=function_under_test) as runner:
-        result: DurableFunctionTestResult = runner.run(input="input str", timeout=10)
+    with create_runner(
+        mode="local",
+        handler=function_under_test,
+        input="input str",
+        timeout=10,
+    ) as runner:
+        result: DurableFunctionTestResult = asyncio.run(runner.run())
 
     assert result.status is InvocationStatus.SUCCEEDED
     assert result.result == '["1 2", "3 4 4 3", "5 6"]'
@@ -163,7 +171,7 @@ def test_my_durable_functions():
 5. **ExecutionNotifier** broadcasts events to **Executor** (observer)
 6. **Executor** updates **Execution** state based on events
 7. **Execution** completion triggers final event notifications
-8. **DurableTestRunner** run() blocks until it receives completion event, and then returns `DurableFunctionTestResult`.
+8. **DurableTestRunner** exposes async runner methods, so `await runner.run()` resolves once the execution completes and returns `DurableFunctionTestResult`.
 
 ## Major Components
 

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/README.md

@@ -1,3 +1,5 @@
+from async_durable_execution.operation import child
+
 # Async Durable Execution Runner for Python
 
 [![PyPI - Version](https://img.shields.io/pypi/v/async-durable-execution-runner.svg)](https://pypi.org/project/async-durable-execution-runner)
@@ -19,6 +21,8 @@
 
 ## Installation
 
+Requires Python 3.10 or newer.
+
 ```console
 pip install async-durable-execution-runner
 ```
@@ -38,58 +42,54 @@ before you deploy it.
 
 ```python
 import asyncio
+from datetime import timedelta
+from functools import partial
 from typing import Any
 
 from async_durable_execution import (
-    DurableContext,
     durable_execution,
-    durable_step,
-    durable_with_child_context,
+    get_current_context,
 )
-from async_durable_execution.config import Duration
 
 
-@durable_step
 async def one(a: int, b: int) -> str:
     await asyncio.sleep(0)
     return f"{a} {b}"
 
 
-@durable_step
 async def two_1(a: int, b: int) -> str:
     await asyncio.sleep(0)
     return f"{a} {b}"
 
 
-@durable_step
 async def two_2(a: int, b: int) -> str:
     await asyncio.sleep(0)
     return f"{b} {a}"
 
 
-@durable_with_child_context
-async def two(ctx: DurableContext, a: int, b: int) -> str:
+async def two(a: int, b: int) -> str:
+    ctx = get_current_context()
     two_1_result: str = ctx.step(two_1(a, b))
     two_2_result: str = ctx.step(two_2(a, b))
     return f"{two_1_result} {two_2_result}"
 
 
-@durable_step
 async def three(a: int, b: int) -> str:
     await asyncio.sleep(0)
     return f"{a} {b}"
 
 
 @durable_execution
-async def function_under_test(event: Any, context: DurableContext) -> list[str]:
+async def function_under_test(event: Any) -> list[str]:
+    context = get_current_context()
     results: list[str] = []
 
     result_one: str = context.step(one(1, 2))
     results.append(result_one)
 
-    context.wait(duration=Duration.from_seconds(1))
+    context.wait(duration=timedelta(seconds=1))
 
-    result_two: str = context.run_in_child_context(two(3, 4))
+    result_two: str = child.run_in_child_context(partial(two, 3, 4), name="two")
     results.append(result_two)
 
     result_three: str = context.step(three(5, 6))
@@ -101,18 +101,25 @@ async def function_under_test(event: Any, context: DurableContext) -> list[str]:
 ### Your test code
 
 ```python
-from async_durable_execution.execution import InvocationStatus
-from async_durable_execution_runner.runner import (
+import asyncio
+
+from async_durable_execution import InvocationStatus
+from async_durable_execution_runner import (
     ContextOperation,
+    create_runner,
     DurableFunctionTestResult,
-    DurableFunctionTestRunner,
     StepOperation,
 )
 
 
 def test_my_durable_functions():
-    with DurableFunctionTestRunner(handler=function_under_test) as runner:
-        result: DurableFunctionTestResult = runner.run(input="input str", timeout=10)
+    with create_runner(
+        mode="local",
+        handler=function_under_test,
+        input="input str",
+        timeout=10,
+    ) as runner:
+        result: DurableFunctionTestResult = asyncio.run(runner.run())
 
     assert result.status is InvocationStatus.SUCCEEDED
     assert result.result == '["1 2", "3 4 4 3", "5 6"]'
@@ -139,7 +146,7 @@ def test_my_durable_functions():
 5. **ExecutionNotifier** broadcasts events to **Executor** (observer)
 6. **Executor** updates **Execution** state based on events
 7. **Execution** completion triggers final event notifications
-8. **DurableTestRunner** run() blocks until it receives completion event, and then returns `DurableFunctionTestResult`.
+8. **DurableTestRunner** exposes async runner methods, so `await runner.run()` resolves once the execution completes and returns `DurableFunctionTestResult`.
 
 ## Major Components
 

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/VERSION.py

@@ -2,4 +2,4 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 # Modified for the async-durable-execution fork; shared version source for all packages.
-__version__ = "2.0.0a1"
+__version__ = "2.0.0a2"

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/async_durable_execution_runner/__init__.py

@@ -1,23 +1,26 @@
 """DurableExecutionsPythonTestingLibrary module."""
 
-from async_durable_execution_runner.runner import (
-    DurableChildContextTestRunner,
+from .__about__ import __version__
+from .runner import (
     DurableFunctionCloudTestRunner,
+    DurableFunctionLocalTestRunner,
     DurableFunctionTestResult,
-    DurableFunctionTestRunner,
     WebRunner,
     WebRunnerConfig,
+    create_runner,
+    ContextOperation,
+    StepOperation,
 )
 
-from async_durable_execution_runner.__about__ import __version__
-
 
 __all__ = [
-    "DurableChildContextTestRunner",
     "DurableFunctionCloudTestRunner",
+    "DurableFunctionLocalTestRunner",
     "DurableFunctionTestResult",
-    "DurableFunctionTestRunner",
     "WebRunner",
     "WebRunnerConfig",
     "__version__",
+    "create_runner",
+    "ContextOperation",
+    "StepOperation",
 ]

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/async_durable_execution_runner/checkpoint/processor.py

@@ -4,30 +4,29 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from async_durable_execution.lambda_service import (
+from async_durable_execution.models import (
     CheckpointOutput,
     CheckpointUpdatedExecutionState,
     OperationUpdate,
     StateOutput,
 )
-
-from async_durable_execution_runner.checkpoint.transformer import (
+from .transformer import (
     OperationTransformer,
 )
-from async_durable_execution_runner.checkpoint.validators.checkpoint import (
+from .validators.checkpoint import (
     CheckpointValidator,
 )
-from async_durable_execution_runner.exceptions import (
+from ..exceptions import (
     InvalidParameterValueException,
 )
-from async_durable_execution_runner.observer import ExecutionNotifier
-from async_durable_execution_runner.token import CheckpointToken
+from ..observer import ExecutionNotifier
+from ..token import CheckpointToken
 
 
 if TYPE_CHECKING:
-    from async_durable_execution_runner.execution import Execution
-    from async_durable_execution_runner.scheduler import Scheduler
-    from async_durable_execution_runner.stores.base import ExecutionStore
+    from ..execution import Execution
+    from ..scheduler import Scheduler
+    from ..stores.base import ExecutionStore
 
 
 class CheckpointProcessor:

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/async_durable_execution_runner/checkpoint/processors/base.py

@@ -6,7 +6,7 @@ import datetime
 from datetime import timedelta
 from typing import TYPE_CHECKING
 
-from async_durable_execution.lambda_service import (
+from async_durable_execution.models import (
     CallbackDetails,
     ChainedInvokeDetails,
     ContextDetails,
@@ -22,7 +22,7 @@ from async_durable_execution.lambda_service import (
 
 
 if TYPE_CHECKING:
-    from async_durable_execution_runner.observer import ExecutionNotifier
+    from ...observer import ExecutionNotifier
 
 
 class OperationProcessor:
@@ -44,7 +44,7 @@ class OperationProcessor:
         start_time: datetime.datetime | None = (
             current_operation.start_timestamp
             if current_operation
-            else datetime.datetime.now(tz=datetime.UTC)
+            else datetime.datetime.now(tz=datetime.timezone.utc)
         )
         return start_time
 
@@ -61,7 +61,7 @@ class OperationProcessor:
             OperationStatus.TIMED_OUT,
             OperationStatus.STOPPED,
         }:
-            return datetime.datetime.now(tz=datetime.UTC)
+            return datetime.datetime.now(tz=datetime.timezone.utc)
         return None
 
     def _create_execution_details(
@@ -193,7 +193,7 @@ class OperationProcessor:
                 )
             else:
                 scheduled_end_timestamp = datetime.datetime.now(
-                    tz=datetime.UTC
+                    tz=datetime.timezone.utc
                 ) + timedelta(seconds=update.wait_options.wait_seconds)
             return WaitDetails(scheduled_end_timestamp=scheduled_end_timestamp)
         return None

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/async_durable_execution_runner/checkpoint/processors/callback.py

@@ -5,25 +5,26 @@ from __future__ import annotations
 import datetime
 from typing import TYPE_CHECKING
 
-from async_durable_execution.lambda_service import (
+from async_durable_execution.models import (
+    CallbackDetails,
+    CallbackOptions,
     Operation,
     OperationAction,
     OperationStatus,
-    OperationUpdate,
-    CallbackDetails,
     OperationType,
-    CallbackOptions,
+    OperationUpdate,
 )
-from async_durable_execution_runner.checkpoint.processors.base import (
+from .base import (
     OperationProcessor,
 )
-from async_durable_execution_runner.exceptions import (
+from ...exceptions import (
     InvalidParameterValueException,
 )
-from async_durable_execution_runner.token import CallbackToken
+from ...token import CallbackToken
+
 
 if TYPE_CHECKING:
-    from async_durable_execution_runner.observer import ExecutionNotifier
+    from ...observer import ExecutionNotifier
 
 
 class CallbackProcessor(OperationProcessor):
@@ -33,8 +34,8 @@ class CallbackProcessor(OperationProcessor):
         self,
         update: OperationUpdate,
         current_op: Operation | None,
-        notifier: ExecutionNotifier,  # noqa: ARG002
-        execution_arn: str,  # noqa: ARG002
+        notifier: ExecutionNotifier,
+        execution_arn: str,
     ) -> Operation:
         """Process CALLBACK operation update with scheduler integration for activities."""
         match update.action:

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/async_durable_execution_runner/checkpoint/processors/context.py

@@ -4,23 +4,22 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from async_durable_execution.lambda_service import (
+from async_durable_execution.models import (
     Operation,
     OperationAction,
     OperationStatus,
     OperationUpdate,
 )
-
-from async_durable_execution_runner.checkpoint.processors.base import (
+from .base import (
     OperationProcessor,
 )
-from async_durable_execution_runner.exceptions import (
+from ...exceptions import (
     InvalidParameterValueException,
 )
 
 
 if TYPE_CHECKING:
-    from async_durable_execution_runner.observer import ExecutionNotifier
+    from ...observer import ExecutionNotifier
 
 
 class ContextProcessor(OperationProcessor):

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/async_durable_execution_runner/checkpoint/processors/execution.py

@@ -4,20 +4,19 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from async_durable_execution.lambda_service import (
+from async_durable_execution.models import (
     ErrorObject,
     Operation,
     OperationAction,
     OperationUpdate,
 )
-
-from async_durable_execution_runner.checkpoint.processors.base import (
+from .base import (
     OperationProcessor,
 )
 
 
 if TYPE_CHECKING:
-    from async_durable_execution_runner.observer import ExecutionNotifier
+    from ...observer import ExecutionNotifier
 
 
 class ExecutionProcessor(OperationProcessor):
@@ -38,12 +37,8 @@ class ExecutionProcessor(OperationProcessor):
                 )
             case _:
                 # intentional. actual service will fail any EXECUTION update that is not SUCCEED.
-                error = (
-                    update.error
-                    if update.error
-                    else ErrorObject.from_message(
-                        "There is no error details but EXECUTION checkpoint action is not SUCCEED."
-                    )
+                error = update.error or ErrorObject.from_message(
+                    "There is no error details but EXECUTION checkpoint action is not SUCCEED."
                 )
                 # All EXECUTION failures go through normal fail path
                 # Timeout/Stop status is set by executor based on the operation that caused it

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/async_durable_execution_runner/checkpoint/processors/step.py

@@ -2,27 +2,26 @@
 
 from __future__ import annotations
 
-from datetime import UTC, datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING
 
-from async_durable_execution.lambda_service import (
+from async_durable_execution.models import (
     Operation,
     OperationAction,
     OperationStatus,
     OperationUpdate,
     StepDetails,
 )
-
-from async_durable_execution_runner.checkpoint.processors.base import (
+from .base import (
     OperationProcessor,
 )
-from async_durable_execution_runner.exceptions import (
+from ...exceptions import (
     InvalidParameterValueException,
 )
 
 
 if TYPE_CHECKING:
-    from async_durable_execution_runner.observer import ExecutionNotifier
+    from ...observer import ExecutionNotifier
 
 
 class StepProcessor(OperationProcessor):
@@ -50,7 +49,9 @@ class StepProcessor(OperationProcessor):
                     if update.step_options
                     else 0
                 )
-                next_attempt_time = datetime.now(UTC) + timedelta(seconds=delay)
+                next_attempt_time = datetime.now(timezone.utc) + timedelta(
+                    seconds=delay
+                )
 
                 # Build new step_details with incremented attempt
                 current_attempt = (
@@ -81,7 +82,9 @@ class StepProcessor(OperationProcessor):
                     parent_id=update.parent_id,
                     name=update.name,
                     start_timestamp=(
-                        current_op.start_timestamp if current_op else datetime.now(UTC)
+                        current_op.start_timestamp
+                        if current_op
+                        else datetime.now(timezone.utc)
                     ),
                     end_timestamp=None,
                     sub_type=update.sub_type,

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/async_durable_execution_runner/checkpoint/processors/wait.py

@@ -4,27 +4,26 @@ from __future__ import annotations
 
 import logging
 import os
-from datetime import UTC, datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING
 
-from async_durable_execution.lambda_service import (
+from async_durable_execution.models import (
     Operation,
     OperationAction,
     OperationStatus,
     OperationUpdate,
     WaitDetails,
 )
-
-from async_durable_execution_runner.checkpoint.processors.base import (
+from .base import (
     OperationProcessor,
 )
-from async_durable_execution_runner.exceptions import (
+from ...exceptions import (
     InvalidParameterValueException,
 )
 
 
 if TYPE_CHECKING:
-    from async_durable_execution_runner.observer import ExecutionNotifier
+    from ...observer import ExecutionNotifier
 
 
 class WaitProcessor(OperationProcessor):
@@ -47,7 +46,7 @@ class WaitProcessor(OperationProcessor):
                 logging.info("Using DURABLE_EXECUTION_TIME_SCALE: %f", time_scale)
                 scaled_wait_seconds = wait_seconds * time_scale
 
-                scheduled_end_timestamp = datetime.now(UTC) + timedelta(
+                scheduled_end_timestamp = datetime.now(timezone.utc) + timedelta(
                     seconds=scaled_wait_seconds
                 )
 
@@ -63,7 +62,7 @@ class WaitProcessor(OperationProcessor):
                     status=OperationStatus.STARTED,
                     parent_id=update.parent_id,
                     name=update.name,
-                    start_timestamp=datetime.now(UTC),
+                    start_timestamp=datetime.now(timezone.utc),
                     end_timestamp=None,
                     sub_type=update.sub_type,
                     execution_details=None,

{async_durable_execution_runner-2.0.0a1 → async_durable_execution_runner-2.0.0a2}/async_durable_execution_runner/checkpoint/transformer.py

@@ -4,28 +4,27 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from async_durable_execution.lambda_service import (
+from async_durable_execution.models import (
     Operation,
     OperationType,
     OperationUpdate,
 )
-
-from async_durable_execution_runner.checkpoint.processors.callback import (
+from .processors.callback import (
     CallbackProcessor,
 )
-from async_durable_execution_runner.checkpoint.processors.context import (
+from .processors.context import (
     ContextProcessor,
 )
-from async_durable_execution_runner.checkpoint.processors.execution import (
+from .processors.execution import (
     ExecutionProcessor,
 )
-from async_durable_execution_runner.checkpoint.processors.step import (
+from .processors.step import (
     StepProcessor,
 )
-from async_durable_execution_runner.checkpoint.processors.wait import (
+from .processors.wait import (
     WaitProcessor,
 )
-from async_durable_execution_runner.exceptions import (
+from ..exceptions import (
     InvalidParameterValueException,
 )
 
@@ -33,7 +32,7 @@ from async_durable_execution_runner.exceptions import (
 if TYPE_CHECKING:
     from collections.abc import MutableMapping
 
-    from async_durable_execution_runner.checkpoint.processors.base import (
+    from .processors.base import (
         OperationProcessor,
     )
 
@@ -55,7 +54,7 @@ class OperationTransformer:
         self,
         processors: MutableMapping[OperationType, OperationProcessor] | None = None,
     ):
-        self.processors = processors if processors else self._DEFAULT_PROCESSORS
+        self.processors = processors or self._DEFAULT_PROCESSORS
 
     def process_updates(
         self,