Feat: cleanup

app.py

@@ -1,54 +1,93 @@
+from typing import Callable
 import gradio as gr
 import asyncio
 import time
 import threading
-from src.retrieve_data import populate_lb_data
+from src.retrieve_data import (
+    get_gpus_for_leaderboard,
+    get_leaderboard_names,
+    get_leaderboard_submissions,
+)
 
-leaderboard_data = {}
+from src.envs import CACHE_TIMEOUT, BACKGROUND_REFRESH_INTERVAL
 
+# key: func_name:args:kwargs, value: (timestamp, data)
+cache = {}
 
-async def fetch_data():
-    """Fetch the leaderboard data asynchronously"""
-    global leaderboard_data
-    try:
-        data = await populate_lb_data()
-        leaderboard_data = data
-        return True
-    except Exception as e:
-        print(f"Error fetching data: {e}")
-        return False
-
-
-def background_update():
-    """Background thread function to update data every 5 minutes"""
-    while True:
-        print("Updating leaderboard data...")
-        asyncio.run(fetch_data())
-        time.sleep(300)  # 5 minutes
-
-
-def create_table_for_lb(lb_name, gpu_name):
-    """Create a formatted table for a specific leaderboard and GPU"""
-    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][gpu_name]
+active_selections = {
+    "leaderboard": None,
+    "gpu": None,
+}
+
+loop = asyncio.new_event_loop()
+asyncio.set_event_loop(loop)
+
+background_refresh_running = True
+
+
+def cached_fetch(func: Callable, *args, force_refresh=False, **kwargs):
+    """Fetch data with caching to avoid redundant API calls"""
+    cache_key = f"{func.__name__}:{str(args)}:{str(kwargs)}"
+
+    current_time = time.time()
+
+    if not force_refresh and cache_key in cache:
+        timestamp, data = cache[cache_key]
+        if current_time - timestamp < CACHE_TIMEOUT:
+            return data
+
+    result = loop.run_until_complete(func(*args, **kwargs))
+    cache[cache_key] = (current_time, result)
+    return result
+
+
+def invalidate_cache(prefix=None):
+    """Invalidate all cache entries or those matching a prefix"""
+    global cache
+    if prefix is None:
+        cache = {}
+    else:
+        cache = {k: v for k, v in cache.items() if not k.startswith(prefix)}
+
+
+def background_refresh():
+    """Background thread to refresh active data periodically"""
+    while background_refresh_running:
+        try:
+            time.sleep(BACKGROUND_REFRESH_INTERVAL)
+
+            lb_name = active_selections["leaderboard"]
+            gpu_name = active_selections["gpu"]
+
+            if lb_name and gpu_name:
+                cached_fetch(
+                    get_leaderboard_submissions, lb_name, gpu_name, force_refresh=True
+                )
+
+                cached_fetch(get_gpus_for_leaderboard, lb_name, force_refresh=True)
 
-    headers = ["Rank", "Discord User ID", "Submission Name", "Score", "Date"]
+            cached_fetch(get_leaderboard_names, force_refresh=True)
+
+        except Exception as e:
+            print(f"Background refresh error: {e}")
+
+
+background_thread = threading.Thread(target=background_refresh, daemon=True)
+background_thread.start()
+
+
+def create_table_for_lb(lb_data):
+    headers = [
+        "Rank",
+        "Discord User ID",
+        "Submission Name",
+        "Runtime (ms)",
+        "Submission Date",
+    ]
 
     rows = []
     for i, result in enumerate(lb_data.results, 1):
-        # Add medal emoji for top 3 ranks
         rank_display = i
         if i == 1:
             rank_display = "🥇 1"
@@ -75,7 +114,7 @@ def create_table_for_lb(lb_name, gpu_name):
             "str",
             "str",
             "datetime",
-        ],  # Changed first column to str for medals
+        ],
         value=rows,
         interactive=False,
     )
@@ -83,38 +122,27 @@ def create_table_for_lb(lb_name, gpu_name):
     return df
 
 
-def refresh_ui():
-    """Force refresh the UI with latest data"""
-    asyncio.run(fetch_data())
-    return "Data refreshed!", get_lb_names(), [], None
-
-
-def get_lb_names():
-    """Get list of available leaderboard names"""
-    return list(leaderboard_data.keys())
-
-
-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)
+    gpu_choices = cached_fetch(get_gpus_for_leaderboard, lb_name)
+
+    active_selections["leaderboard"] = lb_name
+    if gpu_choices:
+        active_selections["gpu"] = gpu_choices[0]
 
     return (
         gr.update(choices=gpu_choices, value=gpu_choices[0] if gpu_choices else None),
-        update_table(lb_name, gpu_choices[0]),
+        update_table(lb_name, gpu_choices[0] if gpu_choices else None),
     )
 
 
 def update_table(lb_name, gpu_name):
-    """Update the table based on selected leaderboard and GPU"""
-    if not lb_name or not gpu_name:
+    if not gpu_name:
         return None
-    return create_table_for_lb(lb_name, gpu_name)
+
+    active_selections["gpu"] = gpu_name
+
+    data = cached_fetch(get_leaderboard_submissions, lb_name, gpu_name)
+    return create_table_for_lb(data)
 
 
 def build_ui():
