Update app.py

app.py

@@ -60,7 +60,6 @@ class WebSocketInputOutput:
         """Reads a line from stdin, waiting for input from WebSocket."""
         try:
             print("DEBUG: Sending input_request to client.")
-            # CORRECTED: Access send_text via self.websocket
             await self.websocket.send_text(json.dumps({"type": "input_request"}))
             line = await self.input_queue.get() # Wait for input from client
             print(f"DEBUG: Received input from queue: {line.strip()[:50]}...")
@@ -79,7 +78,6 @@ class WebSocketInputOutput:
         """Synchronous wrapper for readline for use with exec."""
         try:
             print("DEBUG: Synchronous input wrapper called.")
-            # This is called from the executor thread, so asyncio.run is appropriate here
             return asyncio.run(self.readline())
         except Exception as e:
             print(f"ERROR: Synchronous input wrapper error: {e}")
@@ -386,30 +384,44 @@ class SecurePythonExecutor:
         print(f"DEBUG: run_with_timeout called. Client: {websocket_io.websocket.client}")
         
         # Define the synchronous target function to be run in the executor thread
-        def _execute_in_thread_test1():
-            # This function runs in a separate thread managed by the event loop's executor
+        def _execute_in_thread_test2(): # Renamed to test2 for clarity
             nonlocal result
-            
-            # --- START TEST 1 MODIFICATIONS ---
-            # DO NOT redirect sys.stdin/stdout/stderr here yet
-            print(f"DEBUG: Executor thread '{threading.current_thread().name}' started. (No IO redirected yet)")
-            result['success'] = True
-            # Do not call exec yet. Just write directly to output_buffer for testing.
-            websocket_io.output_buffer.write("DEBUG: Test message from executor thread (no exec).\n")
-            # Do not call asyncio.run(websocket_io.write) here. The main loop will check buffer.
-            print("DEBUG: _execute_in_thread finished with direct buffer write.")
-            # --- END TEST 1 MODIFICATIONS ---
+            original_stdin = sys.stdin
+            original_stdout = sys.stdout
+            original_stderr = sys.stderr
+            try:
+                sys.stdin = websocket_io
+                sys.stdout = websocket_io
+                sys.stderr = websocket_io
+                print(f"DEBUG: Executor thread '{threading.current_thread().name}' started. IO redirected.")
+                print("DEBUG: This should now go via websocket_io.write!")
+                
+                # We are still not calling exec here, just testing sys.stdout print
+                print("Hello from redirected stdout!")
+                
+                result['success'] = True
+            except Exception as e:
+                error_msg = f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()}"
+                print(f"ERROR: Exception in _execute_in_thread_test2 during sys redirection test: {error_msg}")
+                websocket_io.error_buffer.write(error_msg)
+                result['success'] = False
+            finally:
+                sys.stdin = original_stdin
+                sys.stdout = original_stdout
+                sys.stderr = original_stderr
+                print(f"DEBUG: Executor thread '{threading.current_thread().name}' finished. IO restored.")
+
 
         # Use the event loop's default ThreadPoolExecutor to run the synchronous code
         loop = asyncio.get_running_loop()
         try:
-            print(f"DEBUG: Scheduling _execute_in_thread_test1 in executor with timeout {self.timeout}s.")
-            # Run the synchronous _execute_in_thread_test1 in a separate thread
+            print(f"DEBUG: Scheduling _execute_in_thread_test2 in executor with timeout {self.timeout}s.")
+            # Run the synchronous _execute_in_thread_test2 in a separate thread
             await asyncio.wait_for(
-                loop.run_in_executor(None, _execute_in_thread_test1), # None uses the default ThreadPoolExecutor
+                loop.run_in_executor(None, _execute_in_thread_test2), # Changed to _execute_in_thread_test2
                 timeout=self.timeout
             )
-            print("DEBUG: _execute_in_thread_test1 completed via executor.")
+            print("DEBUG: _execute_in_thread_test2 completed via executor.")
         except asyncio.TimeoutError:
             print(f"ERROR: Code execution timed out after {self.timeout} seconds in run_in_executor.")
             result['error'] = f"Code execution timed out after {self.timeout} seconds"
@@ -419,8 +431,7 @@ class SecurePythonExecutor:
             except Exception:
                 pass # Ignore if websocket is already closed
         except Exception as e:
