Remove unused models

app.py

@@ -6,6 +6,14 @@ import gradio as gr
 import pandas as pd
 import requests
 
+from src.about import TITLE, INTRODUCTION_TEXT
+from src.display.css_html_js import custom_css
+from src.leaderboard.read_evals import (
+    TabularLeaderboardEntry,
+    parse_tabular_leaderboard,
+    tabular_leaderboard_to_dataframe,
+)
+
 # GitHub API endpoint for the file (handles Git LFS files)
 LEADERBOARD_API_URL = "https://api.github.com/repos/upgini/mle-bench/contents/rankings/low/tabular/overall_ranks.csv"
 LEADERBOARD_GITHUB_URL = "https://github.com/upgini/mle-bench/blob/main/rankings/low/tabular/overall_ranks.csv"
@@ -22,8 +30,11 @@ DISPLAY_COLUMNS = [
 ]
 
 
-def download_leaderboard() -> pd.DataFrame:
-    """Download the remote leaderboard CSV from GitHub (handles Git LFS) and return a cleaned dataframe."""
+def download_leaderboard() -> list[TabularLeaderboardEntry]:
+    """Download the remote leaderboard CSV from GitHub (handles Git LFS).
+
+    Returns a list of TabularLeaderboardEntry objects.
+    """
     # Use GitHub API to get file content (handles Git LFS files)
     response = requests.get(LEADERBOARD_API_URL, timeout=30)
     response.raise_for_status()
@@ -59,7 +70,7 @@ def download_leaderboard() -> pd.DataFrame:
 
     df = pd.read_csv(io.StringIO(csv_content))
     if df.empty:
-        return df
+        return []
 
     missing_cols = [col for col in DISPLAY_COLUMNS if col not in df.columns]
     if missing_cols:
@@ -71,12 +82,20 @@ def download_leaderboard() -> pd.DataFrame:
     df["mean_medal_pct"] = (df["mean_medal_pct"] * 100).round(1)
     df["sem_medal_pct"] = (df["sem_medal_pct"] * 100).round(1)
     df["Date"] = pd.to_datetime(df["Date"], errors="coerce").dt.strftime("%Y-%m-%d")
-    return df.sort_values(by="mean_normalized_score", ascending=False, ignore_index=True)
+
+    # Sort by mean_normalized_score before converting to data models
+    df = df.sort_values(by="mean_normalized_score", ascending=False, ignore_index=True)
+
+    # Parse into data models
+    entries = parse_tabular_leaderboard(df)
+
+    return entries
 
 
 def refresh_leaderboard():
     """Fetch the leaderboard and build the status message for the UI."""
