aws-durable-execution-sdk-python-testing 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

aws_durable_execution_sdk_python_testing/cli.py

@@ -19,13 +19,13 @@ from dataclasses import dataclass
 from typing import Any
 from urllib.parse import urljoin
 
-import aws_durable_execution_sdk_python
 import boto3  # type: ignore
 from urllib.error import HTTPError, URLError
 from urllib.request import Request, urlopen
 
 from botocore.exceptions import ConnectionError  # type: ignore
 
+from aws_durable_execution_sdk_python_testing.child_dispatcher import FunctionConfigs
 from aws_durable_execution_sdk_python_testing.exceptions import (
     DurableFunctionsLocalRunnerError,
     DurableFunctionsTestError,
@@ -41,6 +41,14 @@ from aws_durable_execution_sdk_python_testing.web.server import WebServiceConfig
 logger = logging.getLogger(__name__)
 
 
+def _function_configs(value: str) -> FunctionConfigs:
+    """argparse type for ``--function-configs``: parse at the boundary."""
+    try:
+        return FunctionConfigs.from_value(value)
+    except (ValueError, OSError) as exc:
+        raise argparse.ArgumentTypeError(str(exc)) from exc
+
+
 @dataclass(frozen=True)
 class CliConfig:
     """Configuration for the CLI application with environment variable support."""
@@ -210,6 +218,42 @@ class CliApp:
             default=self.config.store_path,
             help=f"Path for filesystem store (default: {self.config.store_path or '.durable_executions'}, env: AWS_DEX_STORE_PATH)",
         )
+        start_server_parser.add_argument(
+            "--execution-timeout",
+            type=int,
+            default=300,
+            help="Default execution timeout in seconds (default: 300)",
+        )
+        start_server_parser.add_argument(
+            "--invocation-timeout",
+            type=int,
+            default=900,
+            help=(
+                "Per-invocation timeout in seconds, simulates Lambda Timeout "
+                "(default: 900). Also bounds how long the runner waits on any "
+                "Invoke it sends, with 60 seconds of headroom"
+            ),
+        )
+        start_server_parser.add_argument(
+            "--skip-time",
+            action=argparse.BooleanOptionalAction,
+            default=False,
+            help="Skip durable timer wall-clock waits; history keeps real modeled durations. Default is real timing (--no-skip-time); pass --skip-time to opt in",
+        )
+        start_server_parser.add_argument(
+            "--function-configs",
+            default=None,
+            type=_function_configs,
+            help=(
+                "The Lambda functions a durable function may invoke: a JSON "
+                "object mapping each function name to its configuration in "
+                "Lambda's own shape, or file://<path> to a file holding it. "
+                "A durable function carries a DurableConfig, e.g. "
+                '{"ProcessPayment": {"DurableConfig": {"ExecutionTimeout": 60, '
+                '"RetentionPeriodInDays": 7}}, "LookupPrice": {}}. Required for '
+                "chained invokes; without it every chained invoke fails"
+            ),
+        )
         start_server_parser.set_defaults(func=self.start_server_command)
 
     def _create_invoke_parser(self, subparsers) -> None:
@@ -282,6 +326,9 @@ class CliApp:
                 local_runner_mode=args.local_runner_mode,
                 store_type=StoreType(args.store_type),
                 store_path=args.store_path,
