initial

README copy.md

@@ -0,0 +1,75 @@
+# LLM Leaderboard Demo
+
+This demo showcases a modern LLM leaderboard application built with Gradio and FastAPI.
+
+## Features
+
+- Displays a sortable, filterable table of LLM models and their performance
+- Shows scores across multiple benchmarks
+- External links to model documentation for both open and closed models
+- Dynamic filtering by model performance categories
+- Real-time data refresh functionality
+- Last-updated timestamp display
+- Automatic startup of both API and frontend
+
+## Installation
+
+First, install the required dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+There are two ways to run the application:
+
+### Option 1: Using run.py (all-in-one)
+
+```bash
+python run.py
+```
+
+This will start both the FastAPI backend and Gradio interface in a single process.
+
+### Option 2: Using run_all.py (separate processes)
+
+```bash
+python run_all.py
+```
+
+This runs the API server and Gradio interface in separate processes, making it easier to debug each component.
+
+With either option, the application will be available at:
+- Frontend: http://localhost:7860
+- API: http://localhost:8000
+
+## Architecture
+
+The application consists of two main components:
+
+1. **FastAPI Backend** (`api.py`):
+   - Provides API endpoints for leaderboard data
+   - Caches data to improve performance
+   - Handles data processing and filtering
+
+2. **Gradio Frontend** (`run.py`):
+   - Creates an interactive web interface
+   - Fetches data from the API
+   - Provides filtering and search capabilities
+
+## API Endpoints
+
+- `GET /api/leaderboard` - Get the full leaderboard data
+- `GET /api/leaderboard?refresh=true` - Force refresh data from source
+- `GET /api/models` - Get a list of all model names
+- `GET /api/model/{model_name}` - Get details for a specific model
+- `GET /api/filters` - Get counts for different filter categories
+
+## Customization
+
+You can modify the appearance by editing the CSS in `run.py`. The application uses Gradio's theme system for styling.
+
+## License
+
+This project is licensed under the MIT License. 

api.py

