Cleaning and removing df copy causing storage issue

app.py

@@ -1,145 +1,64 @@
-import subprocess
-
 import gradio as gr
 import pandas as pd
 from apscheduler.schedulers.background import BackgroundScheduler
 from huggingface_hub import snapshot_download
 import time
+import functools
+import gc
+
+import os
 
 from src.about import (
-    CITATION_BUTTON_LABEL,
-    CITATION_BUTTON_TEXT,
-    EVALUATION_QUEUE_TEXT,
-    INTRODUCTION_TEXT,
-    LLM_BENCHMARKS_TEXT_1,
-    LLM_BENCHMARKS_TEXT_2,
-    CROSS_EVALUATION_METRICS,
-    NOTE_GENERATION_METRICS,
-    HEALTHBENCH_METRICS,
-    # EVALUATION_EXAMPLE_IMG,
-    # LLM_BENCHMARKS_TEXT_2,
-    # ENTITY_DISTRIBUTION_IMG,
-    # LLM_BENCHMARKS_TEXT_3,
-    TITLE,
-    LOGO,
-    FIVE_PILLAR_DIAGRAM
+    CITATION_BUTTON_LABEL, CITATION_BUTTON_TEXT, EVALUATION_QUEUE_TEXT, INTRODUCTION_TEXT,
+    LLM_BENCHMARKS_TEXT_1, LLM_BENCHMARKS_TEXT_2, CROSS_EVALUATION_METRICS,
+    NOTE_GENERATION_METRICS, HEALTHBENCH_METRICS, TITLE, LOGO, FIVE_PILLAR_DIAGRAM
 )
 from src.display.css_html_js import custom_css
-# changes to be made here
 from src.display.utils import (
-    DATASET_BENCHMARK_COLS,
-    OPEN_ENDED_BENCHMARK_COLS,
-    MED_SAFETY_BENCHMARK_COLS,
-    MEDICAL_SUMMARIZATION_BENCHMARK_COLS,
-    ACI_BENCHMARK_COLS,
-    SOAP_BENCHMARK_COLS,
-    HEALTHBENCH_BENCHMARK_COLS,
-    HEALTHBENCH_HARD_BENCHMARK_COLS,
-    DATASET_COLS,
-    OPEN_ENDED_COLS,
-    MED_SAFETY_COLS,
-    MEDICAL_SUMMARIZATION_COLS,
-    ACI_COLS,
-    SOAP_COLS,
-    HEALTHBENCH_COLS,
-    HEALTHBENCH_HARD_COLS,
-    EVAL_COLS,
-    EVAL_TYPES,
-    NUMERIC_INTERVALS,
-    TYPES,
-    AutoEvalColumn,
-    ModelType,
-    ModelArch,
-    PromptTemplateName,
-    Precision,
-    WeightType,
-    fields,
-    render_generation_templates,
-    OpenEndedArabic_COLS,
-    OpenEndedArabic_BENCHMARK_COLS,
-    OpenEndedFrench_COLS,
-    OpenEndedFrench_BENCHMARK_COLS,
-    OpenEndedPortuguese_COLS,
-    OpenEndedPortuguese_BENCHMARK_COLS,
-    OpenEndedRomanian_COLS,
-    OpenEndedRomanian_BENCHMARK_COLS,
-    OpenEndedGreek_COLS,
-    OpenEndedGreek_BENCHMARK_COLS,
-    OpenEndedSpanish_COLS,
-    OpenEndedSpanish_BENCHMARK_COLS,
-    ClosedEndedMultilingual_COLS,
-    ClosedEndedMultilingual_BENCHMARK_COLS,
+    DATASET_BENCHMARK_COLS, OPEN_ENDED_BENCHMARK_COLS, MED_SAFETY_BENCHMARK_COLS,
+    MEDICAL_SUMMARIZATION_BENCHMARK_COLS, ACI_BENCHMARK_COLS, SOAP_BENCHMARK_COLS,
+    HEALTHBENCH_BENCHMARK_COLS, HEALTHBENCH_HARD_BENCHMARK_COLS, DATASET_COLS,
+    OPEN_ENDED_COLS, MED_SAFETY_COLS, MEDICAL_SUMMARIZATION_COLS, ACI_COLS, SOAP_COLS,
+    HEALTHBENCH_COLS, HEALTHBENCH_HARD_COLS, EVAL_COLS, EVAL_TYPES, NUMERIC_INTERVALS,
+    TYPES, AutoEvalColumn, ModelType, Precision, WeightType, fields, render_generation_templates,
+    OpenEndedArabic_COLS, OpenEndedArabic_BENCHMARK_COLS, OpenEndedFrench_COLS,
+    OpenEndedFrench_BENCHMARK_COLS, OpenEndedPortuguese_COLS, OpenEndedPortuguese_BENCHMARK_COLS,
+    OpenEndedRomanian_COLS, OpenEndedRomanian_BENCHMARK_COLS, OpenEndedGreek_COLS,
+    OpenEndedGreek_BENCHMARK_COLS, OpenEndedSpanish_COLS, OpenEndedSpanish_BENCHMARK_COLS,
+    ClosedEndedMultilingual_COLS, ClosedEndedMultilingual_BENCHMARK_COLS,
 )
-
-from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN, PRIVATE_REPO
+from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN
 from src.populate import get_evaluation_queue_df, get_leaderboard_df
-from src.submission.submit import add_new_eval, PLACEHOLDER_DATASET_WISE_NORMALIZATION_CONFIG
+from src.submission.submit import add_new_eval
+
+# =====================================================================================
+# 1. SETUP AND DATA LOADING 
+# =====================================================================================
 
 def restart_space():
     API.restart_space(repo_id=REPO_ID)
 
 
-print(f"QUEUE_REPO: {QUEUE_REPO}")
-print(f"RESULTS_REPO: {RESULTS_REPO}")
-print(f"EVAL_REQUESTS_PATH: {EVAL_REQUESTS_PATH}")
-print(f"EVAL_RESULTS_PATH: {EVAL_RESULTS_PATH}")
-print(f"TOKEN: {TOKEN}")
-
-try:
-    print(f"EVAL_REQUESTS_PATH: {EVAL_REQUESTS_PATH}")
-    snapshot_download(
-        repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
-    )
-    print(f"EVAL_REQUESTS_PATH downloaded")
-except Exception:
-    print("An error occurred while downloading EVAL_REQUESTS_PATH. Please check the connection or the repository settings.")
-    restart_space()
+print("Downloading evaluation data...")
 try:
-    print(f"EVAL_RESULTS_PATH: {EVAL_RESULTS_PATH}")
-    snapshot_download(
-        repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
-    )
-    print(f"EVAL_RESULTS_PATH downloaded")
-except Exception:
-    print("An error occurred while downloading EVAL_RESULTS_PATH. Please check the connection or the repository settings.")
+    snapshot_download(repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", token=TOKEN)
+    snapshot_download(repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", token=TOKEN)
+    print("Downloads complete.")
+except Exception as e:
+    print(f"An error occurred during download: {e}")
     restart_space()
 
-# Span based results
-# changes to be made here
-
+print("Loading all dataframes into a central dictionary...")
 start_time = time.time()
 
 _, harness_datasets_original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, DATASET_COLS, DATASET_BENCHMARK_COLS, "accuracy", "datasets")
-harness_datasets_leaderboard_df = harness_datasets_original_df.copy()
-print("Closed ended English results loaded")
-
 _, open_ended_original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, OPEN_ENDED_COLS, OPEN_ENDED_BENCHMARK_COLS, "score", "open_ended")
-open_ended_leaderboard_df = open_ended_original_df.copy()
-print("Open ended English results loaded")
-
 _, med_safety_original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, MED_SAFETY_COLS, MED_SAFETY_BENCHMARK_COLS, "score", "med_safety")
-med_safety_leaderboard_df = med_safety_original_df.copy()
-print("Med safety results loaded")
-
 _, medical_summarization_original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, MEDICAL_SUMMARIZATION_COLS, MEDICAL_SUMMARIZATION_BENCHMARK_COLS, "score", "medical_summarization")
-medical_summarization_leaderboard_df = medical_summarization_original_df.copy()
-print("Medical summarization results loaded")
-
 _, aci_original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, ACI_COLS, ACI_BENCHMARK_COLS, "score", "aci")
-aci_leaderboard_df = aci_original_df.copy()
-print("ACI results loaded")
-
 _, soap_original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, SOAP_COLS, SOAP_BENCHMARK_COLS, "score", "soap")
-soap_leaderboard_df = soap_original_df.copy()
-print("SOAP results loaded")
-
 _, healthbench_original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, HEALTHBENCH_COLS, HEALTHBENCH_BENCHMARK_COLS, "score", "healthbench")
-healthbench_leaderboard_df = healthbench_original_df.copy()
-
 _, healthbench_hard_original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, HEALTHBENCH_HARD_COLS, HEALTHBENCH_HARD_BENCHMARK_COLS, "score", "healthbench_hard")
-healthbench_hard_leaderboard_df = healthbench_hard_original_df.copy()
-print("Healthbench results loaded")
-
 _, open_ended_arabic_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, OpenEndedArabic_COLS, OpenEndedArabic_BENCHMARK_COLS, "score", "open_ended_arabic")
 _, open_ended_french_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, OpenEndedFrench_COLS, OpenEndedFrench_BENCHMARK_COLS, "score", "open_ended_french")
 _, open_ended_portuguese_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, OpenEndedPortuguese_COLS, OpenEndedPortuguese_BENCHMARK_COLS, "score", "open_ended_portuguese")
@@ -148,128 +67,36 @@ _, open_ended_greek_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PAT
 _, open_ended_spanish_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, OpenEndedSpanish_COLS, OpenEndedSpanish_BENCHMARK_COLS, "score", "open_ended_spanish")
 _, closed_ended_multilingual_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, ClosedEndedMultilingual_COLS, ClosedEndedMultilingual_BENCHMARK_COLS, "score", "closed_ended_multilingual")
 
-
-open_ended_arabic_leaderboard_df = open_ended_arabic_df.copy()
-open_ended_french_leaderboard_df = open_ended_french_df.copy()
-open_ended_portuguese_leaderboard_df = open_ended_portuguese_df.copy()
-open_ended_romanian_leaderboard_df = open_ended_romanian_df.copy()
-open_ended_greek_leaderboard_df = open_ended_greek_df.copy()
-open_ended_spanish_leaderboard_df = open_ended_spanish_df.copy()
-print("Open ended multilingual results loaded")
-
-closed_ended_multilingual_leaderboard_df = closed_ended_multilingual_df.copy()
-print("Closed ended multilingual results loaded")
-
+ALL_DATASETS = {
+    "datasets": harness_datasets_original_df,
+    "open_ended": open_ended_original_df,
+    "med_safety": med_safety_original_df,
+    "medical_summarization": medical_summarization_original_df,
+    "aci": aci_original_df,
+    "soap": soap_original_df,
+    "healthbench": healthbench_original_df,
+    "healthbench_hard": healthbench_hard_original_df,
+    "open_ended_arabic": open_ended_arabic_df,
+    "open_ended_french": open_ended_french_df,
+    "open_ended_portuguese": open_ended_portuguese_df,
+    "open_ended_romanian": open_ended_romanian_df,
+    "open_ended_greek": open_ended_greek_df,
+    "open_ended_spanish": open_ended_spanish_df,
+    "closed_ended_multilingual": closed_ended_multilingual_df,
+}
 end_time = time.time()
-total_time = end_time - start_time
-print(f"Total time taken to load all results: {total_time:.2f} seconds")
-
-# breakpoint()
-# # Token based results
-# _, token_based_datasets_original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, DATASET_COLS, DATASET_BENCHMARK_COLS, "TokenBasedWithMacroAverage", "datasets")
-# token_based_datasets_leaderboard_df = token_based_datasets_original_df.copy()
-
-# _, token_based_types_original_df = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, Clinical_TYPES_COLS, TYPES_BENCHMARK_COLS, "TokenBasedWithMacroAverage", "clinical_types")
-# token_based_types_leaderboard_df = token_based_types_original_df.copy()
+print(f"Dataframes loaded in {end_time - start_time:.2f} seconds.")
 
+# Evaluation Queue DataFrames
+(finished_eval_queue_df, running_eval_queue_df, pending_eval_queue_df) = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
 
