Feat: stuff works and looks human-ish?

app.py

@@ -27,11 +27,22 @@ def background_update():
         time.sleep(300)  # 5 minutes
 
 
-def create_table_for_lb(lb_name):
+def create_table_for_lb(lb_name, gpu_name):
     """Create a formatted table for a specific leaderboard and GPU"""
-    global leaderboard_data
+    if (
+        not lb_name
+        or not gpu_name
+        or lb_name not in leaderboard_data
+        or gpu_name not in leaderboard_data[lb_name]
+    ):
+        return gr.Dataframe(
+            headers=["Rank", "Submission Name", "User ID", "Score", "Date"],
+            datatype=["number", "str", "str", "str", "str"],
+            value=[],
+            interactive=False,
+        )
 
-    lb_data = leaderboard_data[lb_name]
+    lb_data = leaderboard_data[lb_name][gpu_name]
 
     headers = ["Rank", "Submission Name", "User ID", "Score", "Date"]
 
@@ -58,43 +69,79 @@ def create_table_for_lb(lb_name):
 def refresh_ui():
     """Force refresh the UI with latest data"""
     asyncio.run(fetch_data())
-    return "Data refreshed!"
+    return "Data refreshed!", get_lb_names(), [], None
 
 
-def build_ui():
-    """Build the Gradio UI"""
-    global leaderboard_data
+def get_lb_names():
+    """Get list of available leaderboard names"""
+    return list(leaderboard_data.keys())
 
-    with gr.Blocks(title="ML Leaderboards") as app:
-        gr.Markdown("# Machine Learning Leaderboards")
 
-        with gr.Row():
-            refresh_btn = gr.Button("Refresh Data")
-            status = gr.Textbox(label="Status", value="Ready")
+def get_gpu_names(lb_name):
+    """Get list of available GPUs for a specific leaderboard"""
+    if not lb_name or lb_name not in leaderboard_data:
+        return []
+    return list(leaderboard_data[lb_name].keys())
+
+
+def on_lb_change(lb_name):
+    gpu_choices = get_gpu_names(lb_name)
+
+    return (
+        gr.update(choices=gpu_choices, value=gpu_choices[0] if gpu_choices else None),
+        update_table(lb_name, gpu_choices[0]),
+    )
+
 
-        refresh_btn.click(fn=refresh_ui, outputs=status)
+def update_table(lb_name, gpu_name):
+    """Update the table based on selected leaderboard and GPU"""
+    if not lb_name or not gpu_name:
+        return None
+    return create_table_for_lb(lb_name, gpu_name)
+
+
+def build_ui():
+    with gr.Blocks(title="ML Leaderboards", theme=gr.themes.Soft()) as app:
+        gr.Markdown("# 🍿 KernelBot Leaderboard 🍿")
 
-        # Initial data fetch
         asyncio.run(fetch_data())
 
-        # Create tabs for each leaderboard
-        if leaderboard_data:
-            with gr.Tabs():
-                for lb_name, lb_data in leaderboard_data.items():
-                    with gr.Tab(lb_name):
-                        gr.Markdown(f"## {lb_name} - {lb_data.gpu}")
-                        create_table_for_lb(lb_name)
-        else:
-            gr.Markdown("No leaderboard data available. Please refresh.")
+        with gr.Row():
+            with gr.Column(scale=1):
+                lb_dropdown = gr.Dropdown(
+                    choices=get_lb_names(),
+                    label="Select Leaderboard",
+                    interactive=True,
+                )
+                gpu_dropdown = gr.Dropdown(
+                    choices=get_gpu_names(lb_dropdown.value),
+                    label="Select GPU",
+                    interactive=True,
+                )
+
+        with gr.Row():
+            results_table = gr.Dataframe(
+                headers=["Rank", "Submission Name", "User ID", "Score", "Date"],
+                datatype=["number", "str", "str", "str", "str"],
+                interactive=False,
+                label="Results",
+            )
+
+        lb_dropdown.change(
+            fn=on_lb_change,
+            inputs=[lb_dropdown],
+            outputs=[gpu_dropdown, results_table],
+        )
+        
+        gpu_dropdown.change(
+            fn=update_table, inputs=[lb_dropdown, gpu_dropdown], outputs=results_table
+        )
 
     return app
 
 
 if __name__ == "__main__":
-    # Start the background update thread
     update_thread = threading.Thread(target=background_update, daemon=True)
     update_thread.start()
-
-    # Launch the Gradio app
     app = build_ui()
     app.launch()

src/retrieve_data.py

@@ -1,4 +1,5 @@
 import asyncio
+from collections import defaultdict
 
 from httpx import AsyncClient
 
@@ -32,12 +33,12 @@ async def get_submissions(lb_name: str, gpu: str) -> LbData:
 
 
 async def populate_lb_data():
-    leaderboards: dict[str, LbData] = {}
+    leaderboards: dict[str, dict[str, LbData]] = defaultdict(dict)
     lb_names = await get_leaderboards()
     for lb_name in lb_names:
         gpus = await get_lb_gpus(lb_name)
         for gpu in gpus:
             lb_data = await get_submissions(lb_name, gpu)
-            leaderboards[f"{lb_name}_{gpu}"] = lb_data
+            leaderboards[lb_name][gpu] = lb_data
 
     return leaderboards