aws-durable-execution-sdk-python-testing 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

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.0"
+__version__ = "1.1.2"

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/execution.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 from dataclasses import replace
 from datetime import UTC, datetime
 from enum import Enum
@@ -33,7 +32,6 @@ from aws_durable_execution_sdk_python_testing.model import (
 )
 from aws_durable_execution_sdk_python_testing.token import (
     CheckpointToken,
-    CallbackToken,
 )
 
 
@@ -96,15 +94,15 @@ class Execution:
             durable_execution_arn=str(uuid4()), start_input=input, operations=[]
         )
 
-    def to_dict(self) -> dict[str, Any]:
-        """Serialize execution to dictionary."""
+    def to_json_dict(self) -> dict[str, Any]:
+        """Serialize execution to JSON-serializable dictionary"""
         return {
             "DurableExecutionArn": self.durable_execution_arn,
             "StartInput": self.start_input.to_dict(),
-            "Operations": [op.to_dict() for op in self.operations],
+            "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,
@@ -115,13 +113,15 @@ class Execution:
         }
 
     @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> Execution:
+    def from_json_dict(cls, data: dict[str, Any]) -> Execution:
         """Deserialize execution from dictionary."""
         # Reconstruct start_input
         start_input = StartDurableExecutionInput.from_dict(data["StartInput"])
 
         # Reconstruct operations
-        operations = [Operation.from_dict(op_data) for op_data in data["Operations"]]
+        operations = [
+            Operation.from_json_dict(op_data) for op_data in data["Operations"]
+        ]
 
         # Create execution
         execution = cls(
@@ -135,7 +135,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/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/invoker.py

@@ -7,20 +7,23 @@ 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,
     DurableExecutionInvocationOutput,
     InitialExecutionState,
-    InvocationStatus,
 )
 
 from aws_durable_execution_sdk_python_testing.exceptions import (
     DurableFunctionsTestError,
-    ServiceException,
+    InvalidParameterValueException,
+    ResourceNotFoundException,
 )
 from aws_durable_execution_sdk_python_testing.model import LambdaContext
 
+
 if TYPE_CHECKING:
     from collections.abc import Callable
 
