Remove unnecessary requirements.txt

Dependencies are handled by the build script copying from hatch environment

Author: bchampp

examples/src/requirements.txt

@@ -648,9 +648,11 @@ async def invoke() -> None:
                     self._invoker.create_invocation_input(execution=execution)
                 )
 
+                logger.info("[%s] Invoking Lambda function: %s", execution_arn, execution.start_input.function_name)
                 response: DurableExecutionInvocationOutput = self._invoker.invoke(
                     execution.start_input.function_name, invocation_input
                 )
+                logger.info("[%s] Lambda invocation completed with status: %s", execution_arn, response.status)
 
                 # Reload execution after invocation in case it was completed via checkpoint
                 execution = self._store.load(execution_arn)

src/aws_durable_execution_sdk_python_testing/executor.py

@@ -112,7 +112,11 @@ def create(endpoint_url: str, region_name: str) -> LambdaInvoker:
         """Create with the boto lambda client."""
         return LambdaInvoker(
             boto3.client(
-                "lambdainternal", endpoint_url=endpoint_url, region_name=region_name
+                "lambdainternal", 
+                endpoint_url=endpoint_url, 
+                region_name=region_name,
+                aws_access_key_id="test",
+                aws_secret_access_key="test"
             )
         )
 

src/aws_durable_execution_sdk_python_testing/invoker.py

@@ -197,16 +197,23 @@ async def delayed_func() -> Any:
 
     def create_event(self) -> Event:
         """Create an event controlled by the Scheduler to signal between threads and coroutines."""
+        logger.info("Creating event - submitting to scheduler event loop")
         # create event inside the Scheduler event-loop
         future: Future[asyncio.Event] = asyncio.run_coroutine_threadsafe(
             self._create_event(), self._loop
         )
+        logger.info("Event creation future submitted, waiting for result...")
 
         # Add timeout to prevent surprising "hangs" if for whatever reason event fails to create.
         # result with block. Do NOT call anything in _create_event that calls back into scheduler
         # methods because it could create a circular depdendency which will deadlock.
-        event = future.result(timeout=5.0)
-        return Event(self, event)
+        try:
+            event = future.result(timeout=5.0)
+            logger.info("Event created successfully")
+            return Event(self, event)
+        except TimeoutError:
+            logger.error("Timeout waiting for event creation - scheduler event loop may be blocked")
+            raise
 
     def wait_for_event(
         self, event: asyncio.Event, timeout: float | None = None

src/aws_durable_execution_sdk_python_testing/scheduler.py

@@ -249,14 +249,18 @@ def handle(self, parsed_route: Route, request: HTTPRequest) -> HTTPResponse:  #
         """
         try:
             body_data: dict[str, Any] = self._parse_json_body(request)
+            logger.info(f"Parsed request body: {body_data}")
 
             start_input: StartDurableExecutionInput = (
                 StartDurableExecutionInput.from_dict(body_data)
             )
+            logger.info(f"Created start_input: {start_input}")
 
+            logger.info("Calling executor.start_execution...")
             start_output: StartDurableExecutionOutput = self.executor.start_execution(
                 start_input
             )
+            logger.info(f"Successfully started execution: {start_output}")
 
             response_data: dict[str, Any] = start_output.to_dict()