-            # This catches exceptions from _execute_in_thread_test1 that propagate up
-            # (e.g., if the thread itself crashes in an unrecoverable way before our try/except)
+            # This catches exceptions from _execute_in_thread_test2 that propagate up
             print(f"ERROR: Unexpected exception from executor: {e}")
             result['error'] = f"Unexpected executor error: {type(e).__name__}: {str(e)}"
             result['success'] = False
@@ -430,21 +441,20 @@ class SecurePythonExecutor:
                 pass
 
         # After execution (or timeout), collect output
-        if result['success']: # Only if execution was successful in _execute_in_thread_test1
+        if result['success']:
             result['output'] = websocket_io.output_buffer.getvalue()
-        if websocket_io.error_buffer.getvalue(): # Error buffer always checked
+        if websocket_io.error_buffer.getvalue():
             result['error'] = result['error'] + "\n" + websocket_io.error_buffer.getvalue() if result['error'] else websocket_io.error_buffer.getvalue()
-            result['success'] = False # Ensure success is false if there's any error output
+            result['success'] = False
         
         # Send a final message to the client indicating execution is complete
         try:
             print(f"DEBUG: Attempting to send execution_complete message (success={result['success']}).")
-            # CORRECTED: Access send_text via websocket_io.websocket
             await websocket_io.websocket.send_text(json.dumps({"type": "execution_complete", "result": result}))
             print("DEBUG: execution_complete message sent.")
         except WebSocketDisconnect:
             print("DEBUG: WebSocketDisconnect when sending execution_complete.")
-            pass # Ignore if websocket is already closed
+            pass
         except Exception as e:
             print(f"ERROR: Error sending execution_complete message: {e}")
 
@@ -466,8 +476,6 @@ app = FastAPI(
 @app.get("/", response_class=HTMLResponse)
 async def get_index():
     """Serves the interactive frontend."""
-    # This assumes index.html is in the same directory as app.py
-    # Explicitly copy index.html to /app/index.html to avoid any ambiguity with '.'
     with open("index.html", "r") as f:
         return HTMLResponse(content=f.read())
 
@@ -487,15 +495,12 @@ async def websocket_endpoint(websocket: WebSocket):
             if data["type"] == "code":
                 code = data["content"]
                 print(f"Received code from {websocket_io.websocket.client}: {code[:50]}...")
-                # Execute code asynchronously in the background
                 asyncio.create_task(executor.execute_code(code, websocket_io))
             elif data["type"] == "input":
                 user_input = data["content"]
                 print(f"Received input from {websocket_io.websocket.client}: {user_input.strip()[:50]}...")
-                await websocket_io.input_queue.put(user_input + "\n") # Add newline for readline
+                await websocket_io.input_queue.put(user_input + "\n")
             elif data["type"] == "ping":
-                # Respond to pings to keep connection alive
-                # CORRECTED: Access send_text via websocket_io.websocket
                 await websocket_io.websocket.send_text(json.dumps({"type": "pong"}))
                 print(f"DEBUG: Sent pong to {websocket_io.websocket.client}")
             else:
@@ -509,7 +514,6 @@ async def websocket_endpoint(websocket: WebSocket):
         print(f"WebSocket error for {websocket.client}: {e}")
     finally:
         websocket_io.closed = True
-        # Clean up any pending input requests if the client disconnects
         while not websocket_io.input_queue.empty():
             try:
                 websocket_io.input_queue.get_nowait()
@@ -517,8 +521,6 @@ async def websocket_endpoint(websocket: WebSocket):
                 pass
         print(f"WebSocket connection closed for {websocket_io.websocket.client}")
 
-# This block is for local development using `uvicorn`
-# Hugging Face Spaces will use `uvicorn` directly via the Dockerfile CMD
 if __name__ == "__main__":
     import uvicorn
     print("Starting Interactive Python Code Executor API (FastAPI)...")
@@ -532,10 +534,10 @@ if __name__ == "__main__":
     
     try:
         uvicorn.run(
-            "app:app",  # app:app means the `app` object in `app.py`
+            "app:app",
             host=server_name,
             port=server_port,
-            reload=False, # Set to True for local dev to auto-reload on code changes
+            reload=False,
             log_level="info"
         )
     except Exception as e: