remove dead code

Author: FullyTyped

src/aws_durable_execution_sdk_python_testing/executor.py

@@ -16,6 +16,7 @@
     CallbackTimeoutType,
     ErrorObject,
     Operation,
+    OperationAction,
     OperationUpdate,
     OperationStatus,
     OperationType,
@@ -1133,11 +1134,6 @@ def _checkpoint_chained_invoke_succeed(
         result: str | None,
     ) -> None:
         """Checkpoint a successful chained invoke."""
-        from aws_durable_execution_sdk_python.lambda_service import (
-            OperationAction,
-            OperationUpdate,
-        )
-
         execution = self._store.load(execution_arn)
         checkpoint_token = execution.get_new_checkpoint_token()
 
@@ -1163,11 +1159,6 @@ def _checkpoint_chained_invoke_fail(
         error: ErrorObject,
     ) -> None:
         """Checkpoint a failed chained invoke."""
-        from aws_durable_execution_sdk_python.lambda_service import (
-            OperationAction,
-            OperationUpdate,
-        )
-
         execution = self._store.load(execution_arn)
         checkpoint_token = execution.get_new_checkpoint_token()
 

src/aws_durable_execution_sdk_python_testing/runner.py

@@ -18,13 +18,15 @@
 
 import aws_durable_execution_sdk_python
 import boto3  # type: ignore