-(
-    finished_eval_queue_df,
-    running_eval_queue_df,
-    pending_eval_queue_df,
-) = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
-
-# breakpoint()
-def update_df(shown_columns, subset="datasets"):
-    # changes to be made here
-    if subset == "datasets":
-        leaderboard_table_df = harness_datasets_leaderboard_df.copy()
-        hidden_leader_board_df = harness_datasets_original_df
-    elif subset == "open_ended":
-        leaderboard_table_df = open_ended_leaderboard_df.copy()
-        hidden_leader_board_df = open_ended_original_df
-    elif subset == "med_safety":
-        leaderboard_table_df = med_safety_leaderboard_df.copy()
-        hidden_leader_board_df = med_safety_original_df
-    elif subset == "medical_summarization":
-        leaderboard_table_df = medical_summarization_leaderboard_df.copy()
-        hidden_leader_board_df = medical_summarization_original_df
-    elif subset == "aci":
-        leaderboard_table_df = aci_leaderboard_df.copy()
-        hidden_leader_board_df = aci_original_df
-    elif subset == "soap":
-        leaderboard_table_df = soap_leaderboard_df.copy()
-        hidden_leader_board_df = soap_original_df
-    elif subset == "healthbench":
-        leaderboard_table_df = healthbench_leaderboard_df.copy()
-        hidden_leader_board_df = healthbench_original_df
-    elif subset == "healthbench_hard":
-        leaderboard_table_df = healthbench_hard_leaderboard_df.copy()
-        hidden_leader_board_df = healthbench_hard_original_df
-    elif subset == "open_ended_arabic": 
-        leaderboard_table_df = open_ended_arabic_df.copy()
-        hidden_leader_board_df = open_ended_arabic_df
-    elif subset == "open_ended_french":
-        leaderboard_table_df = open_ended_french_df.copy()
-        hidden_leader_board_df = open_ended_french_df
-    elif subset == "open_ended_portuguese":
-        leaderboard_table_df = open_ended_portuguese_df.copy()
-        hidden_leader_board_df = open_ended_portuguese_df
-    elif subset == "open_ended_romanian":
-        leaderboard_table_df = open_ended_romanian_df.copy()
-        hidden_leader_board_df = open_ended_romanian_df
-    elif subset == "open_ended_greek":
-        leaderboard_table_df = open_ended_greek_df.copy()
-        hidden_leader_board_df = open_ended_greek_df
-    elif subset == "open_ended_spanish":
-        leaderboard_table_df = open_ended_spanish_df.copy()
-        hidden_leader_board_df = open_ended_spanish_df
-    elif subset == "closed_ended_multilingual":
-        leaderboard_table_df = closed_ended_multilingual_df.copy()
-        hidden_leader_board_df = closed_ended_multilingual_df
-    
-
-    value_cols = [c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns
-    # breakpoint()
-    return leaderboard_table_df[value_cols], hidden_leader_board_df
-
-
-# Searching and filtering
-def update_table(
-    hidden_df: pd.DataFrame,
-    columns: list,
-    query: str = "",
-    # type_query: list = None,
-    domain_specific_query: list = None,
-    size_query: list = None,
-    precision_query: str = None,
-    show_deleted: bool = False,
-):
-    # breakpoint()
-    type_query = None
-    filtered_df = filter_models(hidden_df, type_query, domain_specific_query, size_query, precision_query, show_deleted)
-    # breakpoint()
-    filtered_df = filter_queries(query, filtered_df)
-    # breakpoint()
-    df = select_columns(filtered_df, columns, list(hidden_df.columns))
-    # breakpoint()
-    return df
-
+# =====================================================================================
+# 2. EFFICIENT FILTERING LOGIC
+# =====================================================================================
 
 def search_table(df: pd.DataFrame, query: str) -> pd.DataFrame:
     return df[(df[AutoEvalColumn.model.name].str.contains(query, case=False))]
 
-
-def select_columns(df: pd.DataFrame, columns: list, cols:list) -> pd.DataFrame:
-    always_here_cols = [
-        AutoEvalColumn.model_type_symbol.name,
-        AutoEvalColumn.model.name,
-    ]
-    # We use COLS to maintain sorting
-    filtered_df = df[always_here_cols + [c for c in cols if c in df.columns and c in columns]]
-    return filtered_df
-
-
 def filter_queries(query: str, filtered_df: pd.DataFrame) -> pd.DataFrame:
     final_df = []
     if query != "":
@@ -285,8 +112,6 @@ def filter_queries(query: str, filtered_df: pd.DataFrame) -> pd.DataFrame:
             filtered_df = filtered_df.drop_duplicates(
                 subset=[
                     AutoEvalColumn.model.name,
-                    # AutoEvalColumn.precision.name,
-                    # AutoEvalColumn.revision.name,
                 ]
             )
 
@@ -296,11 +121,6 @@ def filter_queries(query: str, filtered_df: pd.DataFrame) -> pd.DataFrame:
 def filter_models(
     df: pd.DataFrame, type_query: list, domain_specific_query: list, size_query: list, precision_query: list, show_deleted: bool
 ) -> pd.DataFrame:
-    # Show all models
-    # if show_deleted:
-    #     filtered_df = df
-    # else:  # Show only still on the hub models
-    #     filtered_df = df[df[AutoEvalColumn.still_on_hub.name] == True]
 
     filtered_df = df
 
@@ -315,12 +135,7 @@ def filter_models(
         if "Generic models" in domain_specific_query:
             domain_specifics.append(False)
         filtered_df = filtered_df.loc[df[AutoEvalColumn.is_domain_specific.name].isin(domain_specifics)]
-        
-    # if architecture_query is not None:
-    #     arch_types = [t for t in architecture_query]
-    #     filtered_df = filtered_df.loc[df[AutoEvalColumn.architecture.name].isin(arch_types)]
-    #         # filtered_df = filtered_df.loc[df[AutoEvalColumn.architecture.name].isin(architecture_query + ["None"])]
-    
+
     if precision_query is not None:
         if AutoEvalColumn.precision.name in df.columns:
             filtered_df = filtered_df.loc[df[AutoEvalColumn.precision.name].isin(precision_query + ["None"])]
@@ -333,1075 +148,225 @@ def filter_models(
 
     return filtered_df
 
-            
+def get_filtered_table(
+    shown_columns: list,
+    query: str,
+    domain_specific_query: list,
+    size_query: list,
+    *, # force subset_name to be a keyword-only argument
+    subset_name: str
+):
+    original_df = ALL_DATASETS[subset_name]
+    
+    type_query = None 
+    filtered_df = filter_models(original_df, type_query, domain_specific_query, size_query, None, False)
+    filtered_df = filter_queries(query, filtered_df)
+
+    always_here_cols = [AutoEvalColumn.model.name]
+    available_cols = [c for c in shown_columns if c in filtered_df.columns]
+    final_df = filtered_df[always_here_cols + available_cols]
+
+    del filtered_df
+    gc.collect()
+
+    
+    return final_df
+
+# =====================================================================================
+# 3. REUSABLE UI CREATION FUNCTION
+# =====================================================================================
+
+def create_leaderboard_ui(subset_name: str, column_choices: list, default_columns: list):
+    """Creates a full leaderboard UI block for a given subset."""
+    with gr.Row():
+        with gr.Column():
+            with gr.Row():
+                search_bar = gr.Textbox(
+                    placeholder=f"🔍 Search for models...",
+                    show_label=False,
+                    elem_id=f"search-bar-{subset_name}",
+                )
+            with gr.Row():
+                shown_columns = gr.CheckboxGroup(
+                    choices=column_choices,
+                    value=default_columns,
+                    label="Select columns to show",
+                    elem_id=f"column-select-{subset_name}",
+                    interactive=True,
+                )
+        with gr.Column(min_width=320):
+            filter_domain_specific = gr.CheckboxGroup(
+                label="Domain Specificity",
+                choices=["🏥 Clinical models", "Generic models"],
+                value=["🏥 Clinical models", "Generic models"],
+                interactive=True,
+                elem_id=f"filter-domain-{subset_name}",
+            )
+            filter_columns_size = gr.CheckboxGroup(
+                label="Model sizes (in billions of parameters)",
+                choices=list(NUMERIC_INTERVALS.keys()),
+                value=list(NUMERIC_INTERVALS.keys()),
+                interactive=True,
+                elem_id=f"filter-size-{subset_name}",
+            )
+    
+    update_fn = functools.partial(get_filtered_table, subset_name=subset_name)
+
+    initial_df = update_fn(
+        shown_columns=default_columns,
+        query="",
+        domain_specific_query=["🏥 Clinical models", "Generic models"],
+        size_query=list(NUMERIC_INTERVALS.keys())
+    )
+
+    leaderboard_table = gr.Dataframe(
+        value=initial_df,
+        headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + default_columns,
+        datatype=TYPES,
+        elem_id=f"leaderboard-table-{subset_name}",
+        interactive=False,
+    )
+
+    inputs = [shown_columns, search_bar, filter_domain_specific, filter_columns_size]
+    
+    # Attach listeners to all input components
+    for component in inputs:
+        if isinstance(component, gr.Textbox):
+            component.submit(update_fn, inputs, leaderboard_table)
+        else:
+            component.change(update_fn, inputs, leaderboard_table)
+
+    return leaderboard_table
+
+# =====================================================================================
+# 4. GRADIO DEMO UI (Main application layout)
+# =====================================================================================
+
 demo = gr.Blocks(css=custom_css)
+
 with demo:
-    print("hello")
     gr.HTML(LOGO)
     gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
-    filter_columns_type = None
+    
     with gr.Tabs(elem_classes="tab-buttons") as tabs:
         with gr.TabItem("🏅 Open Ended Evaluation", elem_id="llm-benchmark-tab-table", id=1):
             with gr.Tabs(elem_classes="tab-buttons6") as language_tabs:
                 LANGUAGES = {
-                    "🇺🇸 English": "open_ended",
-                    "🇦🇪 Arabic": "open_ended_arabic",
-                    "🇫🇷 French": "open_ended_french",
-                    "🇪🇸 Spanish": "open_ended_spanish",
-                    "🇵🇹 Portuguese": "open_ended_portuguese",
-                    "🇷🇴 Romanian": "open_ended_romanian",
+                    "🇺🇸 English": "open_ended", "🇦🇪 Arabic": "open_ended_arabic",
+                    "🇫🇷 French": "open_ended_french", "🇪🇸 Spanish": "open_ended_spanish",
+                    "🇵🇹 Portuguese": "open_ended_portuguese", "🇷🇴 Romanian": "open_ended_romanian",
                     "🇬🇷 Greek": "open_ended_greek",
                 }
-
                 for idx, (label, subset) in enumerate(LANGUAGES.items()):
                     with gr.TabItem(label, elem_id=f"llm-benchmark-tab-open-{subset}", id=idx):
-                        # Custom judge information for each language
-                        if label == "🇺🇸 English":
-                            judge_text = "**Note:** Llama 3.1 70B Instruct has been used as judge for English."
-                        else:
-                            judge_text = "**Note:** Qwen 2.5 72B Instruct has been used as judge for this language."
-                        
+                        judge_text = "**Note:** Llama 3.1 70B Instruct has been used as judge for English." if label == "🇺🇸 English" else "**Note:** Qwen 2.5 72B Instruct has been used as judge for this language."
                         gr.Markdown(judge_text, elem_classes="markdown-text")
                         
-                        with gr.Row():
-                            with gr.Column():
-                                with gr.Row():
-                                    search_bar = gr.Textbox(
-                                        placeholder=f"🔍 Search for your model in {label}...",
-                                        show_label=False,
-                                        elem_id=f"search-bar-{subset}",
-                                    )
-                                with gr.Row():
-                                    shown_columns = gr.CheckboxGroup(
-                                        choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.open_ended_col)],
-                                        value=[
-                                            c.name
-                                            for c in fields(AutoEvalColumn)
-                                            if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.open_ended_col)
-                                        ],
-                                        label="Select columns to show",
-                                        elem_id=f"column-select-{subset}",
-                                        interactive=True,
-                                    )
-                            with gr.Column(min_width=320):
-                                # filter_columns_type = gr.CheckboxGroup(
-                                #     label="Model Types",
-                                #     choices=[t.to_str() for t in ModelType],
-                                #     value=[t.to_str() for t in ModelType],
-                                #     interactive=True,
-                                #     elem_id=f"filter-columns-type-{subset}",
-                                # )
-
-                                filter_domain_specific = gr.CheckboxGroup(
-                                    label="Domain Specificity",
-                                    choices=["🏥  Clinical models", "Generic models"],
-                                    value=["🏥  Clinical models", "Generic models"],
-                                    interactive=True,
-                                    elem_id=f"filter-columns-domain-{subset}",
-                                )
-                                filter_columns_size = gr.CheckboxGroup(
-                                    label="Model sizes (in billions of parameters)",
-                                    choices=list(NUMERIC_INTERVALS.keys()),
-                                    value=list(NUMERIC_INTERVALS.keys()),
-                                    interactive=True,
-                                    elem_id=f"filter-columns-size-{subset}",
-                                )
-
-                        datasets_leaderboard_df, datasets_original_df = update_df(shown_columns.value, subset=subset)
-
-                        leaderboard_table = gr.Dataframe(
-                            value=datasets_leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
-                            headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                            datatype=TYPES,
-                            elem_id=f"leaderboard-table-{subset}",
-                            interactive=False,
-                            visible=True,
+                        create_leaderboard_ui(
+                            subset_name=subset,
+                            column_choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.open_ended_col)],
+                            default_columns=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.open_ended_col)]
                         )