-    df = download_leaderboard()
+    entries = download_leaderboard()
+    df = tabular_leaderboard_to_dataframe(entries)
     status = (
         f"Showing data from [GitHub]({LEADERBOARD_GITHUB_URL}). "
         f"Last refreshed: {datetime.now(timezone.utc):%Y-%m-%d %H:%M UTC}."
@@ -86,15 +105,9 @@ def refresh_leaderboard():
 
 def create_app():
     """Create and configure the Gradio app without launching it."""
-    with gr.Blocks(title="Upgini MLE-Bench Leaderboard") as demo:
-        gr.Markdown(
-            """
-            # Upgini MLE-Bench Tabular Leaderboard
-
-            This app mirrors the remote leaderboard so you always see the latest public results.
-            Click **Refresh leaderboard** any time to re-download the CSV from GitHub.
-            """
-        )
+    with gr.Blocks(title="Upgini MLE-Bench Leaderboard", css=custom_css) as demo:
+        gr.HTML(TITLE)
+        gr.Markdown(INTRODUCTION_TEXT)
 
         leaderboard_table = gr.DataFrame(
             value=pd.DataFrame(columns=DISPLAY_COLUMNS),
@@ -102,6 +115,7 @@ def create_app():
             interactive=False,
             type="pandas",
             label="Leaderboard",
+            elem_id="leaderboard-table",
         )
         status_text = gr.Markdown()
         refresh_button = gr.Button("Refresh leaderboard", variant="primary")

src/about.py

@@ -1,70 +1,10 @@
-from dataclasses import dataclass
-from enum import Enum
-
-@dataclass
-class Task:
-    benchmark: str
-    metric: str
-    col_name: str
-
-
-# Select your tasks here
-# ---------------------------------------------------
-class Tasks(Enum):
-    # task_key in the json file, metric_key in the json file, name to display in the leaderboard 
-    task0 = Task("anli_r1", "acc", "ANLI")
-    task1 = Task("logiqa", "acc_norm", "LogiQA")
-
-NUM_FEWSHOT = 0 # Change with your few shot
-# ---------------------------------------------------
-
-
-
 # Your leaderboard name
-TITLE = """<h1 align="center" id="space-title">Demo leaderboard</h1>"""
+TITLE = """<h1 align="center" id="space-title">Upgini MLE-Bench Tabular Leaderboard</h1>"""
 
 # What does your leaderboard evaluate?
 INTRODUCTION_TEXT = """
-Intro text
-"""
-
-# Which evaluations are you running? how can people reproduce what you have?
-LLM_BENCHMARKS_TEXT = f"""
-## How it works
-
-## Reproducibility
-To reproduce our results, here is the commands you can run:
-
-"""
-
-EVALUATION_QUEUE_TEXT = """
-## Some good practices before submitting a model
-
-### 1) Make sure you can load your model and tokenizer using AutoClasses:
-```python
-from transformers import AutoConfig, AutoModel, AutoTokenizer
-config = AutoConfig.from_pretrained("your model name", revision=revision)
-model = AutoModel.from_pretrained("your model name", revision=revision)
-tokenizer = AutoTokenizer.from_pretrained("your model name", revision=revision)
-```
-If this step fails, follow the error messages to debug your model before submitting it. It's likely your model has been improperly uploaded.
-
-Note: make sure your model is public!
-Note: if your model needs `use_remote_code=True`, we do not support this option yet but we are working on adding it, stay posted!
-
-### 2) Convert your model weights to [safetensors](https://huggingface.co/docs/safetensors/index)
-It's a new format for storing weights which is safer and faster to load and use. It will also allow us to add the number of parameters of your model to the `Extended Viewer`!
-
-### 3) Make sure your model has an open license!
-This is a leaderboard for Open LLMs, and we'd love for as many people as possible to know they can use your model 🤗
-
-### 4) Fill up your model card
-When we add extra information about models to the leaderboard, it will be automatically taken from the model card
-
-## In case of model failure
-If your model is displayed in the `FAILED` category, its execution stopped.
-Make sure you have followed the above steps first.
-If everything is done, check you can launch the EleutherAIHarness on your model locally, using the above command without modifications (you can add `--limit` to limit the number of examples per task).
+This app mirrors the remote leaderboard so you always see the latest public results.
+Click **Refresh leaderboard** any time to re-download the CSV from GitHub.
 """
 
 CITATION_BUTTON_LABEL = "Copy the following snippet to cite these results"

src/display/formatting.py

@@ -1,12 +1,3 @@
-def model_hyperlink(link, model_name):
-    return f'<a target="_blank" href="{link}" style="color: var(--link-text-color); text-decoration: underline;text-decoration-style: dotted;">{model_name}</a>'
-
-
-def make_clickable_model(model_name):
-    link = f"https://huggingface.co/{model_name}"
-    return model_hyperlink(link, model_name)
-
-
 def styled_error(error):
     return f"<p style='color: red; font-size: 20px; text-align: center;'>{error}</p>"
 
@@ -17,11 +8,3 @@ def styled_warning(warn):
 
 def styled_message(message):
     return f"<p style='color: green; font-size: 20px; text-align: center;'>{message}</p>"
-
-
-def has_no_nan_values(df, columns):
-    return df[columns].notna().all(axis=1)
-
-
-def has_nan_values(df, columns):
-    return df[columns].isna().any(axis=1)

src/display/utils.py

@@ -1,110 +0,0 @@
-from dataclasses import dataclass, make_dataclass
-from enum import Enum
-
-import pandas as pd
-
-from src.about import Tasks
-
-def fields(raw_class):
-    return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
-
-
-# These classes are for user facing column names,
-# to avoid having to change them all around the code
-# when a modif is needed
-@dataclass
-class ColumnContent:
-    name: str
-    type: str
-    displayed_by_default: bool
-    hidden: bool = False
-    never_hidden: bool = False
-
-## Leaderboard columns
-auto_eval_column_dict = []
-# Init
-auto_eval_column_dict.append(["model_type_symbol", ColumnContent, ColumnContent("T", "str", True, never_hidden=True)])
-auto_eval_column_dict.append(["model", ColumnContent, ColumnContent("Model", "markdown", True, never_hidden=True)])
-#Scores
-auto_eval_column_dict.append(["average", ColumnContent, ColumnContent("Average ⬆️", "number", True)])
-for task in Tasks:
-    auto_eval_column_dict.append([task.name, ColumnContent, ColumnContent(task.value.col_name, "number", True)])
-# Model information
-auto_eval_column_dict.append(["model_type", ColumnContent, ColumnContent("Type", "str", False)])
-auto_eval_column_dict.append(["architecture", ColumnContent, ColumnContent("Architecture", "str", False)])
-auto_eval_column_dict.append(["weight_type", ColumnContent, ColumnContent("Weight type", "str", False, True)])
-auto_eval_column_dict.append(["precision", ColumnContent, ColumnContent("Precision", "str", False)])
-auto_eval_column_dict.append(["license", ColumnContent, ColumnContent("Hub License", "str", False)])
-auto_eval_column_dict.append(["params", ColumnContent, ColumnContent("#Params (B)", "number", False)])
-auto_eval_column_dict.append(["likes", ColumnContent, ColumnContent("Hub ❤️", "number", False)])
-auto_eval_column_dict.append(["still_on_hub", ColumnContent, ColumnContent("Available on the hub", "bool", False)])
-auto_eval_column_dict.append(["revision", ColumnContent, ColumnContent("Model sha", "str", False, False)])
-
-# We use make dataclass to dynamically fill the scores from Tasks
-AutoEvalColumn = make_dataclass("AutoEvalColumn", auto_eval_column_dict, frozen=True)
-
-## For the queue columns in the submission tab
-@dataclass(frozen=True)
-class EvalQueueColumn:  # Queue column
-    model = ColumnContent("model", "markdown", True)
-    revision = ColumnContent("revision", "str", True)
-    private = ColumnContent("private", "bool", True)
-    precision = ColumnContent("precision", "str", True)
-    weight_type = ColumnContent("weight_type", "str", "Original")
-    status = ColumnContent("status", "str", True)
-
-## All the model information that we might need
-@dataclass
-class ModelDetails:
-    name: str
-    display_name: str = ""
-    symbol: str = "" # emoji
-
-
-class ModelType(Enum):
-    PT = ModelDetails(name="pretrained", symbol="🟢")
-    FT = ModelDetails(name="fine-tuned", symbol="🔶")
-    IFT = ModelDetails(name="instruction-tuned", symbol="⭕")
-    RL = ModelDetails(name="RL-tuned", symbol="🟦")
-    Unknown = ModelDetails(name="", symbol="?")
-
-    def to_str(self, separator=" "):
-        return f"{self.value.symbol}{separator}{self.value.name}"
-
-    @staticmethod
-    def from_str(type):
-        if "fine-tuned" in type or "🔶" in type:
-            return ModelType.FT
-        if "pretrained" in type or "🟢" in type:
-            return ModelType.PT
-        if "RL-tuned" in type or "🟦" in type:
-            return ModelType.RL
-        if "instruction-tuned" in type or "⭕" in type:
-            return ModelType.IFT
-        return ModelType.Unknown
-
-class WeightType(Enum):
-    Adapter = ModelDetails("Adapter")
-    Original = ModelDetails("Original")
-    Delta = ModelDetails("Delta")
-
-class Precision(Enum):
-    float16 = ModelDetails("float16")
-    bfloat16 = ModelDetails("bfloat16")
-    Unknown = ModelDetails("?")
-
-    def from_str(precision):
-        if precision in ["torch.float16", "float16"]:
-            return Precision.float16
-        if precision in ["torch.bfloat16", "bfloat16"]:
-            return Precision.bfloat16
-        return Precision.Unknown
-
-# Column selection
-COLS = [c.name for c in fields(AutoEvalColumn) if not c.hidden]
-
-EVAL_COLS = [c.name for c in fields(EvalQueueColumn)]
-EVAL_TYPES = [c.type for c in fields(EvalQueueColumn)]
-
-BENCHMARK_COLS = [t.value.col_name for t in Tasks]
-

src/envs.py

@@ -1,25 +0,0 @@
-import os
-
-from huggingface_hub import HfApi
-
-# Info to change for your repository
-# ----------------------------------
-TOKEN = os.environ.get("HF_TOKEN") # A read/write token for your org
-
-OWNER = "demo-leaderboard-backend" # Change to your org - don't forget to create a results and request dataset, with the correct format!
-# ----------------------------------
-
-REPO_ID = f"{OWNER}/leaderboard"
-QUEUE_REPO = f"{OWNER}/requests"
-RESULTS_REPO = f"{OWNER}/results"
-
-# If you setup a cache later, just change HF_HOME
-CACHE_PATH=os.getenv("HF_HOME", ".")
-
-# Local caches
-EVAL_REQUESTS_PATH = os.path.join(CACHE_PATH, "eval-queue")
-EVAL_RESULTS_PATH = os.path.join(CACHE_PATH, "eval-results")
-EVAL_REQUESTS_PATH_BACKEND = os.path.join(CACHE_PATH, "eval-queue-bk")
-EVAL_RESULTS_PATH_BACKEND = os.path.join(CACHE_PATH, "eval-results-bk")
-
-API = HfApi(token=TOKEN)

src/leaderboard/read_evals.py

@@ -1,196 +1,86 @@
 import glob
 import json
-import math
 import os
 from dataclasses import dataclass
 
 import dateutil
 import numpy as np
-
-from src.display.formatting import make_clickable_model
-from src.display.utils import AutoEvalColumn, ModelType, Tasks, Precision, WeightType
-from src.submission.check_validity import is_model_on_hub
+import pandas as pd
 
 
 @dataclass
-class EvalResult:
-    """Represents one full evaluation. Built from a combination of the result and request file for a given run.
-    """
-    eval_name: str # org_model_precision (uid)
-    full_model: str # org/model (path on hub)
-    org: str 
-    model: str
-    revision: str # commit hash, "" if main
-    results: dict
-    precision: Precision = Precision.Unknown
-    model_type: ModelType = ModelType.Unknown # Pretrained, fine tuned, ...
-    weight_type: WeightType = WeightType.Original # Original or Adapter
-    architecture: str = "Unknown" 
-    license: str = "?"
-    likes: int = 0
-    num_params: int = 0
-    date: str = "" # submission date of request file
-    still_on_hub: bool = False
+class TabularLeaderboardEntry:
+    """Represents a single entry in the tabular leaderboard."""
+
+    experiment_id: str
+    agent: str
+    llms_used: str
+    mean_normalized_score: float
+    std_normalized_score: float
+    mean_medal_pct: float
+    sem_medal_pct: float
+    date: str
 
     @classmethod
-    def init_from_json_file(self, json_filepath):
-        """Inits the result from the specific model result file"""
-        with open(json_filepath) as fp:
-            data = json.load(fp)
-
-        config = data.get("config")
-
-        # Precision
-        precision = Precision.from_str(config.get("model_dtype"))
-
-        # Get model and org
-        org_and_model = config.get("model_name", config.get("model_args", None))
-        org_and_model = org_and_model.split("/", 1)
-
-        if len(org_and_model) == 1:
-            org = None
-            model = org_and_model[0]
-            result_key = f"{model}_{precision.value.name}"
-        else:
-            org = org_and_model[0]
-            model = org_and_model[1]
-            result_key = f"{org}_{model}_{precision.value.name}"
-        full_model = "/".join(org_and_model)
-
-        still_on_hub, _, model_config = is_model_on_hub(
-            full_model, config.get("model_sha", "main"), trust_remote_code=True, test_tokenizer=False
+    def from_dataframe_row(cls, row: pd.Series) -> "TabularLeaderboardEntry":
+        """Create a TabularLeaderboardEntry from a pandas DataFrame row."""
+        return cls(
+            experiment_id=str(row.get("experiment_id", "")),
+            agent=str(row.get("Agent", "")),
+            llms_used=str(row.get("LLM(s) used", "")),
+            mean_normalized_score=float(row.get("mean_normalized_score", 0.0)),
+            std_normalized_score=float(row.get("std_normalized_score", 0.0)),
+            mean_medal_pct=float(row.get("mean_medal_pct", 0.0)),
+            sem_medal_pct=float(row.get("sem_medal_pct", 0.0)),
+            date=str(row.get("Date", "")),
         )
-        architecture = "?"
-        if model_config is not None:
-            architectures = getattr(model_config, "architectures", None)
-            if architectures:
-                architecture = ";".join(architectures)
-
-        # Extract results available in this file (some results are split in several files)
-        results = {}
-        for task in Tasks:
-            task = task.value
 
-            # We average all scores of a given metric (not all metrics are present in all files)
-            accs = np.array([v.get(task.metric, None) for k, v in data["results"].items() if task.benchmark == k])
-            if accs.size == 0 or any([acc is None for acc in accs]):
-                continue
-
-            mean_acc = np.mean(accs) * 100.0
-            results[task.benchmark] = mean_acc
+    def to_dict(self) -> dict:
+        """Convert the entry to a dictionary compatible with DataFrame display."""
+        return {
+            "experiment_id": self.experiment_id,
+            "Agent": self.agent,
+            "LLM(s) used": self.llms_used,
+            "mean_normalized_score": self.mean_normalized_score,
+            "std_normalized_score": self.std_normalized_score,
+            "mean_medal_pct": self.mean_medal_pct,
+            "sem_medal_pct": self.sem_medal_pct,
+            "Date": self.date,
+        }
 
-        return self(
-            eval_name=result_key,
-            full_model=full_model,
-            org=org,
-            model=model,
-            results=results,
-            precision=precision,  
-            revision= config.get("model_sha", ""),
-            still_on_hub=still_on_hub,
-            architecture=architecture
-        )
 
-    def update_with_request_file(self, requests_path):
-        """Finds the relevant request file for the current model and updates info with it"""
-        request_file = get_request_file_for_model(requests_path, self.full_model, self.precision.value.name)
+def parse_tabular_leaderboard(df: pd.DataFrame) -> list[TabularLeaderboardEntry]:
+    """Parse a DataFrame into a list of TabularLeaderboardEntry objects."""
+    if df.empty:
+        return []
 
+    entries = []
+    for _, row in df.iterrows():
         try:
-            with open(request_file, "r") as f:
-                request = json.load(f)
-            self.model_type = ModelType.from_str(request.get("model_type", ""))
-            self.weight_type = WeightType[request.get("weight_type", "Original")]
-            self.license = request.get("license", "?")
-            self.likes = request.get("likes", 0)
-            self.num_params = request.get("params", 0)
-            self.date = request.get("submitted_time", "")
+            entry = TabularLeaderboardEntry.from_dataframe_row(row)
+            entries.append(entry)
         except Exception:
-            print(f"Could not find request file for {self.org}/{self.model} with precision {self.precision.value.name}")
-
-    def to_dict(self):
-        """Converts the Eval Result to a dict compatible with our dataframe display"""
-        average = sum([v for v in self.results.values() if v is not None]) / len(Tasks)
-        data_dict = {
-            "eval_name": self.eval_name,  # not a column, just a save name,
-            AutoEvalColumn.precision.name: self.precision.value.name,
-            AutoEvalColumn.model_type.name: self.model_type.value.name,
-            AutoEvalColumn.model_type_symbol.name: self.model_type.value.symbol,
-            AutoEvalColumn.weight_type.name: self.weight_type.value.name,
-            AutoEvalColumn.architecture.name: self.architecture,
-            AutoEvalColumn.model.name: make_clickable_model(self.full_model),
-            AutoEvalColumn.revision.name: self.revision,
-            AutoEvalColumn.average.name: average,
-            AutoEvalColumn.license.name: self.license,
-            AutoEvalColumn.likes.name: self.likes,
-            AutoEvalColumn.params.name: self.num_params,
-            AutoEvalColumn.still_on_hub.name: self.still_on_hub,
-        }
-
-        for task in Tasks:
-            data_dict[task.value.col_name] = self.results[task.value.benchmark]
-
-        return data_dict
-
-
-def get_request_file_for_model(requests_path, model_name, precision):
-    """Selects the correct request file for a given model. Only keeps runs tagged as FINISHED"""
-    request_files = os.path.join(
-        requests_path,
-        f"{model_name}_eval_request_*.json",
-    )
-    request_files = glob.glob(request_files)
-
-    # Select correct request file (precision)
-    request_file = ""
-    request_files = sorted(request_files, reverse=True)
-    for tmp_request_file in request_files:
-        with open(tmp_request_file, "r") as f:
-            req_content = json.load(f)
-            if (
-                req_content["status"] in ["FINISHED"]
-                and req_content["precision"] == precision.split(".")[-1]
-            ):
-                request_file = tmp_request_file
-    return request_file
-
-
-def get_raw_eval_results(results_path: str, requests_path: str) -> list[EvalResult]:
-    """From the path of the results folder root, extract all needed info for results"""
-    model_result_filepaths = []
-
-    for root, _, files in os.walk(results_path):
-        # We should only have json files in model results
-        if len(files) == 0 or any([not f.endswith(".json") for f in files]):
+            # Skip rows that can't be parsed
             continue
 
-        # Sort the files by date
-        try:
-            files.sort(key=lambda x: x.removesuffix(".json").removeprefix("results_")[:-7])
-        except dateutil.parser._parser.ParserError:
-            files = [files[-1]]
-
-        for file in files:
-            model_result_filepaths.append(os.path.join(root, file))
-
-    eval_results = {}
-    for model_result_filepath in model_result_filepaths:
-        # Creation of result
-        eval_result = EvalResult.init_from_json_file(model_result_filepath)
-        eval_result.update_with_request_file(requests_path)
-
-        # Store results of same eval together
-        eval_name = eval_result.eval_name
-        if eval_name in eval_results.keys():
-            eval_results[eval_name].results.update({k: v for k, v in eval_result.results.items() if v is not None})
-        else:
-            eval_results[eval_name] = eval_result
-
-    results = []
-    for v in eval_results.values():
-        try:
-            v.to_dict() # we test if the dict version is complete
-            results.append(v)
-        except KeyError:  # not all eval values present
-            continue
+    return entries
+
+
+def tabular_leaderboard_to_dataframe(entries: list[TabularLeaderboardEntry]) -> pd.DataFrame:
+    """Convert a list of TabularLeaderboardEntry objects to a DataFrame."""
+    if not entries:
+        return pd.DataFrame(
+            columns=[
+                "experiment_id",
+                "Agent",
+                "LLM(s) used",
+                "mean_normalized_score",
+                "std_normalized_score",
+                "mean_medal_pct",
+                "sem_medal_pct",
+                "Date",
+            ]
+        )
 
-    return results
+    data = [entry.to_dict() for entry in entries]
+    return pd.DataFrame(data)

src/populate.py

@@ -1,58 +0,0 @@
-import json
-import os
-
-import pandas as pd
-
-from src.display.formatting import has_no_nan_values, make_clickable_model
-from src.display.utils import AutoEvalColumn, EvalQueueColumn
-from src.leaderboard.read_evals import get_raw_eval_results
-
-
-def get_leaderboard_df(results_path: str, requests_path: str, cols: list, benchmark_cols: list) -> pd.DataFrame:
-    """Creates a dataframe from all the individual experiment results"""
-    raw_data = get_raw_eval_results(results_path, requests_path)
-    all_data_json = [v.to_dict() for v in raw_data]
-
-    df = pd.DataFrame.from_records(all_data_json)
-    df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
-    df = df[cols].round(decimals=2)
-
-    # filter out if any of the benchmarks have not been produced
-    df = df[has_no_nan_values(df, benchmark_cols)]
-    return df
-
-
-def get_evaluation_queue_df(save_path: str, cols: list) -> list[pd.DataFrame]:
-    """Creates the different dataframes for the evaluation queues requestes"""
-    entries = [entry for entry in os.listdir(save_path) if not entry.startswith(".")]
-    all_evals = []
-
-    for entry in entries:
-        if ".json" in entry:
-            file_path = os.path.join(save_path, entry)
-            with open(file_path) as fp:
-                data = json.load(fp)
-
-            data[EvalQueueColumn.model.name] = make_clickable_model(data["model"])
-            data[EvalQueueColumn.revision.name] = data.get("revision", "main")
-
-            all_evals.append(data)
-        elif ".md" not in entry:
-            # this is a folder
-            sub_entries = [e for e in os.listdir(f"{save_path}/{entry}") if os.path.isfile(e) and not e.startswith(".")]
-            for sub_entry in sub_entries:
-                file_path = os.path.join(save_path, entry, sub_entry)
-                with open(file_path) as fp:
-                    data = json.load(fp)
-
-                data[EvalQueueColumn.model.name] = make_clickable_model(data["model"])
-                data[EvalQueueColumn.revision.name] = data.get("revision", "main")
-                all_evals.append(data)
-
-    pending_list = [e for e in all_evals if e["status"] in ["PENDING", "RERUN"]]
-    running_list = [e for e in all_evals if e["status"] == "RUNNING"]
-    finished_list = [e for e in all_evals if e["status"].startswith("FINISHED") or e["status"] == "PENDING_NEW_EVAL"]
-    df_pending = pd.DataFrame.from_records(pending_list, columns=cols)
-    df_running = pd.DataFrame.from_records(running_list, columns=cols)
-    df_finished = pd.DataFrame.from_records(finished_list, columns=cols)
-    return df_finished[cols], df_running[cols], df_pending[cols]

src/submission/check_validity.py

@@ -1,99 +0,0 @@
-import json
-import os
-import re
-from collections import defaultdict
-from datetime import datetime, timedelta, timezone
-
-import huggingface_hub
-from huggingface_hub import ModelCard
-from huggingface_hub.hf_api import ModelInfo
-from transformers import AutoConfig
-from transformers.models.auto.tokenization_auto import AutoTokenizer
-
-def check_model_card(repo_id: str) -> tuple[bool, str]:
-    """Checks if the model card and license exist and have been filled"""
-    try:
-        card = ModelCard.load(repo_id)
-    except huggingface_hub.utils.EntryNotFoundError:
-        return False, "Please add a model card to your model to explain how you trained/fine-tuned it."
-
-    # Enforce license metadata
-    if card.data.license is None:
-        if not ("license_name" in card.data and "license_link" in card.data):
-            return False, (
-                "License not found. Please add a license to your model card using the `license` metadata or a"
-                " `license_name`/`license_link` pair."
-            )
-
-    # Enforce card content
-    if len(card.text) < 200:
-        return False, "Please add a description to your model card, it is too short."
-
-    return True, ""
-
-def is_model_on_hub(model_name: str, revision: str, token: str = None, trust_remote_code=False, test_tokenizer=False) -> tuple[bool, str]:
-    """Checks if the model model_name is on the hub, and whether it (and its tokenizer) can be loaded with AutoClasses."""
-    try:
-        config = AutoConfig.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token)
-        if test_tokenizer:
-            try:
-                tk = AutoTokenizer.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token)
-            except ValueError as e:
-                return (
-                    False,
-                    f"uses a tokenizer which is not in a transformers release: {e}",
-                    None
-                )
-            except Exception as e:
-                return (False, "'s tokenizer cannot be loaded. Is your tokenizer class in a stable transformers release, and correctly configured?", None)
-        return True, None, config
-
-    except ValueError:
-        return (
-            False,
-            "needs to be launched with `trust_remote_code=True`. For safety reason, we do not allow these models to be automatically submitted to the leaderboard.",
-            None
-        )
-
-    except Exception as e:
-        return False, "was not found on hub!", None
-
-
-def get_model_size(model_info: ModelInfo, precision: str):
-    """Gets the model size from the configuration, or the model name if the configuration does not contain the information."""
-    try:
-        model_size = round(model_info.safetensors["total"] / 1e9, 3)
-    except (AttributeError, TypeError):
-        return 0  # Unknown model sizes are indicated as 0, see NUMERIC_INTERVALS in app.py
-
-    size_factor = 8 if (precision == "GPTQ" or "gptq" in model_info.modelId.lower()) else 1
-    model_size = size_factor * model_size
-    return model_size
-
-def get_model_arch(model_info: ModelInfo):
-    """Gets the model architecture from the configuration"""
-    return model_info.config.get("architectures", "Unknown")
-
-def already_submitted_models(requested_models_dir: str) -> set[str]:
-    """Gather a list of already submitted models to avoid duplicates"""
-    depth = 1
-    file_names = []
-    users_to_submission_dates = defaultdict(list)
-
-    for root, _, files in os.walk(requested_models_dir):
-        current_depth = root.count(os.sep) - requested_models_dir.count(os.sep)
-        if current_depth == depth:
-            for file in files:
-                if not file.endswith(".json"):
-                    continue
-                with open(os.path.join(root, file), "r") as f:
-                    info = json.load(f)
-                    file_names.append(f"{info['model']}_{info['revision']}_{info['precision']}")
-
-                    # Select organisation
-                    if info["model"].count("/") == 0 or "submitted_time" not in info:
-                        continue
-                    organisation, _ = info["model"].split("/")
-                    users_to_submission_dates[organisation].append(info["submitted_time"])
-
-    return set(file_names), users_to_submission_dates

src/submission/submit.py

@@ -1,119 +0,0 @@
-import json
-import os
-from datetime import datetime, timezone
-
-from src.display.formatting import styled_error, styled_message, styled_warning
-from src.envs import API, EVAL_REQUESTS_PATH, TOKEN, QUEUE_REPO
-from src.submission.check_validity import (
-    already_submitted_models,
-    check_model_card,
-    get_model_size,
-    is_model_on_hub,
-)
-
-REQUESTED_MODELS = None
-USERS_TO_SUBMISSION_DATES = None
-
-def add_new_eval(
-    model: str,
-    base_model: str,
-    revision: str,
-    precision: str,
-    weight_type: str,
-    model_type: str,
-):
-    global REQUESTED_MODELS
-    global USERS_TO_SUBMISSION_DATES
-    if not REQUESTED_MODELS:
-        REQUESTED_MODELS, USERS_TO_SUBMISSION_DATES = already_submitted_models(EVAL_REQUESTS_PATH)
-
-    user_name = ""
-    model_path = model
-    if "/" in model:
-        user_name = model.split("/")[0]
-        model_path = model.split("/")[1]
-
-    precision = precision.split(" ")[0]
-    current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-    if model_type is None or model_type == "":
-        return styled_error("Please select a model type.")
-
-    # Does the model actually exist?
-    if revision == "":
-        revision = "main"
-
-    # Is the model on the hub?
-    if weight_type in ["Delta", "Adapter"]:
-        base_model_on_hub, error, _ = is_model_on_hub(model_name=base_model, revision=revision, token=TOKEN, test_tokenizer=True)
-        if not base_model_on_hub:
-            return styled_error(f'Base model "{base_model}" {error}')
-
-    if not weight_type == "Adapter":
-        model_on_hub, error, _ = is_model_on_hub(model_name=model, revision=revision, token=TOKEN, test_tokenizer=True)
-        if not model_on_hub:
-            return styled_error(f'Model "{model}" {error}')
-
-    # Is the model info correctly filled?
-    try:
-        model_info = API.model_info(repo_id=model, revision=revision)
-    except Exception:
-        return styled_error("Could not get your model information. Please fill it up properly.")
-
-    model_size = get_model_size(model_info=model_info, precision=precision)
-
-    # Were the model card and license filled?
-    try:
-        license = model_info.cardData["license"]
-    except Exception:
-        return styled_error("Please select a license for your model")
-
-    modelcard_OK, error_msg = check_model_card(model)
-    if not modelcard_OK:
-        return styled_error(error_msg)
-
-    # Seems good, creating the eval
-    print("Adding new eval")
-
-    eval_entry = {
-        "model": model,
-        "base_model": base_model,
-        "revision": revision,
-        "precision": precision,
-        "weight_type": weight_type,
-        "status": "PENDING",
-        "submitted_time": current_time,
-        "model_type": model_type,
-        "likes": model_info.likes,
-        "params": model_size,
-        "license": license,
-        "private": False,
-    }
-
-    # Check for duplicate submission
-    if f"{model}_{revision}_{precision}" in REQUESTED_MODELS:
-        return styled_warning("This model has been already submitted.")
-
-    print("Creating eval file")
-    OUT_DIR = f"{EVAL_REQUESTS_PATH}/{user_name}"
-    os.makedirs(OUT_DIR, exist_ok=True)
-    out_path = f"{OUT_DIR}/{model_path}_eval_request_False_{precision}_{weight_type}.json"
-
-    with open(out_path, "w") as f:
-        f.write(json.dumps(eval_entry))
-
-    print("Uploading eval file")
-    API.upload_file(
-        path_or_fileobj=out_path,
-        path_in_repo=out_path.split("eval-queue/")[1],
-        repo_id=QUEUE_REPO,
-        repo_type="dataset",
-        commit_message=f"Add {model} to eval queue",
-    )
-
-    # Remove the local file
-    os.remove(out_path)
-
-    return styled_message(
-        "Your request has been submitted to the evaluation queue!\nPlease wait for up to an hour for the model to show in the PENDING list."
-    )

tests/test_leaderboard.py

@@ -1,5 +1,3 @@
-"""Unit tests for leaderboard functionality."""
-
 import base64
 from unittest.mock import Mock, patch
 
@@ -8,6 +6,7 @@ import pytest
 import requests
 
 from app import DISPLAY_COLUMNS, download_leaderboard, refresh_leaderboard
+from src.leaderboard.read_evals import TabularLeaderboardEntry
 
 
 def create_github_api_response(csv_content, is_lfs_pointer=False, use_download_url=False):
@@ -86,12 +85,12 @@ class TestDownloadLeaderboard:
         mock_get.side_effect = mock_responses
 
         # Execute
-        df = download_leaderboard()
+        entries = download_leaderboard()
 
         # Assertions
-        assert isinstance(df, pd.DataFrame)
-        assert len(df) == 3
-        assert list(df.columns) == DISPLAY_COLUMNS
+        assert isinstance(entries, list)
+        assert len(entries) == 3
+        assert all(isinstance(entry, TabularLeaderboardEntry) for entry in entries)
         assert mock_get.call_count == 1
 
     @patch("app.requests.get")
@@ -100,15 +99,15 @@ class TestDownloadLeaderboard:
         mock_responses = create_github_api_response(sample_csv_data)
         mock_get.side_effect = mock_responses
 
