Format last eval timestamp as UTC+8

app.py

@@ -3,7 +3,6 @@ import os
 from pathlib import Path
 
 import gradio as gr
-import pandas as pd
 
 from src.about import (
     CITATION_BUTTON_LABEL,
@@ -12,196 +11,116 @@ from src.about import (
     LLM_BENCHMARKS_TEXT,
     TITLE,
 )
-from src.benchmark_config import BENCHMARK_INTERVAL_SECONDS, EVAL_WATCH_POLL_SECONDS, LIVE_EVAL_ENABLED
-from src.display.css_html_js import (
-    build_custom_css,
-    eval_countdown_head_js,
-    eval_countdown_markup,
-)
-from src.eval_scheduler import get_scheduler, start_live_eval_scheduler
+from src.display.css_html_js import custom_css
+from src.display.formatting import format_timestamp_utc8
 from src.utils import (
     get_grouped_dfs,
+    load_baseline_name,
     prepare_ranks_table,
     prepare_values_table,
 )
 
 RESULTS_PATH = os.getenv("TSFM_RESULTS_PATH", "results")
-
-start_live_eval_scheduler()
-
-_last_seen_eval_token: str | None = None
+REFRESH_SECONDS = int(os.getenv("TSFM_REFRESH_SECONDS", "300"))
 
 
 def load_online_status(results_path: str = RESULTS_PATH) -> dict:
     status_path = Path(results_path) / "online_status.json"
     if not status_path.exists():
-        return {"status": "unknown", "message": "No online_status.json yet."}
+        return {"status": "unknown", "message": "No online_status.json yet. Run run_online_eval.py."}
     return json.loads(status_path.read_text())
 
 
-def build_countdown_html() -> str:
-    scheduler = get_scheduler()
-    running = scheduler.is_running()
-    return eval_countdown_markup(
-        next_eval_at_unix=scheduler.next_eval_at_unix(),
-        interval_seconds=BENCHMARK_INTERVAL_SECONDS,
-        running=running,
+def build_status_line(status: dict, baseline: str) -> str:
+    finished = format_timestamp_utc8(status.get("finished_at", "n/a"))
+    data_source = status.get("data_source", "n/a")
+    ts_bench_root = status.get("ts_bench_root", "")
+    root_hint = f" · TS-Bench: `{ts_bench_root}`" if ts_bench_root else ""
+    return (
+        f"**Live benchmark** · Data: `{data_source}`{root_hint} · "
+        f"Baseline: `{baseline}` · Last eval: **{finished}** · "
+        f"Auto-refresh every {REFRESH_SECONDS}s"
     )
 
 
-def build_status_line(status: dict) -> str:
-    eval_state = get_scheduler().snapshot()
-    finished = status.get("finished_at", "n/a")
-    eval_status = eval_state.get("status", "unknown")
-    eval_message = eval_state.get("message", "")
-
-    if eval_status == "running":
-        live_hint = "**Evaluating now** — collecting TS-Bench data and calling TSFM.ai…"
-    elif not LIVE_EVAL_ENABLED:
-        if eval_status in {"ok", "partial"}:
-            live_hint = (
-                f"**Leaderboard** · Last eval `{finished}` · "
-                f"results updated every **{BENCHMARK_INTERVAL_SECONDS // 60} min** from local runner"
-            )
-        else:
-            live_hint = "**Leaderboard** · waiting for first results push from local runner"
-    elif eval_status == "disabled":
-        live_hint = f"**Live eval off** — {eval_message}"
-    else:
-        live_hint = (
-            f"**Live eval** · Last run `{finished}` · "
-            f"collect + eval every **{BENCHMARK_INTERVAL_SECONDS // 60} min** · "
-            f"leaderboard refreshes when each run completes"
-        )
-
-    return live_hint
-
-
 def refresh_leaderboard() -> tuple:
     grouped = get_grouped_dfs(RESULTS_PATH)
     status = load_online_status(RESULTS_PATH)
+    baseline = load_baseline_name(RESULTS_PATH)
 
     outputs: list = [
         prepare_values_table(grouped["overall_values"]),
         prepare_ranks_table(grouped["overall_ranks"]),
-        build_status_line(status),
-        build_countdown_html(),
+        build_status_line(status, baseline),
+        REFRESH_SECONDS,
+        f"Next auto-refresh in **{REFRESH_SECONDS}s**",
     ]
-    domains: list[str] = grouped["domains"]
-    for domain in domains:
+    for domain in DOMAINS:
         values_df = grouped["domain_values"].get(domain)
-        ranks_df = grouped["domain_ranks"].get(domain)
         if values_df is not None and not values_df.empty:
             outputs.append(prepare_values_table(values_df))
         else:
             outputs.append(prepare_values_table(grouped["overall_values"].iloc[:0]))
-        if ranks_df is not None and not ranks_df.empty:
-            outputs.append(prepare_ranks_table(ranks_df))
-        else:
-            outputs.append(prepare_ranks_table(grouped["overall_ranks"].iloc[:0]))
     return tuple(outputs)
 
 
-def load_initial_outputs() -> tuple[list[str], tuple]:
-    try:
-        grouped = get_grouped_dfs(RESULTS_PATH)
-        status = load_online_status(RESULTS_PATH)
-        domains = grouped["domains"]
-        outputs: list = [
-            prepare_values_table(grouped["overall_values"]),
-            prepare_ranks_table(grouped["overall_ranks"]),
-            build_status_line(status),
-            build_countdown_html(),
-        ]
-        for domain in domains:
-            values_df = grouped["domain_values"].get(domain)
-            ranks_df = grouped["domain_ranks"].get(domain)
-            if values_df is not None and not values_df.empty:
-                outputs.append(prepare_values_table(values_df))
-            else:
-                outputs.append(prepare_values_table(grouped["overall_values"].iloc[:0]))
-            if ranks_df is not None and not ranks_df.empty:
-                outputs.append(prepare_ranks_table(ranks_df))
-            else:
-                outputs.append(prepare_ranks_table(grouped["overall_ranks"].iloc[:0]))
-        return domains, tuple(outputs)
-    except FileNotFoundError:
-        empty = pd.DataFrame(columns=["Model"])
-        placeholder = (
-            "**Leaderboard** · no `results/` data yet — "
-            "run `python scripts/run_online_daemon.py --once` locally"
-        )
-        return [], (
-            empty,
-            empty,
-            placeholder,
-            eval_countdown_markup(0, BENCHMARK_INTERVAL_SECONDS, running=False),
-        )
-
+def tick_refresh_progress(remaining: int) -> tuple[int, str]:
+    next_remaining = max(int(remaining) - 1, 0)
+    return next_remaining, f"Next auto-refresh in **{next_remaining}s**"
 
-DOMAINS, INITIAL_OUTPUTS = load_initial_outputs()
 
+grouped_initial = get_grouped_dfs(RESULTS_PATH)
+DOMAINS: list[str] = grouped_initial["domains"]
+INITIAL_OUTPUTS = refresh_leaderboard()
 
-def maybe_refresh_after_eval() -> tuple:
-    """Refresh leaderboard only when eval state changes (start or finish)."""
-    global _last_seen_eval_token
+demo = gr.Blocks(css=custom_css)
+with demo:
+    gr.HTML(TITLE)
+    gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
+    status = gr.Markdown(INITIAL_OUTPUTS[2], elem_classes="markdown-text")
 
-    eval_state = get_scheduler().snapshot()
-    token = "|".join(
-        [
-            str(eval_state.get("status", "")),
-            str(eval_state.get("updated_at", "")),
-            str(eval_state.get("finished_at", "")),
-            str(eval_state.get("next_eval_at_unix", "")),
-        ]
+    refresh_progress = gr.Slider(
+        minimum=0,
+        maximum=REFRESH_SECONDS,
+        value=REFRESH_SECONDS,
+        step=1,
+        label="Auto-refresh countdown",
+        interactive=False,
+        elem_id="refresh-progress",
+    )
+    refresh_countdown = gr.Markdown(
+        f"Next auto-refresh in **{REFRESH_SECONDS}s**",
+        elem_classes="markdown-text",
     )
-    if token == _last_seen_eval_token:
-        raise gr.Skip()
-    _last_seen_eval_token = token
-    return refresh_leaderboard()
 
+    with gr.Row():
+        refresh_btn = gr.Button("Refresh now", variant="secondary")
 
-demo = gr.Blocks(
-    css=build_custom_css(),
-    head=eval_countdown_head_js(),
-)
-with demo:
-    gr.Markdown(f"# {TITLE.strip()}")
-    gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
-    status = gr.Markdown(INITIAL_OUTPUTS[2], elem_classes="markdown-text")
-    countdown = gr.HTML(INITIAL_OUTPUTS[3])
+    gr.Markdown("### Overall", elem_classes="domain-heading")
+    overall_values_df = gr.Dataframe(
+        value=INITIAL_OUTPUTS[0],
+        interactive=False,
+        wrap=True,
+        label="Metric values (normalized vs baseline, lower is better)",
+    )
+    overall_ranks_df = gr.Dataframe(
+        value=INITIAL_OUTPUTS[1],
+        interactive=False,
+        wrap=True,
+        label="Ranks (average per-dataset rank, lower is better)",
+    )
 
-    domain_tables: list[tuple[gr.Dataframe, gr.Dataframe]] = []
-    with gr.Tabs():
-        with gr.Tab("Overall"):
-            overall_values_df = gr.Dataframe(
-                value=INITIAL_OUTPUTS[0],
+    domain_value_dfs: list[gr.Dataframe] = []
+    for i, domain in enumerate(DOMAINS):
+        gr.Markdown(f"### {domain}", elem_classes="domain-heading")
+        domain_value_dfs.append(
+            gr.Dataframe(
+                value=INITIAL_OUTPUTS[5 + i],
                 interactive=False,
                 wrap=True,
-                label="Metric values (geometric mean across datasets, lower is better)",
+                label=f"{domain} · metric values (lower is better)",
             )
-            overall_ranks_df = gr.Dataframe(
-                value=INITIAL_OUTPUTS[1],
-                interactive=False,
-                wrap=True,
-                label="Ranks (average per-dataset rank, lower is better)",
-            )
-
-        for i, domain in enumerate(DOMAINS):
-            with gr.Tab(domain):
-                values_df = gr.Dataframe(
-                    value=INITIAL_OUTPUTS[4 + i * 2],
-                    interactive=False,
-                    wrap=True,
-                    label="Metric values (lower is better)",
-                )
-                ranks_df = gr.Dataframe(
-                    value=INITIAL_OUTPUTS[5 + i * 2],
-                    interactive=False,
-                    wrap=True,
-                    label="Ranks (lower is better)",
-                )
-                domain_tables.append((values_df, ranks_df))
+        )
 
     with gr.Accordion("About", open=False):
         gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
@@ -214,14 +133,22 @@ with demo:
             show_copy_button=True,
         )
 
-    refresh_outputs = [overall_values_df, overall_ranks_df, status, countdown]
-    for values_df, ranks_df in domain_tables:
-        refresh_outputs.extend([values_df, ranks_df])
+    refresh_outputs = [
+        overall_values_df,
+        overall_ranks_df,
+        status,
+        refresh_progress,
+        refresh_countdown,
+        *domain_value_dfs,
+    ]
 
-    # UI-only: data updates on container rebuild after local push — no load hook or timer.
-    if LIVE_EVAL_ENABLED:
-        gr.Timer(value=EVAL_WATCH_POLL_SECONDS).tick(
-            maybe_refresh_after_eval, inputs=[], outputs=refresh_outputs
-        )
+    refresh_btn.click(refresh_leaderboard, inputs=[], outputs=refresh_outputs)
+    demo.load(refresh_leaderboard, inputs=[], outputs=refresh_outputs)
+    gr.Timer(value=REFRESH_SECONDS).tick(refresh_leaderboard, inputs=[], outputs=refresh_outputs)
+    gr.Timer(value=1).tick(
+        tick_refresh_progress,
+        inputs=[refresh_progress],
+        outputs=[refresh_progress, refresh_countdown],
+    )
 
-demo.launch()
+demo.queue(default_concurrency_limit=20).launch()