app.py

import gradio as gr
import asyncio
import time
import threading
from src.retrieve_data import populate_lb_data

leaderboard_data = {}


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()