-        df = download_leaderboard()
+        entries = download_leaderboard()
 
-        # Check rounding
-        assert df["mean_normalized_score"].dtype in [float, "float64"]
-        assert df["std_normalized_score"].dtype in [float, "float64"]
-        # Values should be rounded to 3 decimal places
-        assert df.loc[0, "mean_normalized_score"] == 0.912
-        assert df.loc[1, "mean_normalized_score"] == 0.854
-        assert df.loc[2, "mean_normalized_score"] == 0.789
+        # Check rounding - entries are sorted by score descending
+        assert entries[0].mean_normalized_score == 0.912
+        assert entries[1].mean_normalized_score == 0.854
+        assert entries[2].mean_normalized_score == 0.789
+        # Check that scores are floats
+        assert isinstance(entries[0].mean_normalized_score, float)
+        assert isinstance(entries[0].std_normalized_score, float)
 
     @patch("app.requests.get")
     def test_percentage_conversion(self, mock_get, sample_csv_data):
@@ -116,12 +115,13 @@ class TestDownloadLeaderboard:
         mock_responses = create_github_api_response(sample_csv_data)
         mock_get.side_effect = mock_responses
 
-        df = download_leaderboard()
+        entries = download_leaderboard()
 
         # Check percentage conversion (0.876543 * 100 = 87.6543, rounded to 87.7)
