serve/leaderboard.py

import argparse
import ast
import pickle
import os
import threading
import time

import gradio as gr
import numpy as np
import pandas as pd
from serve.model import model_config

def hyperlink(name, link):
    return f'<a target="_blank" href="{link}" style="color: var(--link-text-color); \
    text-decoration: underline;text-decoration-style: dotted;">{name}</a>'

def amend_model_name(name, rank):
    model_name = model_config[name].model_name
    if rank==1:
        return "🥇 " + model_name
    elif rank==2:
        return "🥈 " + model_name
    elif rank==3:
        return '🥉 ' + model_name
    else:
        return model_name

def get_cfg_info(name):
    config = model_config[name]
    links = []
    if config.page_link:
        links.append(hyperlink("Page", config.page_link))
    if config.code_link:
        links.append(hyperlink("Code", config.code_link))
    return ", ".join(links) if links else "N/A", config.organization if config.organization else "N/A"

def get_leaderboard_values(leaderboard_df):
    leaderboard_vals = []
    for i, row in leaderboard_df.iterrows():
        rank = i+1
        model_name = row["Method"]
        task = row["Task"]
        if model_name not in model_config.keys() or model_config[model_name].task != task:
            continue
        
        values = [rank, amend_model_name(model_name, rank), task]
        values = values + [row.get(dim, np.NaN) for dim in leaderboard_df.columns[2:]]
        # values.append(round(np.sum([v for v in values[3:] if pd.notna(v)]), 4))

        links, organization = get_cfg_info(model_name)
        # values.append(links)
        values.append(organization)
        
        leaderboard_vals.append(values)
    return leaderboard_vals

def get_topk_ranks(df, k=3):
    ranks = {}
    for col_idx, col in enumerate(df.columns[2:]):  # skip "Model" “Task"
        topk = df[col].nlargest(k)
        for rank, idx in enumerate(topk.index):
            if idx not in ranks:
                ranks[idx] = {}
            ranks[idx][col_idx] = rank + 1  # 1-based rank
    for i in range(k): ranks[i][5] = i + 1
    return ranks  # dict: row -> {col: rank}

def build_leaderboard_tab(leaderboard_file: str, task: str = ""):
    if not isinstance(leaderboard_file, str):
        leaderboard_file = leaderboard_file.value
    if not isinstance(task, str):
        task = task.value

    df = pd.read_csv(leaderboard_file)
    if task in ["Text-to-3D only", "Image-to-3D only"]:
        df = df[df["Task"] == task.split()[0]]
        # df = df.drop(df[df["Task"]!=task.split()[0]].index)
    leaderboard_df = df.drop(df[df["Method"].isnull()].index)
    leaderboard_df = leaderboard_df.reset_index(drop=True)

    leaderboard_vals = get_leaderboard_values(leaderboard_df)
    leaderboard = gr.Dataframe(
        headers = ['Rank', "🤖 Model", "🪧 Task" ] 
            + [f"{dim}" for dim in leaderboard_df.keys()[2:-1]] 
            + ["⭐ Overall", "🏛️ Orgnization"],     # "🔗 Links",
        datatype = ["number", "str", "str"] 
            + ["number"] * (len(leaderboard_df.columns) - 3) 
            + ["number", "str"],
        value = leaderboard_vals,
        height = 680,
        column_widths = [60, 140, 100] 
            + [120] * (len(leaderboard_df.columns) - 3) 
            + [120, 160],
        wrap = True,
    )
    return leaderboard