cleaner ux

app.py

@@ -3,7 +3,7 @@ import time
 from apscheduler.schedulers.background import BackgroundScheduler
 import threading
 import globals
-from utils.io import initialize_models_providers_file, save_results, load_results, load_models_providers, get_results_table, load_models_providers_str
+from utils.io import initialize_models_providers_file, save_results, load_results, load_models_providers, get_results_table, load_models_providers_str, get_summary_stats
 from utils.jobs import run_single_job, launch_jobs, update_job_statuses, relaunch_failed_jobs
 from typing import List, Optional
 
@@ -28,23 +28,25 @@ def create_app() -> gr.Blocks:
             gr.Markdown("# Inference Provider Testing Dashboard")
             gr.Markdown("Launch and monitor evaluation jobs for multiple models and providers.")
 
-            # All action buttons in one row
+            # Simplified action buttons - only essential ones
             with gr.Row():
-                init_btn = gr.Button("Fetch and Initialize Models/Providers", variant="secondary")
-                launch_btn = gr.Button("Launch All Jobs", variant="primary")
-                relaunch_failed_btn = gr.Button("Relaunch Failed", variant="stop")
-                refresh_btn = gr.Button("Refresh Results", variant="secondary")
+                launch_btn = gr.Button("Launch All Jobs", variant="primary", scale=2)
+                relaunch_failed_btn = gr.Button("Relaunch Failed", variant="stop", scale=1)
 
             output = gr.Textbox(label="Status", interactive=False)
 
-            # Accordion for viewing models/providers list
+            # Accordion for viewing/editing models/providers list and initialization
             with gr.Accordion("Models/Providers Configuration", open=False):
+                init_btn = gr.Button("Fetch and Initialize Models/Providers", variant="secondary")
                 models_providers_display = gr.Code(
                     label="Current Models and Providers",
                     value=load_models_providers_str(),
                     interactive=False,
                 )
 
+            # Summary statistics
+            summary_stats = gr.Markdown(value=get_summary_stats())
+
             with gr.Row():
                 with gr.Column():
                     gr.Markdown("## Job Results")
@@ -67,19 +69,24 @@ def create_app() -> gr.Blocks:
                 outputs=[output, models_providers_display]
             )
 
+            def launch_and_update():
+                """Launch jobs and return updated table and stats."""
+                result = launch_jobs()
+                return result, get_results_table(), get_summary_stats()
+
+            def relaunch_and_update():
+                """Relaunch failed jobs and return updated table and stats."""
+                result = relaunch_failed_jobs()
+                return result, get_results_table(), get_summary_stats()
+
             launch_btn.click(
-                fn=launch_jobs,
-                outputs=output
+                fn=launch_and_update,
+                outputs=[output, results_table, summary_stats]
             )
 
             relaunch_failed_btn.click(
-                fn=relaunch_failed_jobs,
-                outputs=output
-            )
-
-            refresh_btn.click(
-                fn=get_results_table,
-                outputs=results_table
+                fn=relaunch_and_update,
+                outputs=[output, results_table, summary_stats]
             )
 
             # Handle dataframe cell selection for relaunch
@@ -101,13 +108,25 @@ def create_app() -> gr.Blocks:
                     # Save after individual relaunch
                     save_results()
 
