style theme

app.py

@@ -13,7 +13,6 @@ import plotly.graph_objects as go
 from apscheduler.schedulers.background import BackgroundScheduler
 import numpy as np
 from gradio.themes.utils import fonts, colors
-from dataclasses import fields
 
 from src.about import (
     CITATION_BUTTON_LABEL,
@@ -171,44 +170,27 @@ def update_column_choices(df):
 
 # Update the column_selector initialization
 def get_initial_columns():
-    """Get initial columns to show in the dropdown (as display names)."""
+    """Get initial columns to show in the dropdown"""
     try:
-        internal_defaults = []
         # Get available columns in the main dataframe
         available_cols = list(LEADERBOARD_DF.columns)
         logger.info(f"Available columns in LEADERBOARD_DF: {available_cols}")
 
-        # Get default visible internal names that actually exist
-        internal_defaults = [col for col in get_default_visible_columns() if col in available_cols]
+        # If dataframe is empty, use default visible columns
+        if not available_cols:
+            return get_default_visible_columns()
 
-        # If none of the defaults exist, use all available columns
-        if not internal_defaults:
-             internal_defaults = available_cols
+        # Get default visible columns that actually exist in the dataframe
+        valid_defaults = [col for col in get_default_visible_columns() if col in available_cols]
 
-        # Map internal names to display names
-        gb_cols_instance = GUARDBENCH_COLUMN()
-        all_columns_map = {
-            field.name: getattr(gb_cols_instance, field.name).display_name
-            for field in fields(gb_cols_instance)
-            if hasattr(getattr(gb_cols_instance, field.name), 'display_name')
-        }
-        display_defaults = [all_columns_map.get(col, col) for col in internal_defaults]
-        return display_defaults
+        # If none of the defaults exist, return all available columns
+        if not valid_defaults:
+            return available_cols
 
+        return valid_defaults
     except Exception as e:
         logger.error(f"Error getting initial columns: {e}")
-        # Fallback to default internal names mapped to display names if possible
-        try:
-            gb_cols_instance = GUARDBENCH_COLUMN()
-            all_columns_map = {
-                field.name: getattr(gb_cols_instance, field.name).display_name
-                for field in fields(gb_cols_instance)
-                if hasattr(getattr(gb_cols_instance, field.name), 'display_name')
-            }
-            default_internal = get_default_visible_columns()
-            return [all_columns_map.get(col, col) for col in default_internal]
-        except:
-             return get_default_visible_columns() # Final fallback
+        return get_default_visible_columns()
 
 def init_leaderboard(dataframe, visible_columns=None):
     """
@@ -272,17 +254,6 @@ def init_leaderboard(dataframe, visible_columns=None):
 
         datatypes.append(col_type)
 
-    # Create a mapping from internal column names to display names
-    gb_cols_instance = GUARDBENCH_COLUMN() # Create an instance
-    all_columns_map = {
-        field.name: getattr(gb_cols_instance, field.name).display_name
-        for field in fields(gb_cols_instance)
-        if hasattr(getattr(gb_cols_instance, field.name), 'display_name') # Ensure it has display_name
-    }
-
-    # Create the list of headers using display names
-    display_headers = [all_columns_map.get(col, col) for col in visible_columns]
-
     # Create a dummy column for search functionality if it doesn't exist
     if 'search_dummy' not in dataframe.columns:
         dataframe['search_dummy'] = dataframe.apply(
@@ -306,10 +277,17 @@ def init_leaderboard(dataframe, visible_columns=None):
         if not pd.api.types.is_integer_dtype(display_df[col]):
             display_df[col] = display_df[col].round(3)
 
+    # Create a mapping from internal names to display names
+    all_choices = get_all_column_choices()
+    display_name_map = {internal_name: display_name for internal_name, display_name in all_choices}
+
+    # Generate the list of headers to display based on the visible internal column names
+    display_headers = [display_name_map.get(col, col) for col in visible_columns] # Default to internal name if no mapping found
+
     return gr.Dataframe(
-        value=display_df,
-        headers=display_headers,
-        datatype=datatypes,  # Now using the correct format
+        value=display_df, # The dataframe still uses internal names
+        headers=display_headers, # Use display headers for the UI
+        datatype=datatypes,
         interactive=False,
         wrap=True,
         elem_id="leaderboard-table",
@@ -361,32 +339,13 @@ def refresh_data_with_filters(version=CURRENT_VERSION, search_query="", model_ty
     """
     Refresh the leaderboard data and update all components with filtering.
     Ensures we handle cases where dataframes might have limited columns.
-
-    Args:
-        version: Benchmark version.
-        search_query: Text search query.
-        model_types: List of model types to filter by.
-        selected_columns: List of display names for columns to show.
     """
     try:
         logger.info(f"Performing refresh of leaderboard data with filters...")
         # Get new data
         main_df = get_leaderboard_df(version=version)
         category_dfs = [get_category_leaderboard_df(category, version=version) for category in CATEGORIES]
-
-        # Create reverse mapping from display name to internal name
-        gb_cols_instance = GUARDBENCH_COLUMN()
-        display_to_internal_map = {
-            getattr(gb_cols_instance, field.name).display_name: field.name
-            for field in fields(gb_cols_instance)
-            if hasattr(getattr(gb_cols_instance, field.name), 'display_name')
-        }
-
-        # Convert selected display names to internal names
-        if selected_columns:
-            internal_selected_columns = [display_to_internal_map.get(disp_name, disp_name) for disp_name in selected_columns]
-        else:
-            internal_selected_columns = None # Let init_leaderboard handle default
+        selected_columns = [x.lower().replace(" ", "_").replace("(", "").replace(")", "").replace("_recall", "_recall_binary") for x in selected_columns]
 
         # Log the actual columns we have
         logger.info(f"Main dataframe columns: {list(main_df.columns)}")
@@ -398,31 +357,27 @@ def refresh_data_with_filters(version=CURRENT_VERSION, search_query="", model_ty
             for df in category_dfs
         ]
 
-        # Get available columns from the filtered data
+        # Get available columns from the dataframe
         available_columns = list(filtered_main_df.columns)
 
-        # Filter internal selected columns to only those available in the data
-        if internal_selected_columns:
-            valid_internal_selected_columns = [col for col in internal_selected_columns if col in available_columns]
-            # Ensure model_name is always present if available
-            if 'model_name' in available_columns and 'model_name' not in valid_internal_selected_columns:
-                valid_internal_selected_columns = ['model_name'] + valid_internal_selected_columns
+        # Filter selected columns to only those available in the data
+        if selected_columns:
+            valid_selected_columns = [col for col in selected_columns if col in available_columns]
+            if not valid_selected_columns and 'model_name' in available_columns:
+                valid_selected_columns = ['model_name'] + get_default_visible_columns()
         else:
-            # If no columns were selected initially, use all available internal columns
-            valid_internal_selected_columns = available_columns
+            valid_selected_columns = available_columns
 
-        # Initialize dataframes for display with valid internal selected columns
-        main_dataframe = init_leaderboard(filtered_main_df, valid_internal_selected_columns)
+        # Initialize dataframes for display with valid selected columns
+        main_dataframe = init_leaderboard(filtered_main_df, valid_selected_columns)
 
         # For category dataframes, get columns that actually exist in each one
         category_dataframes = []
         for df in filtered_category_dfs:
             df_columns = list(df.columns)
-            # Use the same valid internal columns, filtered for existence in this specific df
-            df_valid_columns = [col for col in valid_internal_selected_columns if col in df_columns]
-            # Ensure model_name if available
-            if 'model_name' in df_columns and 'model_name' not in df_valid_columns:
-                 df_valid_columns = ['model_name'] + df_valid_columns
+            df_valid_columns = [col for col in valid_selected_columns if col in df_columns]
+            if not df_valid_columns and 'model_name' in df_columns:
+                df_valid_columns = ['model_name'] + get_default_visible_columns()
             category_dataframes.append(init_leaderboard(df, df_valid_columns))
 
         return main_dataframe, *category_dataframes
@@ -717,44 +672,45 @@ with demo:
                     Update all leaderboards to show the selected columns.
                     Ensures all selected columns are preserved in the update.
 
-                    Args:
-                        selected_columns: List of display names from the dropdown.
                     """
 
                     try:
-                        logger.info(f"Updating columns based on display names: {selected_columns}")
+                        logger.info(f"Updating columns to show: {selected_columns}")
 
-                        # Create reverse mapping from display name to internal name
-                        gb_cols_instance = GUARDBENCH_COLUMN()
-                        display_to_internal_map = {
-                            getattr(gb_cols_instance, field.name).display_name: field.name
-                            for field in fields(gb_cols_instance)
-                            if hasattr(getattr(gb_cols_instance, field.name), 'display_name')
-                        }
-
-                        # Convert selected display names to internal names
+                        # If no columns are selected, use default visible columns
                         if not selected_columns or len(selected_columns) == 0:
-                            # If empty, get default internal names
-                            internal_selected_columns = get_default_visible_columns()
-                            logger.info(f"No columns selected, using default internal names: {internal_selected_columns}")
-                        else:
-                            internal_selected_columns = [display_to_internal_map.get(disp_name, disp_name) for disp_name in selected_columns]
-                            logger.info(f"Converted display names to internal names: {internal_selected_columns}")
+                            selected_columns = get_default_visible_columns()
+                            logger.info(f"No columns selected, using defaults: {selected_columns}")
+
+                        selected_columns = [x.lower().replace(" ", "_").replace("(", "").replace(")", "").replace("_recall", "_recall_binary") for x in selected_columns]
 
-                        # Ensure 'model_name' is always included internally
-                        if 'model_name' not in internal_selected_columns:
-                             internal_selected_columns = ['model_name'] + internal_selected_columns
 
                         # Get the current data with ALL columns preserved
                         main_df = get_leaderboard_df(version=version_selector.value)
+
+                        # Get category dataframes with ALL columns preserved
                         category_dfs = [get_category_leaderboard_df(category, version=version_selector.value)
                                        for category in CATEGORIES]
 
-                        # Initialize leaderboards with the internal selected columns
-                        main_leaderboard = init_leaderboard(main_df, internal_selected_columns)
+                        # Log columns for debugging
+                        logger.info(f"Main dataframe columns: {list(main_df.columns)}")
+                        logger.info(f"Selected columns: {selected_columns}")
+
+                        # IMPORTANT: Make sure model_name is always included
+                        if 'model_name' in main_df.columns and 'model_name' not in selected_columns:
+                            selected_columns = ['model_name'] + selected_columns
+
+                        # Initialize the main leaderboard with the selected columns
+                        # We're passing the raw selected_columns directly to preserve the selection
+                        main_leaderboard = init_leaderboard(main_df, selected_columns)
+
+                        # Initialize category dataframes with the same selected columns
+                        # This ensures consistency across all tabs
                         category_leaderboards = []
                         for df in category_dfs:
-                            category_leaderboards.append(init_leaderboard(df, internal_selected_columns))
+                            # Use the same selected columns for each category
+                            # init_leaderboard will automatically handle filtering to columns that exist
+                            category_leaderboards.append(init_leaderboard(df, selected_columns))
 
                         return main_leaderboard, *category_leaderboards
 
@@ -762,8 +718,6 @@ with demo:
                         logger.error(f"Error updating columns: {e}")
                         import traceback
                         logger.error(traceback.format_exc())
-                        # Fallback logic might need adjustment if state uses display names
-                        # For now, return existing components
                         return leaderboard, *[tab.children[0] for tab in category_tabs.children[1:len(CATEGORIES)+1]]
 
                 # Connect column selector to update function

src/display/utils.py

@@ -373,9 +373,23 @@ METRICS = [
 ]
 
 def get_all_column_choices():
-    """Get all possible column choices as display names."""
-    gb_cols_instance = GuardBenchColumn()
-    return [getattr(gb_cols_instance, field.name).display_name for field in fields(gb_cols_instance) if hasattr(getattr(gb_cols_instance, field.name), 'display_name')]
+    """
+    Get all available column choices for the multiselect dropdown.
+
+    Returns:
+        List of tuples with (column_name, display_name) for all columns.
+    """
+    column_choices = []
+
+    default_visible_columns = get_default_visible_columns()
+
+    for f in fields(GUARDBENCH_COLUMN):
+        column_info = getattr(GUARDBENCH_COLUMN, f.name)
+        # Create a tuple with both the internal name and display name
+        if column_info.name not in default_visible_columns:
+            column_choices.append((column_info.name, column_info.display_name))
+
+    return column_choices
 
 def get_default_visible_columns():
     """