Create app.py

app.py

@@ -0,0 +1,176 @@
+import os
+import subprocess
+import tempfile
+import sqlite3
+import psycopg2
+import pymysql
+import sys
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+app = Flask(__name__)
+CORS(app)
+
+@app.route('/')
+def home():
+    return jsonify({
+        "status": "ok",
+        "message": "Playground Backend Running. Use /api/run-python or /api/run-sql"
+    })
+
+# --- PYTHON RUNNER ---
+@app.route('/api/run-python', methods=['POST'])
+def run_python():
+    code = request.json.get('code', '')
+    user_input = request.json.get('input', '')
+    if not code:
+        return jsonify({'error': 'No code provided.'}), 400
+    
+    temp_file_path = None
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode='w', encoding='utf-8') as temp_file:
+            temp_file.write(code)
+            temp_file_path = temp_file.name
+
+        run_process = subprocess.run(
+            [sys.executable, temp_file_path], # Use current python executable
+            input=user_input,
+            capture_output=True,
+            text=True,
+            timeout=15
+        )
+        
+        # Return stdout if successful, or stderr if failed
+        if run_process.returncode != 0:
+             return jsonify({'output': run_process.stderr or run_process.stdout})
+        else:
+             return jsonify({'output': run_process.stdout})
+
+    except subprocess.TimeoutExpired:
+        return jsonify({'output': 'Error: Code execution timed out (15s limit).'})
+    except Exception as e:
+        return jsonify({'output': f"Error: {str(e)}"})
+    finally:
+        if temp_file_path and os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+# --- SQL RUNNER ---
+@app.route('/api/run-sql', methods=['POST'])
+def run_sql():
+    data = request.json
+    sql_code = data.get('code', '')
+    # Default to sqlite if not specified
+    db_type = data.get('type', 'sqlite').lower()
+
+    if not sql_code:
+        return jsonify({'error': 'No SQL code provided.'}), 400
+
+    output_log = ""
+
+    try:
+        # 1. SQLITE (In-Memory)
+        if db_type == 'sqlite':
+            # Create a fresh in-memory DB every time
+            con = sqlite3.connect(':memory:')
+            cur = con.cursor()
+            try:
+                # executescript allows multiple statements (CREATE + INSERT + SELECT)
+                cur.executescript(sql_code)
+                output_log = "Executed successfully.\n"
+                
+                # Simple heuristic: If user didn't print anything, try to verify tables
+                # But sqlite3 executescript doesn't return rows. 
+                # Use a specific fetch loop if you want to support SELECTs explicitly
+                # or tell users to use PRINT in python. 
+                # For SQL playground, we usually just run it. 
+                # To show data, we can iterate cursor if the last statement was SELECT.
+                # (Complex to detect in executescript, so we just return success message)
+                output_log += "(Note: SQLite script ran. If you need results, ensure your frontend handles 'select' logic or splits queries)"
+            except Exception as e:
+                output_log = f"SQLite Error: {e}"
+            finally:
+                con.close()
+
+        # 2. POSTGRESQL
+        elif db_type in ['postgres', 'postgresql']:
+            # Connect using the 'playground' user we created in start.sh
+            # No password needed because of 'trust' in pg_hba.conf
+            con = psycopg2.connect(
+                host="localhost",
+                user="playground",
+                database="playground"
+            )
+            con.autocommit = True
+            cur = con.cursor()
+            try:
+                # Psycopg2 execute cannot run multiple statements easily separated by ;
+                # unless we use simple execute. 
+                cur.execute(sql_code)
+                
+                if cur.description:
+                    rows = cur.fetchall()
+                    colnames = [desc[0] for desc in cur.description]
+                    output_log = f"Columns: {colnames}\n"
+                    for row in rows:
+                        output_log += f"{row}\n"
+                else:
+                    output_log = f"Command executed. Rows affected: {cur.rowcount}"
+            except Exception as e:
+                output_log = f"PostgreSQL Error: {e}"
+            finally:
+                con.close()
+
+        # 3. MYSQL / MARIADB
+        elif db_type == 'mysql':
+            # Connect using the 'playground' user from start.sh
+            con = pymysql.connect(
+                host="localhost",
+                user="playground",
+                database="playground",
+                cursorclass=pymysql.cursors.DictCursor,
+                client_flag=pymysql.constants.CLIENT.MULTI_STATEMENTS
+            )
+            try:
+                with con.cursor() as cur:
+                    cur.execute(sql_code)
+                    # Fetch results from all statements
+                    while True:
+                        if cur.description:
+                            rows = cur.fetchall()
+                            output_log += f"--- Result ---\n{rows}\n"
+                        else:
+                            output_log += f"Affected rows: {cur.rowcount}\n"
+                        if not cur.nextset():
+                            break
+            except Exception as e:
+                output_log = f"MySQL Error: {e}"
+            finally:
+                con.close()
+
+        else:
+            return jsonify({'output': 'Error: Unsupported database type'}), 400
+
+        return jsonify({'output': output_log})
+
+    except Exception as e:
+        return jsonify({'output': f"System Error: {str(e)}"})
+
+if __name__ == '__main__':
+    # Hugging Face expects port 7860
+    app.run(host="0.0.0.0", port=7860)
+```
+
+### How to use this API from your HTML/Frontend
+
+**1. For Python (Existing)**
+URL: `https://your-space-url.hf.space/api/run-python`
+Body: `{"code": "print(1+1)"}`
+
+**2. For SQL (New)**
+URL: `https://your-space-url.hf.space/api/run-sql`
+Body:
+```json
+{
+  "type": "mysql",
+  "code": "CREATE TABLE test (id INT); INSERT INTO test VALUES (1); SELECT * FROM test;"
+}