+                invocation_timeout_seconds=args.invocation_timeout,
+                skip_time=args.skip_time,
+                function_configs=args.function_configs,
             )
 
             logger.info(

aws_durable_execution_sdk_python_testing/client.py

@@ -9,42 +9,53 @@ from aws_durable_execution_sdk_python.lambda_service import (
     StateOutput,
 )
 
+from aws_durable_execution_sdk_python_testing.clock import real_now
 from aws_durable_execution_sdk_python_testing.checkpoint.processor import (
     CheckpointProcessor,
 )
+from aws_durable_execution_sdk_python_testing.worker.checkpoint_tasks import (
+    CheckpointTask,
+    GetStateTask,
+)
+from aws_durable_execution_sdk_python_testing.worker.registry import ExecutionRegistry
 
 
 class InMemoryServiceClient(DurableServiceClient):
     """An in-memory service client, that can replace the boto lambda service client."""
 
-    def __init__(self, checkpoint_processor: CheckpointProcessor):
+    def __init__(
+        self,
+        checkpoint_processor: CheckpointProcessor,
+        registry: ExecutionRegistry,
+    ):
         self._checkpoint_processor: CheckpointProcessor = checkpoint_processor
+        self._registry: ExecutionRegistry = registry
 
     def checkpoint(
         self,
-        durable_execution_arn: str,  # noqa: ARG002
+        durable_execution_arn: str,
         checkpoint_token: str,
         updates: list[OperationUpdate],
         client_token: str | None,
     ) -> CheckpointOutput:
-        # durable_execution_arn is not used in in-memory testing
-        return self._checkpoint_processor.process_checkpoint(
-            checkpoint_token, updates, client_token
+        task = CheckpointTask(
+            self._checkpoint_processor, checkpoint_token, updates, client_token
         )
+        return self._registry.submit(durable_execution_arn, task).result()
 
     def get_execution_state(
         self,
-        durable_execution_arn: str,  # noqa: ARG002
+        durable_execution_arn: str,
         checkpoint_token: str,
         next_marker: str,
         max_items: int = 1000,
     ) -> StateOutput:
-        # durable_execution_arn is not used in in-memory testing
-        return self._checkpoint_processor.get_execution_state(
-            checkpoint_token, next_marker, max_items
+        task = GetStateTask(
+            self._checkpoint_processor, checkpoint_token, next_marker, max_items
         )
+        return self._registry.submit(durable_execution_arn, task).result()
 
     def stop(self, execution_arn: str, payload: bytes | None) -> datetime.datetime:  # noqa: ARG002
         # TODO: implement
         # Return current time for in-memory testing
-        return datetime.datetime.now(tz=datetime.UTC)
+        return real_now()

aws_durable_execution_sdk_python_testing/clock.py

@@ -0,0 +1,69 @@
+"""Clock sources for scheduler-driven durable timers.
+
+A clock decides how long the local runner actually waits before a
+scheduled wake fires, and supplies the "now" used to stamp operation
+and invocation timestamps. All time reads in the runner go through one
+clock so history events share a single, totally ordered clock domain.
+"""
+
+from __future__ import annotations
+
+import datetime
+import threading
+from typing import Protocol
+
+
+def real_now() -> datetime.datetime:
+    """Return the current wall-clock time in UTC."""
+    return datetime.datetime.now(datetime.UTC)  # noqa: TID251
+
+
+class Clock(Protocol):
+    """Time source used to arm timers and stamp timestamps."""
+
+    def now(self) -> datetime.datetime:
+        """Return the current time on this clock."""
+        ...
+
+    def arm(self, wake: datetime.datetime) -> float:
+        """Return the real seconds to wait before firing at ``wake``."""
+        ...
+
+
+class RealClock:
+    """Wall-clock time source. Timers wait the real modeled duration."""
+
+    def now(self) -> datetime.datetime:
+        return real_now()
+
+    def arm(self, wake: datetime.datetime) -> float:
+        return max((wake - self.now()).total_seconds(), 0.0)
+
+
+class SkipClock:
+    """Virtual clock that skips over armed timer horizons.
+
+    Tracks the total duration skipped so far: ``now`` returns real time
+    plus the accumulated skip, so the clock advances with real time
+    between jumps and every read is distinct and monotonic. Arming a
+    wake beyond virtual now adds the remaining gap to the accumulated
+    skip and returns a zero delay, so the wake fires on the next
+    event-loop turn rather than after the modeled duration. Guards its
+    state with a lock because ``arm`` and ``now`` run on different
+    threads.
+    """
+
+    def __init__(self) -> None:
+        self._skipped: datetime.timedelta = datetime.timedelta(0)
+        self._lock: threading.Lock = threading.Lock()
+
+    def now(self) -> datetime.datetime:
+        with self._lock:
+            return real_now() + self._skipped
+
+    def arm(self, wake: datetime.datetime) -> float:
+        with self._lock:
+            gap: datetime.timedelta = wake - (real_now() + self._skipped)
+            if gap > datetime.timedelta(0):
+                self._skipped += gap
+        return 0.0

aws_durable_execution_sdk_python_testing/exceptions.py

@@ -109,6 +109,20 @@ class DurableFunctionsTestError(Exception):
     """Base class for testing errors."""
 
 
+class InvalidInvocationOutputError(DurableFunctionsTestError):
+    """The handler's output cannot be parsed as an invocation output."""
+
+    def __init__(self, message: str, request_id: str | None = None) -> None:
+        """Initialize with the message and the invocation's request ID.
+
+        Args:
+            message: Why the output cannot be parsed
+            request_id: Request ID of the invocation that returned the output
+        """
+        self.request_id = request_id
+        super().__init__(message)
+
+
 # endregion Testing