+import requests  # type: ignore
 from botocore.exceptions import ClientError  # type: ignore
 from aws_durable_execution_sdk_python.execution import (
     InvocationStatus,
     durable_execution,
 )
 from aws_durable_execution_sdk_python.lambda_service import (
     ErrorObject,
+    OperationAction,
     OperationPayload,
     OperationStatus,
     OperationSubType,
@@ -348,8 +350,6 @@ def from_svc_operation(
 class InvokeOperation(Operation):
     result: OperationPayload | None = None
     error: ErrorObject | None = None
-    function_name: str | None = None
-    input_payload: str | None = None
 
     @staticmethod
     def from_svc_operation(
@@ -360,14 +360,6 @@ def from_svc_operation(
             msg: str = f"Expected INVOKE operation, got {operation.operation_type}"
             raise InvalidParameterValueException(msg)
 
-        # Extract function_name from chained_invoke_options if available
-        function_name: str | None = None
-        input_payload: str | None = None
-        if operation.chained_invoke_details:
-            # Note: function_name and input_payload would need to be added to
-            # ChainedInvokeDetails in the SDK, or extracted from operation metadata
-            pass
-
         return InvokeOperation(
             operation_id=operation.operation_id,
             operation_type=operation.operation_type,
@@ -383,8 +375,6 @@ def from_svc_operation(
             error=operation.chained_invoke_details.error
             if operation.chained_invoke_details
             else None,
-            function_name=function_name,
-            input_payload=input_payload,
         )
 
 
@@ -916,7 +906,6 @@ def register_endpoint(self, function_name: str, endpoint: str) -> None:
         Raises:
             InvalidParameterValueException: If function_name is empty/None or endpoint is empty/None
         """
-        import requests
 
         if not function_name:
             raise InvalidParameterValueException("function_name is required")

tests/e2e/chained_invoke_test.py

@@ -51,16 +51,16 @@ def test_handler_registration_and_retrieval(self):
         def dummy_handler(event, context):
             return {"status": "ok"}
 
-        def child_handler(payload: str | None) -> str | None:
-            return json.dumps({"result": "child_result"})
+        def child_handler(event, context):
+            return {"result": "child_result"}
 
         with DurableFunctionTestRunner(handler=dummy_handler) as runner:
             # Register handler
             runner.register_handler("child-function", child_handler)
 
-            # Verify handler can be retrieved
+            # Verify handler can be retrieved (returns wrapped marshalled handler)
             retrieved = runner.get_handler("child-function")
-            assert retrieved is child_handler
+            assert retrieved is not None
 
             # Verify non-existent handler returns None
             assert runner.get_handler("non-existent") is None
@@ -76,19 +76,19 @@ def dummy_handler(event, context):
             return {"status": "ok"}
 
         handlers = {
-            "handler-a": lambda p: '{"result": "a"}',
-            "handler-b": lambda p: '{"result": "b"}',
-            "handler-c": lambda p: '{"result": "c"}',
+            "handler-a": lambda event, context: {"result": "a"},
+            "handler-b": lambda event, context: {"result": "b"},
+            "handler-c": lambda event, context: {"result": "c"},
         }
 
         with DurableFunctionTestRunner(handler=dummy_handler) as runner:
             # Register all handlers
             for name, handler in handlers.items():
                 runner.register_handler(name, handler)
 
-            # Verify all handlers are retrievable
-            for name, handler in handlers.items():
-                assert runner.get_handler(name) is handler
+            # Verify all handlers are retrievable (returns wrapped marshalled handlers)
+            for name in handlers:
+                assert runner.get_handler(name) is not None
 
     def test_handler_registration_validation(self):
         """
@@ -360,22 +360,22 @@ def test_non_durable_function_synchronous_execution(self):
         """
         execution_order = []
 
-        def child_handler(payload: str | None) -> str | None:
+        def child_handler(event, context):
             execution_order.append("child_executed")
-            data = json.loads(payload) if payload else {}
-            return json.dumps({"processed": data.get("value", 0) * 2})
+            value = event.get("value", 0) if event else 0
+            return {"processed": value * 2}
 
         def dummy_handler(event, context):
             return {"status": "ok"}
 
         with DurableFunctionTestRunner(handler=dummy_handler) as runner:
             runner.register_handler("sync-child", child_handler)
 
-            # Get the handler and invoke it directly (simulating synchronous execution)
+            # Get the marshalled handler and invoke it directly (simulating synchronous execution)
             handler = runner.get_handler("sync-child")
             assert handler is not None
 
-            # Execute synchronously
+            # Execute synchronously (marshalled handler takes JSON string payload)
             result = handler('{"value": 21}')
             execution_order.append("after_child")
 
@@ -390,17 +390,15 @@ def test_non_durable_function_result_serialization(self):
         _Requirements: 8.2_
         """
 
-        def child_handler(payload: str | None) -> str | None:
-            # Handler returns serialized JSON string
-            return json.dumps(
-                {
-                    "string": "value",
-                    "number": 123,
-                    "boolean": True,
-                    "array": [1, 2, 3],
-                    "nested": {"key": "value"},
-                }
-            )
+        def child_handler(event, context):
+            # Handler returns dict (Lambda-style), marshalled handler serializes it
+            return {
+                "string": "value",
+                "number": 123,
+                "boolean": True,
+                "array": [1, 2, 3],
+                "nested": {"key": "value"},
+            }
 
         def dummy_handler(event, context):
             return {"status": "ok"}
@@ -411,7 +409,7 @@ def dummy_handler(event, context):
             handler = runner.get_handler("serializing-child")
             result = handler(None)
 
-            # Verify result is valid JSON
+            # Verify result is valid JSON (marshalled handler serializes the dict)
             parsed = json.loads(result)
             assert parsed["string"] == "value"
             assert parsed["number"] == 123
@@ -426,7 +424,7 @@ def test_non_durable_function_exception_capture(self):
         _Requirements: 8.3_
         """
 
-        def failing_child(payload: str | None) -> str | None:
+        def failing_child(event, context):
             raise RuntimeError("Child function failed")
 
         def dummy_handler(event, context):
@@ -437,6 +435,6 @@ def dummy_handler(event, context):
 
             handler = runner.get_handler("failing-child")
 
-            # Verify exception is raised
+            # Verify exception is raised (marshalled handler propagates exceptions)
             with pytest.raises(RuntimeError, match="Child function failed"):
                 handler('{"input": "data"}')

tests/runner_test.py

@@ -2338,6 +2338,7 @@ def test_local_and_cloud_runner_result_structure_consistency():
 
     # Check DurableFunctionTestResult has expected attributes
     for attr in result_attrs:
-        assert hasattr(DurableFunctionTestResult, attr) or attr in DurableFunctionTestResult.__dataclass_fields__, (
-            f"DurableFunctionTestResult should have '{attr}' attribute"
-        )
+        assert (
+            hasattr(DurableFunctionTestResult, attr)
+            or attr in DurableFunctionTestResult.__dataclass_fields__
+        ), f"DurableFunctionTestResult should have '{attr}' attribute"