added

Dockerfile

@@ -0,0 +1,47 @@
+# Use official Python runtime as base image
+FROM python:3.9-slim
+
+# Set working directory in container
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV FASTAPI_SERVER_NAME=0.0.0.0
+ENV FASTAPI_SERVER_PORT=7860
+
+# Install build dependencies for some Python packages (like uvicorn, fastapi)
+# and for the signal handling
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements.txt and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# --- Diagnostic step: List contents of /app before copying index.html ---
+# This command will output the contents of the /app directory in the build logs.
+# It can help diagnose if an unexpected 'file' is already present.
+RUN echo "Contents of /app before copying index.html:"
+RUN ls -la /app
+# --- End Diagnostic step ---
+
+# Copy the application files
+COPY app.py .
+# Explicitly copy index.html to /app/index.html to avoid any ambiguity with '.'
+# This is the primary change to address "cannot copy to non-directory: .../app/file"
+COPY index.html /app/index.html
+
+# Create a non-root user for security
+RUN useradd --create-home --shell /bin/bash app && \
+    chown -R app:app /app
+USER app
+
+# Expose the port FastAPI will run on
+EXPOSE 7860
+
+# Command to run the FastAPI application using Uvicorn
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,11 @@
 ---
-title: Python Server
-emoji: 🌖
-colorFrom: pink
-colorTo: green
+title: Collaborative Python Executor
+emoji: 🐨
+colorFrom: yellow
+colorTo: yellow
 sdk: docker
 pinned: false