-        assert df.loc[1, "mean_medal_pct"] == 87.7
-        assert df.loc[0, "mean_medal_pct"] == 92.3
-        assert df.loc[2, "mean_medal_pct"] == 76.5
+        # Entries are sorted by score descending: exp_003 (92.3), exp_001 (87.7), exp_002 (76.5)
+        assert entries[0].mean_medal_pct == 92.3  # exp_003
+        assert entries[1].mean_medal_pct == 87.7  # exp_001
+        assert entries[2].mean_medal_pct == 76.5  # exp_002
 
     @patch("app.requests.get")
     def test_date_formatting(self, mock_get, sample_csv_data):
@@ -129,26 +129,27 @@ class TestDownloadLeaderboard:
         mock_responses = create_github_api_response(sample_csv_data)
         mock_get.side_effect = mock_responses
 
-        df = download_leaderboard()
+        entries = download_leaderboard()
 
-        # Check date formatting
-        assert df.loc[0, "Date"] == "2024-02-01"
-        assert df.loc[1, "Date"] == "2024-01-15"
-        assert df.loc[2, "Date"] == "2024-01-20"
+        # Check date formatting - entries sorted by score descending
+        # exp_003 (2024-02-01), exp_001 (2024-01-15), exp_002 (2024-01-20)
+        assert entries[0].date == "2024-02-01"
+        assert entries[1].date == "2024-01-15"
+        assert entries[2].date == "2024-01-20"
 
     @patch("app.requests.get")
     def test_sorting(self, mock_get, sample_csv_data):