@@ -28,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."""
@@ -135,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
@@ -147,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
@@ -163,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]
 
@@ -219,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():
@@ -239,7 +254,7 @@ class LambdaInvoker(Invoker):
             response = client.invoke(
                 FunctionName=function_name,
                 InvocationType="RequestResponse",  # Synchronous invocation
-                Payload=json.dumps(input.to_dict(), default=str),
+                Payload=json.dumps(input.to_json_dict()),
             )
 
             # Check HTTP status code

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/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/stores/filesystem.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import json
 import logging
-from datetime import UTC, datetime
 from pathlib import Path
 
 from aws_durable_execution_sdk_python_testing.exceptions import (
@@ -16,30 +15,6 @@ from aws_durable_execution_sdk_python_testing.stores.base import (
 )
 
 
-class DateTimeEncoder(json.JSONEncoder):
-    """Custom JSON encoder that handles datetime objects."""
-
-    def default(self, obj):
-        if isinstance(obj, datetime):
-            return obj.timestamp()
-        return super().default(obj)
-
-
-def datetime_object_hook(obj):
-    """JSON object hook to convert unix timestamps back to datetime objects."""
-    if isinstance(obj, dict):
-        for key, value in obj.items():
-            if isinstance(value, int | float) and key.endswith(
-                ("_timestamp", "_time", "Timestamp", "Time")
-            ):
-                try:  # noqa: SIM105
-                    obj[key] = datetime.fromtimestamp(value, tz=UTC)
-                except (ValueError, OSError):
-                    # Leave as number if not a valid timestamp
-                    pass
-    return obj
-
-
 class FileSystemExecutionStore(BaseExecutionStore):
     """File system-based execution store for persistence."""
 
@@ -69,10 +44,10 @@ class FileSystemExecutionStore(BaseExecutionStore):
     def save(self, execution: Execution) -> None:
         """Save execution to file system."""
         file_path = self._get_file_path(execution.durable_execution_arn)
-        data = execution.to_dict()
+        data = execution.to_json_dict()
 
         with open(file_path, "w", encoding="utf-8") as f:
-            json.dump(data, f, indent=2, cls=DateTimeEncoder)
+            json.dump(data, f, indent=2)
 
     def load(self, execution_arn: str) -> Execution:
         """Load execution from file system."""
@@ -82,9 +57,9 @@ class FileSystemExecutionStore(BaseExecutionStore):
             raise ResourceNotFoundException(msg)
 
         with open(file_path, encoding="utf-8") as f:
-            data = json.load(f, object_hook=datetime_object_hook)
+            data = json.load(f)
 
-        return Execution.from_dict(data)
+        return Execution.from_json_dict(data)
 
     def update(self, execution: Execution) -> None:
         """Update execution in file system (same as save)."""
@@ -96,8 +71,8 @@ class FileSystemExecutionStore(BaseExecutionStore):
         for file_path in self._storage_dir.glob("*.json"):
             try:
                 with open(file_path, encoding="utf-8") as f:
-                    data = json.load(f, object_hook=datetime_object_hook)
-                executions.append(Execution.from_dict(data))
+                    data = json.load(f)
+                executions.append(Execution.from_json_dict(data))
             except (json.JSONDecodeError, KeyError, OSError) as e:
                 logging.warning("Skipping corrupted file %s: %s", file_path, e)
                 continue

aws_durable_execution_sdk_python_testing/stores/sqlite.py

@@ -17,10 +17,6 @@ from aws_durable_execution_sdk_python_testing.execution import Execution
 from aws_durable_execution_sdk_python_testing.stores.base import (
     ExecutionStore,
 )
-from aws_durable_execution_sdk_python_testing.stores.filesystem import (
-    DateTimeEncoder,
-    datetime_object_hook,
-)
 
 
 class SQLiteExecutionStore(ExecutionStore):
@@ -102,7 +98,7 @@ class SQLiteExecutionStore(ExecutionStore):
                         execution_op.end_timestamp.timestamp()
                         if execution_op.end_timestamp
                         else None,
-                        json.dumps(execution.to_dict(), cls=DateTimeEncoder),
+                        json.dumps(execution.to_json_dict()),
                     ),
                 )
         except sqlite3.Error as e:
@@ -125,9 +121,7 @@ class SQLiteExecutionStore(ExecutionStore):
             if not row:
                 raise ResourceNotFoundException(f"Execution {execution_arn} not found")
 
-            return Execution.from_dict(
-                json.loads(row[0], object_hook=datetime_object_hook)
-            )
+            return Execution.from_json_dict(json.loads(row[0]))
         except sqlite3.Error as e:
             raise RuntimeError(f"Failed to load execution {execution_arn}: {e}") from e
         except json.JSONDecodeError as e:
@@ -222,11 +216,7 @@ class SQLiteExecutionStore(ExecutionStore):
             executions: list[Execution] = []
             for durable_execution_arn, data in rows:
                 try:
-                    executions.append(
-                        Execution.from_dict(
-                            json.loads(data, object_hook=datetime_object_hook)
-                        )
-                    )
+                    executions.append(Execution.from_json_dict(json.loads(data)))
                 except (json.JSONDecodeError, ValueError) as e:
                     # Log corrupted data but continue with other records
                     print(

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.0.dist-info → aws_durable_execution_sdk_python_testing-1.1.2.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: aws-durable-execution-sdk-python-testing
-Version: 1.1.0
+Version: 1.1.2
 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

{aws_durable_execution_sdk_python_testing-1.1.0.dist-info → aws_durable_execution_sdk_python_testing-1.1.2.dist-info}/RECORD

@@ -1,15 +1,15 @@
-aws_durable_execution_sdk_python_testing/__about__.py,sha256=J8Ioq0hfedDOXKbDonThH6dyrixwCOoGnMoJKfbnTuQ,137
-aws_durable_execution_sdk_python_testing/__init__.py,sha256=bNtlkAlTpEvWJlUyFHcadozQfnb0PjnDze6upzJiog4,483
+aws_durable_execution_sdk_python_testing/__about__.py,sha256=7qzc63t8OUhHP9YvXrUIRIK7LxcEvXL60VN7Z4b_y4M,137
+aws_durable_execution_sdk_python_testing/__init__.py,sha256=NJnSWv9wZndxH7C0lBDVyQ61uhT6i79m5Z_u-PJCVxg,578
 aws_durable_execution_sdk_python_testing/cli.py,sha256=ET2C3pYX_54BtV6GpLfP7FKkwOTgGoubPl0G9ixLmJk,18875
 aws_durable_execution_sdk_python_testing/client.py,sha256=1CFuUXBZIkM7YOWwlJu4OrcjrJSTk01-Zc3N75kYSR4,1682
 aws_durable_execution_sdk_python_testing/exceptions.py,sha256=ZgFPDtKgBn4-tj7fqaye901CksNQWL9RmMhgJBhEu_U,9110
-aws_durable_execution_sdk_python_testing/execution.py,sha256=pWawO619mE6uEEEMrgtmNVI155uapIrHJCx0NhwjLTE,17448
-aws_durable_execution_sdk_python_testing/executor.py,sha256=EOWLFXzRgd_h2lz0Smb5wvgPeDcruG11Q32a0vdztEw,48548
-aws_durable_execution_sdk_python_testing/invoker.py,sha256=jOOcccs7v551lSXC_ozx3TorOfx6fPlZklFyySo_mmo,13156
-aws_durable_execution_sdk_python_testing/model.py,sha256=__3Vtq6n_FgcdRd0SbWN30y6eUcw9p7nj_agEX3KD1g,120112
+aws_durable_execution_sdk_python_testing/execution.py,sha256=kU34EsVgtEPXQ8p4s-zjqhH38h0Gp9LxxyA16ofuwHI,17486
+aws_durable_execution_sdk_python_testing/executor.py,sha256=Q0ktkPa8OUUX8ky8pujmUfiiIRNyMIEPCagqdmOw008,48594
+aws_durable_execution_sdk_python_testing/invoker.py,sha256=Glx9ZN9hRRO_94Skb_qp95Y-DYCdTOfRapmt_KJ5uaU,13494
+aws_durable_execution_sdk_python_testing/model.py,sha256=xS6kHPEo4RdHph_rN8dVpQxZC0XzZJpYRLtbABe3A_U,121291
 aws_durable_execution_sdk_python_testing/observer.py,sha256=32MOYOfrmlKRqbfTXTM7m22iT38U2oYLGUkp7ar4Kvw,4935
 aws_durable_execution_sdk_python_testing/py.typed,sha256=DbCDcAirv769HS1ibzZLXq8VPazYf7JCkKSzj3ctudM,58
-aws_durable_execution_sdk_python_testing/runner.py,sha256=iRhNs3BDEkKj03i3toVTqCYoyK0C11P-FUf97g44S98,42559
+aws_durable_execution_sdk_python_testing/runner.py,sha256=RKjttyO-hb4o_JPvlpiXYi_2Znk6yAfrFN4zJ0vKyrY,42512
 aws_durable_execution_sdk_python_testing/scheduler.py,sha256=yqKGu8r3OoqPaERpILVNCIwjhFRxGOKxk5u2QJyF-44,8551
 aws_durable_execution_sdk_python_testing/token.py,sha256=5rUpWMMcfZUVdOX_ptukRYiIRDsOdUA7faHXNyDGJRU,1530
 aws_durable_execution_sdk_python_testing/checkpoint/__init__.py,sha256=sPmvbGOTRrDUvjiQwxsN8jS7uEQhpobt84yzYLEHfhk,81
@@ -34,19 +34,19 @@ aws_durable_execution_sdk_python_testing/checkpoint/validators/operations/step.p
 aws_durable_execution_sdk_python_testing/checkpoint/validators/operations/wait.py,sha256=E6m_upz1qQ6vQPOpU7mht0i_bBLLqfBP0UMYhGQG00k,1626
 aws_durable_execution_sdk_python_testing/stores/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 aws_durable_execution_sdk_python_testing/stores/base.py,sha256=LdvwrhRgY8yCjxvnT1yZX6manFGzg_wmHwshnE8tWCg,5454
-aws_durable_execution_sdk_python_testing/stores/filesystem.py,sha256=ieMvPGogtDe7HElFMoZTfIRveJaGq5d0mPq0Qd7nwgc,3838
+aws_durable_execution_sdk_python_testing/stores/filesystem.py,sha256=o9DJ18bThSl1QUpfR3nE_BffLHchslePpz2VxrvLrJI,2910
 aws_durable_execution_sdk_python_testing/stores/memory.py,sha256=V9PQTU6r-EHUqWPRui8YnjvEpxnLKKJxvfteNK3kgBo,1076
-aws_durable_execution_sdk_python_testing/stores/sqlite.py,sha256=Onhfx6u8sNSBROVyjq6S2xd2XYfvcN7ROARtfDhlruc,11148
+aws_durable_execution_sdk_python_testing/stores/sqlite.py,sha256=QvMY_BUyg3FAYNDzqQz7BMseGmCTlRLlPa0r02JYvMc,10822
 aws_durable_execution_sdk_python_testing/web/__init__.py,sha256=S8pemv1lfMXK4Kp8MIOAPEDMaUQGt9MArobCJhUERxw,84
 aws_durable_execution_sdk_python_testing/web/errors.py,sha256=8elkOXggINFhmfRFSPqu3XvD0msiJ2gd5GD86o7pTQU,340
-aws_durable_execution_sdk_python_testing/web/handlers.py,sha256=TBbroWvf_45Xus9zUR0ENVVQJMWWrO1Gt65F3KlTj6c,29129
+aws_durable_execution_sdk_python_testing/web/handlers.py,sha256=5_r6zaoaPujnNJohXQ_iPbXJJCR7vPMJfDT_fXr-VjI,29523
 aws_durable_execution_sdk_python_testing/web/models.py,sha256=B4SKVcTculNsO4Qd53tqkPnwVxwguP5PjNgnWF7dp8o,8852
 aws_durable_execution_sdk_python_testing/web/routes.py,sha256=AU9fMhuR0HF9fltNZ6TZMNOueQc8wEeNyJqoBpMctm0,19466
 aws_durable_execution_sdk_python_testing/web/serialization.py,sha256=qN6qJNgEYVqRQD9uhHupJVxyZfz4sc8KzIwxEqVIEcI,7747
 aws_durable_execution_sdk_python_testing/web/server.py,sha256=DQWwgyb_GKkHbFw_OYgPG1o7uIZ4-sG7F-GAUclLYu0,8853
-aws_durable_execution_sdk_python_testing-1.1.0.dist-info/METADATA,sha256=_6AVzNE0BWzUaN59UskC6ZKhjOX7IXIgxMJeJ7qPFbE,8924
-aws_durable_execution_sdk_python_testing-1.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-aws_durable_execution_sdk_python_testing-1.1.0.dist-info/entry_points.txt,sha256=fMm3DMHWb7k4-PSseaQ-BjUxNV_3Z7RyJaDVSwqnkEo,87
-aws_durable_execution_sdk_python_testing-1.1.0.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-aws_durable_execution_sdk_python_testing-1.1.0.dist-info/licenses/NOTICE,sha256=1CkO1kwu3Q_OHYTj-d-yiBJA_lNN73a4zSntavaD4oc,67
-aws_durable_execution_sdk_python_testing-1.1.0.dist-info/RECORD,,
+aws_durable_execution_sdk_python_testing-1.1.2.dist-info/METADATA,sha256=WchFeXSbyfcodoypxrqTScDRwdrfqV2mk410VrSNo9s,8953
+aws_durable_execution_sdk_python_testing-1.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+aws_durable_execution_sdk_python_testing-1.1.2.dist-info/entry_points.txt,sha256=fMm3DMHWb7k4-PSseaQ-BjUxNV_3Z7RyJaDVSwqnkEo,87
+aws_durable_execution_sdk_python_testing-1.1.2.dist-info/licenses/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+aws_durable_execution_sdk_python_testing-1.1.2.dist-info/licenses/NOTICE,sha256=1CkO1kwu3Q_OHYTj-d-yiBJA_lNN73a4zSntavaD4oc,67
+aws_durable_execution_sdk_python_testing-1.1.2.dist-info/RECORD,,

{aws_durable_execution_sdk_python_testing-1.1.0.dist-info → aws_durable_execution_sdk_python_testing-1.1.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: hatchling 1.29.0
 Root-Is-Purelib: true
 Tag: py3-none-any