Update app.py

app.py

@@ -10,7 +10,7 @@ from typing import Dict, Any, Optional
 import threading
 import asyncio
 import signal
-from concurrent.futures import ThreadPoolExecutor # NEW: for loop.run_in_executor
+from concurrent.futures import ThreadPoolExecutor
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request
 from pydantic import BaseModel
 from starlette.responses import HTMLResponse
@@ -384,70 +384,31 @@ class SecurePythonExecutor:
         result = {'success': False, 'output': '', 'error': ''}
         print(f"DEBUG: run_with_timeout called. Client: {websocket_io.websocket.client}")
         
-        # Store original stdin/stdout/stderr
-        original_stdin = sys.stdin
-        original_stdout = sys.stdout
-        original_stderr = sys.stderr
-
         # Define the synchronous target function to be run in the executor thread
-        def _execute_in_thread():
+        def _execute_in_thread_test1():
             # This function runs in a separate thread managed by the event loop's executor
             nonlocal result
-            try:
-                # Redirect sys.stdin, sys.stdout, sys.stderr for this thread
-                sys.stdin = websocket_io
-                sys.stdout = websocket_io
-                sys.stderr = websocket_io
-                print(f"DEBUG: Executor thread '{threading.current_thread().name}' started. IO redirected.")
-                
-                # Create restricted execution environment
-                restricted_globals = {
-                    '__builtins__': self.safe_builtins,
-                    '__name__': '__main__',
-                    '__doc__': None,
-                }
-                print("DEBUG: Restricted globals prepared in executor thread.") # ADDED THIS LINE
-                
-                print(f"DEBUG: Preparing to execute code (executor thread): {code[:100]}...")
-                exec(code, restricted_globals)
-                print("DEBUG: Code execution completed successfully in executor thread.")
-                result['success'] = True
-                
-            except EOFError as e:
-                # This happens if the WebSocket disconnects during input()
-                result['error'] = f"Input stream closed: {str(e)}"
-                result['success'] = False
-                print(f"ERROR: EOFError during execution in executor thread: {e}")
-            except Exception as e:
-                error_msg = f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()}"
-                print(f"ERROR: Unhandled exception during execution in executor thread: {error_msg}")
-                try:
-                    # If this write fails, it's still good to log the error to stderr buffer
-                    # This asyncio.run call is crucial and runs a new event loop for this async call
-                    asyncio.run(websocket_io.write(f"Error: {error_msg}\n"))
-                    print("DEBUG: Attempted to write error via websocket_io.write from executor thread.")
-                except Exception as write_e:
-                    print(f"ERROR: Failed to write error to WebSocket from executor thread (inner): {write_e}")
-                websocket_io.error_buffer.write(error_msg)
-                result['success'] = False
-            finally:
-                # Restore original stdin/stdout/stderr for the thread pool
-                sys.stdin = original_stdin
-                sys.stdout = original_stdout
-                sys.stderr = original_stderr
-                print(f"DEBUG: Executor thread '{threading.current_thread().name}' finished. IO restored.")
-
+            
+            # --- 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)") # UPDATED PRINT
+            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") # Write to buffer directly
+            # 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.") # ADDED THIS LINE
+            # --- END TEST 1 MODIFICATIONS ---
 
         # 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 in executor with timeout {self.timeout}s.")
-            # Run the synchronous _execute_in_thread in a separate thread
+            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
             await asyncio.wait_for(
-                loop.run_in_executor(None, _execute_in_thread), # None uses the default ThreadPoolExecutor
+                loop.run_in_executor(None, _execute_in_thread_test1), # None uses the default ThreadPoolExecutor
                 timeout=self.timeout
             )
-            print("DEBUG: _execute_in_thread completed via executor.")
+            print("DEBUG: _execute_in_thread_test1 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"
@@ -457,7 +418,7 @@ class SecurePythonExecutor:
             except Exception:
                 pass # Ignore if websocket is already closed
         except Exception as e:
-            # This catches exceptions from _execute_in_thread that propagate up
+            # 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)
             print(f"ERROR: Unexpected exception from executor: {e}")
             result['error'] = f"Unexpected executor error: {type(e).__name__}: {str(e)}"
@@ -468,7 +429,7 @@ class SecurePythonExecutor:
                 pass
 
         # After execution (or timeout), collect output
-        if result['success']: # Only if execution was successful in _execute_in_thread
+        if result['success']: # Only if execution was successful in _execute_in_thread_test1
             result['output'] = websocket_io.output_buffer.getvalue()
         if websocket_io.error_buffer.getvalue(): # Error buffer always checked
             result['error'] = result['error'] + "\n" + websocket_io.error_buffer.getvalue() if result['error'] else websocket_io.error_buffer.getvalue()
@@ -523,17 +484,17 @@ async def websocket_endpoint(websocket: WebSocket):
 
             if data["type"] == "code":
                 code = data["content"]
-                print(f"Received code from {websocket.client}: {code[:50]}...")
+                print(f"Received code from {websocket_io.websocket.client}: {code[:50]}...") # Use websocket_io.websocket.client here
                 # 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.client}: {user_input.strip()[:50]}...")
+                print(f"Received input from {websocket_io.websocket.client}: {user_input.strip()[:50]}...") # Use websocket_io.websocket.client here
                 await websocket_io.input_queue.put(user_input + "\n") # Add newline for readline
             elif data["type"] == "ping":
                 # Respond to pings to keep connection alive
                 await websocket.send_text(json.dumps({"type": "pong"}))
-                print(f"DEBUG: Sent pong to {websocket.client}")
+                print(f"DEBUG: Sent pong to {websocket_io.websocket.client}") # Use websocket_io.websocket.client here
             else:
                 await websocket_io.write(f"Unknown message type: {data['type']}\n")
 
@@ -551,29 +512,4 @@ async def websocket_endpoint(websocket: WebSocket):
                 websocket_io.input_queue.get_nowait()
             except asyncio.QueueEmpty:
                 pass
-        print(f"WebSocket connection closed for {websocket_io.websocket.client}") # Use websocket_io.websocket.client here too
-
-# 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)...")
-    print(f"Python version: {sys.version}")
-    print(f"Working directory: {os.getcwd()}")
-    
-    server_name = os.getenv('FASTAPI_SERVER_NAME', '0.0.0.0')
-    server_port = int(os.getenv('FASTAPI_SERVER_PORT', 7860))
-    
-    print(f"Starting server on {server_name}:{server_port}")
-    
-    try:
-        uvicorn.run(
-            "app:app",  # app:app means the `app` object in `app.py`
-            host=server_name,
-            port=server_port,
-            reload=False, # Set to True for local dev to auto-reload on code changes
-            log_level="info"
-        )
-    except Exception as e:
-        print(f"Failed to start server: {e}")
-        sys.exit(1)
+        print(f"WebSocket connection closed for {websocket_io.websocket.client}")