add inference / elapsed time

app.py

@@ -526,7 +526,7 @@ with gr.Blocks() as demo_submission:
                     )
             with gr.Accordion(
                 f"🔄 Running Evaluation Queue ({len(RUNNING_EVAL_QUEUE_DF)})",
-                open=False,
+                open=True,
             ):
                 with gr.Row():
                     running_eval_table = gr.Dataframe(

src/display/utils.py

@@ -56,6 +56,8 @@ auto_eval_column_dict.append(["revision", ColumnContent, ColumnContent("Revision
 auto_eval_column_dict.append(["add_special_tokens", ColumnContent, ColumnContent("Add Special Tokens", "bool", False)])
 auto_eval_column_dict.append(["enable_thinking", ColumnContent, ColumnContent("Enable Thinking", "bool", False)])
 auto_eval_column_dict.append(["apply_chat_template", ColumnContent, ColumnContent("Apply Chat Template", "bool", False)])
+auto_eval_column_dict.append(["inference_time", ColumnContent, ColumnContent("Inference Time (s)", "number", False)])
+auto_eval_column_dict.append(["co2_emission", ColumnContent, ColumnContent("CO2 (kg)", "number", False)])
 auto_eval_column_dict.append(["dummy", ColumnContent, ColumnContent("model_name_for_query", "str", False, dummy=True)])
 auto_eval_column_dict.append(["row_id", ColumnContent, ColumnContent("ID", "number", False, dummy=True)])
 
@@ -72,6 +74,10 @@ class EvalQueueColumn:  # Queue column (not a dataclass - used as class attribut
     add_special_tokens = ColumnContent("add_special_tokens", "str", True)
     status = ColumnContent("status", "str", True)
     submitted_by = ColumnContent("submitted_by", "str", True)
+    submitted_time = ColumnContent("submitted_time", "str", True)
+    started_time = ColumnContent("started_time", "str", True)
+    elapsed_time = ColumnContent("elapsed_time", "str", True)
+    queue_position = ColumnContent("queue_position", "number", True)
     apply_chat_template = ColumnContent("apply_chat_template", "bool", False)
     enable_thinking = ColumnContent("enable_thinking", "bool", False)
     reasoning_parser = ColumnContent("reasoning_parser", "str", False)

src/populate.py

@@ -1,5 +1,6 @@
 import json
 import os
+from datetime import datetime, timezone
 
 import pandas as pd
 from huggingface_hub import hf_hub_download
@@ -49,6 +50,8 @@ def get_leaderboard_df(contents_repo: str, cols: list[str], benchmark_cols: list
         "apply_chat_template": "Apply Chat Template",
         "model_type": "Type",
         "model": "model_name_for_query",
+        "inference_time_seconds": "Inference Time (s)",
+        "co2_emission_kg": "CO2 (kg)",
     }
     # Only rename columns that exist in the dataframe
     rename_dict = {k: v for k, v in rename_dict.items() if k in df.columns}
@@ -81,8 +84,76 @@ def get_leaderboard_df(contents_repo: str, cols: list[str], benchmark_cols: list
     return df
 
 
+def _compute_elapsed_time(time_str: str | None) -> str:
+    """Compute human-readable elapsed time from an ISO timestamp.
+
+    Args:
+        time_str: ISO 8601 timestamp string, or None.
+
+    Returns:
+        Human-readable elapsed duration (e.g. "3h 25m"), or "-" if unavailable.
+    """
+    if not time_str:
+        return "-"
+    try:
+        submitted = datetime.fromisoformat(time_str.replace("Z", "+00:00"))
+        delta = datetime.now(timezone.utc) - submitted
+        total_seconds = int(delta.total_seconds())
+        if total_seconds < 0:
+            return "-"
+        days, remainder = divmod(total_seconds, 86400)
+        hours, remainder = divmod(remainder, 3600)
+        minutes, _ = divmod(remainder, 60)
+        if days > 0:
+            return f"{days}d {hours}h {minutes}m"
+        if hours > 0:
+            return f"{hours}h {minutes}m"
+        return f"{minutes}m"
+    except (ValueError, TypeError):
+        return "-"
+
+
+def _enrich_queue_entry(data: dict) -> dict:
+    """Add timing fields to a queue entry.
+
+    Elapsed time is only meaningful for active entries:
+    - RUNNING: time since evaluation started (or submitted, as fallback)
+    - PENDING/RERUN: time since submission (waiting time)
+    - FINISHED/FAILED: shows "-" since the evaluation is already done
+
+    Args:
+        data: Raw queue entry dict loaded from JSON.
+
+    Returns:
+        The same dict with elapsed_time, submitted_time, and started_time populated.
+    """
+    data[EvalQueueColumn.model.name] = make_clickable_model(data["model"])
+    data[EvalQueueColumn.revision.name] = data.get("revision", "main")
+    data["submitted_time"] = data.get("submitted_time", "-")
+    data["started_time"] = data.get("started_time", "-")
+
+    status = data.get("status", "")
+    if status == "RUNNING":
+        ref_time = data["started_time"] if data["started_time"] != "-" else data["submitted_time"]
+        data["elapsed_time"] = _compute_elapsed_time(ref_time)
+    elif status in ("PENDING", "RERUN"):
+        data["elapsed_time"] = _compute_elapsed_time(data["submitted_time"])
+    else:
+        data["elapsed_time"] = "-"
+
+    return data
+
+
 def get_evaluation_queue_df(save_path: str, cols: list[str]) -> list[pd.DataFrame]:
-    """Creates the different dataframes for the evaluation queues requestes"""
+    """Creates the different dataframes for the evaluation queues requests.
+
+    Args:
+        save_path: Path to the directory containing queue JSON files.
+        cols: List of column names to include in the output DataFrames.
+
+    Returns:
+        A list of four DataFrames: [finished, running, pending, failed].
+    """
     entries = [entry for entry in os.listdir(save_path) if not entry.startswith(".")]
     all_evals = []
 
@@ -91,27 +162,32 @@ def get_evaluation_queue_df(save_path: str, cols: list[str]) -> list[pd.DataFram
             file_path = os.path.join(save_path, entry)
             with open(file_path) as fp:
                 data = json.load(fp)
-
-            data[EvalQueueColumn.model.name] = make_clickable_model(data["model"])
-            data[EvalQueueColumn.revision.name] = data.get("revision", "main")
-
-            all_evals.append(data)
+            all_evals.append(_enrich_queue_entry(data))
         elif ".md" not in entry:
-            # this is a folder
             sub_entries = [e for e in os.listdir(f"{save_path}/{entry}") if not e.startswith(".")]
             for sub_entry in sub_entries:
                 file_path = os.path.join(save_path, entry, sub_entry)
                 with open(file_path) as fp:
                     data = json.load(fp)
-
-                data[EvalQueueColumn.model.name] = make_clickable_model(data["model"])
-                data[EvalQueueColumn.revision.name] = data.get("revision", "main")
-                all_evals.append(data)
+                all_evals.append(_enrich_queue_entry(data))
 
     pending_list = [e for e in all_evals if e["status"] in ["PENDING", "RERUN"]]
     running_list = [e for e in all_evals if e["status"] == "RUNNING"]
     finished_list = [e for e in all_evals if e["status"].startswith("FINISHED") or e["status"] == "PENDING_NEW_EVAL"]
     failed_list = [e for e in all_evals if e["status"] == "FAILED"]
+
+    # Add queue position to pending list (sorted by submitted_time)
+    pending_list = sorted(pending_list, key=lambda x: x.get("submitted_time", ""))
+    for i, entry in enumerate(pending_list):
+        entry["queue_position"] = i + 1
+
+    # Running models: position 0 means currently being processed
+    for entry in running_list:
+        entry["queue_position"] = 0
+
+    for entry in finished_list + failed_list:
+        entry["queue_position"] = None
+
     df_pending = pd.DataFrame.from_records(pending_list, columns=cols)
     df_running = pd.DataFrame.from_records(running_list, columns=cols)
     df_finished = pd.DataFrame.from_records(finished_list, columns=cols)