Use gradio's built-in refresh

app.py

@@ -1,8 +1,7 @@
 import json
 import os
-import time
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, timedelta
 from zoneinfo import ZoneInfo
 
 import bittensor as bt
@@ -31,6 +30,7 @@ bt.logging.disable_logging()
 
 runs: dict[int, list[Run]] = {}
 validator_identities: dict[int, str] = {}
+last_refresh: datetime = datetime.now(tz=ZoneInfo("America/New_York"))
 
 
 @dataclass
@@ -82,11 +82,15 @@ def calculate_score(baseline_generation_time: float, generation_time: float, sim
     return (baseline_generation_time - generation_time) * similarity_score
 
 
+def date_from_run(run: Run) -> datetime:
+    return datetime.strptime(run.created_at, "%Y-%m-%dT%H:%M:%SZ").astimezone(ZoneInfo("America/New_York"))
+
+
 def get_graph_entries(runs: list[Run]) -> dict[int, GraphEntry]:
     entries: dict[int, GraphEntry] = {}
 
     for run in reversed(runs[:GRAPH_HISTORY_DAYS]):
-        date = datetime.strptime(run.created_at, "%Y-%m-%dT%H:%M:%SZ")
+        date = date_from_run(run)
 
         for summary_key, summary_value in run.summary.items():
             if not summary_key.startswith("benchmarks"):
@@ -165,53 +169,6 @@ def create_graph(runs: list[Run]) -> go.Figure:
     return fig
 
 
-def create_leaderboard(runs: list[Run]) -> list[tuple]:
-    entries: dict[int, LeaderboardEntry] = {}
-
-    for run in runs:
-        has_data = False
-        for summary_key, summary_value in run.summary.items():
-            if not summary_key == "benchmarks":
-                continue
-            for key, value in summary_value.items():
-                has_data = True
-
-                uid = int(key)
-                generation_time = value["generation_time"]
-                baseline_generation_time = value["baseline_generation_time"]
-                similarity = min(1, value["similarity"])
-
-                entries[uid] = LeaderboardEntry(
-                    uid=uid,
-                    winner="winner" in value,
-                    repository=run.summary["submissions"][str(uid)]["repository"],
-                    score=calculate_score(baseline_generation_time, generation_time, similarity),
-                    similarity=similarity,
-                    baseline_generation_time=baseline_generation_time,
-                    generation_time=generation_time,
-                    size=value["size"],
-                    vram_used=value["vram_used"],
-                    watts_used=value["watts_used"],
-                    hotkey=value["hotkey"],
-                )
-
-        if has_data:
-            break
-
-    return [(
-        entry.uid,
-        f"<span style='color: {'springgreen' if entry.winner else 'red'}'>{entry.winner}</span>",
-        entry.repository,
-        round(entry.score, 3),
-        f"{entry.generation_time:.3f}s",
-        f"{entry.similarity:.3f}",
-        f"{entry.size / 1_000_000_000:.3f}GB",
-        f"{entry.vram_used / 1_000_000_000:.3f}GB",
-        f"{entry.watts_used:.3f}W",
-        entry.hotkey,
-    ) for entry in sorted(entries.values(), key=lambda entry: (entry.winner, entry.score), reverse=True)]
-
-
 def get_run_validator_uid(run: Run) -> int:
     json_config = json.loads(run.json_config)
     uid = int(json_config["uid"]["value"])
@@ -260,8 +217,17 @@ def get_validator_name(validator_uid: int) -> str:
 
 
 def get_choices() -> list[tuple[str, int]]:
+    now = datetime.now(tz=ZoneInfo("America/New_York"))
+    noon = now.replace(hour=12, minute=0, second=0, microsecond=0)
+    if now.hour < 12:
+        noon -= timedelta(days=1)
+
     choices: list[tuple[str, int]] = []
     for uid, run in runs.items():
+        date = date_from_run(run[0])
+        if date < noon:
+            continue
+
         benchmarks = dict(run[0].summary.get("benchmarks", {}))
         finished = any("winner" in value for value in benchmarks.values())
         progress_text = "Finished" if finished else "In Progress"
@@ -273,9 +239,81 @@ def refresh():
     metagraph.sync(subtensor=subtensor)
     fetch_wandb_data()
     fetch_identities()
-    demo.clear()
+
+
+def get_data(validator_uid: int) -> gr.Dataframe:
+    global last_refresh
     now = datetime.now(tz=ZoneInfo("America/New_York"))
 
+    if (now - last_refresh).total_seconds() > REFRESH_RATE:
+        refresh()
+        last_refresh = now
+        print(f"Refreshing Leaderboard at {now.strftime('%Y-%m-%d %H:%M:%S')}")
+
+    entries: dict[int, LeaderboardEntry] = {}
+
+    for run in runs[validator_uid]:
+        has_data = False
+        for summary_key, summary_value in run.summary.items():
+            if not summary_key == "benchmarks":
+                continue
+            for key, value in summary_value.items():
+                has_data = True
+
+                uid = int(key)
+                generation_time = value["generation_time"]
+                baseline_generation_time = value["baseline_generation_time"]
+                similarity = min(1, value["similarity"])
+
+                entries[uid] = LeaderboardEntry(
+                    uid=uid,
+                    winner="winner" in value,
+                    repository=run.summary["submissions"][str(uid)]["repository"],
+                    score=calculate_score(baseline_generation_time, generation_time, similarity),
+                    similarity=similarity,
+                    baseline_generation_time=baseline_generation_time,
+                    generation_time=generation_time,
+                    size=value["size"],
+                    vram_used=value["vram_used"],
+                    watts_used=value["watts_used"],
+                    hotkey=value["hotkey"],
+                )
+
+        if has_data:
+            break
+
+    sorted_entries = [(
+        entry.uid,
+        f"<span style='color: {'springgreen' if entry.winner else 'red'}'>{entry.winner}</span>",
+        entry.repository,
+        round(entry.score, 3),
+        f"{entry.generation_time:.3f}s",
+        f"{entry.similarity:.3f}",
+        f"{entry.size / 1_000_000_000:.3f}GB",
+        f"{entry.vram_used / 1_000_000_000:.3f}GB",
+        f"{entry.watts_used:.3f}W",
+        entry.hotkey,
+    ) for entry in sorted(entries.values(), key=lambda entry: (entry.winner, entry.score), reverse=True)]
+
+    return gr.Dataframe(
+        sorted_entries,
+        headers=["Uid", "Winner", "Model", "Score", "Gen Time", "Similarity", "Size", "VRAM Usage", "Power Usage", "Hotkey"],
+        datatype=["number", "markdown", "markdown", "number", "markdown", "number", "markdown", "markdown", "markdown", "markdown"],
+        label=f"Last updated: {last_refresh.strftime('%Y-%m-%d %I:%M:%S %p')} EST",
+        interactive=False,
+    )
+
+
+dropdown_value = SOURCE_VALIDATOR_UID
+
+
+def set_checkbox_value(value: int):
+    global dropdown_value
+    dropdown_value = value
+
+
+def main():
+    refresh()
     with demo:
         gr.Image(
             "cover.png",
@@ -291,12 +329,12 @@ def refresh():
             """
             <center>
             <h1 style="font-size: 50px"> SN39 EdgeMaxxing Leaderboard </h1>
-            
+
             This leaderboard for SN39 tracks the results and top model submissions from current and previous contests.
             </center>
             """)
 
-        with gr.Accordion(f"Contest #1 Submission Leader: New Dream SDXL on NVIDIA RTX 4090s (Last updated: {now.strftime('%Y-%m-%d %I:%M:%S %p')} EST)"):
+        with gr.Accordion(f"Contest #1 Submission Leader: New Dream SDXL on NVIDIA RTX 4090s"):
             dropdown = gr.Dropdown(
                 get_choices(),
                 value=SOURCE_VALIDATOR_UID,
@@ -304,28 +342,18 @@ def refresh():
                 label="Source Validator"
             )
 
-            leaderboard = gr.components.Dataframe(
-                create_leaderboard(runs[dropdown.value]),
-                headers=["Uid", "Winner", "Model", "Score", "Gen Time", "Similarity", "Size", "VRAM Usage", "Power Usage", "Hotkey"],
-                datatype=["number", "markdown", "markdown", "number", "markdown", "number", "markdown", "markdown", "markdown", "markdown"],
-                elem_id="leaderboard-table",
-            )
+            table = get_data(dropdown.value)
+            table.attach_load_event(lambda _: get_data(dropdown_value), REFRESH_RATE, [table])
+            dropdown.change(lambda uid: get_data(uid), [dropdown], [table])
 
             graph = gr.Plot()
-            demo.load(lambda uid: create_graph(runs[uid]), [dropdown], [graph])
-
+            graph.attach_load_event(lambda _: create_graph(runs[dropdown_value]), REFRESH_RATE, [graph])
             dropdown.change(lambda uid: create_graph(runs[uid]), [dropdown], [graph])
-            dropdown.change(lambda uid: create_leaderboard(runs[uid]), [dropdown], [leaderboard])
 
+            dropdown.change(set_checkbox_value, [dropdown])  # TODO hacky
 
-if __name__ == "__main__":
-    refresh()
-    demo.launch(prevent_thread_lock=True)
+    demo.queue().launch()
 
-    while True:
-        time.sleep(REFRESH_RATE)
 
-        now = datetime.now(tz=ZoneInfo("America/New_York"))
-        print(f"Refreshing Leaderboard at {now.strftime('%Y-%m-%d %H:%M:%S')}")
-
-        refresh()
+if __name__ == "__main__":
+    main()