Rollback to stable app.py (no streaming)

remote-gpu-server/app.py

@@ -14,8 +14,6 @@ import glob
 import shutil
 import os
 import sys
-import json
-
 
 app = FastAPI()
 
@@ -120,7 +118,7 @@ def get_system_info():
 
 @app.get("/")
 def read_root():
-    return {"status": "running", "message": "Remote GPU Execution Server v2.2 (Streaming Enabled)"}
+    return {"status": "running", "message": "Remote GPU Execution Server"}
 
 
 @app.post("/execute")
@@ -133,92 +131,6 @@ async def execute(data: dict):
         import traceback
         return {"output": f"❌ Server Error: {str(e)}\n\n{traceback.format_exc()}", "files": []}
 
-# --- STREAMING LOGIC ---
-from fastapi.responses import StreamingResponse
-
-def stream_code_execution(python_code: str):
-    """
-    Generatore che esegue codice e yielda output riga per riga.
-    Alla fine yielda un JSON speciale con i file.
-    """
-    if not python_code or not python_code.strip():
-        yield "❌ Errore: Nessun codice ricevuto.\n"
-        return
-
-    work_dir = tempfile.mkdtemp()
-    script_path = os.path.join(work_dir, "script.py")
-    
-    with open(script_path, 'w', encoding='utf-8') as f:
-        f.write(python_code)
-
-    yield "🚀 Avvio esecuzione (STREAMING)...\n"
-    yield f"📂 Directory: {work_dir}\n"
-    yield "=" * 50 + "\n"
-
-    try:
-        # Popen per leggere output in tempo reale
-        process = subprocess.Popen(
-            [sys.executable, script_path],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT, # Combina stderr in stdout
-            text=True,
-            cwd=work_dir,
-            env={**os.environ, "PYTHONUNBUFFERED": "1"},
-            bufsize=1 # Line buffered
-        )
-
-        # Leggi riga per riga
-        for line in process.stdout:
-            yield line
-
-        process.wait()
-        
-        yield "=" * 50 + "\n"
-        status = "✅ Successo" if process.returncode == 0 else f"❌ Errore ({process.returncode})"
-        yield f"{status}\n"
-
-        # RACCOLTA FILE FINALI
-        generated_files = []
-        # Cerca file generati (immagini, csv, json)
-        for ext in ['*.png', '*.jpg', '*.svg', '*.csv', '*.json', '*.txt', '*.pth', '*.pt']:
-            if ext == '*.txt': continue
-            for filepath in glob.glob(os.path.join(work_dir, ext)):
-                filename = os.path.basename(filepath)
-                try:
-                    with open(filepath, "rb") as f:
-                        if os.path.getsize(filepath) > 10 * 1024 * 1024:
-                            yield f"⚠️ File '{filename}' troppo grande (>10MB), saltato.\n"
-                            continue
-                        encoded = base64.b64encode(f.read()).decode('utf-8')
-                        generated_files.append({
-                            "name": filename,
-                            "data": encoded,
-                            "mime": "application/octet-stream"
-                        })
-                    yield f"📦 File generato: {filename}\n"
-                except Exception as e:
-                    yield f"❌ Errore lettura {filename}: {e}\n"
-
-        # Special marker for files payload
-        if generated_files:
-            payload = json.dumps({"files": generated_files})
-            yield f"__ANTIGRAVITY_FILES_JSON__:{payload}\n"
-
-    except Exception as e:
-        import traceback
-        yield f"❌ Eccezione: {str(e)}\n{traceback.format_exc()}\n"
-    
-    finally:
-        shutil.rmtree(work_dir, ignore_errors=True)
-
-
-@app.post("/execute_stream")
-async def execute_stream(data: dict):
-    """Endpoint POST per eseguire codice Python con output streaming"""
-    code = data.get("code", "")
-    return StreamingResponse(stream_code_execution(code), media_type="text/plain")
-# -----------------------
-
 
 # Interfaccia Gradio (Wrapper semplificato)
 def gradio_wrapper(code):