-
-                        hidden_leaderboard_table_for_search = gr.Dataframe(
-                            value=datasets_original_df[OPEN_ENDED_COLS],
-                            headers=OPEN_ENDED_COLS,
-                            datatype=TYPES,
-                            visible=False,
-                        )
-
-                        search_bar.submit(
-                            update_table,
-                            [
-                                hidden_leaderboard_table_for_search,
-                                shown_columns,
-                                search_bar,
-                                # filter_columns_type,
-                                filter_domain_specific,
-                                filter_columns_size
-                            ],
-                            leaderboard_table,
-                        )
-
-                        for selector in [
-                            shown_columns,
-                            # filter_columns_type,
-                            filter_domain_specific,
-                            filter_columns_size,
-                        ]:
-                            selector.change(
-                                update_table,
-                                [
-                                    hidden_leaderboard_table_for_search,
-                                    shown_columns,
-                                    search_bar,
-                                    # filter_columns_type,
-                                    filter_domain_specific,
-                                    filter_columns_size
-                                ],
-                                leaderboard_table,
-                                queue=True,
-                            )
-
                         with gr.Accordion("💬 Generation templates", open=False):
                             with gr.Accordion("Response generation", open=False):
                                 render_generation_templates(task="open_ended", generation_type="response_generation")
                             with gr.Accordion("Scoring Rubric", open=False):
                                 render_generation_templates(task="open_ended", generation_type="scoring_rubric")
-
+        
         with gr.TabItem("🏅 Medical Summarization", elem_id="llm-benchmark-tab-table", id=2):
             gr.Markdown(CROSS_EVALUATION_METRICS, elem_classes="markdown-text")
-            with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        search_bar = gr.Textbox(
-                            placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
-                            show_label=False,
-                            elem_id="search-bar",
-                        )
-                    with gr.Row():
-                        shown_columns = gr.CheckboxGroup(
-                            choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.medical_summarization_col)],
-                            value=[
-                                c.name
-                                for c in fields(AutoEvalColumn)
-                                if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.medical_summarization_col)
-                            ],
-                            label="Select columns to show",
-                            elem_id="column-select",
-                            interactive=True,
-                        )
-                    # with gr.Row():
-                    #     deleted_models_visibility = gr.Checkbox(
-                    #         value=False, label="Show gated/private/deleted models", interactive=True
-                    #     )
-                with gr.Column(min_width=320):
-                    # with gr.Box(elem_id="box-filter"):
-                    # filter_columns_type = gr.CheckboxGroup(
-                    #     label="Model Types",
-                    #     choices=[t.to_str() for t in ModelType],
-                    #     value=[t.to_str() for t in ModelType],
-                    #     interactive=True,
-                    #     elem_id="filter-columns-type",
-                    # )
-                    # filter_columns_architecture = gr.CheckboxGroup(
-                    #     label="Architecture Types",
-                    #     choices=[i.value.name for i in ModelArch],
-                    #     value=[i.value.name for i in ModelArch],
-                    #     interactive=True,
-                    #     elem_id="filter-columns-architecture",
-                    # )
-                    filter_domain_specific = gr.CheckboxGroup(
-                        label="Domain Specificity",
-                        choices=["🏥  Clinical models", "Generic models"],
-                        value=["🏥  Clinical models", "Generic models"],
-                        interactive=True,
-                        elem_id="filter-columns-type",
-                    )
-                    filter_columns_size = gr.CheckboxGroup(
-                        label="Model sizes (in billions of parameters)",
-                        choices=list(NUMERIC_INTERVALS.keys()),
-                        value=list(NUMERIC_INTERVALS.keys()),
-                        interactive=True,
-                        elem_id="filter-columns-size",
-                    )
-
-            datasets_leaderboard_df, datasets_original_df = update_df(shown_columns.value, subset="medical_summarization")
-
-            leaderboard_table = gr.components.Dataframe(
-                value=datasets_leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
-                headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                datatype=TYPES,
-                elem_id="leaderboard-table",
-                interactive=False,
-                visible=True,
-            )
-
-            # Dummy leaderboard for handling the case when the user uses backspace key
-            hidden_leaderboard_table_for_search = gr.components.Dataframe(
-                value=datasets_original_df[MEDICAL_SUMMARIZATION_COLS],
-                headers=MEDICAL_SUMMARIZATION_COLS,
-                datatype=TYPES,
-                visible=False,
+            create_leaderboard_ui(
+                subset_name="medical_summarization",
+                column_choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.medical_summarization_col)],
+                default_columns=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.medical_summarization_col)]
             )
-
-                        
-            search_bar.submit(
-                update_table,
-                [
-                    hidden_leaderboard_table_for_search,
-                    shown_columns,
-                    search_bar,
-                    # filter_columns_type,
-                    filter_domain_specific,
-                    filter_columns_size
-                    # filter_columns_architecture
-                ],
-                leaderboard_table,
-            )
-            for selector in [
-                shown_columns,
-                # filter_columns_type,
-                filter_domain_specific,
-                filter_columns_size,
-                # deleted_models_visibility,
-            ]:
-                selector.change(
-                    update_table,
-                    [
-                        hidden_leaderboard_table_for_search,
-                        shown_columns,
-                        search_bar,
-                        # filter_columns_type,
-                        filter_domain_specific,
-                        filter_columns_size
-                    ],
-                    leaderboard_table,
-                    queue=True,
-                )
             with gr.Accordion("💬 Generation templates", open=False):
                 with gr.Accordion("Response generation", open=False):
-                    system_prompt, user_prompt = render_generation_templates(task="medical_summarization", generation_type="response_generation")
+                    render_generation_templates(task="medical_summarization", generation_type="response_generation")
                 with gr.Accordion("Question generation", open=False):
-                    system_prompt, user_prompt = render_generation_templates(task="ce", generation_type="question_generation")
+                    render_generation_templates(task="ce", generation_type="question_generation")
                 with gr.Accordion("Cross Examination", open=False):
-                    system_prompt, user_prompt = render_generation_templates(task="ce", generation_type="cross_examination")  
-        
+                    render_generation_templates(task="ce", generation_type="cross_examination")
+                    
         with gr.TabItem("🏅 Note generation", elem_id="llm-benchmark-tab-table", id=3):
             gr.Markdown(NOTE_GENERATION_METRICS, elem_classes="markdown-text")