@@ -135,28 +163,30 @@ def build_ui():
     ) as app:
         gr.Markdown("# 🍿 KernelBot Leaderboard 🍿")
 
-        asyncio.run(fetch_data())
+        lb_names = cached_fetch(get_leaderboard_names)
+        selected_lb = lb_names[0]
+        gpu_names = cached_fetch(get_gpus_for_leaderboard, selected_lb)
+        selected_gpu = gpu_names[0]
+
+        data = cached_fetch(get_leaderboard_submissions, selected_lb, selected_gpu)
 
         with gr.Row():
             with gr.Column(scale=1):
                 lb_dropdown = gr.Dropdown(
-                    choices=get_lb_names(),
+                    choices=lb_names,
                     label="Select Leaderboard",
                     interactive=True,
+                    value=selected_lb,
                 )
                 gpu_dropdown = gr.Dropdown(
-                    choices=get_gpu_names(lb_dropdown.value),
+                    choices=gpu_names,
                     label="Select GPU",
                     interactive=True,
+                    value=selected_gpu,
                 )
 
         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",
-            )
+            results_table = create_table_for_lb(data)
 
         lb_dropdown.change(
             fn=on_lb_change,
@@ -172,7 +202,10 @@ def build_ui():
 
 
 if __name__ == "__main__":
-    update_thread = threading.Thread(target=background_update, daemon=True)
-    update_thread.start()
-    app = build_ui()
-    app.launch()
+    try:
+        app = build_ui()
+        app.launch()
+    finally:
+        background_refresh_running = False
+        background_thread.join(timeout=1.0)
+        loop.close()

src/envs.py

@@ -3,9 +3,7 @@ import os
 
 API_URL = os.getenv("API_URL", "http://localhost:8000")
 OWNER = "siro1"
+TIMEOUT = 2000
 
-QUEUE_REPO = f"{OWNER}/requests"
-RESULTS_REPO = f"{OWNER}/results"
-
-CACHE_PATH = os.getenv("HF_HOME", ".")
-
+CACHE_TIMEOUT = 300
+BACKGROUND_REFRESH_INTERVAL = 240

src/result.py

@@ -8,6 +8,7 @@ class Result:
     submission_name: str
     submission_time: datetime
     submission_score: float
+    submission_id: str
     user_id: str
     rank: int
 
@@ -17,6 +18,7 @@ class Result:
             submission_name=data["submission_name"],
             submission_time=datetime.fromisoformat(data["submission_time"]),
             submission_score=data["submission_score"],
+            submission_id=data["submission_id"],
             user_id=data["user_id"],
             rank=data["rank"],
         )
@@ -29,10 +31,12 @@ class Result:
 
     def to_dict(self) -> dict:
         return {
-            "filename": self.filename,
-            "score": self.score,
-            "user_name": self.user_name,
-            "created_at": self.created_at.isoformat(),
+            "submission_name": self.submission_name,
+            "submission_time": self.submission_time.isoformat(),
+            "submission_score": self.submission_score,
+            "submission_id": self.submission_id,
+            "user_id": self.user_id,
+            "rank": self.rank,
         }
 
 

src/retrieve_data.py

@@ -2,26 +2,26 @@ from collections import defaultdict
 
 from httpx import AsyncClient
 
-from src.envs import API_URL
+from src.envs import API_URL, TIMEOUT
 from src.result import LbData, Result
 
 
-async def get_leaderboards() -> list[str]:
-    async with AsyncClient() as client:
+async def get_leaderboard_names() -> list[str]:
+    async with AsyncClient(timeout=TIMEOUT) as client:
         response = await client.get(f"{API_URL}/leaderboards")
         response.raise_for_status()
         return [lb["name"] for lb in response.json()]
 
 
-async def get_lb_gpus(lb_name: str) -> list[str]:
-    async with AsyncClient() as client:
+async def get_gpus_for_leaderboard(lb_name: str) -> list[str]:
+    async with AsyncClient(timeout=TIMEOUT) as client:
         response = await client.get(f"{API_URL}/gpus/{lb_name}")
         response.raise_for_status()
         return response.json()
 
 
-async def get_submissions(lb_name: str, gpu: str) -> LbData:
-    async with AsyncClient() as client:
+async def get_leaderboard_submissions(lb_name: str, gpu: str) -> LbData:
+    async with AsyncClient(timeout=TIMEOUT) as client:
         response = await client.get(f"{API_URL}/submissions/{lb_name}/{gpu}")
         response.raise_for_status()
         return LbData(
@@ -33,11 +33,11 @@ async def get_submissions(lb_name: str, gpu: str) -> LbData:
 
 async def populate_lb_data():
     leaderboards: dict[str, dict[str, LbData]] = defaultdict(dict)
-    lb_names = await get_leaderboards()
+    lb_names = await get_leaderboard_names()
     for lb_name in lb_names:
-        gpus = await get_lb_gpus(lb_name)
+        gpus = await get_gpus_for_leaderboard(lb_name)
         for gpu in gpus:
-            lb_data = await get_submissions(lb_name, gpu)
+            lb_data = await get_leaderboard_submissions(lb_name, gpu)
             leaderboards[lb_name][gpu] = lb_data
 
     return leaderboards