-        """Test that dataframe is sorted by mean_normalized_score descending."""
+        """Test that entries are sorted by mean_normalized_score descending."""
         mock_responses = create_github_api_response(sample_csv_data)
         mock_get.side_effect = mock_responses
 
-        df = download_leaderboard()
+        entries = download_leaderboard()
 
         # Check sorting (highest score first)
-        scores = df["mean_normalized_score"].tolist()
+        scores = [entry.mean_normalized_score for entry in entries]
         assert scores == sorted(scores, reverse=True)
-        assert df.loc[0, "experiment_id"] == "exp_003"  # Highest score
-        assert df.loc[2, "experiment_id"] == "exp_002"  # Lowest score
+        assert entries[0].experiment_id == "exp_003"  # Highest score
+        assert entries[2].experiment_id == "exp_002"  # Lowest score
 
     @patch("app.requests.get")
     def test_extra_columns_filtered(self, mock_get, sample_csv_with_extra_columns):
@@ -156,11 +157,14 @@ class TestDownloadLeaderboard:
         mock_responses = create_github_api_response(sample_csv_with_extra_columns)
         mock_get.side_effect = mock_responses
 
-        df = download_leaderboard()
+        entries = download_leaderboard()
 
-        # Check that only display columns are present
-        assert list(df.columns) == DISPLAY_COLUMNS
-        assert "extra_col" not in df.columns
+        # Check that entries are created correctly (extra columns should be filtered before parsing)
+        assert len(entries) == 2
+        assert all(isinstance(entry, TabularLeaderboardEntry) for entry in entries)
+        # Verify the data model doesn't have extra columns by converting to dict
+        entry_dict = entries[0].to_dict()
+        assert "extra_col" not in entry_dict
 
     @patch("app.requests.get")
     def test_missing_columns_error(self, mock_get, sample_csv_missing_columns):
