fix: fix datetime serilization for lambda invoker

- Fix datetime serilization for lambda invoker
- Refactor serilization for filesystem and web module
- Remove unused import
- Remove unused txt file
- More unit tests for web/server

Author: Alex Wang

src/aws_durable_execution_sdk_python_testing/invoker.py

@@ -12,14 +12,13 @@
     DurableExecutionInvocationInputWithClient,
     DurableExecutionInvocationOutput,
     InitialExecutionState,
-    InvocationStatus,
 )
 
 from aws_durable_execution_sdk_python_testing.exceptions import (
     DurableFunctionsTestError,
-    ServiceException,
 )
 from aws_durable_execution_sdk_python_testing.model import LambdaContext
+from aws_durable_execution_sdk_python_testing.serialization import SimthyDateTimeEncoder
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -239,7 +238,7 @@ def invoke(
             response = client.invoke(
                 FunctionName=function_name,
                 InvocationType="RequestResponse",  # Synchronous invocation
-                Payload=json.dumps(input.to_dict(), default=str),
+                Payload=json.dumps(input.to_dict(), cls=SimthyDateTimeEncoder),
             )
 
             # Check HTTP status code

…_sdk_python_testing/web/serialization.py …tion_sdk_python_testing/serialization.pysrc/aws_durable_execution_sdk_python_testing/web/serialization.py renamed to src/aws_durable_execution_sdk_python_testing/serialization.py src/aws_durable_execution_sdk_python_testing/web/serialization.py renamed to src/aws_durable_execution_sdk_python_testing/serialization.py

@@ -6,12 +6,11 @@
 
 from __future__ import annotations
 
-import json
 import os
+import json
 from typing import Any, Protocol
-from datetime import datetime
+from datetime import datetime, UTC
 
-import aws_durable_execution_sdk_python
 import botocore.loaders  # type: ignore
 from botocore.model import ServiceModel  # type: ignore
 from botocore.parsers import create_parser  # type: ignore
@@ -22,6 +21,40 @@
 )
 
 
+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)
+
+
+class SimthyDateTimeEncoder(json.JSONEncoder):
+    """Custom JSON encoder that converts datetime objects to millisecond timestamps, which match smithy encoding behaviour"""
+
+    def default(self, obj):
+        if isinstance(obj, datetime):
+            # seconds_float to milliseconds
+            return int(obj.timestamp() * 1000)
+        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 Serializer(Protocol):
     """Interface for serializing data to bytes."""
 
@@ -64,22 +97,13 @@ class JSONSerializer:
     def to_bytes(self, data: Any) -> bytes:
         """Serialize data to JSON bytes."""
         try:
-            json_string = json.dumps(
-                data, separators=(",", ":"), default=self._default_handler
-            )
+            json_string = json.dumps(data, separators=(",", ":"), cls=DateTimeEncoder)
             return json_string.encode("utf-8")
         except (TypeError, ValueError) as e:
             raise InvalidParameterValueException(
                 f"Failed to serialize data to JSON: {str(e)}"
             )
 
-    def _default_handler(self, obj: Any) -> float:
-        """Handle non-permitive objects."""
-        if isinstance(obj, datetime):
-            return obj.timestamp()
-        # Raise TypeError for unsupported types
-        raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
-
 
 class AwsRestJsonSerializer:
     """AWS rest-json serializer using boto."""

src/aws_durable_execution_sdk_python_testing/stores/filesystem.py

@@ -4,42 +4,21 @@
 
 import json
 import logging
-from datetime import UTC, datetime
 from pathlib import Path
 
 from aws_durable_execution_sdk_python_testing.exceptions import (
     ResourceNotFoundException,
 )
+from aws_durable_execution_sdk_python_testing.serialization import (
+    DateTimeEncoder,
+    datetime_object_hook,
+)
 from aws_durable_execution_sdk_python_testing.execution import Execution
 from aws_durable_execution_sdk_python_testing.stores.base import (
     BaseExecutionStore,
 )
 
 
