Feat: stuff works

.gitignore

@@ -5,6 +5,7 @@ build/
 dist/
 wheels/
 *.egg-info
+*.json
 
 # Virtual environments
 .venv

app.py

@@ -7,6 +7,7 @@ from src.retrieve_data import (
     get_gpus_for_leaderboard,
     get_leaderboard_names,
     get_leaderboard_submissions,
+    get_submission_count,
 )
 
 from src.envs import CACHE_TIMEOUT, BACKGROUND_REFRESH_INTERVAL
@@ -14,7 +15,6 @@ from src.envs import CACHE_TIMEOUT, BACKGROUND_REFRESH_INTERVAL
 # key: func_name:args:kwargs, value: (timestamp, data)
 cache = {}
 
-
 active_selections = {
     "leaderboard": None,
     "gpu": None,
@@ -26,9 +26,13 @@ asyncio.set_event_loop(loop)
 background_refresh_running = True
 
 
-def cached_fetch(func: Callable, *args, force_refresh=False, **kwargs):
+def cached_fetch(
+    func: Callable, *args, force_refresh=False, limit=None, offset=0, **kwargs
+):
     """Fetch data with caching to avoid redundant API calls"""
-    cache_key = f"{func.__name__}:{str(args)}:{str(kwargs)}"
+    cache_key = (
+        f"{func.__name__}:{str(args)}:{str(kwargs)}:limit={limit}:offset={offset}"
+    )
 
     current_time = time.time()
 
@@ -37,7 +41,13 @@ def cached_fetch(func: Callable, *args, force_refresh=False, **kwargs):
         if current_time - timestamp < CACHE_TIMEOUT:
             return data
 
-    result = loop.run_until_complete(func(*args, **kwargs))
+    if func.__name__ == "get_leaderboard_submissions":
+        result = loop.run_until_complete(
+            func(*args, limit=limit, offset=offset, **kwargs)
+        )
+    else:
+        result = loop.run_until_complete(func(*args, **kwargs))
+
     cache[cache_key] = (current_time, result)
     return result
 
@@ -80,7 +90,7 @@ background_thread.start()
 def create_table_for_lb(lb_data):
     headers = [
         "Rank",
-        "Discord User ID",
+        "User Name",
         "Submission Name",
         "Runtime (ms)",
         "Submission Date",
@@ -99,10 +109,10 @@ def create_table_for_lb(lb_data):
         rows.append(
             [
                 rank_display,
-                result.user_id,
+                result.user_name,
                 result.submission_name,
                 f"{float(result.submission_score):.4f}",
-                result.submission_time,
+                result.submission_time.strftime("%Y-%m-%d %H:%M:%S"),
             ]
         )
 
@@ -113,7 +123,7 @@ def create_table_for_lb(lb_data):
             "int",
             "str",
             "str",
-            "datetime",
+            "timestamp",
         ],
         value=rows,
         interactive=False,
@@ -122,34 +132,71 @@ def create_table_for_lb(lb_data):
     return df
 
 
-def on_lb_change(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] if gpu_choices else None),
-    )
-
-
-def update_table(lb_name, gpu_name):
-    if not gpu_name:
-        return None
-
-    active_selections["gpu"] = gpu_name
-
-    data = cached_fetch(get_leaderboard_submissions, lb_name, gpu_name)
-    return create_table_for_lb(data)
+def build_ui():
+    # Define the function first before using it
+    def create_table_for_lb_with_global_rank(lb_data, offset):
+        """Create table with global ranks instead of page-specific ranks"""
+        headers = [
+            "Rank",
+            "User Name",
+            "Submission ID",
+            "Submission Name",
+            "Runtime (ms)",
+            "Submission Date",
+        ]
+
+        rows = []
+        for i, result in enumerate(lb_data.results, 1):
+            # Calculate global rank by adding offset
+            global_rank = i + offset
+
+            # Only show medals for the top 3 overall and only on the first page
+            if offset == 0 and global_rank <= 3:  # first page and top 3
+                if global_rank == 1:
+                    rank_display = "🥇 1"
+                elif global_rank == 2:
+                    rank_display = "🥈 2"
+                elif global_rank == 3:
+                    rank_display = "🥉 3"
+            else:
+                rank_display = str(global_rank)
+
+            rows.append(
+                [
+                    rank_display,
+                    result.user_name,
+                    str(result.submission_id),  # Add submission ID as a new column
+                    result.submission_name,
+                    f"{float(result.submission_score):.4f}",
+                    result.submission_time.strftime("%Y-%m-%d %H:%M:%S"),
+                ]
+            )
+
+        # Apply different class based on whether it's the first page or not
+        elem_classes = "" if offset == 0 else "non-first-page-table"
+
+        df = gr.Dataframe(
+            headers=headers,
+            datatype=[
+                "str",
+                "str",
+                "str",  # Submission ID
+                "str",
+                "str",
+                "timestamp",
+            ],
+            value=rows,
+            interactive=False,
+            elem_classes=elem_classes,
+        )
 
