style theme

app.py

@@ -171,27 +171,44 @@ def update_column_choices(df):
 
 # Update the column_selector initialization
 def get_initial_columns():
-    """Get initial columns to show in the dropdown"""
+    """Get initial columns to show in the dropdown (as display names)."""
     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}")
 
-        # If dataframe is empty, use default visible columns
-        if not available_cols:
-            return get_default_visible_columns()
+        # Get default visible internal names that actually exist
+        internal_defaults = [col for col in get_default_visible_columns() if col in 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]
+        # If none of the defaults exist, use all available columns
+        if not internal_defaults:
+             internal_defaults = available_cols
 
-        # If none of the defaults exist, return all available columns
-        if not valid_defaults:
-            return 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
 
-        return valid_defaults
     except Exception as e:
         logger.error(f"Error getting initial columns: {e}")
-        return get_default_visible_columns()
+        # 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
 
 def init_leaderboard(dataframe, visible_columns=None):
     """
@@ -256,7 +273,12 @@ def init_leaderboard(dataframe, visible_columns=None):
         datatypes.append(col_type)
 
     # Create a mapping from internal column names to display names
-    all_columns_map = {field.name: field.display_name for field in fields(GUARDBENCH_COLUMN)}
+    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]
@@ -339,13 +361,32 @@ 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]
-        selected_columns = [x.lower().replace(" ", "_").replace("(", "").replace(")", "").replace("_recall", "_recall_binary") for x in 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 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
 
         # Log the actual columns we have
         logger.info(f"Main dataframe columns: {list(main_df.columns)}")
@@ -357,27 +398,31 @@ def refresh_data_with_filters(version=CURRENT_VERSION, search_query="", model_ty
             for df in category_dfs
         ]
 
-        # Get available columns from the dataframe
+        # Get available columns from the filtered data
         available_columns = list(filtered_main_df.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()
+        # 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
         else:
-            valid_selected_columns = available_columns
+            # If no columns were selected initially, use all available internal columns
+            valid_internal_selected_columns = available_columns
 
-        # Initialize dataframes for display with valid selected columns
-        main_dataframe = init_leaderboard(filtered_main_df, valid_selected_columns)
+        # Initialize dataframes for display with valid internal selected columns
+        main_dataframe = init_leaderboard(filtered_main_df, valid_internal_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)
-            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()
+            # 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
             category_dataframes.append(init_leaderboard(df, df_valid_columns))
 
         return main_dataframe, *category_dataframes
@@ -672,45 +717,44 @@ 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 to show: {selected_columns}")
+                        logger.info(f"Updating columns based on display names: {selected_columns}")
 
-                        # If no columns are selected, use default visible columns
-                        if not selected_columns or len(selected_columns) == 0:
-                            selected_columns = get_default_visible_columns()
-                            logger.info(f"No columns selected, using defaults: {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')
+                        }
 
-                        selected_columns = [x.lower().replace(" ", "_").replace("(", "").replace(")", "").replace("_recall", "_recall_binary") for x in selected_columns]
+                        # Convert selected display names to internal names
+                        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}")
 
+                        # 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]
 
-                        # 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
+                        # Initialize leaderboards with the internal selected columns
+                        main_leaderboard = init_leaderboard(main_df, internal_selected_columns)
                         category_leaderboards = []
                         for df in category_dfs:
-                            # 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))
+                            category_leaderboards.append(init_leaderboard(df, internal_selected_columns))
 
                         return main_leaderboard, *category_leaderboards
 
@@ -718,6 +762,8 @@ 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,23 +373,9 @@ METRICS = [
 ]
 
 def get_all_column_choices():
-    """
-    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
+    """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')]
 
 def get_default_visible_columns():
     """