Revert "initial"

This reverts commit cce0ed9c2ee4e552d2f504d06f28ed0a29c10cb8.

README copy.md

@@ -1,75 +0,0 @@
-# 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

@@ -1,250 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,280 +0,0 @@
-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

@@ -1,68 +0,0 @@
-#!/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

@@ -1,44 +0,0 @@
-.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;
-}
-