Update app.py

app.py

@@ -2,8 +2,11 @@ import gradio as gr
 from gradio_client import Client
 import random
 import time
+import threading
 
-# Backend clients
+# -------------------------
+# Backend HF clients
+# -------------------------
 backend_engines = [
     Client("ChocoLaboratory/SANDBOX_BACKEND"),
     Client("ChocoLaboratory/SANDBOXBACKEND2")
@@ -11,10 +14,9 @@ backend_engines = [
 
 SANDBOX_TTL_SEC = 2 * 3600  # 2 hours
 
-# States
-sandbox_backend_state = gr.State(value=None)
-start_time_state = gr.State(value=0)
-
+# -------------------------
+# Helper functions
+# -------------------------
 def pick_engine():
     return random.choice(backend_engines)
 
@@ -23,31 +25,19 @@ def launch_sandbox(code):
     result = engine.predict(code=code, api_name="/launch_sandbox")
     sandbox_id = result if isinstance(result, str) else result.get("sandbox_id", "unknown")
     start_time = time.time()
-    return f"Sandbox launched! ID: {sandbox_id}\n", sandbox_id, SANDBOX_TTL_SEC, start_time, engine
+    return f"Sandbox launched! ID: {sandbox_id}\n", sandbox_id, start_time, engine
 
-def fetch_logs_and_timer(sandbox_id, start_time, engine):
+def fetch_logs(sandbox_id, engine):
+    if not sandbox_id or not engine:
+        return "No sandbox ID. Launch a sandbox first!"
     try:
         logs = engine.predict(api_name="/fetch_logs")
+        return logs
     except Exception as e:
-        logs = f"Error fetching logs: {e}"
-    elapsed = int(time.time() - start_time)
-    remaining = max(0, SANDBOX_TTL_SEC - elapsed)
-    minutes, seconds = divmod(remaining, 60)
-    time_str = f"{minutes:02d}:{seconds:02d}"
-    return logs, time_str
-
-def run_command(cmd, sandbox_id, start_time, engine):
-    if not sandbox_id:
-        return "No sandbox ID. Launch a sandbox first!", "0:00"
-    try:
-        engine.predict(code=cmd, api_name="/launch_sandbox")  # ideally /run_command
-        logs, remaining = fetch_logs_and_timer(sandbox_id, start_time, engine)
-        return logs, remaining
-    except Exception as e:
-        return f"Error: {e}", "0:00"
+        return f"Error fetching logs: {e}"
 
 def kill_sandbox(sandbox_id, engine):
-    if not sandbox_id:
+    if not sandbox_id or not engine:
         return "No sandbox ID to kill."
     try:
         result = engine.predict(api_name="/kill_sandbox")
@@ -55,21 +45,52 @@ def kill_sandbox(sandbox_id, engine):
     except Exception as e:
         return f"Error: {e}"
 
-def get_status(sandbox_id, start_time, engine):
-    if not sandbox_id:
+def status_sandbox(sandbox_id, start_time, engine):
+    if not sandbox_id or not engine:
         return "No sandbox ID.", "0:00"
     try:
         status = engine.predict(api_name="/status_sandbox")
-        elapsed = int(time.time() - start_time)
-        remaining = max(0, SANDBOX_TTL_SEC - elapsed)
-        minutes, seconds = divmod(remaining, 60)
-        time_str = f"{minutes:02d}:{seconds:02d}"
-        return status, time_str
+    except:
+        status = "Unknown"
+    elapsed = int(time.time() - start_time)
+    remaining = max(0, SANDBOX_TTL_SEC - elapsed)
+    minutes, seconds = divmod(remaining, 60)
+    time_str = f"{minutes:02d}:{seconds:02d}"
+    return status, time_str
+
+def run_command(cmd, sandbox_id, start_time, engine):
+    if not sandbox_id or not engine:
+        return "No sandbox ID. Launch a sandbox first!", "0:00"
+    try:
+        engine.predict(code=cmd, api_name="/launch_sandbox")  # ideally /run_command
+        logs, time_str = status_and_logs(sandbox_id, start_time, engine)
+        return logs, time_str
     except Exception as e:
         return f"Error: {e}", "0:00"
 
+def status_and_logs(sandbox_id, start_time, engine):
+    logs = fetch_logs(sandbox_id, engine)
+    _, time_str = status_sandbox(sandbox_id, start_time, engine)
+    return logs, time_str
+
+# -------------------------
+# Auto-update logs thread
 # -------------------------
-# UI
+def start_auto_update(terminal_output, sandbox_id_box, start_time_state, sandbox_backend_state, time_remaining):
+    def updater():
+        while True:
+            sandbox_id = sandbox_id_box.value
+            start_time = start_time_state.value
+            engine = sandbox_backend_state.value
+            if sandbox_id and engine:
+                logs, time_str = status_and_logs(sandbox_id, start_time, engine)
+                terminal_output.value = logs
+                time_remaining.value = time_str
+            time.sleep(1)
+    threading.Thread(target=updater, daemon=True).start()
+
+# -------------------------
+# Gradio UI
 # -------------------------
 with gr.Blocks() as demo:
     # Dark theme CSS
@@ -85,42 +106,51 @@ with gr.Blocks() as demo:
     with gr.Row():
         # Terminal Column
         with gr.Column(scale=3):
-            gr.Markdown("### 🖥 Sandbox Cloud Console")
+            gr.Markdown("### 🖥 Sandbox Terminal")
             terminal_output = gr.Textbox(label="", lines=20, interactive=False, elem_classes=["terminal-box"])
             command_input = gr.Textbox(label="Command Input", placeholder="print('Hello!')", interactive=True)
             run_btn = gr.Button("Run Command")
         
         # Side Panel
-        with gr.Column(scale=1):
-            with gr.Box(elem_classes=["side-panel"]):
-                gr.Markdown("### Sandbox Controls")
-                launch_btn = gr.Button("Launch Sandbox")
-                kill_btn = gr.Button("Kill Sandbox")
-                status_btn = gr.Button("Check Status")
-                sandbox_id_box = gr.Textbox(label="Sandbox ID", interactive=False)
-                time_remaining = gr.Textbox(label="Time Remaining", interactive=False)
-                gr.Markdown("💡 Running on a Debian-based container!")
+        with gr.Column(scale=1, elem_classes=["side-panel"]):
+            gr.Markdown("### Sandbox Controls")
+            launch_btn = gr.Button("Launch Sandbox")
+            kill_btn = gr.Button("Kill Sandbox")
+            status_btn = gr.Button("Check Status")
+            sandbox_id_box = gr.Textbox(label="Sandbox ID", interactive=False)
+            time_remaining = gr.Textbox(label="Time Remaining", interactive=False)
+            gr.Markdown("💡 Running on a Debian-based HF container!")
+
+    # States
+    start_time_state = gr.State(value=0)
+    sandbox_backend_state = gr.State(value=None)
 
     # Callbacks
     launch_btn.click(
         launch_sandbox,
         inputs=command_input,
-        outputs=[terminal_output, sandbox_id_box, time_remaining, start_time_state, sandbox_backend_state]
+        outputs=[terminal_output, sandbox_id_box, start_time_state, sandbox_backend_state]
     )
+
     run_btn.click(
         run_command,
         inputs=[command_input, sandbox_id_box, start_time_state, sandbox_backend_state],
         outputs=[terminal_output, time_remaining]
     )
+
     kill_btn.click(
         kill_sandbox,
         inputs=[sandbox_id_box, sandbox_backend_state],
         outputs=terminal_output
     )
+
     status_btn.click(
-        get_status,
+        status_sandbox,
         inputs=[sandbox_id_box, start_time_state, sandbox_backend_state],
         outputs=[terminal_output, time_remaining]
     )
 
+    # Start auto-update logs thread
+    start_auto_update(terminal_output, sandbox_id_box, start_time_state, sandbox_backend_state, time_remaining)
+
 demo.launch()