@@ -211,11 +215,10 @@ class TestDownloadLeaderboard:
         mock_responses = create_github_api_response(csv_data)
         mock_get.side_effect = mock_responses
 
-        df = download_leaderboard()
+        entries = download_leaderboard()
 
-        assert isinstance(df, pd.DataFrame)
-        assert len(df) == 0
-        assert list(df.columns) == DISPLAY_COLUMNS
+        assert isinstance(entries, list)
+        assert len(entries) == 0
 
     @patch("app.requests.get")
     def test_invalid_date_handling(self, mock_get):
@@ -226,11 +229,13 @@ exp_002,0.789012,0.023456,0.765432,0.012345,Agent B,Claude-3,2024-01-20"""
         mock_responses = create_github_api_response(csv_with_invalid_date)
         mock_get.side_effect = mock_responses
 
-        df = download_leaderboard()
+        entries = download_leaderboard()
 
-        # Invalid dates should become NaT and then empty string or NaN
-        assert pd.isna(df.loc[0, "Date"]) or df.loc[0, "Date"] == ""
-        assert df.loc[1, "Date"] == "2024-01-20"
+        # Invalid dates should become NaT and then empty string
+        # Find entries by experiment_id since order may vary
+        entry_dict = {entry.experiment_id: entry for entry in entries}
+        assert entry_dict["exp_001"].date == "nan"
+        assert entry_dict["exp_002"].date == "2024-01-20"
 
     @patch("app.requests.get")
     def test_git_lfs_pointer_file(self, mock_get, sample_csv_data):
@@ -244,12 +249,12 @@ exp_002,0.789012,0.023456,0.765432,0.012345,Agent B,Claude-3,2024-01-20"""
         mock_responses.append(download_response)
         mock_get.side_effect = mock_responses
 
-        df = download_leaderboard()
+        entries = download_leaderboard()
 
         # Should successfully download via download_url
-        assert isinstance(df, pd.DataFrame)
-        assert len(df) == 3
-        assert list(df.columns) == DISPLAY_COLUMNS
+        assert isinstance(entries, list)
+        assert len(entries) == 3
+        assert all(isinstance(entry, TabularLeaderboardEntry) for entry in entries)
         # Should make 2 calls: API call + download_url call
         assert mock_get.call_count == 2
 
@@ -259,11 +264,11 @@ exp_002,0.789012,0.023456,0.765432,0.012345,Agent B,Claude-3,2024-01-20"""
         mock_responses = create_github_api_response(sample_csv_data, use_download_url=True)
         mock_get.side_effect = mock_responses
 
-        df = download_leaderboard()
+        entries = download_leaderboard()
 
-        assert isinstance(df, pd.DataFrame)
-        assert len(df) == 3
-        assert list(df.columns) == DISPLAY_COLUMNS
+        assert isinstance(entries, list)
+        assert len(entries) == 3
+        assert all(isinstance(entry, TabularLeaderboardEntry) for entry in entries)
         # Should make 2 calls: API call + download_url call
         assert mock_get.call_count == 2
 
@@ -271,10 +276,22 @@ exp_002,0.789012,0.023456,0.765432,0.012345,Agent B,Claude-3,2024-01-20"""
 class TestRefreshLeaderboard:
     """Tests for refresh_leaderboard function."""
 
+    @patch("app.tabular_leaderboard_to_dataframe")
     @patch("app.download_leaderboard")
-    def test_refresh_leaderboard_success(self, mock_download):
+    def test_refresh_leaderboard_success(self, mock_download, mock_to_df):
         """Test that refresh_leaderboard returns dataframe and status message."""
         # Setup mocks
+        mock_entry = TabularLeaderboardEntry(
+            experiment_id="exp_001",
+            agent="Agent A",
+            llms_used="GPT-4",
+            mean_normalized_score=0.85,
+            std_normalized_score=0.01,
+            mean_medal_pct=87.0,
+            sem_medal_pct=1.0,
+            date="2024-01-15",
+        )
+        mock_entries = [mock_entry]
         mock_df = pd.DataFrame(
             {
                 "experiment_id": ["exp_001"],
@@ -282,13 +299,14 @@ class TestRefreshLeaderboard:
                 "Agent": ["Agent A"],
             }
         )
-        mock_download.return_value = mock_df
+        mock_download.return_value = mock_entries
+        mock_to_df.return_value = mock_df
 
         # Execute
         df, status = refresh_leaderboard()
 
         # Assertions
-        assert df is mock_df
+        assert isinstance(df, pd.DataFrame)
         assert "Showing data from" in status
         assert "GitHub" in status
         # Check that status contains timestamp in expected format (YYYY-MM-DD HH:MM UTC)
@@ -300,12 +318,16 @@ class TestRefreshLeaderboard:
         timestamp_pattern = r"\d{4}-\d{2}-\d{2} \d{2}:\d{2} UTC"
         assert re.search(timestamp_pattern, status) is not None
         mock_download.assert_called_once()
+        mock_to_df.assert_called_once_with(mock_entries)
 
+    @patch("app.tabular_leaderboard_to_dataframe")
     @patch("app.download_leaderboard")
-    def test_refresh_leaderboard_includes_url(self, mock_download):
+    def test_refresh_leaderboard_includes_url(self, mock_download, mock_to_df):
         """Test that status message includes the GitHub URL."""
+        mock_entries = []
         mock_df = pd.DataFrame()
-        mock_download.return_value = mock_df
+        mock_download.return_value = mock_entries
+        mock_to_df.return_value = mock_df
 
         df, status = refresh_leaderboard()