-            with gr.Tabs(elem_classes="tab-buttons2") as tabs:
-                with gr.TabItem("ACI Bench", elem_id="llm-benchmark-tab-table2", id=0):
-                    with gr.Row():
-                        with gr.Column():
-                            with gr.Row():
-                                search_bar = gr.Textbox(
-                                    placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
-                                    show_label=False,
-                                    elem_id="search-bar",
-                                )
-                            with gr.Row():
-                                shown_columns = gr.CheckboxGroup(
-                                    choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.aci_col)],
-                                    value=[
-                                        c.name
-                                        for c in fields(AutoEvalColumn)
-                                        if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.aci_col)
-                                    ],
-                                    label="Select columns to show",
-                                    elem_id="column-select",
-                                    interactive=True,
-                                )
-                            # with gr.Row():
-                            #     deleted_models_visibility = gr.Checkbox(
-                            #         value=False, label="Show gated/private/deleted models", interactive=True
-                            #     )
-                        with gr.Column(min_width=320):
-                            # with gr.Box(elem_id="box-filter"):
-                            # filter_columns_type = gr.CheckboxGroup(
-                            #     label="Model Types",
-                            #     choices=[t.to_str() for t in ModelType],
-                            #     value=[t.to_str() for t in ModelType],
-                            #     interactive=True,
-                            #     elem_id="filter-columns-type",
-                            # )
-                            # filter_columns_architecture = gr.CheckboxGroup(
-                            #     label="Architecture Types",
-                            #     choices=[i.value.name for i in ModelArch],
-                            #     value=[i.value.name for i in ModelArch],
-                            #     interactive=True,
-                            #     elem_id="filter-columns-architecture",
-                            # )
-                            filter_domain_specific = gr.CheckboxGroup(
-                                label="Domain Specificity",
-                                choices=["🏥  Clinical models", "Generic models"],
-                                value=["🏥  Clinical models", "Generic models"],
-                                interactive=True,
-                                elem_id="filter-columns-type",
-                            )
-                            filter_columns_size = gr.CheckboxGroup(
-                                label="Model sizes (in billions of parameters)",
-                                choices=list(NUMERIC_INTERVALS.keys()),
-                                value=list(NUMERIC_INTERVALS.keys()),
-                                interactive=True,
-                                elem_id="filter-columns-size",
-                            )
-
-                    datasets_leaderboard_df, datasets_original_df = update_df(shown_columns.value, subset="aci")
-
-                    leaderboard_table = gr.components.Dataframe(
-                        value=datasets_leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
-                        headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                        datatype=TYPES,
-                        elem_id="leaderboard-table",
-                        interactive=False,
-                        visible=True,
-                    )
-
-                    # Dummy leaderboard for handling the case when the user uses backspace key
-                    hidden_leaderboard_table_for_search = gr.components.Dataframe(
-                        value=datasets_original_df[ACI_COLS],
-                        headers=ACI_COLS,
-                        datatype=TYPES,
-                        visible=False,
-                    )
-
-                                
-                    search_bar.submit(
-                        update_table,
-                        [
-                            hidden_leaderboard_table_for_search,
-                            shown_columns,
-                            search_bar,
-                            # filter_columns_type,
-                            filter_domain_specific,
-                            filter_columns_size
-                            # filter_columns_architecture
-                        ],
-                        leaderboard_table,
-                    )
-                    for selector in [
-                        shown_columns,
-                        # filter_columns_type,
-                        filter_domain_specific,
-                        filter_columns_size,
-                        # deleted_models_visibility,
-                    ]:
-                        selector.change(
-                            update_table,
-                            [
-                                hidden_leaderboard_table_for_search,
-                                shown_columns,
-                                search_bar,
-                                # filter_columns_type,
-                                filter_domain_specific,
-                                filter_columns_size
-                            ],
-                            leaderboard_table,
-                            queue=True,
-                        )
-                with gr.TabItem("SOAP Notes", elem_id="llm-benchmark-tab-table2", id=1):
-                    with gr.Row():
-                        with gr.Column():
-                            with gr.Row():
-                                search_bar = gr.Textbox(
-                                    placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
-                                    show_label=False,
-                                    elem_id="search-bar",
-                                )
-                            with gr.Row():
-                                shown_columns = gr.CheckboxGroup(
-                                    choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.soap_col)],
-                                    value=[
-                                        c.name
-                                        for c in fields(AutoEvalColumn)
-                                        if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.soap_col)
-                                    ],
-                                    label="Select columns to show",
-                                    elem_id="column-select",
-                                    interactive=True,
-                                )
-                            # with gr.Row():
-                            #     deleted_models_visibility = gr.Checkbox(
-                            #         value=False, label="Show gated/private/deleted models", interactive=True
-                            #     )
-                        with gr.Column(min_width=320):
-                            # with gr.Box(elem_id="box-filter"):
-                            # filter_columns_type = gr.CheckboxGroup(
-                            #     label="Model Types",
-                            #     choices=[t.to_str() for t in ModelType],
-                            #     value=[t.to_str() for t in ModelType],
-                            #     interactive=True,
-                            #     elem_id="filter-columns-type",
-                            # )
-                            # filter_columns_architecture = gr.CheckboxGroup(
-                            #     label="Architecture Types",
-                            #     choices=[i.value.name for i in ModelArch],
-                            #     value=[i.value.name for i in ModelArch],
-                            #     interactive=True,
-                            #     elem_id="filter-columns-architecture",
-                            # )
-                            filter_domain_specific = gr.CheckboxGroup(
-                                label="Domain Specificity",
-                                choices=["🏥  Clinical models", "Generic models"],
-                                value=["🏥  Clinical models", "Generic models"],
-                                interactive=True,
-                                elem_id="filter-columns-type",
-                            )
-                            filter_columns_size = gr.CheckboxGroup(
-                                label="Model sizes (in billions of parameters)",
-                                choices=list(NUMERIC_INTERVALS.keys()),
-                                value=list(NUMERIC_INTERVALS.keys()),
-                                interactive=True,
-                                elem_id="filter-columns-size",
-                            )
-
-                    datasets_leaderboard_df, datasets_original_df = update_df(shown_columns.value, subset="soap")
-
-                    leaderboard_table = gr.components.Dataframe(
-                        value=datasets_leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
-                        headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                        datatype=TYPES,
-                        elem_id="leaderboard-table",
-                        interactive=False,
-                        visible=True,
-                    )
-
-                    # Dummy leaderboard for handling the case when the user uses backspace key
-                    hidden_leaderboard_table_for_search = gr.components.Dataframe(
-                        value=datasets_original_df[SOAP_COLS],
-                        headers=SOAP_COLS,
-                        datatype=TYPES,
-                        visible=False,
+            with gr.Tabs(elem_classes="tab-buttons2"):
+                with gr.TabItem("ACI Bench", id=0):
+                    create_leaderboard_ui(
+                        subset_name="aci",
+                        column_choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.aci_col)],
+                        default_columns=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.aci_col)]
                     )
-
-                                
-                    search_bar.submit(
-                        update_table,
-                        [
-                            hidden_leaderboard_table_for_search,
-                            shown_columns,
-                            search_bar,
-                            # filter_columns_type,
-                            filter_domain_specific,
-                            filter_columns_size
-                            # filter_columns_architecture
-                        ],
-                        leaderboard_table,
+                with gr.TabItem("SOAP Notes", id=1):
+                    create_leaderboard_ui(
+                        subset_name="soap",
+                        column_choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.soap_col)],
+                        default_columns=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.soap_col)]
                     )
-                    for selector in [
-                        shown_columns,
-                        # filter_columns_type,
-                        filter_domain_specific,
-                        filter_columns_size,
-                        # deleted_models_visibility,
-                    ]:
-                        selector.change(
-                            update_table,
-                            [
-                                hidden_leaderboard_table_for_search,
-                                shown_columns,
-                                search_bar,
-                                # filter_columns_type,
-                                filter_domain_specific,
-                                filter_columns_size
-                            ],
-                            leaderboard_table,
-                            queue=True,
-                        )
-            with gr.Accordion("💬 Generation templates", open=False):
-                with gr.Accordion("ACI-Bench Response generation", open=False):
-                    system_prompt, user_prompt = render_generation_templates(task="aci", generation_type="response_generation")
-                with gr.Accordion("SOAP Notes Response generation", open=False):
-                    system_prompt, user_prompt = render_generation_templates(task="soap", generation_type="response_generation")
-                with gr.Accordion("Question generation", open=False):
-                    system_prompt, user_prompt = render_generation_templates(task="ce", generation_type="question_generation")
-                with gr.Accordion("Cross Examination", open=False):
-                    system_prompt, user_prompt = render_generation_templates(task="ce", generation_type="cross_examination")
+            # Add accordions for this section if needed, similar to other tabs
         
         with gr.TabItem("🏅 HealthBench", elem_id="llm-benchmark-tab-table", id=4):
             gr.Markdown(HEALTHBENCH_METRICS, elem_classes="markdown-text")
