Feat: claude stuff but works

app.py

@@ -1,7 +1,100 @@
 import gradio as gr
+import asyncio
+import time
+import threading
+from src.retrieve_data import populate_lb_data
 
-def greet(name):
-    return "Hello " + name + "!!"
+leaderboard_data = {}
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+
+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):
+    """Create a formatted table for a specific leaderboard and GPU"""
+    global leaderboard_data
+
+    lb_data = leaderboard_data[lb_name]
+
+    headers = ["Rank", "Submission Name", "User ID", "Score", "Date"]
+
+    rows = []
+    for i, result in enumerate(lb_data.results, 1):
+        rows.append(
+            [
+                i,
+                result.submission_name,
+                result.user_id,
+                f"{float(result.submission_score):.4f}",
+                result.submission_time,
+            ]
+        )
+
+    return gr.Dataframe(
+        headers=headers,
+        datatype=["number", "str", "str", "str", "str"],
+        value=rows,
+        interactive=False,
+    )
+
+
+def refresh_ui():
+    """Force refresh the UI with latest data"""
+    asyncio.run(fetch_data())
+    return "Data refreshed!"
+
+
+def build_ui():
+    """Build the Gradio UI"""
+    global leaderboard_data
+
+    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")
+
+        refresh_btn.click(fn=refresh_ui, outputs=status)
+
+        # 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.")
+
+    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/envs.py

@@ -0,0 +1,11 @@
+import os
+
+
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+OWNER = "siro1"
+
+QUEUE_REPO = f"{OWNER}/requests"
+RESULTS_REPO = f"{OWNER}/results"
+
+CACHE_PATH = os.getenv("HF_HOME", ".")
+

src/result.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+import json
+
+
+@dataclass(frozen=True, slots=True)
+class Result:
+    submission_name: str
+    submission_time: datetime
+    submission_score: float
+    user_id: str
+    rank: int
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Result":
+        return cls(
+            submission_name=data["submission_name"],
+            submission_time=datetime.fromisoformat(data["submission_time"]),
+            submission_score=data["submission_score"],
+            user_id=data["user_id"],
+            rank=data["rank"],
+        )
+
+    @classmethod
+    def from_json(cls, json_path: str) -> "Result":
+        with open(json_path, "r") as f:
+            data = json.load(f)
+        return cls.from_dict(data)
+
+    def to_dict(self) -> dict:
+        return {
+            "filename": self.filename,
+            "score": self.score,
+            "user_name": self.user_name,
+            "created_at": self.created_at.isoformat(),
+        }
+
+
+@dataclass
+class LbData:
+    name: str
+    gpu: str
+    results: list[Result] = field(default_factory=list)
+
+    def add_result(self, result: Result):
+        self.results.append(result)

src/retrieve_data.py

@@ -0,0 +1,43 @@
+import asyncio
+
+from httpx import AsyncClient
+
+from src.envs import API_URL
+from src.result import LbData, Result
+
+
+async def get_leaderboards() -> list[str]:
+    async with AsyncClient() 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:
+        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:
+        response = await client.get(f"{API_URL}/submissions/{lb_name}/{gpu}")
+        response.raise_for_status()
+        return LbData(
+            gpu=gpu,
+            name=lb_name,
+            results=[Result.from_dict(result) for result in response.json()],
+        )
+
+
+async def populate_lb_data():
+    leaderboards: dict[str, LbData] = {}
+    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
+
+    return leaderboards