@@ -0,0 +1,250 @@
+import json
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import numpy as np
+import requests
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+
+class LeaderboardModel(BaseModel):
+    model_name: str
+    type: str
+    model_link: Optional[str] = None
+    scores: Dict[str, float]
+    co2_cost: Optional[float] = None
+
+class LeaderboardData(BaseModel):
+    models: List[LeaderboardModel]
+    updated_at: str
+
+app = FastAPI(
+    title="LLM Leaderboard API",
+    description="API for serving Open LLM Leaderboard data",
+    version="1.0.0"
+)
+
+# Add CORS middleware to allow requests from your Gradio app
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # For production, specify your exact frontend URL
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Cache for leaderboard data
+cached_data = None
+cache_file = Path("leaderboard_cache.json")
+
+def fetch_external_leaderboard_data(refresh: bool = False) -> Optional[Dict]:
+    """
+    Fetch leaderboard data from external sources like HuggingFace.
+    Uses local cache if available and refresh is False.
+    """
+    global cached_data
+
+    if not refresh and cached_data:
+        return cached_data
+
+    if not refresh and cache_file.exists():
+        try:
+            with open(cache_file) as f:
+                cached_data = json.load(f)
+                return cached_data
+        except:
+            pass  # Fall back to fetching if cache read fails
+
+    try:
+        # Try different endpoints that might contain leaderboard data
+        endpoints = [
+            "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/raw/main/leaderboard_data.json",
+            "https://huggingface.co/api/spaces/HuggingFaceH4/open_llm_leaderboard/api/get_results",
+        ]
+
+        for url in endpoints:
+            response = requests.get(url)
+            if response.status_code == 200:
+                data = response.json()
+                cached_data = data
+                with open(cache_file, "w") as f:
+                    json.dump(data, f)
+                return data
+
+        # If all endpoints fail, return None
+        return None
+    except Exception as e:
+        print(f"Error fetching external leaderboard data: {e}")
+        return None
+
+def generate_sample_data() -> Dict:
+    """
+    Generate sample leaderboard data when external data can't be fetched.
+    """
+    models = [
+        {"model_name": "meta-llama/llama-3-70b-instruct", "type": "open"},
+        {"model_name": "mistralai/Mistral-7B-Instruct-v0.3", "type": "open"},
+        {"model_name": "google/gemma-7b-it", "type": "open"},
+        {"model_name": "Qwen/Qwen2-7B-Instruct", "type": "open"},
+        {"model_name": "anthropic/claude-3-opus", "type": "closed", "external_link": "https://www.anthropic.com/claude"},
+        {"model_name": "OpenAI/gpt-4o", "type": "closed", "external_link": "https://openai.com/gpt-4"},
+        {"model_name": "01-ai/Yi-1.5-34B-Chat", "type": "open"},
+        {"model_name": "google/gemma-2b", "type": "open"},
+        {"model_name": "microsoft/phi-3-mini-4k-instruct", "type": "open"},
+        {"model_name": "microsoft/phi-3-mini-128k-instruct", "type": "open"},
+        {"model_name": "stabilityai/stable-beluga-7b", "type": "open"},
+        {"model_name": "togethercomputer/RedPajama-INCITE-7B-Instruct", "type": "open"},
+        {"model_name": "databricks/dbrx-instruct", "type": "closed", "external_link": "https://www.databricks.com/product/machine-learning/large-language-models"},
+        {"model_name": "mosaicml/mpt-7b-instruct", "type": "open"},
+        {"model_name": "01-ai/Yi-1.5-9B-Chat", "type": "open"},
+        {"model_name": "anthropic/claude-3-sonnet", "type": "closed", "external_link": "https://www.anthropic.com/claude"},
+        {"model_name": "cohere/command-r-plus", "type": "closed", "external_link": "https://cohere.com/models/command-r-plus"},
+        {"model_name": "meta-llama/llama-3-8b-instruct", "type": "open"}
+    ]
+
+    np.random.seed(42)  # For reproducibility
+
+    model_data = []
+    for model_info in models:
+        model_name = model_info["model_name"]
+        model_type = model_info["type"]
+        external_link = model_info.get("external_link", None)
+
+        # Generate random scores
+        average = round(np.random.uniform(40, 90), 2)
+        ifeval = round(np.random.uniform(30, 90), 2)
+        bbhi = round(np.random.uniform(40, 85), 2)
+        math = round(np.random.uniform(20, 80), 2)
+        gpqa = round(np.random.uniform(10, 70), 2)
+        mujb = round(np.random.uniform(10, 70), 2)
+        mmlu = round(np.random.uniform(40, 85), 2)
+        co2_cost = round(np.random.uniform(1, 100), 2)
+
+        # If it's an open model, it should have a link to Hugging Face
+        model_link = None
+        if external_link:
+            model_link = external_link
+        elif "/" in model_name:
+            model_link = f"https://huggingface.co/{model_name}"
+        else:
+            model_link = f"https://huggingface.co/models?search={model_name}"
+
+        model_data.append({
+            "model_name": model_name,
+            "type": model_type,
+            "model_link": model_link,
+            "scores": {
+                "average": average,
+                "ifeval": ifeval,
+                "bbhi": bbhi,
+                "math": math,
+                "gpqa": gpqa,
+                "mujb": mujb,
+                "mmlu": mmlu
+            },
+            "co2_cost": co2_cost
+        })
+
+    # Sort by average score
+    model_data.sort(key=lambda x: x["scores"]["average"], reverse=True)
+
+    # Create the final data structure
+    from datetime import datetime
+    leaderboard_data = {
+        "models": model_data,
+        "updated_at": datetime.now().isoformat()
+    }
+
+    return leaderboard_data
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to the LLM Leaderboard API"}
+
+@app.get("/api/leaderboard", response_model=LeaderboardData)
+def get_leaderboard(refresh: bool = Query(False, description="Force refresh data from source")):
+    """
+    Get the full leaderboard data.
+    If refresh is True, force fetch from source instead of using cache.
+    """
+    external_data = fetch_external_leaderboard_data(refresh=refresh)
+
+    if external_data:
+        # Process external data to match our expected format
+        try:
+            # Here you would transform the external data to match LeaderboardData model
+            # This is a simplified example - you'd need to adapt this to the actual structure
+            return external_data
+        except Exception as e:
+            print(f"Error processing external data: {e}")
+
+    # Fall back to sample data if external data can't be processed
+    return generate_sample_data()
+
+@app.get("/api/models", response_model=List[str])
+def get_models():
+    """Get a list of all model names in the leaderboard"""
+    data = fetch_external_leaderboard_data() or generate_sample_data()
+    return [model["model_name"] for model in data["models"]]
+
+@app.get("/api/model/{model_name}", response_model=LeaderboardModel)
+def get_model_details(model_name: str):
+    """Get detailed information about a specific model"""
+    data = fetch_external_leaderboard_data() or generate_sample_data()
+
+    for model in data["models"]:
+        if model["model_name"] == model_name:
+            return model
+
+    raise HTTPException(status_code=404, detail=f"Model {model_name} not found")
+
+@app.get("/api/filters")
+def get_filter_counts():
+    """
+    Get counts for different filter categories to display in the UI.
+    This matches what's shown in the 'Quick Filters' section of the leaderboard.
+    """
+    data = fetch_external_leaderboard_data() or generate_sample_data()
+
+    # Count models by different categories
+    edge_count = 0
+    consumer_count = 0
+    midrange_count = 0
+    gpu_rich_count = 0
+    official_count = 0
+
+    for model in data["models"]:
+        # Edge devices (typically small models)
+        if "scores" in model and model["scores"].get("average", 0) < 45:
+            edge_count += 1
+
+        # Consumer (moderate size/performance)
+        if "scores" in model and 45 <= model["scores"].get("average", 0) < 55:
+            consumer_count += 1
+
+        # Mid-range
+        if "scores" in model and 55 <= model["scores"].get("average", 0) < 65:
+            midrange_count += 1
+
+        # GPU-rich (high-end models)
+        if "scores" in model and model["scores"].get("average", 0) >= 65:
+            gpu_rich_count += 1
+
+        # Official providers
+        # This is just a placeholder logic - adapt to your actual criteria
+        if "/" not in model["model_name"] or model["model_name"].startswith("meta/") or model["model_name"].startswith("google/"):
+            official_count += 1
+
+    return {
+        "edge_devices": edge_count,
+        "consumers": consumer_count,
+        "midrange": midrange_count,
+        "gpu_rich": gpu_rich_count,
+        "official_providers": official_count
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,30 @@
+aiofiles>=22.0,<24.0
+anyio>=3.0,<5.0
+audioop-lts<1.0; python_version >= "3.13" #it provides support for 'audioop' module removed in latest python version used by pydub
+fastapi>=0.95.0
+ffmpy
+groovy~=0.1
+gradio>=5.0.0
+httpx>=0.24.1
+huggingface_hub>=0.28.1
+Jinja2<4.0
+markupsafe>=2.0,<4.0
+numpy>=1.20.0
+orjson~=3.0
+packaging
+pandas>=1.3.0
+pillow>=8.0,<12.0
+pydantic>=1.10.0
+python-multipart>=0.0.18 # required for fastapi forms.
+pydub
+pyyaml>=5.0,<7.0
+ruff>=0.9.3; sys.platform != 'emscripten'  # needed here for custom component docs generation
+safehttpx>=0.1.6,<0.2.0
+semantic_version~=2.0
+starlette>=0.40.0,<1.0; sys.platform != 'emscripten'
+tomlkit>=0.12.0,<0.14.0
+typer>=0.12,<1.0; sys.platform != 'emscripten'
+typing_extensions~=4.0
+urllib3~=2.0; sys.platform == 'emscripten'  # urllib3 is used for Lite support. Version spec can be omitted because urllib3==2.1.0 is prebuilt for Pyodide and urllib>=2.2.0 supports Pyodide as well.
+uvicorn>=0.21.0
+requests>=2.28.0

run.py

@@ -0,0 +1,280 @@
+import pandas as pd
+import requests
+from urllib.parse import quote
+import subprocess
+import os
+import time
+import sys
+from datetime import datetime
+
+import gradio as gr
+
+def style_dataframe(df):
+    if len(df) == 0:
+        return df
+
+    # Define the columns to highlight based on the screenshot
+    highlight_cols = ["Average", "IFEval", "BBHI", "MATH", "GPQA", "MUJB", "MMLU-PRO"]
+
+    # Initialize the styler
+    styled = df.style
+
+    # Function to create gradient background based on value
+    def highlight_green(val):
+        try:
+            # Extract numeric value from string (remove % if present)
+            val_float = float(str(val).replace('%', '').replace(' kg', ''))
+
+            # Create gradient background filling based on the value percentage
+            # Use the exact colors from the example
+            return f'background: linear-gradient(90deg, rgba(46, 125, 50, 0.5) {val_float}%, rgba(46, 125, 50, 0.1) {val_float}%); color: white;'
+        except:
+            return 'background-color: #121212; color: white;'
+
+    # Apply the highlighting to performance metric columns
+    for col in highlight_cols:
+        styled = styled.applymap(highlight_green, subset=[col])
+
+    styled = styled.set_properties(
+        subset=["Model"],
+        **{'color': '#4da6ff'}
+    )
+
+    return styled
+
+def increment_counter(counter):
+    return counter + 1
+
+def handle_select(evt: gr.SelectData, counter):
+    return counter + 1, f"{evt.index}", f"{evt.value}"
+
+def start_api_server():
+    api_process = subprocess.Popen(
+        [sys.executable, "api.py"],
+        cwd=os.path.dirname(os.path.abspath(__file__))
+    )
+    # Give the API server a moment to start
+    time.sleep(2)
+    return api_process
+
+def apply_filters(filters, models_data):
+    if not filters or len(filters) == 0:
+        # No filters selected, return all data
+        return models_data
+
+    filtered_models = []
+
+    for model in models_data:
+        scores = model.get("scores", {})
+        average_score = scores.get("average", 0)
+        model_name = model.get("model_name", "")
+
+        # Check which filters are selected and apply them
+        should_include = False
+        for filter_option in filters:
+            if "Edge Devices" in filter_option and average_score < 45 or "Consumers" in filter_option and 45 <= average_score < 55 or "Mid-range" in filter_option and 55 <= average_score < 65 or "GPU-rich" in filter_option and average_score >= 65 or "Official Providers" in filter_option and ("/" not in model_name or
+                                                           model_name.startswith("meta/") or
+                                                           model_name.startswith("google/") or
+                                                           model_name.startswith("openai/") or
+                                                           model_name.startswith("microsoft/")):
+                should_include = True
+                break
+
+        if should_include:
+            filtered_models.append(model)
+
+    return filtered_models
+
+def format_timestamp(timestamp_str):
+    try:
+        # Parse ISO format timestamp
+
+        # Try to parse ISO format with timezone
+        try:
+            dt = datetime.fromisoformat(timestamp_str)
+        except:
+            # Fallback for different timestamp formats
+            dt = datetime.strptime(timestamp_str, "%Y-%m-%dT%H:%M:%S.%f")
+
+        # Format nicely for display
+        return dt.strftime("%B %d, %Y at %I:%M %p")
+    except Exception as e:
+        print(f"Error formatting timestamp: {e}")
+        return timestamp_str
+
+def create_leaderboard_data(selected_filters=None):
+    try:
+        response = requests.get("http://localhost:8000/api/leaderboard")
+        if response.status_code == 200:
+            data = response.json()
+            models_data = data.get("models", [])
+            updated_at = data.get("updated_at", "Unknown")
+            formatted_time = format_timestamp(updated_at)
+
+            # Apply filters if any are selected
+            if selected_filters:
+                models_data = apply_filters(selected_filters, models_data)
+
+            rows = []
+            for i, model in enumerate(models_data, 1):
+                model_name = model["model_name"]
+                model_type = model["type"]
+                scores = model["scores"]
+                co2_cost = model.get("co2_cost", "N/A")
+
+                # Only use green for open and red for closed
+                emoji = "🟢" if model_type.lower() == "open" else "🔴"
+                type_with_emoji = f"{emoji} {model_type.upper()}"
+
+                # Use model_link from API if available, otherwise create one
+                if "model_link" in model and model["model_link"]:
+                    model_link = f"[{model_name}]({model['model_link']})"
+                # Format model name with link
+                elif "/" in model_name:
+                    org, name = model_name.split("/", 1)
+                    model_link = f"[{model_name}](https://huggingface.co/{quote(model_name)})"
+                else:
+                    model_link = f"[{model_name}](https://huggingface.co/models?search={quote(model_name)})"
+
+                rows.append([
+                    i,  # Rank
+                    type_with_emoji,
+                    model_link,
+                    f"{scores.get('average', 0):.2f}",
+                    f"{scores.get('ifeval', 0):.2f}",
+                    f"{scores.get('bbhi', 0):.2f}",
+                    f"{scores.get('math', 0):.2f}",
+                    f"{scores.get('gpqa', 0):.2f}",
+                    f"{scores.get('mujb', 0):.2f}",
+                    f"{scores.get('mmlu', 0):.2f}",
+                    f"{co2_cost}" if isinstance(co2_cost, (int, float)) else co2_cost
+                ])
+
+            df = pd.DataFrame(rows, columns=["Rank", "Type", "Model", "Average", "IFEval", "BBHI", "MATH", "GPQA", "MUJB", "MMLU-PRO", "CO_Cost"])
+            styled_df = style_dataframe(df)
+            return styled_df, formatted_time
+        else:
+            # Return an empty dataframe with proper columns if API fails
+            empty_df = pd.DataFrame(columns=["Rank", "Type", "Model", "Average", "IFEval", "BBHI", "MATH", "GPQA", "MUJB", "MMLU-PRO", "CO_Cost"])
+            return empty_df, "Unknown"
+    except Exception as e:
+        print(f"Error fetching leaderboard data: {e}")
+        # Return an empty dataframe with proper columns if API fails
+        empty_df = pd.DataFrame(columns=["Rank", "Type", "Model", "Average", "IFEval", "BBHI", "MATH", "GPQA", "MUJB", "MMLU-PRO", "CO_Cost"])
+        return empty_df, "Unknown"
+
+def load_svg(file_path="hf.svg"):
+        with open(file_path) as f:
+            svg_content = f.read()
+        return svg_content
+
+def get_filter_data():
+    try:
+        response = requests.get("http://localhost:8000/api/filters")
+        if response.status_code == 200:
+            filter_data = response.json()
+            return [
+                f"For Edge Devices · {filter_data.get('edge_devices', 0)}",
+                f"For Consumers · {filter_data.get('consumers', 0)}",
+                f"Mid-range · {filter_data.get('midrange', 0)}",
+                f"For the GPU-rich · {filter_data.get('gpu_rich', 0)}",
+                f"Only Official Providers · {filter_data.get('official_providers', 0)}"
+            ]
+        else:
+            return [
+                "For Edge Devices · 0",
+                "For Consumers · 0",
+                "Mid-range · 0",
+                "For the GPU-rich · 0",
+                "Only Official Providers · 0"
+            ]
+    except Exception as e:
+        print(f"Error fetching filter data: {e}")
+        return [
+            "For Edge Devices · 0",
+            "For Consumers · 0",
+            "Mid-range · 0",
+            "For the GPU-rich · 0",
+            "Only Official Providers · 0"
+        ]
+
+def refresh_leaderboard(selected_filters=None):
+    try:
+        # Request a refresh from the API
+        requests.get("http://localhost:8000/api/leaderboard?refresh=true")
+        # Get updated data
+        df, timestamp = create_leaderboard_data(selected_filters)
+        filter_choices = get_filter_data()
+        return df, filter_choices, f"Last updated: {timestamp}"
+    except Exception as e:
+        print(f"Error refreshing data: {e}")
+        return None, None, "Error refreshing data"
+
+def update_table(filters):
+    df, timestamp = create_leaderboard_data(filters)
+    return df, f"Last updated: {timestamp}"
+
+def load_css(file_path="style.css"):
+    try:
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        css_path = os.path.join(current_dir, file_path)
+        with open(css_path) as f:
+            css_content = f.read()
+        return css_content
+    except Exception as e:
+        print(f"Error loading CSS file: {e}")
+        # Return a basic CSS if file not found
+        return """
+        .dataframe-container {
+            border-radius: 8px;
+            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+        }
+        """
+
+with gr.Blocks(css=load_css()) as demo:
+    df, timestamp = create_leaderboard_data()
+
+    with gr.Row():
+        svg_content = load_svg()
+        gr.HTML(svg_content)
+    gr.HTML("""
+        <div style="display: flex; align-items: center; justify-content: center; margin-bottom: 10px;">
+            <div class="leaderboard-title">Open LLM Leaderboard</div>
+        </div>
+        <div class="leaderboard-subtitle">Comparing Large Language Models in an open and reproducible way</div>
+    """)
+    status_text = gr.HTML(f"""<div style="text-align: center; margin-bottom: 10px;">Last updated: {timestamp}</div>""")
+
+    with gr.Row(elem_classes="filters-container"):
+        filter_choices = get_filter_data()
+        filters = gr.CheckboxGroup(
+            label="Quick Filters",
+            choices=filter_choices,
+        )
+
+    # Create and display the dataframe
+
+    leaderboard_table = gr.Dataframe(
+        value=df,
+        headers=["Rank", "Type", "Model", "Average", "IFEval", "BBHI", "MATH", "GPQA", "MUJB", "MMLU-PRO", "CO_Cost"],
+        datatype=["number", "str", "markdown", "str", "str", "str", "str", "str", "str", "str", "str"],
+        elem_id="leaderboard-table",
+        elem_classes="dataframe-container",
+        interactive=False,
+        max_height=600,
+        show_search="search",
+        show_copy_button=True,
+        show_fullscreen_button=True,
+        pinned_columns=2,
+        column_widths=["5%", "10%", "35%", "7%", "7%", "7%", "7%", "7%", "7%", "7%", "6%"]
+    )
+
+    refresh_btn = gr.Button("Refresh Data", elem_classes="refresh-btn")
+    refresh_btn.click(refresh_leaderboard, inputs=[filters], outputs=[leaderboard_table, filters, status_text])
+
+    filters.change(update_table, inputs=[filters], outputs=[leaderboard_table, status_text])
+
+if __name__ == "__main__":
+    api_process = start_api_server()
+    demo.launch()
+    api_process.terminate()

run_all.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+import subprocess
+import sys
+import os
+import time
+import signal
+import atexit
+
+def start_api_server():
+    api_process = subprocess.Popen(
+        [sys.executable, "api.py"],
+        cwd=os.path.dirname(os.path.abspath(__file__))
+    )
+    print("API server started (PID:", api_process.pid, ")")
+    return api_process
+
+def start_gradio_app():
+    gradio_process = subprocess.Popen(
+        [sys.executable, "-c", "import gradio as gr; import run; run.demo.launch()"],
+        cwd=os.path.dirname(os.path.abspath(__file__))
+    )
+    print("Gradio interface started (PID:", gradio_process.pid, ")")
+    return gradio_process
+
+def cleanup_processes(api_process, gradio_process):
+    print("\nShutting down services...")
+
+    if api_process and api_process.poll() is None:
+        api_process.terminate()
+        print("API server terminated")
+
+    if gradio_process and gradio_process.poll() is None:
+        gradio_process.terminate()
+        print("Gradio interface terminated")
+
+def main():
+    api_process = start_api_server()
+    # Give the API server a moment to start
+    time.sleep(2)
+
+    gradio_process = start_gradio_app()
+
+    # Register cleanup function to be called on exit
+    atexit.register(cleanup_processes, api_process, gradio_process)
+
+    # Handle keyboard interrupts
+    def signal_handler(sig, frame):
+        print("\nReceived termination signal")
+        cleanup_processes(api_process, gradio_process)
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    print("\nLeaderboard application started!")
+    print("- API server running at http://localhost:8000")
+    print("- Gradio interface running at http://localhost:7860")
+    print("\nPress Ctrl+C to stop all services")
+
+    # Keep the main process running
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        pass
+
+if __name__ == "__main__":
+    main()

style.css

@@ -0,0 +1,44 @@
+.html-container {
+    text-align: center;
+    display: flex;
+    justify-content: center;
+    width: 100%;
+}
+
+.dataframe-container {
+    margin-top: 0.5rem;
+    margin-bottom: 0.5rem;
+}
+
+.leaderboard-title {
+    font-size: 1.5rem;
+    font-weight: bold;
+    margin-bottom: 0.25rem;
+    color: #f0f0f0;
+}
+
+.leaderboard-subtitle {
+    font-size: 0.9rem;
+    margin-bottom: 1rem;
+    color: #a0a0a0;
+}
+
+.filters-container fieldset {
+   display: flex;
+   flex-direction: row;
+   justify-content: center;
+   align-items: center;
+   gap: 0.5rem;
+}
+
+.refresh-btn {
+    margin-top: 0.5rem;
+}
+
+.status-container {
+    display: flex;
+    justify-content: flex-end;
+    font-size: 0.75rem;
+    color: #a0a0a0;
+}
+