-            with gr.Tabs(elem_classes="tab-buttons2") as tabs:
-                with gr.TabItem("HealthBench", elem_id="llm-benchmark-tab-table3", id=0):
-                    with gr.Row():
-                        with gr.Column():
-                            with gr.Row():
-                                search_bar = gr.Textbox(
-                                    placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
-                                    show_label=False,
-                                    elem_id="search-bar",
-                                )
-                            with gr.Row():
-                                shown_columns = gr.CheckboxGroup(
-                                    choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.healthbench_col)],
-                                    value=[
-                                        c.name
-                                        for c in fields(AutoEvalColumn)
-                                        if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.healthbench_col)
-                                    ],
-                                    label="Select columns to show",
-                                    elem_id="column-select",
-                                    interactive=True,
-                                )
-                            # with gr.Row():
-                            #     deleted_models_visibility = gr.Checkbox(
-                            #         value=False, label="Show gated/private/deleted models", interactive=True
-                            #     )
-                        with gr.Column(min_width=320):
-                            # with gr.Box(elem_id="box-filter"):
-                            # filter_columns_type = gr.CheckboxGroup(
-                            #     label="Model Types",
-                            #     choices=[t.to_str() for t in ModelType],
-                            #     value=[t.to_str() for t in ModelType],
-                            #     interactive=True,
-                            #     elem_id="filter-columns-type",
-                            # )
-                            # filter_columns_architecture = gr.CheckboxGroup(
-                            #     label="Architecture Types",
-                            #     choices=[i.value.name for i in ModelArch],
-                            #     value=[i.value.name for i in ModelArch],
-                            #     interactive=True,
-                            #     elem_id="filter-columns-architecture",
-                            # )
-                            filter_domain_specific = gr.CheckboxGroup(
-                                label="Domain Specificity",
-                                choices=["🏥  Clinical models", "Generic models"],
-                                value=["🏥  Clinical models", "Generic models"],
-                                interactive=True,
-                                elem_id="filter-columns-type",
-                            )
-                            filter_columns_size = gr.CheckboxGroup(
-                                label="Model sizes (in billions of parameters)",
-                                choices=list(NUMERIC_INTERVALS.keys()),
-                                value=list(NUMERIC_INTERVALS.keys()),
-                                interactive=True,
-                                elem_id="filter-columns-size",
-                            )
-
-                    datasets_leaderboard_df, datasets_original_df = update_df(shown_columns.value, subset="healthbench")
-
-                    leaderboard_table = gr.components.Dataframe(
-                        value=datasets_leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
-                        headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                        datatype=TYPES,
-                        elem_id="leaderboard-table",
-                        interactive=False,
-                        visible=True,
-                    )
-
-                    # Dummy leaderboard for handling the case when the user uses backspace key
-                    hidden_leaderboard_table_for_search = gr.components.Dataframe(
-                        value=datasets_original_df[HEALTHBENCH_COLS],
-                        headers=HEALTHBENCH_COLS,
-                        datatype=TYPES,
-                        visible=False,
-                    )
-
-                                
-                    search_bar.submit(
-                        update_table,
-                        [
-                            hidden_leaderboard_table_for_search,
-                            shown_columns,
-                            search_bar,
-                            # filter_columns_type,
-                            filter_domain_specific,
-                            filter_columns_size
-                            # filter_columns_architecture
-                        ],
-                        leaderboard_table,
-                    )
-                    for selector in [
-                        shown_columns,
-                        # filter_columns_type,
-                        filter_domain_specific,
-                        filter_columns_size,
-                        # deleted_models_visibility,
-                    ]:
-                        selector.change(
-                            update_table,
-                            [
-                                hidden_leaderboard_table_for_search,
-                                shown_columns,
-                                search_bar,
-                                # filter_columns_type,
-                                filter_domain_specific,
-                                filter_columns_size
-                            ],
-                            leaderboard_table,
-                            queue=True,
-                        )
-                with gr.TabItem("HealthBench-Hard", elem_id="llm-benchmark-tab-table3", id=1):
-                    with gr.Row():
-                        with gr.Column():
-                            with gr.Row():
-                                search_bar = gr.Textbox(
-                                    placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
-                                    show_label=False,
-                                    elem_id="search-bar",
-                                )
-                            with gr.Row():
-                                shown_columns = gr.CheckboxGroup(
-                                    choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.healthbench_hard_col)],
-                                    value=[
-                                        c.name
-                                        for c in fields(AutoEvalColumn)
-                                        if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.healthbench_hard_col)
-                                    ],
-                                    label="Select columns to show",
-                                    elem_id="column-select",
-                                    interactive=True,
-                                )
-                            # with gr.Row():
-                            #     deleted_models_visibility = gr.Checkbox(
-                            #         value=False, label="Show gated/private/deleted models", interactive=True
-                            #     )
-                        with gr.Column(min_width=320):
-                            # with gr.Box(elem_id="box-filter"):
-                            # filter_columns_type = gr.CheckboxGroup(
-                            #     label="Model Types",
-                            #     choices=[t.to_str() for t in ModelType],
-                            #     value=[t.to_str() for t in ModelType],
-                            #     interactive=True,
-                            #     elem_id="filter-columns-type",
-                            # )
-                            # filter_columns_architecture = gr.CheckboxGroup(
-                            #     label="Architecture Types",
-                            #     choices=[i.value.name for i in ModelArch],
-                            #     value=[i.value.name for i in ModelArch],
-                            #     interactive=True,
-                            #     elem_id="filter-columns-architecture",
-                            # )
-                            filter_domain_specific = gr.CheckboxGroup(
-                                label="Domain Specificity",
-                                choices=["🏥  Clinical models", "Generic models"],
-                                value=["🏥  Clinical models", "Generic models"],
-                                interactive=True,
-                                elem_id="filter-columns-type",
-                            )
-                            filter_columns_size = gr.CheckboxGroup(
-                                label="Model sizes (in billions of parameters)",
-                                choices=list(NUMERIC_INTERVALS.keys()),
-                                value=list(NUMERIC_INTERVALS.keys()),
-                                interactive=True,
-                                elem_id="filter-columns-size",
-                            )
-
-                    datasets_leaderboard_df, datasets_original_df = update_df(shown_columns.value, subset="healthbench_hard")
-
-                    leaderboard_table = gr.components.Dataframe(
-                        value=datasets_leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
-                        headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                        datatype=TYPES,
-                        elem_id="leaderboard-table",
-                        interactive=False,
-                        visible=True,
-                    )
-
-                    # Dummy leaderboard for handling the case when the user uses backspace key
-                    hidden_leaderboard_table_for_search = gr.components.Dataframe(
-                        value=datasets_original_df[HEALTHBENCH_HARD_COLS],
-                        headers=HEALTHBENCH_HARD_COLS,
-                        datatype=TYPES,
-                        visible=False,
+            with gr.Tabs(elem_classes="tab-buttons2"):
+                with gr.TabItem("HealthBench", id=0):
+                    create_leaderboard_ui(
+                        subset_name="healthbench",
+                        column_choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.healthbench_col)],
+                        default_columns=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.healthbench_col)]
                     )
-
-                                
-                    search_bar.submit(
-                        update_table,
-                        [
-                            hidden_leaderboard_table_for_search,
-                            shown_columns,
-                            search_bar,
-                            # filter_columns_type,
-                            filter_domain_specific,
-                            filter_columns_size
-                            # filter_columns_architecture
-                        ],
-                        leaderboard_table,
+                with gr.TabItem("HealthBench-Hard", id=1):
+                    create_leaderboard_ui(
+                        subset_name="healthbench_hard",
+                        column_choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.healthbench_hard_col)],
+                        default_columns=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.healthbench_hard_col)]
                     )