+license: artistic-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,552 @@
+import sys
+import io
+import traceback
+import ast
+import time
+import json
+import os
+from contextlib import redirect_stdout, redirect_stderr
+from typing import Dict, Any, Optional
+import threading
+import asyncio
+import signal
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request
+from pydantic import BaseModel
+from starlette.responses import HTMLResponse
+
+# Set up proper signal handling for Docker
+def signal_handler(signum, frame):
+    print(f"Received signal {signum}, shutting down gracefully...")
+    sys.exit(0)
+
+signal.signal(signal.SIGTERM, signal_handler)
+signal.signal(signal.SIGINT, signal_handler)
+
+# --- Custom IO Redirection for Interactive Execution ---
+
+class WebSocketInputOutput:
+    """
+    Redirects stdin/stdout/stderr to/from a WebSocket connection.
+    Handles interactive input by waiting for messages from the client.
+    """
+    def __init__(self, websocket: WebSocket):
+        self.websocket = websocket
+        self.input_queue = asyncio.Queue()
+        self.output_buffer = io.StringIO()
+        self.error_buffer = io.StringIO()
+        self.closed = False
+
+    async def write(self, s: str):
+        """Writes to stdout/stderr and sends to WebSocket."""
+        self.output_buffer.write(s)
+        try:
+            # Send output in chunks or lines to prevent large messages
+            await self.websocket.send_text(json.dumps({"type": "output", "content": s}))
+        except WebSocketDisconnect:
+            self.closed = True
+            print("WebSocket disconnected during write.")
+        except Exception as e:
+            print(f"Error sending output over WebSocket: {e}")
+            self.closed = True
+
+    def flush(self):
+        """Flushes the buffer (no-op for now, as we send immediately)."""
+        pass
+
+    async def readline(self) -> str:
+        """Reads a line from stdin, waiting for input from WebSocket."""
+        try:
+            await self.websocket.send_text(json.dumps({"type": "input_request"}))
+            line = await self.input_queue.get() # Wait for input from client
+            return line
+        except WebSocketDisconnect:
+            self.closed = True
+            print("WebSocket disconnected during readline.")
+            raise EOFError("Input stream closed due to WebSocket disconnect")
+        except Exception as e:
+            print(f"Error requesting input over WebSocket: {e}")
+            self.closed = True
+            raise EOFError(f"Input stream error: {e}")
+
+    # For compatibility with sys.stdin, which expects a file-like object
+    def _get_input_line(self):
+        """Synchronous wrapper for readline for use with exec."""
+        # This is a bit tricky: exec is synchronous, but WebSocket is async.
+        # We need to bridge this. A simple way is to run the async part
+        # in the event loop, but it's usually better to refactor the executor
+        # to be fully async if input() is truly interactive.
+        # For this example, we'll use a blocking call to asyncio.run
+        # which is generally discouraged in a running event loop,
+        # but works for simple cases or if the exec is in a separate thread.
+        # A more robust solution involves a custom Future/Event loop integration.
+        try:
+            # This will block the current thread until input is available
+            return asyncio.run(self.readline())
+        except Exception as e:
+            print(f"Synchronous input wrapper error: {e}")
+            raise
+
+    def read(self, n=-1):
+        """Reads n characters. For simplicity, we'll treat it as readline."""
+        return self._get_input_line() # Or implement more complex buffering
+
+    def __getattr__(self, name):
+        """Delegate other attributes if needed, or raise AttributeError."""
+        # This is a placeholder; real implementation would be more robust
+        # For now, we only need write, flush, and readline.
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
+
+# --- Python Syntax Validation FSM (unchanged) ---
+
+class PythonSyntaxFSM:
+    """Finite State Machine for Python syntax validation"""
+    
+    def __init__(self):
+        self.reset()
+        
+    def reset(self):
+        self.state = 'normal'
+        self.bracket_stack = []
+        self.in_string = False
+        self.string_delimiter = None
+        self.line_number = 0
+        self.errors = []
+        self.warnings = []
+        
+    def validate_code(self, code: str) -> Dict[str, Any]:
+        """Validate Python code using FSM approach"""
+        self.reset()
+        
+        if not code or not code.strip():
+            return {
+                'valid': False,
+                'errors': [{'line': 0, 'message': 'Empty code input', 'type': 'input_error'}],
+                'warnings': [],
+                'total_issues': 1
+            }
+        
+        lines = code.split('\n')
+        
+        for i, line in enumerate(lines):
+            self.line_number = i + 1
+            self.validate_line(line)
+            
+        # Check for unclosed brackets at end
+        if self.bracket_stack:
+            self.errors.append({
+                'line': self.line_number,
+                'type': 'syntax_error',
+                'message': f'Unclosed bracket: {self.bracket_stack[-1]}',
+                'severity': 'error'
+            })
+            
+        return {
+            'valid': len(self.errors) == 0,
+            'errors': self.errors,
+            'warnings': self.warnings,
+            'total_issues': len(self.errors) + len(self.warnings)
+        }
+    
+    def validate_line(self, line: str):
+        """Validate a single line using FSM logic"""
+        if not line.strip():
+            return
+            
+        # Check indentation
+        leading_spaces = len(line) - len(line.lstrip())
+        if leading_spaces % 4 != 0 and line.strip():
+            self.warnings.append({
+                'line': self.line_number,
+                'type': 'style_warning',
+                'message': 'Inconsistent indentation (PEP 8 recommends 4 spaces)',
+                'severity': 'warning'
+            })
+        
+        # Process character by character for brackets and strings
+        i = 0
+        while i < len(line):
+            char = line[i]
+            
+            # Handle string states
+            if self.in_string:
+                if char == self.string_delimiter and (i == 0 or line[i-1] != '\\'):
+                    self.in_string = False
+                    self.string_delimiter = None
+                i += 1
+                continue
+                
+            # Handle comment detection
+            if char == '#':
+                break   # Rest of line is comment
+                
+            # Handle string detection
+            if char in ['"', "'"]:
+                # Check for triple quotes
+                if i + 2 < len(line) and line[i:i+3] == char * 3:
+                    self.string_delimiter = char * 3
+                    i += 3
+                else:
+                    self.string_delimiter = char
+                    i += 1
+                self.in_string = True
+                continue
+                
+            # Handle brackets
+            if char in '([{':
+                self.bracket_stack.append(char)
+            elif char in ')]}':
+                if not self.bracket_stack:
+                    self.errors.append({
+                        'line': self.line_number,
+                        'type': 'syntax_error',
+                        'message': f'Unmatched closing bracket: {char}',
+                        'severity': 'error'
+                    })
+                else:
+                    expected = {'(': ')', '[': ']', '{': '}'}
+                    last_open = self.bracket_stack[-1]
+                    if expected[last_open] != char:
+                        self.errors.append({
+                            'line': self.line_number,
+                            'type': 'syntax_error',
+                            'message': f'Mismatched brackets: expected {expected[last_open]}, got {char}',
+                            'severity': 'error'
+                        })
+                    else:
+                        self.bracket_stack.pop()
+                        
+            i += 1
+        
+        # Check Python syntax patterns
+        stripped = line.strip()
+        control_keywords = ['def ', 'class ', 'if ', 'elif ', 'for ', 'while ', 'try:', 'except']
+        
+        for keyword in control_keywords:
+            if stripped.startswith(keyword):
+                if not stripped.endswith(':') and keyword != 'except':
+                    self.errors.append({
+                        'line': self.line_number,
+                        'type': 'syntax_error',
+                        'message': f'{keyword.strip()} statement must end with colon',
+                        'severity': 'error'
+                    })
+                break
+
+# --- Secure Python Executor (modified for WebSockets) ---
+
+class SecurePythonExecutor:
+    """Secure Python code executor with sandboxing and timeout, now interactive."""
+    
+    def __init__(self, timeout: int = 10):
+        self.timeout = timeout
+        self.restricted_modules = {
+            'os', 'sys', 'subprocess', 'socket', 'urllib', 'requests',
+            'shutil', 'glob', 'pickle', 'marshal', 'shelve', 'dbm',
+            'sqlite3', 'threading', 'multiprocessing', 'ctypes', 'importlib',
+            'builtins', '__builtin__', 'imp', 'zipimport'
+        }
+        
+        # Create safe builtins
+        # IMPORTANT: 'input' is now included and will be redirected!
+        self.safe_builtins = {
+            'print': print,
+            'len': len,
+            'range': range,
+            'str': str,
+            'int': int,
+            'float': float,
+            'bool': bool,
+            'list': list,
+            'dict': dict,
+            'tuple': tuple,
+            'set': set,
+            'frozenset': frozenset,
+            'abs': abs,
+            'max': max,
+            'min': min,
+            'sum': sum,
+            'sorted': sorted,
+            'reversed': reversed,
+            'enumerate': enumerate,
+            'zip': zip,
+            'map': map,
+            'filter': filter,
+            'all': all,
+            'any': any,
+            'type': type,
+            'isinstance': isinstance,
+            'hasattr': hasattr,
+            'getattr': getattr,
+            'setattr': setattr,
+            'delattr': delattr,
+            'round': round,
+            'pow': pow,
+            'divmod': divmod,
+            'chr': chr,
+            'ord': ord,
+            'hex': hex,
+            'oct': oct,
+            'bin': bin,
+            'format': format,
+            'repr': repr,
+            'ascii': ascii,
+            'iter': iter,
+            'next': next,
+            'slice': slice,
+            'callable': callable,
+            'id': id,
+            'hash': hash,
+            'vars': vars,
+            'dir': dir,
+            'help': help,
+            'Exception': Exception,
+            'ValueError': ValueError,
+            'TypeError': TypeError,
+            'IndexError': IndexError,
+            'KeyError': KeyError,
+            'AttributeError': AttributeError,
+            'NameError': NameError,
+            'ZeroDivisionError': ZeroDivisionError,
+            'input': input # Now included for interactive use
+        }
+        
+    async def execute_code(self, code: str, websocket_io: WebSocketInputOutput) -> Dict[str, Any]:
+        """Execute Python code in a secure environment with WebSocket IO."""
+        start_time = time.time()
+        
+        # Input validation
+        if not code or not code.strip():
+            error_msg = 'No code provided'
+            await websocket_io.write(f"Error: {error_msg}\n")
+            return {
+                'success': False,
+                'output': '',
+                'error': error_msg,
+                'execution_time': 0,
+                'validation': {
+                    'valid': False,
+                    'errors': [{'message': error_msg, 'line': 0}],
+                    'warnings': [],
+                    'total_issues': 1
+                }
+            }
+        
+        # Pre-execution validation
+        fsm = PythonSyntaxFSM()
+        validation_result = fsm.validate_code(code)
+        
+        # Check for restricted imports
+        restricted_check = self.check_restricted_imports(code)
+        if not restricted_check['allowed']:
+            error_msg = f"Security violation: Restricted module '{restricted_check['module']}' is not allowed"
+            await websocket_io.write(f"Error: {error_msg}\n")
+            return {
+                'success': False,
+                'output': '',
+                'error': error_msg,
+                'execution_time': 0,
+                'validation': validation_result
+            }
+        
+        # Execute code with timeout
+        result = await self.run_with_timeout(code, websocket_io) # Pass websocket_io
+        execution_time = time.time() - start_time
+        
+        return {
+            'success': result['success'],
+            'output': result['output'],
+            'error': result['error'],
+            'execution_time': round(execution_time, 3),
+            'validation': validation_result
+        }
+    
+    def check_restricted_imports(self, code: str) -> Dict[str, Any]:
+        """Check for restricted module imports"""
+        try:
+            tree = ast.parse(code)
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        if alias.name.split('.')[0] in self.restricted_modules:
+                            return {'allowed': False, 'module': alias.name}
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module and node.module.split('.')[0] in self.restricted_modules:
+                        return {'allowed': False, 'module': node.module}
+            return {'allowed': True, 'module': None}
+        except Exception:
+            return {'allowed': True, 'module': None}   # If parsing fails, let execution handle it
+    
+    async def run_with_timeout(self, code: str, websocket_io: WebSocketInputOutput) -> Dict[str, Any]:
+        """Run code with timeout protection, interacting via WebSocketIO."""
+        result = {'success': False, 'output': '', 'error': ''}
+        
+        # Store original stdin/stdout/stderr
+        original_stdin = sys.stdin
+        original_stdout = sys.stdout
+        original_stderr = sys.stderr
+
+        # Use a threading.Event to signal completion from the execution thread
+        execution_finished_event = threading.Event()
+
+        def target():
+            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
+
+                # Create restricted execution environment
+                restricted_globals = {
+                    '__builtins__': self.safe_builtins,
+                    '__name__': '__main__',
+                    '__doc__': None,
+                }
+                
+                # Execute the code
+                exec(code, restricted_globals)
+                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
+            except Exception as e:
+                error_msg = f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()}"
+                # Write error to WebSocket and internal buffer
+                try:
+                    asyncio.run(websocket_io.write(f"Error: {error_msg}\n"))
+                except Exception as write_e:
+                    print(f"Failed to write error to WebSocket: {write_e}")
+                websocket_io.error_buffer.write(error_msg)
+                result['success'] = False
+            finally:
+                # Restore original stdin/stdout/stderr for the thread pool (if applicable)
+                sys.stdin = original_stdin
+                sys.stdout = original_stdout
+                sys.stderr = original_stderr
+                execution_finished_event.set() # Signal completion
+
+        # Run the execution in a separate thread to allow for timeout
+        thread = threading.Thread(target=target)
+        thread.daemon = True # Allow the program to exit even if thread is running
+        thread.start()
+
+        # Wait for the thread to finish or timeout
+        thread.join(timeout=self.timeout)
+        
+        if thread.is_alive():
+            result['error'] = f"Code execution timed out after {self.timeout} seconds"
+            result['success'] = False
+            # Attempt to send timeout message to client
+            try:
+                await websocket_io.write(f"Error: {result['error']}\n")
+            except Exception:
+                pass # Ignore if websocket is already closed
+        else:
+            # Execution finished within timeout
+            result['output'] = websocket_io.output_buffer.getvalue()
+            if websocket_io.error_buffer.getvalue():
+                result['error'] = websocket_io.error_buffer.getvalue()
+                result['success'] = False
+            else:
+                result['success'] = True
+        
+        # Send a final message to the client indicating execution is complete
+        try:
+            await websocket_io.send_text(json.dumps({"type": "execution_complete", "result": result}))
+        except WebSocketDisconnect:
+            pass # Ignore if websocket is already closed
+        except Exception as e:
+            print(f"Error sending execution_complete message: {e}")
+
+        return result
+
+
+# Initialize the executor
+executor = SecurePythonExecutor(timeout=10)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Interactive Python Code Executor API",
+    description="A secure WebSocket API for executing Python code interactively.",
+    version="1.0.0",
+)
+
+# Serve the HTML frontend
+@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
+    with open("index.html", "r") as f:
+        return HTMLResponse(content=f.read())
+
+# WebSocket endpoint for interactive execution
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    websocket_io = WebSocketInputOutput(websocket)
+    print(f"WebSocket connection established: {websocket.client}")
+
+    try:
+        while True:
+            message = await websocket.receive_text()
+            data = json.loads(message)
+
+            if data["type"] == "code":
+                code = data["content"]
+                print(f"Received code from {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.client}: {user_input.strip()[:50]}...")
+                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"}))
+            else:
+                await websocket_io.write(f"Unknown message type: {data['type']}\n")
+
+    except WebSocketDisconnect:
+        print(f"WebSocket disconnected: {websocket.client}")
+    except json.JSONDecodeError:
+        print(f"Received invalid JSON from {websocket.client}: {message}")
+    except Exception as e:
+        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()
+            except asyncio.QueueEmpty:
+                pass
+        print(f"WebSocket connection closed for {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)...")
+    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)
+