-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."""
 

src/aws_durable_execution_sdk_python_testing/stores/sqlite.py

@@ -17,7 +17,7 @@
 from aws_durable_execution_sdk_python_testing.stores.base import (
     ExecutionStore,
 )
-from aws_durable_execution_sdk_python_testing.stores.filesystem import (
+from aws_durable_execution_sdk_python_testing.serialization import (
     DateTimeEncoder,
     datetime_object_hook,
 )

src/aws_durable_execution_sdk_python_testing/web/models.py

@@ -14,7 +14,7 @@
 
 # Removed deprecated imports from web.errors
 from aws_durable_execution_sdk_python_testing.web.routes import Route
-from aws_durable_execution_sdk_python_testing.web.serialization import (
+from aws_durable_execution_sdk_python_testing.serialization import (
     AwsRestJsonDeserializer,
     JSONSerializer,
     Serializer,

tests/how-to-run-from-term.txt

@@ -12,6 +12,17 @@
     InvocationStatus,
 )
 
+from aws_durable_execution_sdk_python.lambda_service import (
+    ExecutionDetails,
+    Operation,
+    OperationStatus,
+    OperationType,
+)
+
+from aws_durable_execution_sdk_python_testing.serialization import SimthyDateTimeEncoder
+
+from datetime import datetime, UTC
+
 from aws_durable_execution_sdk_python_testing.execution import Execution
 from aws_durable_execution_sdk_python_testing.invoker import (
     InProcessInvoker,
@@ -168,10 +179,23 @@ def test_lambda_invoker_invoke_success():
 
     invoker = LambdaInvoker(lambda_client)
 
+    mock_operation = Operation(
+        operation_id="op-1",
+        parent_id=None,
+        name="test-execution",
+        start_timestamp=datetime.now(UTC),
+        end_timestamp=datetime.now(UTC),
+        operation_type=OperationType.EXECUTION,
+        status=OperationStatus.SUCCEEDED,
+        execution_details=ExecutionDetails(input_payload='{"test": "data"}'),
+    )
+
     input_data = DurableExecutionInvocationInput(
         durable_execution_arn="test-arn",
         checkpoint_token="test-token",  # noqa: S106
-        initial_execution_state=InitialExecutionState(operations=[], next_marker=""),
+        initial_execution_state=InitialExecutionState(
+            operations=[mock_operation], next_marker=""
+        ),
     )
 
     response = invoker.invoke("test-function", input_data)
@@ -185,7 +209,7 @@ def test_lambda_invoker_invoke_success():
     lambda_client.invoke.assert_called_once_with(
         FunctionName="test-function",
         InvocationType="RequestResponse",
-        Payload=json.dumps(input_data.to_dict(), default=str),
+        Payload=json.dumps(input_data.to_dict(), cls=SimthyDateTimeEncoder),
     )
 
 

tests/invoker_test.py

@@ -11,10 +11,12 @@
 from aws_durable_execution_sdk_python_testing.exceptions import (
     InvalidParameterValueException,
 )
-from aws_durable_execution_sdk_python_testing.web.serialization import (
+from aws_durable_execution_sdk_python_testing.serialization import (
     JSONSerializer,
     AwsRestJsonDeserializer,
     AwsRestJsonSerializer,
+    SimthyDateTimeEncoder,
+    datetime_object_hook,
 )
 
 
@@ -40,12 +42,10 @@ def test_aws_rest_json_serializer_should_initialize_and_serialize_data():
     )
 
 
-@patch("aws_durable_execution_sdk_python_testing.web.serialization.create_serializer")
-@patch("aws_durable_execution_sdk_python_testing.web.serialization.ServiceModel")
-@patch(
-    "aws_durable_execution_sdk_python_testing.web.serialization.botocore.loaders.Loader"
-)
-@patch("aws_durable_execution_sdk_python_testing.web.serialization.os.path.dirname")
+@patch("aws_durable_execution_sdk_python_testing.serialization.create_serializer")
+@patch("aws_durable_execution_sdk_python_testing.serialization.ServiceModel")
+@patch("aws_durable_execution_sdk_python_testing.serialization.botocore.loaders.Loader")
+@patch("aws_durable_execution_sdk_python_testing.serialization.os.path.dirname")
 def test_aws_rest_json_serializer_should_create_serializer_with_boto_components(
     mock_dirname,
     mock_loader_class,
@@ -90,7 +90,7 @@ def test_aws_rest_json_serializer_should_create_serializer_with_boto_components(
     mock_service_model.operation_model.assert_called_once_with(operation_name)
 
 
-@patch("aws_durable_execution_sdk_python_testing.web.serialization.create_serializer")
+@patch("aws_durable_execution_sdk_python_testing.serialization.create_serializer")
 def test_aws_rest_json_serializer_should_raise_serialization_error_when_create_fails(
     mock_create_serializer,
 ):
@@ -222,12 +222,10 @@ def test_aws_rest_json_deserializer_should_initialize_and_deserialize_data():
     mock_parser.parse.assert_called_once_with(expected_response_dict, mock_output_shape)
 
 
-@patch("aws_durable_execution_sdk_python_testing.web.serialization.create_parser")
-@patch("aws_durable_execution_sdk_python_testing.web.serialization.ServiceModel")
-@patch(
-    "aws_durable_execution_sdk_python_testing.web.serialization.botocore.loaders.Loader"
-)
-@patch("aws_durable_execution_sdk_python_testing.web.serialization.os.path.dirname")
+@patch("aws_durable_execution_sdk_python_testing.serialization.create_parser")
+@patch("aws_durable_execution_sdk_python_testing.serialization.ServiceModel")
+@patch("aws_durable_execution_sdk_python_testing.serialization.botocore.loaders.Loader")
+@patch("aws_durable_execution_sdk_python_testing.serialization.os.path.dirname")
 def test_aws_rest_json_deserializer_should_create_deserializer_with_boto_components(
     mock_dirname,
     mock_loader_class,
@@ -274,7 +272,7 @@ def test_aws_rest_json_deserializer_should_create_deserializer_with_boto_compone
     mock_service_model.operation_model.assert_called_once_with(operation_name)
 
 
-@patch("aws_durable_execution_sdk_python_testing.web.serialization.create_parser")
+@patch("aws_durable_execution_sdk_python_testing.serialization.create_parser")
 def test_aws_rest_json_deserializer_should_raise_serialization_error_when_create_fails(
     mock_create_parser,
 ):
@@ -574,3 +572,108 @@ def test_serialize_multiple_datetimes():
     expected = b'{"start":1735689600.0,"end":1767225599.0}'
 
     assert result == expected
+
+
+def test_smithy_datetime_encoder_converts_datetime_to_milliseconds():
+    """Test that SimthyDateTimeEncoder converts datetime to millisecond timestamps."""
+    encoder = SimthyDateTimeEncoder()
+    dt = datetime(2025, 11, 5, 16, 30, 9, 895000, tzinfo=timezone.utc)
+
+    result = encoder.default(dt)
+    expected = int(dt.timestamp() * 1000)
+
+    assert result == expected
+    assert result == 1762360209895
+
+
+def test_smithy_datetime_encoder_handles_non_datetime_objects():
+    """Test that SimthyDateTimeEncoder delegates to parent for non-datetime objects."""
+    encoder = SimthyDateTimeEncoder()
+
+    # Should delegate to parent's default method for non-datetime objects
+    with pytest.raises(TypeError):
+        encoder.default(object())
+
+
+def test_smithy_datetime_encoder_in_json_dumps():
+    """Test SimthyDateTimeEncoder when used with json.dumps."""
+    dt = datetime(2025, 11, 5, 16, 30, 9, 895000, tzinfo=timezone.utc)
+    data = {"timestamp": dt}
+
+    result = json.dumps(data, cls=SimthyDateTimeEncoder)
+    expected = '{"timestamp": 1762360209895}'
+
+    assert result == expected
+
+
+def test_smithy_datetime_encoder_precision():
+    """Test that SimthyDateTimeEncoder maintains millisecond precision."""
+    encoder = SimthyDateTimeEncoder()
+    dt = datetime(2025, 11, 5, 16, 30, 9, 123456, tzinfo=timezone.utc)
+
+    result = encoder.default(dt)
+    expected = int(dt.timestamp() * 1000)
+
+    assert result == expected
+    assert result == 1762360209123
+
+
+def test_datetime_object_hook_converts_timestamp_fields():
+    """Test that datetime_object_hook converts timestamp fields to datetime objects."""
+    from datetime import UTC
+
+    obj = {
+        "user_timestamp": 1762360209,
+        "created_time": 1735689600.0,
+        "lastModifiedTimestamp": 1767225599,
+        "endTime": 1762360209.895,
+    }
+
+    result = datetime_object_hook(obj)
+
+    assert isinstance(result["user_timestamp"], datetime)
+    assert isinstance(result["created_time"], datetime)
+    assert isinstance(result["lastModifiedTimestamp"], datetime)
+    assert isinstance(result["endTime"], datetime)
+    assert result["user_timestamp"].tzinfo == UTC
+
+
+def test_datetime_object_hook_preserves_non_timestamp_fields():
+    """Test that datetime_object_hook preserves fields that don't match timestamp patterns."""
+    obj = {"name": "test", "count": 42, "price": 19.99, "active": True}
+
+    result = datetime_object_hook(obj)
+
+    assert result == obj
+    assert result["name"] == "test"
+    assert result["count"] == 42
+    assert result["price"] == 19.99
+    assert result["active"] is True
+
+
+def test_datetime_object_hook_handles_non_dict_objects():
+    """Test that datetime_object_hook returns non-dict objects unchanged."""
+    assert datetime_object_hook("string") == "string"
+    assert datetime_object_hook(42) == 42
+    assert datetime_object_hook([1, 2, 3]) == [1, 2, 3]
+    assert datetime_object_hook(None) is None
+
+
+def test_datetime_object_hook_mixed_field_types():
+    """Test datetime_object_hook with mixed field types including nested structures."""
+    obj = {
+        "event_timestamp": 1762360209,
+        "metadata": {"created_time": 1735689600, "description": "test event"},
+        "tags": ["important", "user-action"],
+        "count": 1,
+    }
+
+    result = datetime_object_hook(obj)
+
+    assert isinstance(result["event_timestamp"], datetime)
+    assert result["metadata"] == {
+        "created_time": 1735689600,
+        "description": "test event",
+    }
+    assert result["tags"] == ["important", "user-action"]
+    assert result["count"] == 1