+        return df
 
-def build_ui():
     with gr.Blocks(
         title="ML Leaderboards",
         theme=gr.themes.Soft(),
         css="""
+        /* Apply medal colors to all tables by default */
         .gradio-container table tr:nth-child(1) {
             background-color: rgba(255, 215, 0, 0.2) !important;  /* Gold */
         }
@@ -159,7 +206,31 @@ def build_ui():
         .gradio-container table tr:nth-child(3) {
             background-color: rgba(205, 127, 50, 0.2) !important;  /* Bronze */
         }
-    """,
+        
+        /* Remove medal colors for non-first pages */
+        .non-first-page-table tr:nth-child(1),
+        .non-first-page-table tr:nth-child(2),
+        .non-first-page-table tr:nth-child(3) {
+            background-color: inherit !important;
+        }
+        
+        .pagination-controls {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-top: 10px;
+            width: 100%;
+        }
+        
+        .pagination-info {
+            text-align: center;
+            flex-grow: 1;
+        }
+        
+        .pagination-button {
+            min-width: 100px;
+        }
+        """,
     ) as app:
         gr.Markdown("# 🍿 KernelBot Leaderboard 🍿")
 
@@ -168,7 +239,19 @@ def build_ui():
         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)
+        # Set default pagination values
+        items_per_page = 10
+        current_page = 1
+
+        data = cached_fetch(
+            get_leaderboard_submissions,
+            selected_lb,
+            selected_gpu,
+            limit=items_per_page,
+            offset=0,
+        )
+        total_count = cached_fetch(get_submission_count, selected_lb, selected_gpu)
+        total_pages = (total_count + items_per_page - 1) // items_per_page
 
         with gr.Row():
             with gr.Column(scale=1):
@@ -186,16 +269,126 @@ def build_ui():
                 )
 
         with gr.Row():
-            results_table = create_table_for_lb(data)
+            # Initial table is first page
+            results_table = create_table_for_lb_with_global_rank(data, 0)
+
+        with gr.Row(elem_classes="pagination-controls"):
+            with gr.Column(scale=1, min_width=100, elem_classes="pagination-button"):
+                prev_btn = gr.Button("← Previous", interactive=(current_page > 1))
+
+            with gr.Column(scale=2, elem_classes="pagination-info"):
+                page_info = gr.Markdown(f"Page {current_page} of {total_pages}")
+
+            with gr.Column(scale=1, min_width=100, elem_classes="pagination-button"):
+                next_btn = gr.Button("Next →", interactive=(current_page < total_pages))
+
+        def on_lb_change(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]
+
+            # Reset to page 1 when changing leaderboard
+            data = cached_fetch(
+                get_leaderboard_submissions,
+                lb_name,
+                gpu_choices[0] if gpu_choices else None,
+                limit=items_per_page,
+                offset=0,
+            )
+
+            # Get total count for pagination
+            total_count = cached_fetch(
+                get_submission_count, lb_name, gpu_choices[0] if gpu_choices else None
+            )
+            total_pages = (total_count + items_per_page - 1) // items_per_page
+
+            return (
+                gr.update(
+                    choices=gpu_choices, value=gpu_choices[0] if gpu_choices else None
+                ),
+                create_table_for_lb_with_global_rank(data, 0),
+                gr.update(value=f"Page 1 of {total_pages}"),
+                gr.update(interactive=False),  # prev button disabled on page 1
+                gr.update(
+                    interactive=(total_pages > 1)
+                ),  # next button enabled if more than 1 page
+            )
+
+        def update_table(lb_name, gpu_name, page=1):
+            if not gpu_name:
+                return None, gr.update(), gr.update(), gr.update()
+
+            active_selections["gpu"] = gpu_name
+            offset = (page - 1) * items_per_page
+
+            data = cached_fetch(
+                get_leaderboard_submissions,
+                lb_name,
+                gpu_name,
+                limit=items_per_page,
+                offset=offset,
+            )
+
+            # Get total count for pagination
+            total_count = cached_fetch(get_submission_count, lb_name, gpu_name)
+            total_pages = (total_count + items_per_page - 1) // items_per_page
+
+            # Create table with global ranks
+            table = create_table_for_lb_with_global_rank(data, offset)
+
+            return (
+                table,
+                gr.update(value=f"Page {page} of {total_pages}"),
+                gr.update(interactive=(page > 1)),
+                gr.update(interactive=(page < total_pages)),
+            )
+
+        def next_page():
+            nonlocal current_page
+            lb_name = active_selections["leaderboard"]
+            gpu_name = active_selections["gpu"]
+
+            # Get total count to check if we can go to next page
+            total_count = cached_fetch(get_submission_count, lb_name, gpu_name)
+            total_pages = (total_count + items_per_page - 1) // items_per_page
+
+            if current_page < total_pages:
+                current_page += 1
+                return update_table(lb_name, gpu_name, current_page)
+            return update_table(lb_name, gpu_name, current_page)
+
+        def prev_page():
+            nonlocal current_page
+            if current_page > 1:
+                current_page -= 1
+            lb_name = active_selections["leaderboard"]
+            gpu_name = active_selections["gpu"]
+            return update_table(lb_name, gpu_name, current_page)
 
         lb_dropdown.change(
             fn=on_lb_change,
             inputs=[lb_dropdown],
-            outputs=[gpu_dropdown, results_table],
+            outputs=[gpu_dropdown, results_table, page_info, prev_btn, next_btn],
         )
 
         gpu_dropdown.change(
-            fn=update_table, inputs=[lb_dropdown, gpu_dropdown], outputs=results_table
+            fn=lambda lb, gpu: update_table(lb, gpu, 1),  # Reset to page 1
+            inputs=[lb_dropdown, gpu_dropdown],
+            outputs=[results_table, page_info, prev_btn, next_btn],
+        )
+
+        next_btn.click(
+            fn=next_page,
+            inputs=[],
+            outputs=[results_table, page_info, prev_btn, next_btn],
+        )
+
+        prev_btn.click(
+            fn=prev_page,
+            inputs=[],
+            outputs=[results_table, page_info, prev_btn, next_btn],
         )
 
     return app

src/result.py

@@ -10,6 +10,7 @@ class Result:
     submission_score: float
     submission_id: str
     user_id: str
+    user_name: str
     rank: int
 
     @classmethod
@@ -21,6 +22,7 @@ class Result:
             submission_id=data["submission_id"],
             user_id=data["user_id"],
             rank=data["rank"],
+            user_name=data["user_name"],
         )
 
     @classmethod
@@ -36,6 +38,7 @@ class Result:
             "submission_score": self.submission_score,
             "submission_id": self.submission_id,
             "user_id": self.user_id,
+            "user_name": self.user_name,
             "rank": self.rank,
         }
 

src/retrieve_data.py

@@ -1,5 +1,3 @@
-from collections import defaultdict
-
 from httpx import AsyncClient
 
 from src.envs import API_URL, TIMEOUT
@@ -20,9 +18,14 @@ async def get_gpus_for_leaderboard(lb_name: str) -> list[str]:
         return response.json()
 
 
-async def get_leaderboard_submissions(lb_name: str, gpu: str) -> LbData:
+async def get_leaderboard_submissions(
+    lb_name: str, gpu: str, limit: int = None, offset: int = 0
+) -> LbData:
     async with AsyncClient(timeout=TIMEOUT) as client:
-        response = await client.get(f"{API_URL}/submissions/{lb_name}/{gpu}")
+        params = {"limit": limit, "offset": offset}
+        response = await client.get(
+            f"{API_URL}/submissions/{lb_name}/{gpu}", params=params
+        )
         response.raise_for_status()
         return LbData(
             gpu=gpu,
@@ -31,13 +34,8 @@ async def get_leaderboard_submissions(lb_name: str, gpu: str) -> LbData:
         )
 
 
-async def populate_lb_data():
-    leaderboards: dict[str, dict[str, LbData]] = defaultdict(dict)
-    lb_names = await get_leaderboard_names()
-    for lb_name in lb_names:
-        gpus = await get_gpus_for_leaderboard(lb_name)
-        for gpu in gpus:
-            lb_data = await get_leaderboard_submissions(lb_name, gpu)
-            leaderboards[lb_name][gpu] = lb_data
-
-    return leaderboards
+async def get_submission_count(lb_name: str, gpu: str) -> int:
+    async with AsyncClient(timeout=TIMEOUT) as client:
+        response = await client.get(f"{API_URL}/submission_count/{lb_name}/{gpu}")
+        response.raise_for_status()
+        return response.json()["count"]