docker-compose.yml

@@ -0,0 +1,29 @@
+version: '3.8'
+
+services:
+  python-executor:
+    build: .
+    ports:
+      - "7860:7860"
+    environment:
+      - GRADIO_SERVER_NAME=0.0.0.0
+      - GRADIO_SERVER_PORT=7860
+      - PYTHONUNBUFFERED=1
+    volumes:
+      # Optional: Mount for development
+      - ./app.py:/app/app.py:ro
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:7860/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 60s
+    deploy:
+      resources:
+        limits:
+          memory: 512M
+          cpus: '0.5'
+        reservations:
+          memory: 256M
+          cpus: '0.25'

index.html

@@ -0,0 +1,243 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Interactive Python Executor</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap" rel="stylesheet">
+    <style>
+        body {
+            font-family: 'Inter', sans-serif;
+            background-color: #1a202c; /* Dark background */
+            color: #e2e8f0; /* Light text */
+            display: flex;
+            justify-content: center;
+            align-items: flex-start;
+            min-height: 100vh;
+            padding: 2rem;
+            box-sizing: border-box;
+        }
+        .container {
+            background-color: #2d3748; /* Slightly lighter dark for container */
+            border-radius: 0.75rem; /* rounded-xl */
+            box-shadow: 0 10px 15px rgba(0, 0, 0, 0.2); /* shadow-xl */
+            padding: 2rem;
+            max-width: 900px;
+            width: 100%;
+            display: flex;
+            flex-direction: column;
+            gap: 1.5rem;
+        }
+        textarea, input[type="text"] {
+            background-color: #1a202c; /* Even darker for input fields */
+            color: #e2e8f0;
+            border: 1px solid #4a5568; /* border-gray-600 */
+            border-radius: 0.5rem; /* rounded-lg */
+            padding: 0.75rem 1rem;
+            font-family: 'Fira Code', 'Cascadia Code', 'Consolas', monospace; /* Monospace for code */
+            font-size: 0.9rem;
+            resize: vertical;
+        }
+        button {
+            padding: 0.75rem 1.5rem;
+            border-radius: 0.5rem; /* rounded-lg */
+            font-weight: 600; /* font-semibold */
+            transition: background-color 0.2s, transform 0.1s;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+        }
+        button:hover {
+            transform: translateY(-1px);
+        }
+        .btn-primary {
+            background-color: #4299e1; /* blue-500 */
+            color: white;
+        }
+        .btn-primary:hover {
+            background-color: #3182ce; /* blue-600 */
+        }
+        .btn-secondary {
+            background-color: #a0aec0; /* gray-400 */
+            color: #2d3748;
+        }
+        .btn-secondary:hover {
+            background-color: #718096; /* gray-500 */
+        }
+        .terminal-output {
+            background-color: #000; /* Black for terminal */
+            color: #0f0; /* Green text for terminal */
+            border-radius: 0.5rem;
+            padding: 1rem;
+            min-height: 200px;
+            max-height: 400px;
+            overflow-y: auto;
+            white-space: pre-wrap; /* Preserve whitespace and wrap text */
+            font-family: 'Fira Code', 'Cascadia Code', 'Consolas', monospace;
+            font-size: 0.85rem;
+            border: 1px solid #4a5568;
+        }
+        .input-area {
+            display: flex;
+            gap: 0.5rem;
+            margin-top: 1rem;
+        }
+        .hidden {
+            display: none;
+        }
+        .status-message {
+            font-size: 0.8rem;
+            color: #cbd5e0;
+            margin-top: 0.5rem;
+        }
+    </style>
+</head>
+<body class="antialiased">
+    <div class="container">
+        <h1 class="text-3xl font-bold text-center mb-4 text-blue-300">Interactive Python Interpreter</h1>
+        <p class="text-center text-gray-400 mb-6">Enter Python code and interact with it in real-time.</p>
+
+        <div class="flex flex-col gap-4">
+            <label for="code-input" class="text-lg font-semibold text-gray-200">Python Code:</label>
+            <textarea id="code-input" rows="15" class="focus:ring-blue-500 focus:border-blue-500">
+# Example: Interactive input
+n = int(input("Enter a number: "))
+if n % 2 == 0:
+    print("Even")
+else:
+    print("Odd")
+
+# Example: Multiple inputs
+name = input("What is your name? ")
+age = int(input("How old are you? "))
+print(f"Hello, {name}! You are {age} years old.")
+            </textarea>
+            <button id="run-button" class="btn-primary">Run Code</button>
+        </div>
+
+        <div class="flex flex-col gap-4">
+            <label for="terminal-output" class="text-lg font-semibold text-gray-200">Terminal Output:</label>
+            <div id="terminal-output" class="terminal-output"></div>
+            <div id="input-prompt-area" class="input-area hidden">
+                <input type="text" id="user-input" class="flex-grow" placeholder="Enter input here...">
+                <button id="send-input-button" class="btn-primary">Send Input</button>
+            </div>
+            <p id="status-message" class="status-message">Status: Not connected</p>
+        </div>
+    </div>
+
+    <script>
+        const codeInput = document.getElementById('code-input');
+        const runButton = document.getElementById('run-button');
+        const terminalOutput = document.getElementById('terminal-output');
+        const inputPromptArea = document.getElementById('input-prompt-area');
+        const userInput = document.getElementById('user-input');
+        const sendInputButton = document.getElementById('send-input-button');
+        const statusMessage = document.getElementById('status-message');
+
+        let ws;
+        let isAwaitingInput = false;
+
+        function connectWebSocket() {
+            let wsUrl;
+            if (window.location.protocol === 'https:') {
+                // For Hugging Face Spaces, always use wss:// when the page is loaded over HTTPS
+                // window.location.hostname is safer as it never includes the port
+                wsUrl = `wss://${window.location.hostname}/ws`;
+            } else {
+                // For local development (http://localhost:7860)
+                wsUrl = `ws://${window.location.host}/ws`;
+            }
+
+            console.log('Attempting to connect WebSocket to:', wsUrl);
+            console.log('Current page protocol:', window.location.protocol);
+            console.log('Current page hostname:', window.location.hostname);
+            console.log('Current page host (includes port):', window.location.host);
+
+
+            ws = new WebSocket(wsUrl);
+
+            ws.onopen = () => {
+                statusMessage.textContent = 'Status: Connected';
+                runButton.disabled = false;
+                console.log('WebSocket connected');
+            };
+
+            ws.onmessage = (event) => {
+                const data = JSON.parse(event.data);
+                if (data.type === 'output') {
+                    terminalOutput.textContent += data.content;
+                    terminalOutput.scrollTop = terminalOutput.scrollHeight; // Auto-scroll
+                } else if (data.type === 'input_request') {
+                    isAwaitingInput = true;
+                    inputPromptArea.classList.remove('hidden');
+                    userInput.focus();
+                    terminalOutput.scrollTop = terminalOutput.scrollHeight; // Auto-scroll
+                } else if (data.type === 'execution_complete') {
+                    isAwaitingInput = false;
+                    inputPromptArea.classList.add('hidden');
+                    userInput.value = '';
+                    statusMessage.textContent = 'Status: Execution complete.';
+                    console.log('Execution complete:', data.result);
+                } else if (data.type === 'pong') {
+                    // console.log('Pong received');
+                }
+            };
+
+            ws.onclose = (event) => {
+                statusMessage.textContent = `Status: Disconnected (Code: ${event.code}, Reason: ${event.reason})`;
+                runButton.disabled = true;
+                inputPromptArea.classList.add('hidden');
+                console.log('WebSocket disconnected:', event);
+                // Attempt to reconnect after a delay
+                setTimeout(connectWebSocket, 3000);
+            };
+
+            ws.onerror = (error) => {
+                statusMessage.textContent = 'Status: Connection error';
+                console.error('WebSocket error:', error);
+            };
+        }
+
+        runButton.addEventListener('click', () => {
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                terminalOutput.textContent = ''; // Clear previous output
+                statusMessage.textContent = 'Status: Running code...';
+                isAwaitingInput = false;
+                inputPromptArea.classList.add('hidden'); // Hide input area initially
+                userInput.value = ''; // Clear input field
+
+                const code = codeInput.value;
+                ws.send(JSON.stringify({ type: 'code', content: code }));
+            } else {
+                statusMessage.textContent = 'Status: Not connected. Please wait or refresh.';
+            }
+        });
+
+        sendInputButton.addEventListener('click', () => {
+            if (isAwaitingInput && ws && ws.readyState === WebSocket.OPEN) {
+                const inputContent = userInput.value;
+                ws.send(JSON.stringify({ type: 'input', content: inputContent }));
+                userInput.value = ''; // Clear input field after sending
+                inputPromptArea.classList.add('hidden'); // Hide input area until next prompt
+                isAwaitingInput = false;
+            }
+        });
+
+        userInput.addEventListener('keypress', (event) => {
+            if (event.key === 'Enter') {
+                sendInputButton.click();
+            }
+        });
+
+        // Start WebSocket connection when the page loads
+        document.addEventListener('DOMContentLoaded', connectWebSocket);
+
+        // Optional: Send a ping every 30 seconds to keep the WebSocket connection alive
+        setInterval(() => {
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: 'ping' }));
+            }
+        }, 30000); // 30 seconds
+    </script>
+</body>
+</html>