-                # Then update the table
-                return get_results_table()
+                # Then update the table and stats
+                return get_results_table(), get_summary_stats()
 
             results_table.select(
                 fn=handle_table_select,
                 inputs=[],
-                outputs=results_table
+                outputs=[results_table, summary_stats]
+            )
+
+            # Auto-refresh table and stats every 30 seconds
+            def auto_refresh():
+                """Auto-refresh table and summary stats."""
+                return get_results_table(), get_summary_stats()
+
+            demo.load(
+                fn=auto_refresh,
+                inputs=[],
+                outputs=[results_table, summary_stats],
+                every=30
             )
         with gr.Tab("About"):
             gr.Markdown("""

utils/io.py

@@ -117,7 +117,10 @@ def load_results() -> None:
                 "status": row["status"],
                 "current_score": row["current_score"],
                 "previous_score": row["previous_score"],
-                "job_id": row["job_id"]
+                "job_id": row["job_id"],
+                "start_time": row.get("start_time"),
+                "duration": row.get("duration"),
+                "completed_at": row.get("completed_at")
             }
 
         print(f"Loaded {len(globals.job_results)} results from dataset")
@@ -136,10 +139,23 @@ def style_status(val):
         return 'background-color: blue'
     return ''
 
+def get_summary_stats():
+    """Get summary statistics of job results."""
+    if not globals.job_results:
+        return "📊 **Status:** No jobs yet"
+
+    total = len(globals.job_results)
+    running = sum(1 for info in globals.job_results.values() if info.get("status") == "RUNNING")
+    completed = sum(1 for info in globals.job_results.values() if info.get("status") == "COMPLETED")
+    failed = sum(1 for info in globals.job_results.values() if info.get("status") in ["ERROR", "FAILED"])
+
+    return f"📊 **Total:** {total} | 🔵 **Running:** {running} | ✅ **Completed:** {completed} | ❌ **Failed:** {failed}"
+
+
 def get_results_table():
     """Return job results as a styled pandas DataFrame for Gradio DataFrame."""
     if not globals.job_results:
-        return pd.DataFrame(columns=["Model", "Provider", "Last Run", "Status", "Current Score", "Previous Score", "Latest Job Id"])
+        return pd.DataFrame(columns=["Model", "Provider", "Last Run", "Status", "Current Score", "Previous Score", "Duration", "Completed At", "Latest Job Id"])
 
     table_data = []
     for key, info in globals.job_results.items():
@@ -151,6 +167,19 @@ def get_results_table():
         if previous_score is not None and isinstance(previous_score, (int, float)):
             previous_score = f"{previous_score:.4f}"
 
+        # Format duration
+        duration = info.get("duration")
+        if duration is not None and isinstance(duration, (int, float)):
+            # Convert seconds to minutes and seconds
+            minutes = int(duration // 60)
+            seconds = int(duration % 60)
+            duration_str = f"{minutes}m {seconds}s"
+        else:
+            duration_str = "N/A"
+
+        # Get completion time
+        completed_at = info.get("completed_at", "N/A")
+
         job_id = info.get("job_id", "N/A")
         # Create a clickable link for the job ID
         if job_id != "N/A":
@@ -171,11 +200,13 @@ def get_results_table():
             info["status"],
             current_score,
             previous_score,
+            duration_str,
+            completed_at,
             job_link,
             relaunch_link
         ])
 
-    df = pd.DataFrame(table_data, columns=["Model", "Provider", "Last Run", "Status", "Current Score", "Previous Score", "Job Id and Logs", "Actions"])
+    df = pd.DataFrame(table_data, columns=["Model", "Provider", "Last Run", "Status", "Current Score", "Previous Score", "Duration", "Completed At", "Job Id and Logs", "Actions"])
 
     # Apply styling to the Status column
     styled_df = df.style.map(style_status, subset=['Status'])

utils/jobs.py

@@ -98,17 +98,21 @@ def run_single_job(model: str, provider: str, tasks: str = globals.TASKS) -> Opt
         if key in globals.job_results and globals.job_results[key].get("current_score", None) is not None:
             previous_score = globals.job_results[key]["current_score"]
 
+        start_time = datetime.now()
         globals.job_results[key] = {
             "model": model,
             "provider": provider,
-            "last_run": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "last_run": start_time.strftime("%Y-%m-%d %H:%M:%S"),
             "status": "RUNNING",
             "current_score": None,
             "previous_score": previous_score,
-            "job_id": job_id
+            "job_id": job_id,
+            "start_time": start_time.isoformat(),
+            "duration": None,
+            "completed_at": None
         }
 
-    save_results()
+    # Don't save immediately - let the periodic save handle it
     print(f"Job launched: ID={job_id}, model={model}, provider={provider}")
     return job_id
 
@@ -128,9 +132,9 @@ def launch_jobs(tasks: str = globals.TASKS, config_file: str = globals.LOCAL_CON
         job_id = run_single_job(model, provider, tasks)
         if job_id != -1:
             launched_count += 1
-        # Small delay between launches to avoid rate limiting
-        time.sleep(2)
 
+    # Save all results once after launching all jobs
+    save_results()
     print(f"Launched {launched_count}/{len(models_providers)} jobs successfully")
     return f"Launched {launched_count} jobs"
 
@@ -152,8 +156,9 @@ def relaunch_failed_jobs():
         job_id = run_single_job(model, provider, globals.TASKS)
         if job_id != -1:
             relaunched_count += 1
-        time.sleep(2)  # Small delay between launches to avoid rate limiting
 
+    # Save all results once after relaunching all failed jobs
+    save_results()
     return f"Relaunched {relaunched_count}/{len(failed_jobs)} failed jobs"
 
 
@@ -177,8 +182,18 @@ def update_job_statuses() -> None:
                         globals.job_results[key]["status"] = new_status
                         print(f"Job {job_id} status changed: {old_status} -> {new_status}")
 
-                        # If job completed, try to extract score
+                        # If job completed, try to extract score and calculate duration
                         if new_status == "COMPLETED":
+                            completed_time = datetime.now()
+                            globals.job_results[key]["completed_at"] = completed_time.strftime("%Y-%m-%d %H:%M:%S")
+
+                            # Calculate duration if we have start_time
+                            start_time_str = globals.job_results[key].get("start_time")
+                            if start_time_str:
+                                start_time = datetime.fromisoformat(start_time_str)
+                                duration_seconds = (completed_time - start_time).total_seconds()
+                                globals.job_results[key]["duration"] = duration_seconds
+
                             score = extract_score_from_job(job_id)
                             if score is not None:
                                 globals.job_results[key]["current_score"] = score