Update app.py

app.py

@@ -1,37 +1,34 @@
 import gradio as gr
-import requests
+from gradio_client import Client
 import threading
 import time
 
 # -------------------------
-# Backend Space URLs
+# Backend info
 # -------------------------
 BACKENDS = {
-    "Sandbox Backend 1": "https://chocolaboratory-sandboxbackend2.hf.space",
-    "Sandbox Backend 2": "https://chocolaboratory-sandbox-backend.hf.space"
+    "Sandbox Backend 1": "ChocoLaboratory/SANDBOX_BACKEND",
+    "Sandbox Backend 2": "ChocoLaboratory/SANDBOXBACKEND2"
 }
-
-# Track running sandboxes per backend
 backend_load = {name: 0 for name in BACKENDS.keys()}
-# Store user sandboxes: sandbox_id -> {"backend": ..., "start_time": ..., "card": ...}
 user_sandboxes = {}
 SANDBOX_TTL = 2*3600  # 2 hours
 
 # -------------------------
-# API calls
+# API functions
 # -------------------------
 def choose_backend():
     return min(backend_load, key=lambda k: backend_load[k])
 
-def launch_sandbox_api(code):
+def launch_sandbox_api(code, requirements):
     backend_name = choose_backend()
-    url = f"{BACKENDS[backend_name]}/launch_sandbox"
+    client = Client(BACKENDS[backend_name])
     try:
-        r = requests.post(url, json={"code": code})
-        r.raise_for_status()
-        sandbox_id = r.json()["sandbox_id"]
+        sandbox_id = client.predict(code=code, requirements=requirements, api_name="/launch_sandbox")
         backend_load[backend_name] += 1
-        user_sandboxes[sandbox_id] = {"backend": backend_name, "start_time": time.time(), "card": None}
+        user_sandboxes[sandbox_id] = {
+            "backend": backend_name, "start_time": time.time(), "client": client
+        }
         return sandbox_id, backend_name
     except Exception as e:
         return None, str(e)
@@ -40,13 +37,8 @@ def fetch_logs_api(sandbox_id):
     info = user_sandboxes.get(sandbox_id)
     if not info:
         return "Sandbox not found"
-    backend = info["backend"]
-    url = f"{BACKENDS[backend]}/fetch_logs/{sandbox_id}"
     try:
-        r = requests.get(url)
-        r.raise_for_status()
-        logs = r.json()
-        return f"STDOUT:\n{logs['stdout']}\n\nSTDERR:\n{logs['stderr']}"
+        return info["client"].predict(api_name="/fetch_logs", sandbox_id=sandbox_id)
     except Exception as e:
         return str(e)
 
@@ -54,14 +46,11 @@ def kill_sandbox_api(sandbox_id):
     info = user_sandboxes.get(sandbox_id)
     if not info:
         return "Sandbox not found"
-    backend = info["backend"]
-    url = f"{BACKENDS[backend]}/kill_sandbox/{sandbox_id}"
     try:
-        r = requests.post(url)
-        r.raise_for_status()
-        backend_load[backend] -= 1
+        result = info["client"].predict(api_name="/kill_sandbox", sandbox_id=sandbox_id)
+        backend_load[info["backend"]] -= 1
         del user_sandboxes[sandbox_id]
-        return f"Sandbox {sandbox_id} killed"
+        return result
     except Exception as e:
         return str(e)
 
@@ -69,19 +58,15 @@ def status_sandbox_api(sandbox_id):
     info = user_sandboxes.get(sandbox_id)
     if not info:
         return "Sandbox not found"
-    backend = info["backend"]
-    url = f"{BACKENDS[backend]}/status_sandbox/{sandbox_id}"
     try:
-        r = requests.get(url)
-        r.raise_for_status()
-        return r.json().get("status", "Unknown")
+        return info["client"].predict(api_name="/status_sandbox", sandbox_id=sandbox_id)
     except Exception as e:
         return str(e)
 
 # -------------------------
 # Sandbox card creation
 # -------------------------
-def create_sandbox_card(sandbox_id, sandbox_container):
+def create_sandbox_card(sandbox_id, sandbox_container, code, requirements):
     info = user_sandboxes[sandbox_id]
     backend = info["backend"]
 
@@ -92,13 +77,17 @@ def create_sandbox_card(sandbox_id, sandbox_container):
         runtime_box = gr.Textbox(label="Runtime (sec)", value="0", interactive=False)
         logs_box = gr.Textbox(label="Logs", lines=10, interactive=False)
 
-        # Buttons inside card
+        # Side-by-side panels: Main Code | requirements.txt
+        with gr.Row():
+            code_box = gr.Textbox(label="Main Code", value=code, lines=10, interactive=False)
+            req_box = gr.Textbox(label="requirements.txt", value=requirements, lines=10, interactive=False)
+
+        # Buttons
         with gr.Row():
             logs_btn = gr.Button("Fetch Logs")
             kill_btn = gr.Button("Kill Sandbox")
             status_btn = gr.Button("Check Status")
 
-        # Button actions
         logs_btn.click(lambda sid=sandbox_id: fetch_logs_api(sid), inputs=[], outputs=logs_box)
         kill_btn.click(lambda sid=sandbox_id: kill_sandbox_api(sid), inputs=[], outputs=status_badge)
         status_btn.click(lambda sid=sandbox_id: status_sandbox_api(sid), inputs=[], outputs=runtime_box)
@@ -109,12 +98,13 @@ def create_sandbox_card(sandbox_id, sandbox_container):
             elapsed = int(time.time() - info["start_time"])
             runtime_box.value = str(elapsed)
             logs_box.value = fetch_logs_api(sandbox_id)
+            if elapsed >= SANDBOX_TTL:
+                kill_sandbox_api(sandbox_id)
+                break
             time.sleep(2)
-        # Remove card if sandbox killed/expired
         sandbox_container.remove(card)
 
     threading.Thread(target=updater, daemon=True).start()
-    info["card"] = card
     return card
 
 # -------------------------
@@ -129,21 +119,22 @@ with gr.Blocks(css="""
         box-shadow: 0 4px 12px rgba(0,0,0,0.15);
     }
 """) as demo:
-    gr.Markdown("# 🛡 Sandbox Dashboard (AWS-style)")
+    gr.Markdown("# Sandbox Dashboard")
 
-    code_input = gr.Textbox(label="Python Code", lines=10)
+    code_input = gr.Textbox(label="Main Code", lines=10)
+    req_input = gr.Textbox(label="requirements.txt", lines=5)
     launch_btn = gr.Button("Launch Sandbox")
     launch_status = gr.Textbox(label="Launch Status")
 
     sandbox_container = gr.Column()
 
-    def on_launch(code):
-        sandbox_id, backend_or_error = launch_sandbox_api(code)
+    def on_launch(code, requirements):
+        sandbox_id, backend_or_error = launch_sandbox_api(code, requirements)
         if not sandbox_id:
             return f"Error: {backend_or_error}"
-        create_sandbox_card(sandbox_id, sandbox_container)
+        create_sandbox_card(sandbox_id, sandbox_container, code, requirements)
         return f"Sandbox {sandbox_id} launched on {user_sandboxes[sandbox_id]['backend']}"
 
-    launch_btn.click(on_launch, inputs=code_input, outputs=launch_status)
+    launch_btn.click(on_launch, inputs=[code_input, req_input], outputs=launch_status)
 
 demo.launch()