requirements.txt

@@ -0,0 +1,3 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+pydantic==2.5.0

test.py

@@ -0,0 +1,114 @@
+import asyncio
+import websockets
+import json
+
+# Replace with your actual Space URL
+# For Hugging Face Spaces, use wss://<your-space-id>.hf.space/ws
+WS_URL = "wss://Srevarshan1502-collaborative-python-executor.hf.space/ws"
+
+async def run_python_code(code_to_execute: str):
+    try:
+        async with websockets.connect(WS_URL) as websocket:
+            print("Connected to WebSocket.")
+
+            # Send the Python code
+            await websocket.send(json.dumps({"type": "code", "content": code_to_execute}))
+            print(f"Sent code:\n---\n{code_to_execute}\n---")
+
+            full_output = ""
+            execution_complete = False
+
+            while not execution_complete:
+                try:
+                    # Keep waiting for messages until execution_complete
+                    # Increased timeout to 60 seconds as per your last script
+                    message = await asyncio.wait_for(websocket.recv(), timeout=60)
+                    data = json.loads(message)
+
+                    if data["type"] == "output":
+                        full_output += data["content"]
+                        print(f"Received output chunk: {data['content'].strip()}")
+                    elif data["type"] == "input_request":
+                        print("\n--- Input Requested ---")
+                        user_input = input("Please enter input for the script: ")
+                        # IMPORTANT: Add newline character for the server's readline() to process it as a complete line
+                        await websocket.send(json.dumps({"type": "input", "content": user_input + "\n"}))
+                        print(f"Sent input: {user_input}")
+                    elif data["type"] == "execution_complete":
+                        print("\n--- Execution Complete ---")
+                        # The 'result' field from the server's execution_complete message
+                        server_result = data['result']
+                        print(f"Result details from server: {server_result}")
+
+                        # Consolidate output from the server_result as well
+                        if server_result.get('output'):
+                            full_output += server_result['output']
+                        if server_result.get('error'):
+                            # Prepend "Error:" if it's the first error message
+                            if "Error from server:" not in full_output:
+                                full_output += "\nError from server:\n"
+                            full_output += server_result['error']
+                            
+                        execution_complete = True
+                    elif data["type"] == "pong":
+                        # print("Received pong.") # Optional: uncomment to see pongs
+                        pass
+                    else:
+                        print(f"Received unknown message type: {data['type']} - {data.get('content')}")
+
+                except asyncio.TimeoutError:
+                    print("Timeout: No message received from server for 60 seconds. Disconnecting.")
+                    break
+                except websockets.exceptions.ConnectionClosedOK:
+                    print("Connection closed by server (OK).")
+                    # If it closes OK before execution_complete, it's an issue
+                    if not execution_complete:
+                        print("WARNING: Connection closed OK before execution_complete message was received!")
+                    break
+                except websockets.exceptions.ConnectionClosedError as e:
+                    print(f"Connection closed with error: {e}")
+                    break
+                except json.JSONDecodeError:
+                    print(f"Received invalid JSON: {message}")
+                    break
+                except Exception as e:
+                    print(f"An unexpected error occurred during message reception: {e}")
+                    break
+
+            print("\n--- Final Consolidated Output ---")
+            print(full_output)
+            return full_output
+
+    except websockets.exceptions.InvalidURI as e:
+        print(f"Invalid WebSocket URI: {e}")
+    except ConnectionRefusedError:
+        print("Connection refused. Is the server running and accessible?")
+    except Exception as e:
+        print(f"Could not connect to WebSocket: {e}")
+    return None
+
+if __name__ == "__main__":
+    # Test 1: Simple print statement (Matches the current app.py test 1)
+    print("\n=== Running Test 1: Simple Print ===")
+    asyncio.run(run_python_code(code_to_execute = "print('Hello, Space!')"))
+
+    # Test 2: Code with interactive input (corrected syntax)
+    print("\n=== Running Test 2: Interactive Input ===")
+    interactive_code = """
+name = input("Enter your name: ")
+age = int(input("How old are you? "))
+print(f"Hello, {name}! You are {age} years old.")
+"""
+    # For app.py's Test 2 (where exec is not yet active)
+    # asyncio.run(run_python_code(code_to_execute="DUMMY_CODE_FOR_TESTING_SYS_REDIRECTION"))
+
+    # Once app.py has Test 3 (with exec) uncomment this:
+    asyncio.run(run_python_code(interactive_code))
+
+    # Test 3: Code with error (uncomment when full exec is working)
+    # print("\n=== Running Test 3: Code with Error ===")
+    # asyncio.run(run_python_code("print(1/0)"))
+
+    # Test 4: Long-running code (will hit timeout if not finished, uncomment when full exec is working)
+    # print("\n=== Running Test 4: Long Running Code ===")
+    # asyncio.run(run_python_code("import time\nfor i in range(5):\n    print(f'Counting: {i}')\n    time.sleep(1)"))