Removed debug code in refresh.py intended to only update one board (#20)

* Removed debug code in refresh.py intended to only update one board

I additionally removed types from docstring (some were lying) and added types where I could guess them to make it easier to debug the code in the future.

Also added a minor description to the readme for ease of navigation.

* Added import for type annotations

* Ensure that the reset_index happens inplace

* Avoid adding duplicates in refresh.py

README.md

@@ -12,3 +12,23 @@ tags:
 startup_duration_timeout: 1h
 fullWidth: true
 ---
+
+## The MTEB Leaderboard repository
+
+This repository contains the code for pushing and updating the MTEB leaderboard daily. 
+
+| Relevant Links                                                | Decription                                                                                                                                                                                                |
+|------------------------------------------|------------------------------|
+| [mteb](https://github.com/embeddings-benchmark/mteb)          | The implementation of the benchmark. Here you e.g. find the code to run your model on the benchmark.                                                                                                      |
+| [leaderboard](https://huggingface.co/spaces/mteb/leaderboard) | The leaderboard itself, here you can view results of model run on MTEB.                                                                                                                                   |
+| [results](https://github.com/embeddings-benchmark/results)    | The results of MTEB is stored here. Though you can publish them to the leaderboard [adding](https://github.com/embeddings-benchmark/mteb/blob/main/docs/adding_a_model.md) the result to your model card. |
+
+## Developer setup
+
+To setup the repository:
+
+```         
+git clone {repo_url}
+# potentially create virtual environment using python 3.9
+pip install -r requirements.txt
+```

refresh.py

@@ -1,17 +1,19 @@
-from functools import reduce
+from __future__ import annotations
+
 import json
 import os
 import re
+from functools import reduce
+from typing import Any
 
+import pandas as pd
 from datasets import load_dataset
 from huggingface_hub import hf_hub_download
 from huggingface_hub.repocard import metadata_load
-import pandas as pd
 from tqdm.autonotebook import tqdm
 
+from envs import API, LEADERBOARD_CONFIG, MODEL_META, REPO_ID, RESULTS_REPO
 from utils.model_size import get_model_parameters_memory
-from envs import LEADERBOARD_CONFIG, MODEL_META, REPO_ID, RESULTS_REPO, API
-
 
 MODEL_CACHE = {}
 TASKS_CONFIG = LEADERBOARD_CONFIG["tasks"]
@@ -34,21 +36,44 @@ TASK_TO_METRIC["PairClassification"].append("cos_sim_ap")
 TASK_TO_METRIC["PairClassification"].append("cosine_ap")
 
 
-EXTERNAL_MODELS = {k for k,v in MODEL_META["model_meta"].items() if v.get("is_external", False)}
-EXTERNAL_MODEL_TO_LINK = {k: v["link"] for k,v in MODEL_META["model_meta"].items() if v.get("link", False)}
-EXTERNAL_MODEL_TO_DIM = {k: v["dim"] for k,v in MODEL_META["model_meta"].items() if v.get("dim", False)}
-EXTERNAL_MODEL_TO_SEQLEN = {k: v["seq_len"] for k,v in MODEL_META["model_meta"].items() if v.get("seq_len", False)}
-EXTERNAL_MODEL_TO_SIZE = {k: v["size"] for k,v in MODEL_META["model_meta"].items() if v.get("size", False)}
-PROPRIETARY_MODELS = {k for k,v in MODEL_META["model_meta"].items() if v.get("is_proprietary", False)}
-TASK_DESCRIPTIONS = {k: v["task_description"] for k,v in TASKS_CONFIG.items()}
+EXTERNAL_MODELS = {
+    k for k, v in MODEL_META["model_meta"].items() if v.get("is_external", False)
+}
+EXTERNAL_MODEL_TO_LINK = {
+    k: v["link"] for k, v in MODEL_META["model_meta"].items() if v.get("link", False)
+}
+EXTERNAL_MODEL_TO_DIM = {
+    k: v["dim"] for k, v in MODEL_META["model_meta"].items() if v.get("dim", False)
+}
+EXTERNAL_MODEL_TO_SEQLEN = {
+    k: v["seq_len"]
+    for k, v in MODEL_META["model_meta"].items()
+    if v.get("seq_len", False)
+}
+EXTERNAL_MODEL_TO_SIZE = {
+    k: v["size"] for k, v in MODEL_META["model_meta"].items() if v.get("size", False)
+}
+PROPRIETARY_MODELS = {
+    k for k, v in MODEL_META["model_meta"].items() if v.get("is_proprietary", False)
+}
+TASK_DESCRIPTIONS = {k: v["task_description"] for k, v in TASKS_CONFIG.items()}
 TASK_DESCRIPTIONS["Overall"] = "Overall performance across MTEB tasks."
-SENTENCE_TRANSFORMERS_COMPATIBLE_MODELS = {k for k,v in MODEL_META["model_meta"].items() if v.get("is_sentence_transformers_compatible", False)}
+SENTENCE_TRANSFORMERS_COMPATIBLE_MODELS = {
+    k
+    for k, v in MODEL_META["model_meta"].items()
+    if v.get("is_sentence_transformers_compatible", False)
+}
 MODELS_TO_SKIP = MODEL_META["models_to_skip"]
 CROSS_ENCODERS = MODEL_META["cross_encoders"]
-BI_ENCODERS = [k for k, _ in MODEL_META["model_meta"].items() if k not in CROSS_ENCODERS + ["bm25"]]
-INSTRUCT_MODELS = {k for k,v in MODEL_META["model_meta"].items() if v.get("uses_instruct", False)}
-NOINSTRUCT_MODELS = {k for k,v in MODEL_META["model_meta"].items() if not v.get("uses_instruct", False)}
-
+BI_ENCODERS = [
+    k for k, _ in MODEL_META["model_meta"].items() if k not in CROSS_ENCODERS + ["bm25"]
+]
+INSTRUCT_MODELS = {
+    k for k, v in MODEL_META["model_meta"].items() if v.get("uses_instruct", False)
+}
+NOINSTRUCT_MODELS = {
+    k for k, v in MODEL_META["model_meta"].items() if not v.get("uses_instruct", False)
+}
 
 
 TASK_TO_TASK_TYPE = {task_category: [] for task_category in TASKS}
@@ -64,12 +89,28 @@ MODEL_INFOS = {}
 #     with open(model_infos_path) as f:
 #         MODEL_INFOS = json.load(f)
 
-def add_rank(df):
-    cols_to_rank = [col for col in df.columns if col not in ["Model", "Model Size (Million Parameters)", "Memory Usage (GB, fp32)", "Embedding Dimensions", "Max Tokens"]]
+
+def add_rank(df: pd.DataFrame) -> pd.DataFrame:
+    cols_to_rank = [
+        col
+        for col in df.columns
+        if col
+        not in [
+            "Model",
+            "Model Size (Million Parameters)",
+            "Memory Usage (GB, fp32)",
+            "Embedding Dimensions",
+            "Max Tokens",
+        ]
+    ]
     if len(cols_to_rank) == 1:
         df.sort_values(cols_to_rank[0], ascending=False, inplace=True)
     else:
-        df.insert(len(df.columns) - len(cols_to_rank), "Average", df[cols_to_rank].mean(axis=1, skipna=False))
+        df.insert(
+            len(df.columns) - len(cols_to_rank),
+            "Average",
+            df[cols_to_rank].mean(axis=1, skipna=False),
+        )
         df.sort_values("Average", ascending=False, inplace=True)
     df.insert(0, "Rank", list(range(1, len(df) + 1)))
     df = df.round(2)
@@ -78,23 +119,26 @@ def add_rank(df):
     return df
 
 
-def make_clickable_model(model_name, link=None):
+def make_clickable_model(model_name: str, link: None | str = None) -> str:
     if link is None:
         link = "https://huggingface.co/" + model_name
     # Remove user from model name
-    return (
-        f'<a target="_blank" style="text-decoration: underline" href="{link}">{model_name.split("/")[-1]}</a>'
-    )
+    return f'<a target="_blank" style="text-decoration: underline" href="{link}">{model_name.split("/")[-1]}</a>'
 
 
 def add_lang(examples):
-    if not(examples["eval_language"]) or (examples["eval_language"] == "default"):
+    if not (examples["eval_language"]) or (examples["eval_language"] == "default"):
         examples["mteb_dataset_name_with_lang"] = examples["mteb_dataset_name"]
     else:
-        examples["mteb_dataset_name_with_lang"] = examples["mteb_dataset_name"] + f' ({examples["eval_language"]})'
+        examples["mteb_dataset_name_with_lang"] = (
+            examples["mteb_dataset_name"] + f' ({examples["eval_language"]})'
+        )
     return examples
 
-def norm(names): return set([name.split(" ")[0] for name in names])
+
+def norm(names: str) -> set:
+    return set([name.split(" ")[0] for name in names])
+
 
 def add_task(examples):
     # Could be added to the dataset loading script instead
@@ -111,16 +155,22 @@ def add_task(examples):
         examples["mteb_task"] = "Unknown"
     return examples
 
-def filter_metric_external(x, task, metrics):
-    # This is a hack for the passkey and needle retrieval test, which reports ndcg_at_1 (i.e. accuracy), rather than the ndcg_at_10 that is commonly used for retrieval tasks. 
-    if x['mteb_dataset_name'] in ['LEMBNeedleRetrieval', 'LEMBPasskeyRetrieval']:
-        return x["mteb_task"] == task and x['metric'] == 'ndcg_at_1'
+
+def filter_metric_external(x, task, metrics) -> bool:
+    # This is a hack for the passkey and needle retrieval test, which reports ndcg_at_1 (i.e. accuracy), rather than the ndcg_at_10 that is commonly used for retrieval tasks.
+    if x["mteb_dataset_name"] in ["LEMBNeedleRetrieval", "LEMBPasskeyRetrieval"]:
+        return bool(x["mteb_task"] == task and x["metric"] == "ndcg_at_1")
     else:
-        return x["mteb_task"] == task and x["metric"] in metrics
+        return bool(x["mteb_task"] == task and x["metric"] in metrics)
+
 
-def filter_metric_fetched(name, metric, expected_metrics):
-    # This is a hack for the passkey and needle retrieval test, which reports ndcg_at_1 (i.e. accuracy), rather than the ndcg_at_10 that is commonly used for retrieval tasks. 
-    return metric == 'ndcg_at_1' if name in ['LEMBNeedleRetrieval', 'LEMBPasskeyRetrieval'] else metric in expected_metrics
+def filter_metric_fetched(name: str, metric: str, expected_metrics) -> bool:
+    # This is a hack for the passkey and needle retrieval test, which reports ndcg_at_1 (i.e. accuracy), rather than the ndcg_at_10 that is commonly used for retrieval tasks.
+    return bool(
+        metric == "ndcg_at_1"
+        if name in ["LEMBNeedleRetrieval", "LEMBPasskeyRetrieval"]
+        else metric in expected_metrics
+    )
 
 
 def get_dim_seq_size(model):
@@ -139,12 +189,20 @@ def get_dim_seq_size(model):
         config_path = hf_hub_download(model.modelId, filename="config.json")
         config = json.load(open(config_path))
         if not dim:
-            dim = config.get("hidden_dim", config.get("hidden_size", config.get("d_model", "")))
-        seq = config.get("n_positions", config.get("max_position_embeddings", config.get("n_ctx", config.get("seq_length", ""))))
-    
+            dim = config.get(
+                "hidden_dim", config.get("hidden_size", config.get("d_model", ""))
+            )
+        seq = config.get(
+            "n_positions",
+            config.get(
+                "max_position_embeddings",
+                config.get("n_ctx", config.get("seq_length", "")),
+            ),
+        )
+
     if dim == "" or seq == "":
         raise Exception(f"Could not find dim or seq for model {model.modelId}")
-    
+
     # Get model file size without downloading. Parameters in million parameters and memory in GB
     parameters, memory = get_model_parameters_memory(model)
     return dim, seq, parameters, memory
@@ -159,27 +217,54 @@ def get_external_model_results():
         for model in EXTERNAL_MODELS:
             if model not in EXTERNAL_MODEL_RESULTS:
                 models_to_run.append(model)
-                EXTERNAL_MODEL_RESULTS[model] = {k: {v[0]: []} for k, v in TASK_TO_METRIC.items()}
+                EXTERNAL_MODEL_RESULTS[model] = {
+                    k: {v[0]: []} for k, v in TASK_TO_METRIC.items()
+                }
 
     ## only if we want to re-calculate all instead of using the cache... it's likely they haven't changed
     ## but if your model results have changed, delete it from the "EXTERNAL_MODEL_RESULTS.json" file
     else:
-        EXTERNAL_MODEL_RESULTS = {model: {k: {v[0]: []} for k, v in TASK_TO_METRIC.items()} for model in EXTERNAL_MODELS}
+        EXTERNAL_MODEL_RESULTS = {
+            model: {k: {v[0]: []} for k, v in TASK_TO_METRIC.items()}
+            for model in EXTERNAL_MODELS
+        }
         models_to_run = EXTERNAL_MODELS
 
     pbar = tqdm(models_to_run, desc="Fetching external model results")
     for model in pbar:
         pbar.set_description(f"Fetching external model results for {model!r}")
-        ds = load_dataset(RESULTS_REPO, model, trust_remote_code=True, download_mode='force_redownload', verification_mode="no_checks")
+        ds = load_dataset(
+            RESULTS_REPO,
+            model,
+            trust_remote_code=True,
+            download_mode="force_redownload",
+            verification_mode="no_checks",
+        )
         ds = ds.map(add_lang)
         ds = ds.map(add_task)
-        base_dict = {"Model": make_clickable_model(model, link=EXTERNAL_MODEL_TO_LINK.get(model, f"https://huggingface.co/spaces/{REPO_ID}"))}
+        base_dict = {
+            "Model": make_clickable_model(
+                model,
+                link=EXTERNAL_MODEL_TO_LINK.get(
+                    model, f"https://huggingface.co/spaces/{REPO_ID}"
+                ),
+            )
+        }
 
         for task, metrics in TASK_TO_METRIC.items():
-            ds_dict = ds.filter(lambda x: filter_metric_external(x, task, metrics))["test"].to_dict()
-            ds_dict = {k: round(v, 2) for k, v in zip(ds_dict["mteb_dataset_name_with_lang"], ds_dict["score"])}
+            ds_dict = ds.filter(lambda x: filter_metric_external(x, task, metrics))[
+                "test"
+            ].to_dict()
+            ds_dict = {
+                k: round(v, 2)
+                for k, v in zip(
+                    ds_dict["mteb_dataset_name_with_lang"], ds_dict["score"]
+                )
+            }
             # metrics[0] is the main name for this metric; other names in the list are legacy for backward-compat
-            EXTERNAL_MODEL_RESULTS[model][task][metrics[0]].append({**base_dict, **ds_dict})
+            EXTERNAL_MODEL_RESULTS[model][task][metrics[0]].append(
+                {**base_dict, **ds_dict}
+            )
 
     # Save & cache EXTERNAL_MODEL_RESULTS
     with open("EXTERNAL_MODEL_RESULTS.json", "w") as f:
@@ -188,7 +273,7 @@ def get_external_model_results():
     return EXTERNAL_MODEL_RESULTS
 
 
-def download_or_use_cache(modelId):
+def download_or_use_cache(modelId: str):
     global MODEL_CACHE
     if modelId in MODEL_CACHE:
         return MODEL_CACHE[modelId]
@@ -202,7 +287,15 @@ def download_or_use_cache(modelId):
     return meta
 
 
-def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_emb_dim=True, task_to_metric=TASK_TO_METRIC, rank=True):
+def get_mteb_data(
+    tasks: list = ["Clustering"],
+    langs: list = [],
+    datasets: list = [],
+    fillna: bool = True,
+    add_emb_dim: bool = True,
+    task_to_metric: dict = TASK_TO_METRIC,
+    rank: bool = True,
+) -> pd.DataFrame:
     global MODEL_INFOS
 
     with open("EXTERNAL_MODEL_RESULTS.json", "r") as f:
@@ -211,46 +304,62 @@ def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_
     api = API
     models = list(api.list_models(filter="mteb"))
     # Legacy names changes; Also fetch the old results & merge later
-    if ('MLSUMClusteringP2P (fr)' in datasets):
-        datasets.append('MLSUMClusteringP2P')
-    if ('MLSUMClusteringS2S (fr)' in datasets):
-        datasets.append('MLSUMClusteringS2S')
-    if ('PawsXPairClassification (fr)' in datasets):
-        datasets.append('PawsX (fr)')
+    if "MLSUMClusteringP2P (fr)" in datasets:
+        datasets.append("MLSUMClusteringP2P")
+    if "MLSUMClusteringS2S (fr)" in datasets:
+        datasets.append("MLSUMClusteringS2S")
+    if "PawsXPairClassification (fr)" in datasets:
+        datasets.append("PawsX (fr)")
     # Initialize list to models that we cannot fetch metadata from
     df_list = []
     for model in external_model_results:
         results_list = []
         for task in tasks:
             # Not all models have InstructionRetrieval, other new tasks
-            if task not in external_model_results[model]: continue
+            if task not in external_model_results[model]:
+                continue
             results_list += external_model_results[model][task][task_to_metric[task][0]]
-        
+
         if len(datasets) > 0:
-            res = {k: v for d in results_list for k, v in d.items() if (k == "Model") or any([x in k for x in datasets])}
+            res = {
+                k: v
+                for d in results_list
+                for k, v in d.items()
+                if (k == "Model") or any([x in k for x in datasets])
+            }
         elif langs:
             # Would be cleaner to rely on an extra language column instead
             langs_format = [f"({lang})" for lang in langs]
-            res = {k: v for d in results_list for k, v in d.items() if any([k.split(" ")[-1] in (k, x) for x in langs_format])}
+            res = {
+                k: v
+                for d in results_list
+                for k, v in d.items()
+                if any([k.split(" ")[-1] in (k, x) for x in langs_format])
+            }
         else:
             res = {k: v for d in results_list for k, v in d.items()}
         # Model & at least one result
         if len(res) > 1:
             if add_emb_dim:
-                res["Model Size (Million Parameters)"] = EXTERNAL_MODEL_TO_SIZE.get(model, "")
-                res["Memory Usage (GB, fp32)"] = round(res["Model Size (Million Parameters)"] * 1e6 * 4 / 1024**3, 2) if res["Model Size (Million Parameters)"] != "" else ""
+                res["Model Size (Million Parameters)"] = EXTERNAL_MODEL_TO_SIZE.get(
+                    model, ""
+                )
+                res["Memory Usage (GB, fp32)"] = (
+                    round(res["Model Size (Million Parameters)"] * 1e6 * 4 / 1024**3, 2)
+                    if res["Model Size (Million Parameters)"] != ""
+                    else ""
+                )
                 res["Embedding Dimensions"] = EXTERNAL_MODEL_TO_DIM.get(model, "")
                 res["Max Tokens"] = EXTERNAL_MODEL_TO_SEQLEN.get(model, "")
             df_list.append(res)
 
     pbar = tqdm(models, desc="Fetching model metadata")
     for model in pbar:
-        if model.modelId in MODELS_TO_SKIP: continue
+        if model.modelId in MODELS_TO_SKIP:
+            continue
         pbar.set_description(f"Fetching {model.modelId!r} metadata")
         meta = download_or_use_cache(model.modelId)
-        MODEL_INFOS[model.modelId] = {
-            "metadata": meta
-        }
+        MODEL_INFOS[model.modelId] = {"metadata": meta}
         if "model-index" not in meta:
             continue
         # meta['model-index'][0]["results"] is list of elements like:
@@ -269,13 +378,45 @@ def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_
         # },
         # Use "get" instead of dict indexing to skip incompat metadata instead of erroring out
         if len(datasets) > 0:
-            task_results = [sub_res for sub_res in meta["model-index"][0]["results"] if (sub_res.get("task", {}).get("type", "") in tasks) and any([x in sub_res.get("dataset", {}).get("name", "") for x in datasets])]
+            task_results = [
+                sub_res
+                for sub_res in meta["model-index"][0]["results"]
+                if (sub_res.get("task", {}).get("type", "") in tasks)
+                and any(
+                    [x in sub_res.get("dataset", {}).get("name", "") for x in datasets]
+                )
+            ]
         elif langs:
-            task_results = [sub_res for sub_res in meta["model-index"][0]["results"] if (sub_res.get("task", {}).get("type", "") in tasks) and (sub_res.get("dataset", {}).get("config", "default") in ("default", *langs))]
+            task_results = [
+                sub_res
+                for sub_res in meta["model-index"][0]["results"]
+                if (sub_res.get("task", {}).get("type", "") in tasks)
+                and (
+                    sub_res.get("dataset", {}).get("config", "default")
+                    in ("default", *langs)
+                )
+            ]
         else:
-            task_results = [sub_res for sub_res in meta["model-index"][0]["results"] if (sub_res.get("task", {}).get("type", "") in tasks)]
+            task_results = [
+                sub_res
+                for sub_res in meta["model-index"][0]["results"]
+                if (sub_res.get("task", {}).get("type", "") in tasks)
+            ]
         try:
-            out = [{res["dataset"]["name"].replace("MTEB ", ""): [round(score["value"], 2) for score in res["metrics"] if filter_metric_fetched(res["dataset"]["name"].replace("MTEB ", ""), score["type"], task_to_metric.get(res["task"]["type"]))][0]} for res in task_results]
+            out = [
+                {
+                    res["dataset"]["name"].replace("MTEB ", ""): [
+                        round(score["value"], 2)
+                        for score in res["metrics"]
+                        if filter_metric_fetched(
+                            res["dataset"]["name"].replace("MTEB ", ""),
+                            score["type"],
+                            task_to_metric.get(res["task"]["type"]),
+                        )
+                    ][0]
+                }
+                for res in task_results
+            ]
         except Exception as e:
             print("ERROR", model.modelId, e)
             continue
@@ -286,7 +427,9 @@ def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_
             if add_emb_dim:
                 # The except clause triggers on gated repos, we can use external metadata for those
                 try:
-                    MODEL_INFOS[model.modelId]["dim_seq_size"] = list(get_dim_seq_size(model))
+                    MODEL_INFOS[model.modelId]["dim_seq_size"] = list(
+                        get_dim_seq_size(model)
+                    )
                 except:
                     name_without_org = model.modelId.split("/")[-1]
                     # EXTERNAL_MODEL_TO_SIZE[name_without_org] refers to millions of parameters, so for memory usage
@@ -296,12 +439,29 @@ def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_
                         EXTERNAL_MODEL_TO_DIM.get(name_without_org, ""),
                         EXTERNAL_MODEL_TO_SEQLEN.get(name_without_org, ""),
                         EXTERNAL_MODEL_TO_SIZE.get(name_without_org, ""),
-                        round(EXTERNAL_MODEL_TO_SIZE[name_without_org] * 1e6 * 4 / 1024**3, 2) if name_without_org in EXTERNAL_MODEL_TO_SIZE else "",
+                        round(
+                            EXTERNAL_MODEL_TO_SIZE[name_without_org]
+                            * 1e6
+                            * 4
+                            / 1024**3,
+                            2,
+                        )
+                        if name_without_org in EXTERNAL_MODEL_TO_SIZE
+                        else "",
                     )
-                out["Embedding Dimensions"], out["Max Tokens"], out["Model Size (Million Parameters)"], out["Memory Usage (GB, fp32)"] = tuple(MODEL_INFOS[model.modelId]["dim_seq_size"])
+                (
+                    out["Embedding Dimensions"],
+                    out["Max Tokens"],
+                    out["Model Size (Million Parameters)"],
+                    out["Memory Usage (GB, fp32)"],
+                ) = tuple(MODEL_INFOS[model.modelId]["dim_seq_size"])
             df_list.append(out)
         model_siblings = model.siblings or []
-        if model.library_name == "sentence-transformers" or "sentence-transformers" in model.tags or "modules.json" in {file.rfilename for file in model_siblings}:
+        if (
+            model.library_name == "sentence-transformers"
+            or "sentence-transformers" in model.tags
+            or "modules.json" in {file.rfilename for file in model_siblings}
+        ):
             SENTENCE_TRANSFORMERS_COMPATIBLE_MODELS.add(out["Model"])
 
     # # Save & cache MODEL_INFOS
@@ -314,28 +474,39 @@ def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_
     df = df.groupby("Model", as_index=False).first()
     # Put 'Model' column first
     cols = sorted(list(df.columns))
-    base_columns = ["Model", "Model Size (Million Parameters)", "Memory Usage (GB, fp32)", "Embedding Dimensions", "Max Tokens"]
+    base_columns = [
+        "Model",
+        "Model Size (Million Parameters)",
+        "Memory Usage (GB, fp32)",
+        "Embedding Dimensions",
+        "Max Tokens",
+    ]
     if len(datasets) > 0:
         # Update legacy column names to be merged with newer ones
         # Update 'MLSUMClusteringP2P (fr)' with values from 'MLSUMClusteringP2P'
-        if ('MLSUMClusteringP2P (fr)' in datasets) and ('MLSUMClusteringP2P' in cols):
-            df['MLSUMClusteringP2P (fr)'] = df['MLSUMClusteringP2P (fr)'].fillna(df['MLSUMClusteringP2P'])
-            datasets.remove('MLSUMClusteringP2P')
-        if ('MLSUMClusteringS2S (fr)' in datasets) and ('MLSUMClusteringS2S' in cols):
-            df['MLSUMClusteringS2S (fr)'] = df['MLSUMClusteringS2S (fr)'].fillna(df['MLSUMClusteringS2S'])
-            datasets.remove('MLSUMClusteringS2S')
-        if ('PawsXPairClassification (fr)' in datasets) and ('PawsX (fr)' in cols):
-             # for the first bit no model has it, hence no column for it. We can remove this in a month or so
+        if ("MLSUMClusteringP2P (fr)" in datasets) and ("MLSUMClusteringP2P" in cols):
+            df["MLSUMClusteringP2P (fr)"] = df["MLSUMClusteringP2P (fr)"].fillna(
+                df["MLSUMClusteringP2P"]
+            )
+            datasets.remove("MLSUMClusteringP2P")
+        if ("MLSUMClusteringS2S (fr)" in datasets) and ("MLSUMClusteringS2S" in cols):
+            df["MLSUMClusteringS2S (fr)"] = df["MLSUMClusteringS2S (fr)"].fillna(
+                df["MLSUMClusteringS2S"]
+            )
+            datasets.remove("MLSUMClusteringS2S")
+        if ("PawsXPairClassification (fr)" in datasets) and ("PawsX (fr)" in cols):
+            # for the first bit no model has it, hence no column for it. We can remove this in a month or so
             if "PawsXPairClassification (fr)" not in cols:
-                df['PawsXPairClassification (fr)'] = df['PawsX (fr)']
+                df["PawsXPairClassification (fr)"] = df["PawsX (fr)"]
             else:
-                df['PawsXPairClassification (fr)'] = df['PawsXPairClassification (fr)'].fillna(df['PawsX (fr)'])
+                df["PawsXPairClassification (fr)"] = df[
+                    "PawsXPairClassification (fr)"
+                ].fillna(df["PawsX (fr)"])
             # make all the columns the same
-            datasets.remove('PawsX (fr)')
-            cols.remove('PawsX (fr)')
-            df.drop(columns=['PawsX (fr)'], inplace=True)
-            cols.append('PawsXPairClassification (fr)')
-            
+            datasets.remove("PawsX (fr)")
+            cols.remove("PawsX (fr)")
+            df.drop(columns=["PawsX (fr)"], inplace=True)
+
         # Filter invalid columns
         cols = [col for col in cols if col in base_columns + datasets]
     i = 0
@@ -345,7 +516,7 @@ def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_
             i += 1
     df = df[cols]
     if rank:
-        df = add_rank(df)       
+        df = add_rank(df)
     if fillna:
         df.fillna("", inplace=True)
     return df
@@ -353,7 +524,7 @@ def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_
 
 # Get dict with a task list for each task category
 # E.g. {"Classification": ["AmazonMassiveIntentClassification (en)", ...], "PairClassification": ["SprintDuplicateQuestions", ...]}
-def get_mteb_average(task_dict: dict):
+def get_mteb_average(task_dict: dict) -> tuple[Any, dict]:
     all_tasks = reduce(lambda x, y: x + y, task_dict.values())
     DATA_OVERALL = get_mteb_data(
         tasks=list(task_dict.keys()),
@@ -364,10 +535,20 @@ def get_mteb_average(task_dict: dict):
     )
     # Debugging:
     # DATA_OVERALL.to_csv("overall.csv")
-    DATA_OVERALL.insert(1, f"Average ({len(all_tasks)} datasets)", DATA_OVERALL[all_tasks].mean(axis=1, skipna=False))
+    DATA_OVERALL.insert(
+        1,
+        f"Average ({len(all_tasks)} datasets)",
+        DATA_OVERALL[all_tasks].mean(axis=1, skipna=False),
+    )
     for i, (task_category, task_category_list) in enumerate(task_dict.items()):
-        DATA_OVERALL.insert(i+2, f"{task_category} Average ({len(task_category_list)} datasets)", DATA_OVERALL[task_category_list].mean(axis=1, skipna=False))
-    DATA_OVERALL.sort_values(f"Average ({len(all_tasks)} datasets)", ascending=False, inplace=True)
+        DATA_OVERALL.insert(
+            i + 2,
+            f"{task_category} Average ({len(task_category_list)} datasets)",
+            DATA_OVERALL[task_category_list].mean(axis=1, skipna=False),
+        )
+    DATA_OVERALL.sort_values(
+        f"Average ({len(all_tasks)} datasets)", ascending=False, inplace=True
+    )
     # Start ranking from 1
     DATA_OVERALL.insert(0, "Rank", list(range(1, len(DATA_OVERALL) + 1)))
 
@@ -375,15 +556,32 @@ def get_mteb_average(task_dict: dict):
 
     DATA_TASKS = {}
     for task_category, task_category_list in task_dict.items():
-        DATA_TASKS[task_category] = add_rank(DATA_OVERALL[["Model", "Model Size (Million Parameters)", "Memory Usage (GB, fp32)"] + task_category_list])
-        DATA_TASKS[task_category] = DATA_TASKS[task_category][DATA_TASKS[task_category].iloc[:, 4:].ne("").any(axis=1)]
+        DATA_TASKS[task_category] = add_rank(
+            DATA_OVERALL[
+                ["Model", "Model Size (Million Parameters)", "Memory Usage (GB, fp32)"]
+                + task_category_list
+            ]
+        )
+        DATA_TASKS[task_category] = DATA_TASKS[task_category][
+            DATA_TASKS[task_category].iloc[:, 4:].ne("").any(axis=1)
+        ]
 
     # Fill NaN after averaging
     DATA_OVERALL.fillna("", inplace=True)
 
-    data_overall_rows = ["Rank", "Model", "Model Size (Million Parameters)", "Memory Usage (GB, fp32)", "Embedding Dimensions", "Max Tokens", f"Average ({len(all_tasks)} datasets)"]
+    data_overall_rows = [
+        "Rank",
+        "Model",
+        "Model Size (Million Parameters)",
+        "Memory Usage (GB, fp32)",
+        "Embedding Dimensions",
+        "Max Tokens",
+        f"Average ({len(all_tasks)} datasets)",
+    ]
     for task_category, task_category_list in task_dict.items():
-        data_overall_rows.append(f"{task_category} Average ({len(task_category_list)} datasets)")
+        data_overall_rows.append(
+            f"{task_category} Average ({len(task_category_list)} datasets)"
+        )
 
     DATA_OVERALL = DATA_OVERALL[data_overall_rows]
     DATA_OVERALL = DATA_OVERALL[DATA_OVERALL.iloc[:, 5:].ne("").any(axis=1)]
@@ -391,13 +589,10 @@ def get_mteb_average(task_dict: dict):
     return DATA_OVERALL, DATA_TASKS
 
 
-def refresh_leaderboard():
+def refresh_leaderboard() -> tuple[list, dict]:
     """
     The main code to refresh and calculate results for the leaderboard. It does this by fetching the results from the
         external models and the models in the leaderboard, then calculating the average scores for each task category.
-
-    Returns:
-        dict: A dictionary containing the overall leaderboard and the task category leaderboards.
     """
 
     # get external model results and cache them
@@ -406,14 +601,14 @@ def refresh_leaderboard():
 
     boards_data = {}
     all_data_tasks = []
-    pbar_tasks = tqdm(BOARDS_CONFIG.items(), desc="Fetching leaderboard results for ???", total=len(BOARDS_CONFIG), leave=True)
+    pbar_tasks = tqdm(
+        BOARDS_CONFIG.items(),
+        desc="Fetching leaderboard results for ???",
+        total=len(BOARDS_CONFIG),
+        leave=True,
+    )
     for board, board_config in pbar_tasks:
-        # To add only a single new board, you can uncomment the below to be faster
-        if board != "rar-b": continue
-        boards_data[board] = {
-            "data_overall": None,
-            "data_tasks": {}
-        }
+        boards_data[board] = {"data_overall": None, "data_tasks": {}}
         pbar_tasks.set_description(f"Fetching leaderboard results for {board!r}")
         pbar_tasks.refresh()
         if board_config["has_overall"]:
@@ -423,30 +618,30 @@ def refresh_leaderboard():
             all_data_tasks.extend(data_tasks.values())
         else:
             for task_category, task_category_list in board_config["tasks"].items():
-                data_task_category = get_mteb_data(tasks=[task_category], datasets=task_category_list)
-                data_task_category.drop(columns=["Embedding Dimensions", "Max Tokens"], inplace=True)
+                data_task_category = get_mteb_data(
+                    tasks=[task_category], datasets=task_category_list
+                )
+                data_task_category.drop(
+                    columns=["Embedding Dimensions", "Max Tokens"], inplace=True
+                )
                 boards_data[board]["data_tasks"][task_category] = data_task_category
                 all_data_tasks.append(data_task_category)
 
     return all_data_tasks, boards_data
 
 
-
-def write_out_results(item, item_name: str):
+def write_out_results(item: dict, item_name: str) -> None:
     """
     Due to their complex structure, let's recursively create subfolders until we reach the end
         of the item and then save the DFs as jsonl files
 
     Args:
-        item (dict): The item to save
-        item_name (str): The name of the item
-    
-    Returns:
-        None
+        item: The item to save
+        item_name: The name of the item
     """
     main_folder = item_name
 
-    if isinstance(item, list): 
+    if isinstance(item, list):
         for i, v in enumerate(item):
             write_out_results(v, os.path.join(main_folder, str(i)))
 
@@ -463,8 +658,9 @@ def write_out_results(item, item_name: str):
     elif isinstance(item, pd.DataFrame):
         print(f"Saving {main_folder} to {main_folder}/default.jsonl")
         os.makedirs(main_folder, exist_ok=True)
-        
-        item.reset_index().to_json(f"{main_folder}/default.jsonl", orient="records", lines=True)
+
+        item.reset_index(inplace=True)
+        item.to_json(f"{main_folder}/default.jsonl", orient="records", lines=True)
 
     elif isinstance(item, str):
         print(f"Saving {main_folder} to {main_folder}/default.txt")
@@ -483,38 +679,44 @@ def write_out_results(item, item_name: str):
         raise Exception(f"Unknown type {type(item)}")
 
 
-def load_results(data_path):
+def load_results(data_path: str) -> list | dict | pd.DataFrame | str | None:
     """
     Do the reverse of `write_out_results` to reconstruct the item
 
     Args:
-        data_path (str): The path to the data to load
+        data_path: The path to the data to load
 
     Returns:
-        dict: The loaded data
+        The loaded data
     """
     if os.path.isdir(data_path):
         # if the folder just has numbers from 0 to N, load as a list
         all_files_in_dir = list(os.listdir(data_path))
         if set(all_files_in_dir) == set([str(i) for i in range(len(all_files_in_dir))]):
             ### the list case
-            return [load_results(os.path.join(data_path, str(i))) for i in range(len(os.listdir(data_path)))]
+            return [
+                load_results(os.path.join(data_path, str(i)))
+                for i in range(len(os.listdir(data_path)))
+            ]
         else:
             if len(all_files_in_dir) == 1:
                 file_name = all_files_in_dir[0]
-                if file_name == "default.jsonl": 
+                if file_name == "default.jsonl":
                     return load_results(os.path.join(data_path, file_name))
-                else: ### the dict case
+                else:  ### the dict case
                     return {file_name: load_results(os.path.join(data_path, file_name))}
             else:
-                return {file_name: load_results(os.path.join(data_path, file_name)) for file_name in all_files_in_dir}
-        
+                return {
+                    file_name: load_results(os.path.join(data_path, file_name))
+                    for file_name in all_files_in_dir
+                }
+
     elif data_path.endswith(".jsonl"):
         df = pd.read_json(data_path, orient="records", lines=True)
         if "index" in df.columns:
             df = df.set_index("index")
         return df
-    
+
     else:
         with open(data_path, "r") as f:
             data = f.read()
@@ -524,17 +726,16 @@ def load_results(data_path):
             return data
 
 
-
 if __name__ == "__main__":
-    print(f"Refreshing leaderboard statistics...")
+    print("Refreshing leaderboard statistics...")
     all_data_tasks, boards_data = refresh_leaderboard()
-    print(f"Done calculating, saving...")
+    print("Done calculating, saving...")
     # save them so that the leaderboard can use them.  They're quite complex though
-    #   but we can't use pickle files because of git-lfs. 
+    #   but we can't use pickle files because of git-lfs.
     write_out_results(all_data_tasks, "all_data_tasks")
     write_out_results(boards_data, "boards_data")
 
     # to load them use
     # all_data_tasks = load_results("all_data_tasks")
     # boards_data = load_results("boards_data")
-    print("Done saving results!")
+    print("Done saving results!")