-                    for selector in [
-                        shown_columns,
-                        # filter_columns_type,
-                        filter_domain_specific,
-                        filter_columns_size,
-                        # deleted_models_visibility,
-                    ]:
-                        selector.change(
-                            update_table,
-                            [
-                                hidden_leaderboard_table_for_search,
-                                shown_columns,
-                                search_bar,
-                                # filter_columns_type,
-                                filter_domain_specific,
-                                filter_columns_size
-                            ],
-                            leaderboard_table,
-                            queue=True,
-                        )        
 
         with gr.TabItem("🏅 Med Safety", elem_id="llm-benchmark-tab-table", id=5):
-            with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        search_bar = gr.Textbox(
-                            placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
-                            show_label=False,
-                            elem_id="search-bar",
-                        )
-                    with gr.Row():
-                        shown_columns = gr.CheckboxGroup(
-                            choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.med_safety_col)],
-                            value=[
-                                c.name
-                                for c in fields(AutoEvalColumn)
-                                if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.med_safety_col)
-                            ],
-                            label="Select columns to show",
-                            elem_id="column-select",
-                            interactive=True,
-                        )
-                    # with gr.Row():
-                    #     deleted_models_visibility = gr.Checkbox(
-                    #         value=False, label="Show gated/private/deleted models", interactive=True
-                    #     )
-                with gr.Column(min_width=320):
-                    # with gr.Box(elem_id="box-filter"):
-                    # filter_columns_type = gr.CheckboxGroup(
-                    #     label="Model Types",
-                    #     choices=[t.to_str() for t in ModelType],
-                    #     value=[t.to_str() for t in ModelType],
-                    #     interactive=True,
-                    #     elem_id="filter-columns-type",
-                    # )
-                    # filter_columns_architecture = gr.CheckboxGroup(
-                    #     label="Architecture Types",
-                    #     choices=[i.value.name for i in ModelArch],
-                    #     value=[i.value.name for i in ModelArch],
-                    #     interactive=True,
-                    #     elem_id="filter-columns-architecture",
-                    # )
-                    filter_domain_specific = gr.CheckboxGroup(
-                        label="Domain Specificity",
-                        choices=["🏥  Clinical models", "Generic models"],
-                        value=["🏥  Clinical models", "Generic models"],
-                        interactive=True,
-                        elem_id="filter-columns-type",
-                    )
-                    filter_columns_size = gr.CheckboxGroup(
-                        label="Model sizes (in billions of parameters)",
-                        choices=list(NUMERIC_INTERVALS.keys()),
-                        value=list(NUMERIC_INTERVALS.keys()),
-                        interactive=True,
-                        elem_id="filter-columns-size",
-                    )
-
-            datasets_leaderboard_df, datasets_original_df = update_df(shown_columns.value, subset="med_safety")
-
-            leaderboard_table = gr.components.Dataframe(
-                value=datasets_leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
-                headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                datatype=TYPES,
-                elem_id="leaderboard-table",
-                interactive=False,
-                visible=True,
+            create_leaderboard_ui(
+                subset_name="med_safety",
+                column_choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.med_safety_col)],
+                default_columns=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.med_safety_col)]
             )
-
-            # Dummy leaderboard for handling the case when the user uses backspace key
-            hidden_leaderboard_table_for_search = gr.components.Dataframe(
-                value=datasets_original_df[MED_SAFETY_COLS],
-                headers=MED_SAFETY_COLS,
-                datatype=TYPES,
-                visible=False,
-            )
-
-                        
-            search_bar.submit(
-                update_table,
-                [
-                    hidden_leaderboard_table_for_search,
-                    shown_columns,
-                    search_bar,
-                    # filter_columns_type,
-                    filter_domain_specific,
-                    filter_columns_size
-                    # filter_columns_architecture
-                ],
-                leaderboard_table,
-            )
-            for selector in [
-                shown_columns,
-                # filter_columns_type,
-                filter_domain_specific,
-                filter_columns_size,
-                # deleted_models_visibility,
-            ]:
-                selector.change(
-                    update_table,
-                    [
-                        hidden_leaderboard_table_for_search,
-                        shown_columns,
-                        search_bar,
-                        # filter_columns_type,
-                        filter_domain_specific,
-                        filter_columns_size
-                    ],
-                    leaderboard_table,
-                    queue=True,
-                )
             with gr.Accordion("💬 Generation templates", open=False):
                 with gr.Accordion("Response generation", open=False):
-                    system_prompt, user_prompt = render_generation_templates(task="med_safety", generation_type="response_generation")
+                    render_generation_templates(task="med_safety", generation_type="response_generation")
                 with gr.Accordion("Scoring Rubric", open=False):
-                    system_prompt, user_prompt = render_generation_templates(task="med_safety", generation_type="scoring_rubric")
-
+                    render_generation_templates(task="med_safety", generation_type="scoring_rubric")
+        
         with gr.TabItem("🏅 Closed Ended Evaluation", elem_id="llm-benchmark-tab-closed", id=6):
-            with gr.Tabs(elem_classes="tab-buttons2") as closed_tabs:
-                # ENGLISH TAB
-                with gr.TabItem("English", elem_id="llm-benchmark-tab-closed-english", id=0):
-                    with gr.Row():
-                        with gr.Column():
-                            with gr.Row():
-                                search_bar = gr.Textbox(
-                                    placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
-                                    show_label=False,
-                                    elem_id="search-bar-closed-english",
-                                )
-                            with gr.Row():
-                                shown_columns = gr.CheckboxGroup(
-                                    choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.dataset_task_col)],
-                                    value=[
-                                        c.name
-                                        for c in fields(AutoEvalColumn)
-                                        if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.dataset_task_col)
-                                    ],
-                                    label="Select columns to show",
-                                    elem_id="column-select-closed-english",
-                                    interactive=True,
-                                )
-                        with gr.Column(min_width=320):
-                            # filter_columns_type = gr.CheckboxGroup(
-                            #     label="Model Types",
-                            #     choices=[t.to_str() for t in ModelType],
-                            #     value=[t.to_str() for t in ModelType],
-                            #     interactive=True,
-                            #     elem_id="filter-columns-type-closed-english",
-                            # )
-                            filter_domain_specific = gr.CheckboxGroup(
-                                label="Domain Specificity",
-                                choices=["🏥  Clinical models", "Generic models"],
-                                value=["🏥  Clinical models", "Generic models"],
-                                interactive=True,
-                                elem_id="filter-domain-specific-closed-english",
-                            )
-                            filter_columns_size = gr.CheckboxGroup(
-                                label="Model sizes (in billions of parameters)",
-                                choices=list(NUMERIC_INTERVALS.keys()),
-                                value=list(NUMERIC_INTERVALS.keys()),
-                                interactive=True,
-                                elem_id="filter-columns-size-closed-english",
-                            )
-
-                    datasets_leaderboard_df, datasets_original_df = update_df(shown_columns.value, subset="datasets")
-                    leaderboard_table = gr.components.Dataframe(
-                        value=datasets_leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
-                        headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                        datatype=TYPES,
-                        elem_id="leaderboard-table-english",
-                        interactive=False,
-                        visible=True,
-                    )
-
-                    # Dummy leaderboard for handling the case when the user uses backspace key
-                    hidden_leaderboard_table_for_search = gr.components.Dataframe(
-                        value=datasets_original_df[DATASET_COLS],
-                        headers=DATASET_COLS,
-                        datatype=TYPES,
-                        visible=False,
+            with gr.Tabs(elem_classes="tab-buttons2"):
+                with gr.TabItem("English", id=0):
+                    create_leaderboard_ui(
+                        subset_name="datasets",
+                        column_choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.dataset_task_col)],
+                        default_columns=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.dataset_task_col)]
                     )
-                                
-                    search_bar.submit(
-                        update_table,
-                        [
-                            hidden_leaderboard_table_for_search,
-                            shown_columns,
-                            search_bar,
-                            # filter_columns_type,
-                            filter_domain_specific,
-                            filter_columns_size
-                        ],
-                        leaderboard_table,
+                with gr.TabItem("🌍 Multilingual", id=1):
+                    gr.Markdown("📊 **Dataset Information:** This tab uses the Global MMLU dataset filtering only the subcategory: medical (10.7%)")
+                    create_leaderboard_ui(
+                        subset_name="closed_ended_multilingual",
+                        column_choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.closed_ended_multilingual_col)],
+                        default_columns=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.closed_ended_multilingual_col)]
                     )
