aws-durable-execution-sdk-python-testing 1.1.1__tar.gz → 1.2.0__tar.gz

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/.gitignore

@@ -33,5 +33,5 @@ dist/
 
 .durable_executions
 
-examples/build/*
-examples/*.zip
+durable-executions.db*
+.coverage

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: aws-durable-execution-sdk-python-testing
-Version: 1.1.1
+Version: 1.2.0
 Summary: AWS Durable Execution Testing SDK for Python
 Project-URL: Documentation, https://github.com/aws/aws-durable-execution-sdk-python-testing#readme
 Project-URL: Issues, https://github.com/aws/aws-durable-execution-sdk-python-testing/issues
 Project-URL: Source, https://github.com/aws/aws-durable-execution-sdk-python-testing
-Author-email: yaythomas <tgaigher@amazon.com>
+Author-email: AWS durable-execution-dev <durable-execution-dev@amazon.com>
 License-Expression: Apache-2.0
 License-File: LICENSE
 License-File: NOTICE
@@ -20,7 +20,6 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.11
 Requires-Dist: aws-durable-execution-sdk-python>=1.0.0
 Requires-Dist: boto3>=1.42.1
-Requires-Dist: requests>=2.25.0
 Description-Content-Type: text/markdown
 
 # AWS Durable Execution Testing SDK for Python

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/aws_durable_execution_sdk_python_testing/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Amazon.com, Inc. or its affiliates.
 #
 # SPDX-License-Identifier: Apache-2.0
-__version__ = "1.1.1"
+__version__ = "1.2.0"

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/aws_durable_execution_sdk_python_testing/__init__.py

@@ -9,6 +9,8 @@ from aws_durable_execution_sdk_python_testing.runner import (
     WebRunnerConfig,
 )
 
+from aws_durable_execution_sdk_python_testing.__about__ import __version__
+
 
 __all__ = [
     "DurableChildContextTestRunner",
@@ -17,4 +19,5 @@ __all__ = [
     "DurableFunctionTestRunner",
     "WebRunner",
     "WebRunnerConfig",
+    "__version__",
 ]

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/aws_durable_execution_sdk_python_testing/cli.py

@@ -21,7 +21,9 @@ from urllib.parse import urljoin
 
 import aws_durable_execution_sdk_python
 import boto3  # type: ignore
-import requests
+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.exceptions import (
@@ -348,37 +350,37 @@ class CliApp:
             endpoint_url = self.config.local_runner_endpoint
             url = urljoin(endpoint_url, "/start-durable-execution")
 
-            headers = {"Content-Type": "application/json"}
             payload = start_input.to_dict()
+            data = json.dumps(payload).encode("utf-8")
+            req = Request(
+                url,
+                data=data,
+                headers={"Content-Type": "application/json"},
+                method="POST",
+            )
 
-            response = requests.post(url, json=payload, headers=headers, timeout=30)
-
-            if response.status_code == 201:  # noqa: PLR2004
-                # Success - print the response
-                result = response.json()
-                print(json.dumps(result, indent=2))  # noqa: T201
-                return 0
-
-            # Error - print error details
             try:
-                error_data = response.json()
-                logger.exception("HTTP error response")
-                print(  # noqa: T201
-                    f"Error: {error_data.get('ErrorMessage', 'Unknown error')}",
-                    file=sys.stderr,
-                )
-            except json.JSONDecodeError:
-                logger.exception("Non-JSON error response")
-            return 1  # noqa: TRY300
-
-        except requests.exceptions.ConnectionError:
+                with urlopen(req, timeout=10) as response:  # noqa: S310
+                    result = json.loads(response.read().decode("utf-8"))
+                    print(json.dumps(result, indent=2))  # noqa: T201
+                    return 0
+            except HTTPError as e:
+                try:
+                    error_data = json.loads(e.read().decode("utf-8"))
+                    logger.exception("HTTP error response")
+                    print(  # noqa: T201
+                        f"Error: {error_data.get('ErrorMessage', 'Unknown error')}",
+                        file=sys.stderr,
+                    )
+                except json.JSONDecodeError:
+                    logger.exception("Non-JSON error response")
+                return 1
+
+        except URLError:
             logger.exception(
                 "Error: Could not connect to the local runner server. Is it running?"
             )
             return 1
-        except requests.exceptions.Timeout:
-            logger.exception("Request timeout")
-            return 1
         except Exception:
             logger.exception("Unexpected error in invoke command")
             return 1

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/aws_durable_execution_sdk_python_testing/execution.py

@@ -91,7 +91,11 @@ class Execution:
         # Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:\d{12}:durable-execution:[a-zA-Z0-9-_\.]+:[a-zA-Z0-9-_\.]+:[a-zA-Z0-9-_\.]+
         # Example: arn:aws:lambda:us-east-1:123456789012:durable-execution:myDurableFunction:myDurableExecutionName:ce67da72-3701-4f83-9174-f4189d27b0a5
         return Execution(
-            durable_execution_arn=str(uuid4()), start_input=input, operations=[]
+            durable_execution_arn=str(uuid4())
+            + "/"
+            + (input.invocation_id or str(uuid4())),
+            start_input=input,
+            operations=[],
         )
 
     def to_json_dict(self) -> dict[str, Any]:
@@ -102,7 +106,7 @@ class Execution:
             "Operations": [op.to_json_dict() for op in self.operations],
             "Updates": [update.to_dict() for update in self.updates],
             "InvocationCompletions": [
-                completion.to_dict() for completion in self.invocation_completions
+                completion.to_json_dict() for completion in self.invocation_completions
             ],
             "UsedTokens": list(self.used_tokens),
             "TokenSequence": self._token_sequence,
@@ -135,7 +139,7 @@ class Execution:
             OperationUpdate.from_dict(update_data) for update_data in data["Updates"]
         ]
         execution.invocation_completions = [
-            InvocationCompletedDetails.from_dict(item)
+            InvocationCompletedDetails.from_json_dict(item)
             for item in data.get("InvocationCompletions", [])
         ]
         execution.used_tokens = set(data["UsedTokens"])

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/aws_durable_execution_sdk_python_testing/executor.py

@@ -115,6 +115,7 @@ class Executor(ExecutionObserver):
         execution = Execution.new(input=input)
         execution.start()
         self._store.save(execution)
+        logger.debug("Created execution with ARN: %s", execution.durable_execution_arn)
 
         completion_event = self._scheduler.create_event()
         self._completion_events[execution.durable_execution_arn] = completion_event
@@ -322,14 +323,14 @@ class Executor(ExecutionObserver):
 
         Raises:
             ResourceNotFoundException: If execution does not exist
-            ExecutionAlreadyStartedException: If execution is already completed
         """
         execution = self.get_execution(execution_arn)
 
         if execution.is_complete:
-            # Context-aware mapping: execution already completed maps to ExecutionAlreadyStartedException
-            msg: str = f"Execution {execution_arn} is already completed"
-            raise ExecutionAlreadyStartedException(msg, execution_arn)
+            # Idempotent: return the existing stop timestamp
+            execution_op = execution.get_operation_execution_started()
+            stop_timestamp = execution_op.end_timestamp or datetime.now(UTC)
+            return StopDurableExecutionResponse(stop_timestamp=stop_timestamp)
 
         # Use provided error or create a default one
         stop_error = error or ErrorObject.from_message(

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/aws_durable_execution_sdk_python_testing/invoker.py

@@ -7,6 +7,8 @@ from typing import TYPE_CHECKING, Any, Protocol
 from uuid import uuid4
 
 import boto3  # type: ignore
+from botocore.config import Config  # type: ignore
+
 from aws_durable_execution_sdk_python.execution import (
     DurableExecutionInvocationInput,
     DurableExecutionInvocationInputWithClient,
@@ -16,9 +18,12 @@ from aws_durable_execution_sdk_python.execution import (
 
 from aws_durable_execution_sdk_python_testing.exceptions import (
     DurableFunctionsTestError,
+    InvalidParameterValueException,
+    ResourceNotFoundException,
 )
 from aws_durable_execution_sdk_python_testing.model import LambdaContext
 
+
 if TYPE_CHECKING:
     from collections.abc import Callable
 
@@ -26,6 +31,26 @@ if TYPE_CHECKING:
     from aws_durable_execution_sdk_python_testing.execution import Execution
 
 
+# Max Lambda function timeout is 15 minutes (900s); we give headroom for
+# network round-trip and RIE startup.
+_LAMBDA_READ_TIMEOUT_SECONDS = 960
+_LAMBDA_CLIENT_CONFIG = Config(
+    read_timeout=_LAMBDA_READ_TIMEOUT_SECONDS,
+    retries={"max_attempts": 0},
+)
+
+
+def create_lambda_client(endpoint_url: str | None, region_name: str) -> Any:
+    """Create a boto3 Lambda client configured for durable function invocations."""
+
+    return boto3.client(
+        "lambda",
+        endpoint_url=endpoint_url,
+        region_name=region_name,
+        config=_LAMBDA_CLIENT_CONFIG,
+    )
+
+
 @dataclass(frozen=True)
 class InvokeResponse:
     """Response from invoking a durable function."""
@@ -133,9 +158,7 @@ class LambdaInvoker(Invoker):
     @staticmethod
     def create(endpoint_url: str, region_name: str) -> LambdaInvoker:
         """Create with the boto lambda client."""
-        invoker = LambdaInvoker(
-            boto3.client("lambda", endpoint_url=endpoint_url, region_name=region_name)
-        )
+        invoker = LambdaInvoker(create_lambda_client(endpoint_url, region_name))
         invoker._current_endpoint = endpoint_url
         invoker._endpoint_clients[endpoint_url] = invoker.lambda_client
         return invoker
@@ -145,8 +168,8 @@ class LambdaInvoker(Invoker):
         # Cache client by endpoint to reuse across executions
         with self._lock:
             if endpoint_url not in self._endpoint_clients:
-                self._endpoint_clients[endpoint_url] = boto3.client(
-                    "lambda", endpoint_url=endpoint_url, region_name=region_name
+                self._endpoint_clients[endpoint_url] = create_lambda_client(
+                    endpoint_url, region_name
                 )
             self.lambda_client = self._endpoint_clients[endpoint_url]
         self._current_endpoint = endpoint_url
@@ -161,10 +184,8 @@ class LambdaInvoker(Invoker):
         # Use provided endpoint or fall back to cached endpoint for this execution
         if lambda_endpoint:
             if lambda_endpoint not in self._endpoint_clients:
-                self._endpoint_clients[lambda_endpoint] = boto3.client(
-                    "lambda",
-                    endpoint_url=lambda_endpoint,
-                    region_name=region_name or "us-east-1",
+                self._endpoint_clients[lambda_endpoint] = create_lambda_client(
+                    lambda_endpoint, region_name or "us-east-1"
                 )
             return self._endpoint_clients[lambda_endpoint]
 
@@ -217,10 +238,6 @@ class LambdaInvoker(Invoker):
             InvalidParameterValueException: If parameters are invalid
             DurableFunctionsTestError: For other invocation failures
         """
-        from aws_durable_execution_sdk_python_testing.exceptions import (
-            ResourceNotFoundException,
-            InvalidParameterValueException,
-        )
 
         # Parameter validation
         if not function_name or not function_name.strip():

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/aws_durable_execution_sdk_python_testing/model.py

@@ -3,12 +3,10 @@
 from __future__ import annotations
 
 import datetime
+import json
 from dataclasses import dataclass, replace
 from enum import Enum
 from typing import Any
-import json
-
-from dateutil.tz import UTC
 
 from aws_durable_execution_sdk_python.execution import DurableExecutionInvocationOutput
 
@@ -30,12 +28,14 @@ from aws_durable_execution_sdk_python.lambda_service import (
     OperationUpdate,
     StepDetails,
     StepOptions,
+    TimestampConverter,
     WaitDetails,
     WaitOptions,
 )
 from aws_durable_execution_sdk_python.types import (
     LambdaContext as LambdaContextProtocol,
 )
+from dateutil.tz import UTC
 
 from aws_durable_execution_sdk_python_testing.exceptions import (
     InvalidParameterValueException,
@@ -1239,6 +1239,27 @@ class InvocationCompletedDetails:
             request_id=data["RequestId"],
         )
 
+    @classmethod
+    def from_json_dict(cls, data: dict) -> InvocationCompletedDetails:
+        """Deserialize from JSON dict with Unix millisecond timestamps."""
+        start_ts: datetime.datetime | None = TimestampConverter.from_unix_millis(
+            data["StartTimestamp"]
+        )  # type: ignore[arg-type]
+        end_ts: datetime.datetime | None = TimestampConverter.from_unix_millis(
+            data["EndTimestamp"]
+        )  # type: ignore[arg-type]
+
+        if start_ts is None or end_ts is None:
+            raise InvalidParameterValueException(
+                "StartTimestamp and EndTimestamp cannot be null"
+            )
+
+        return cls(
+            start_timestamp=start_ts,
+            end_timestamp=end_ts,
+            request_id=data["RequestId"],
+        )
+
     def to_dict(self) -> dict[str, Any]:
         return {
             "StartTimestamp": self.start_timestamp,
@@ -1246,6 +1267,14 @@ class InvocationCompletedDetails:
             "RequestId": self.request_id,
         }
 
+    def to_json_dict(self) -> dict[str, Any]:
+        """Convert to JSON-serializable dict with Unix millisecond timestamps."""
+        return {
+            "StartTimestamp": TimestampConverter.to_unix_millis(self.start_timestamp),
+            "EndTimestamp": TimestampConverter.to_unix_millis(self.end_timestamp),
+            "RequestId": self.request_id,
+        }
+
 
 # endregion event_structures
 

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/aws_durable_execution_sdk_python_testing/runner.py

@@ -46,6 +46,7 @@ from aws_durable_execution_sdk_python_testing.executor import Executor
 from aws_durable_execution_sdk_python_testing.invoker import (
     InProcessInvoker,
     LambdaInvoker,
+    create_lambda_client,
 )
 from aws_durable_execution_sdk_python_testing.model import (
     GetDurableExecutionHistoryResponse,
@@ -858,9 +859,7 @@ class WebRunner:
             Exception: If client creation fails - exceptions propagate naturally
                       for CLI to handle as general Exception
         """
-        # Create client with Lambda endpoint configuration
-        return boto3.client(
-            "lambda",
+        return create_lambda_client(
             endpoint_url=self._config.lambda_endpoint,
             region_name=self._config.local_runner_region,
         )

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/aws_durable_execution_sdk_python_testing/web/handlers.py

@@ -291,16 +291,22 @@ class StartExecutionHandler(EndpointHandler):
         Returns:
             HTTPResponse: The HTTP response to send to the client
         """
+        logger.debug("🌟 HANDLER: Received POST /start-durable-execution request")
         try:
             body_data: dict[str, Any] = self._parse_json_body(request)
+            logger.debug("🌟 HANDLER: Parsed request body successfully")
 
             start_input: StartDurableExecutionInput = (
                 StartDurableExecutionInput.from_dict(body_data)
             )
+            logger.debug(
+                "🌟 HANDLER: Created StartDurableExecutionInput, calling executor.start_execution()"
+            )
 
             start_output: StartDurableExecutionOutput = self.executor.start_execution(
                 start_input
             )
+            logger.debug("🌟 HANDLER: executor.start_execution() returned successfully")
 
             response_data: dict[str, Any] = start_output.to_dict()
 

{aws_durable_execution_sdk_python_testing-1.1.1 → aws_durable_execution_sdk_python_testing-1.2.0}/pyproject.toml

@@ -10,7 +10,7 @@ readme = "README.md"
 requires-python = ">=3.11"
 license = "Apache-2.0"
 keywords = []
-authors = [{ name = "yaythomas", email = "tgaigher@amazon.com" }]
+authors = [{ name = "AWS durable-execution-dev", email = "durable-execution-dev@amazon.com" }]
 classifiers = [
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
@@ -23,7 +23,6 @@ classifiers = [
 ]
 dependencies = [
   "boto3>=1.42.1",
-  "requests>=2.25.0",
   "aws_durable_execution_sdk_python>=1.0.0",
 ]
 
@@ -64,28 +63,7 @@ dependencies = [
 
 [tool.hatch.envs.test.scripts]
 test = "pytest tests/ -v"
-examples = "pytest --runner-mode=local -m example examples/test/ -v"
-examples-integration = "pytest --runner-mode=cloud -m example examples/test/ -v {args}"
-cov = "pytest --cov-report=term-missing --cov-config=pyproject.toml --cov=src/aws_durable_execution_sdk_python_testing --cov-fail-under=96"
-
-[tool.hatch.envs.examples]
-dependencies = [
-  "boto3",
-  "PyYAML",
-  "aws_durable_execution_sdk_python>=1.0.0",
-]
-[tool.hatch.envs.examples.scripts]
-cli = "python examples/cli.py {args}"
-bootstrap = "python examples/cli.py bootstrap"
-generate-sam-template = "python examples/scripts/generate_sam_template.py"
-build = "python examples/cli.py build"
-deploy = "python examples/cli.py deploy {args}"
-invoke = "python examples/cli.py invoke {args}"
-get = "python examples/cli.py get {args}"
-history = "python examples/cli.py history {args}"
-policy = "python examples/cli.py policy {args}"
-list = "python examples/cli.py list"
-clean = "rm -rf examples/build examples/.aws-sam examples/*.zip"
+cov = "pytest --cov-report=term-missing --cov-config=pyproject.toml --cov=src/aws_durable_execution_sdk_python_testing --cov-fail-under=95"
 
 [tool.hatch.envs.types]
 extra-dependencies = ["mypy>=1.0.0", "pytest"]
@@ -115,7 +93,7 @@ exclude_lines = [
 
 [tool.ruff]
 line-length = 88
-target-version = "py313"
+target-version = "py311"
 
 [tool.ruff.lint]
 preview = false
@@ -136,15 +114,6 @@ lines-after-imports = 2
   "SIM117",
   "TRY301",
 ]
-"examples/test/**" = [
-  "ARG001",
-  "ARG002",
-  "ARG005",
-  "S101",
-  "PLR2004",
-  "SIM117",
-  "TRY301",
-]
 "src/aws_durable_execution_sdk_python_testing/invoker.py" = [
   "A002", # Argument `input` is shadowing a Python builtin
 ]
@@ -158,6 +127,6 @@ markers = [
   "durable_execution: marks tests that use the durable_runner fixture (not used for test selection)",
 ]
 # Default test discovery paths
-testpaths = ["tests", "examples/test"]
+testpaths = ["tests"]
 # Default options for all test runs
 addopts = "-v --strict-markers"