-                    
-                    for selector in [
-                        shown_columns,
-                        # filter_columns_type,
-                        filter_domain_specific,
-                        filter_columns_size,
-                    ]:
-                        selector.change(
-                            update_table,
-                            [
-                                hidden_leaderboard_table_for_search,
-                                shown_columns,
-                                search_bar,
-                                # filter_columns_type,
-                                filter_domain_specific,
-                                filter_columns_size
-                            ],
-                            leaderboard_table,
-                            queue=True,
-                        )
-                
-                #MULTILINGUAL TAB - Same level as English tab
-                with gr.TabItem("🌍 Multilingual", elem_id="llm-benchmark-tab-table9", id=1):
-                    with gr.Row():
-                        gr.Markdown("📊 **Dataset Information:** This tab uses the Global MMLU dataset filtering only the subcategory: medical (10.7%)")
-                    
-                    with gr.Row():
-                        with gr.Column():
-                            with gr.Row():
-                                search_bar = gr.Textbox(
-                                    placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
-                                    show_label=False,
-                                    elem_id="search-bar",
-                                )
-                                
-                            with gr.Row():
-                                shown_columns = gr.CheckboxGroup(
-                                    choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden and (c.invariant or c.closed_ended_multilingual_col)],
-                                    value=[
-                                        c.name
-                                        for c in fields(AutoEvalColumn)
-                                        if c.displayed_by_default and not c.hidden and not c.never_hidden and (c.invariant or c.closed_ended_multilingual_col)
-                                    ],
-                                    label="Select columns to show",
-                                    elem_id="column-select",
-                                    interactive=True,
-                                )
-                        with gr.Column(min_width=320):
-                            # with gr.Box(elem_id="box-filter"):
-                            # filter_columns_type = gr.CheckboxGroup(
-                            #     label="Model Types",
-                            #     choices=[t.to_str() for t in ModelType],
-                            #     value=[t.to_str() for t in ModelType],
-                            #     interactive=True,
-                            #     elem_id="filter-columns-type",
-                            # )
-                            filter_domain_specific = gr.CheckboxGroup(
-                                label="Domain Specificity",
-                                choices=["🏥  Clinical models", "Generic models"],
-                                value=["🏥  Clinical models", "Generic models"],
-                                interactive=True,
-                                elem_id="filter-columns-type",
-                            )
-                            filter_columns_size = gr.CheckboxGroup(
-                                label="Model sizes (in billions of parameters)",
-                                choices=list(NUMERIC_INTERVALS.keys()),
-                                value=list(NUMERIC_INTERVALS.keys()),
-                                interactive=True,
-                                elem_id="filter-columns-size",
-                            )
 
-                    datasets_leaderboard_df, datasets_original_df = update_df(shown_columns.value, subset="closed_ended_multilingual")
-                    leaderboard_table = gr.components.Dataframe(
-                        value=datasets_leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
-                        headers=[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value,
-                        datatype=TYPES,
-                        elem_id="leaderboard-table",
-                        interactive=False,
-                        visible=True,
-                    )
-                    hidden_leaderboard_table_for_search = gr.components.Dataframe(
-                        value=datasets_original_df[ClosedEndedMultilingual_COLS],
-                        headers=ClosedEndedMultilingual_COLS,
-                        datatype=TYPES,
-                        visible=False,
-                    )
-                        
-                    search_bar.submit(
-                        update_table,
-                        [
-                            hidden_leaderboard_table_for_search,
-                            shown_columns,
-                            search_bar,
-                            # filter_columns_type,
-                            filter_domain_specific,
-                            filter_columns_size
-                            # filter_columns_architecture
-                        ],
-                        leaderboard_table,
-                    )
-                    for selector in [
-                        shown_columns,
-                        # filter_columns_type,
-                        filter_domain_specific,
-                        # filter_columns_architecture,
-                        filter_columns_size,
-                        # deleted_models_visibility,
-                    ]:
-                        selector.change(
-                            update_table,
-                            [
-                                hidden_leaderboard_table_for_search,
-                                shown_columns,
-                                search_bar,
-                                # filter_columns_type,
-                                filter_domain_specific,
-                                filter_columns_size
-                                # filter_columns_architecture,
-                            ],
-                            leaderboard_table,
-                            queue=True,
-                        )
-    
         with gr.TabItem("📝 About", elem_id="llm-benchmark-tab-table", id=7):
             gr.Markdown(LLM_BENCHMARKS_TEXT_1, elem_classes="markdown-text")
             gr.HTML(FIVE_PILLAR_DIAGRAM)
             gr.Markdown(LLM_BENCHMARKS_TEXT_2, elem_classes="markdown-text")
-            # gr.HTML(EVALUATION_EXAMPLE_IMG, elem_classes="logo")
-            # gr.Markdown(LLM_BENCHMARKS_TEXT_2, elem_classes="markdown-text")
-            # gr.HTML(ENTITY_DISTRIBUTION_IMG, elem_classes="logo")
-            # gr.Markdown(LLM_BENCHMARKS_TEXT_3, elem_classes="markdown-text")
             
         with gr.TabItem("🚀 Submit here! ", elem_id="llm-benchmark-tab-table", id=8):
+            
             with gr.Column():
-                with gr.Row():
-                    gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")
-
-                with gr.Column():
-                    with gr.Accordion(
-                        f"✅ Finished Evaluations ({len(finished_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            finished_eval_table = gr.components.Dataframe(
-                                value=finished_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                            )
-                    with gr.Accordion(
-                        f"🔄 Running Evaluation Queue ({len(running_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            running_eval_table = gr.components.Dataframe(
-                                value=running_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                            )
-
-                    with gr.Accordion(
-                        f"⏳ Pending Evaluation Queue ({len(pending_eval_queue_df)})",
-                        open=False,
-                    ):
-                        with gr.Row():
-                            pending_eval_table = gr.components.Dataframe(
-                                value=pending_eval_queue_df,
-                                headers=EVAL_COLS,
-                                datatype=EVAL_TYPES,
-                                row_count=5,
-                            )
+                gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")
+                with gr.Accordion(f"✅ Finished Evaluations ({len(finished_eval_queue_df)})", open=False):
+                    gr.Dataframe(value=finished_eval_queue_df, headers=EVAL_COLS, datatype=EVAL_TYPES, row_count=5)
+                with gr.Accordion(f"🔄 Running Evaluation Queue ({len(running_eval_queue_df)})", open=False):
+                    gr.Dataframe(value=running_eval_queue_df, headers=EVAL_COLS, datatype=EVAL_TYPES, row_count=5)
+                with gr.Accordion(f"⏳ Pending Evaluation Queue ({len(pending_eval_queue_df)})", open=False):
+                    gr.Dataframe(value=pending_eval_queue_df, headers=EVAL_COLS, datatype=EVAL_TYPES, row_count=5)
+            
             with gr.Row():
                 gr.Markdown("# ✉️✨ Submit your model here!", elem_classes="markdown-text")
-
             with gr.Row():
                 with gr.Column():
                     model_name_textbox = gr.Textbox(label="Model name")
@@ -1459,10 +424,9 @@ with demo:
                 submission_result,
             )
 
-
     with gr.Row():
         with gr.Accordion("📙 Citation", open=False):
-            citation_button = gr.Textbox(
+            gr.Textbox(
                 value=CITATION_BUTTON_TEXT,
                 label=CITATION_BUTTON_LABEL,
                 lines=20,
@@ -1470,7 +434,9 @@ with demo:
                 show_copy_button=True,
             )
 
+
 scheduler = BackgroundScheduler()
-scheduler.add_job(restart_space, "interval", seconds=1800)
+scheduler.add_job(restart_space, "interval", seconds=86400) 
 scheduler.start()
+
 demo.queue(default_concurrency_limit=40).launch(allowed_paths=['./assets/'], share=True , ssr_mode=False)