looks good !

app.py

@@ -33,7 +33,9 @@ from src.display.utils import (
     ModelType,
     Precision,
     WeightType,
-    GuardModelType
+    GuardModelType,
+    get_all_column_choices,
+    get_default_visible_columns,
 )
 from src.display.formatting import styled_message, styled_error, styled_warning
 from src.envs import (
@@ -69,9 +71,55 @@ except Exception as e:
 
 print(DISPLAY_COLS)
 
-def init_leaderboard(dataframe):
+# Define the update_column_choices function before initializing the leaderboard components
+def update_column_choices(df):
+    """Update column choices based on what's actually in the dataframe"""
+    if df is None or df.empty:
+        return get_all_column_choices()
+
+    # Get columns that actually exist in the dataframe
+    existing_columns = list(df.columns)
+
+    # Get all possible columns with their display names
+    all_columns = get_all_column_choices()
+
+    # Filter to only include columns that exist in the dataframe
+    valid_columns = [(col_name, display_name) for col_name, display_name in all_columns
+                     if col_name in existing_columns]
+
+    # Return default if there are no valid columns
+    if not valid_columns:
+        return get_all_column_choices()
+
+    return valid_columns
+
+# Update the column_selector initialization
+def get_initial_columns():
+    """Get initial columns to show in the dropdown"""
+    try:
+        # 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 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, 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}")
+        return get_default_visible_columns()
+
+def init_leaderboard(dataframe, visible_columns=None):
     """
-    Initialize the leaderboard component.
+    Initialize a standard Gradio Dataframe component for the leaderboard.
     """
     if dataframe is None or dataframe.empty:
         # Create an empty dataframe with the right columns
@@ -79,26 +127,174 @@ def init_leaderboard(dataframe):
         dataframe = pd.DataFrame(columns=columns)
         logger.warning("Initializing empty leaderboard")
 
-    print("\n\n", "dataframe", dataframe, "--------------------------------\n\n")
+    # print("\n\n", "dataframe", dataframe, "--------------------------------\n\n")
+
+    # Determine which columns to display
+    display_column_names = [getattr(GUARDBENCH_COLUMN, col).name for col in DISPLAY_COLS]
+    hidden_column_names = [getattr(GUARDBENCH_COLUMN, col).name for col in HIDDEN_COLS]
+
+    # Columns that should always be shown
+    always_visible = [getattr(GUARDBENCH_COLUMN, col).name for col in NEVER_HIDDEN_COLS]
+
+    # Use provided visible columns if specified, otherwise use default
+    if visible_columns is None:
+        # Determine which columns to show initially
+        visible_columns = [col for col in display_column_names if col not in hidden_column_names]
+
+    # Always include the never-hidden columns
+    for col in always_visible:
+        if col not in visible_columns and col in dataframe.columns:
+            visible_columns.append(col)
+
+    # Make sure we only include columns that actually exist in the dataframe
+    visible_columns = [col for col in visible_columns if col in dataframe.columns]
+
+    # Map GuardBench column types to Gradio's expected datatype strings
+    # Valid Gradio datatypes are: 'str', 'number', 'bool', 'date', 'markdown', 'html', 'image'
+    type_mapping = {
+        'text': 'str',
+        'number': 'number',
+        'bool': 'bool',
+        'date': 'date',
+        'markdown': 'markdown',
+        'html': 'html',
+        'image': 'image'
+    }
 
-    return Leaderboard(
-        value=dataframe,
-        datatype=[getattr(GUARDBENCH_COLUMN, col).type for col in DISPLAY_COLS],
-        select_columns=SelectColumns(
-            default_selection=[getattr(GUARDBENCH_COLUMN, col).name for col in DISPLAY_COLS],
-            cant_deselect=[getattr(GUARDBENCH_COLUMN, col).name for col in NEVER_HIDDEN_COLS],
-            label="Select Columns to Display:",
-        ),
-        search_columns=[GUARDBENCH_COLUMN.model_name.name],
-        hide_columns=[getattr(GUARDBENCH_COLUMN, col).name for col in HIDDEN_COLS],
-        filter_columns=[
-            ColumnFilter(GUARDBENCH_COLUMN.model_type.name, type="checkboxgroup", label="Model types"),
-        ],
+    # Create a list of datatypes in the format Gradio expects
+    datatypes = []
+    for col in visible_columns:
+        # Find the corresponding GUARDBENCH_COLUMN entry
+        col_type = None
+        for display_col in DISPLAY_COLS:
+            if getattr(GUARDBENCH_COLUMN, display_col).name == col:
+                orig_type = getattr(GUARDBENCH_COLUMN, display_col).type
+                # Map to Gradio's expected types
+                col_type = type_mapping.get(orig_type, 'str')
+                break
+
+        # Default to 'str' if type not found or not mappable
+        if col_type is None:
+            col_type = 'str'
+
+        datatypes.append(col_type)
+
+    # Create a dummy column for search functionality if it doesn't exist
+    if 'search_dummy' not in dataframe.columns:
+        dataframe['search_dummy'] = dataframe.apply(
+            lambda row: ' '.join(str(val) for val in row.values if pd.notna(val)),
+            axis=1
+        )
+
+    # Select only the visible columns for display
+    visible_columns.remove('model_name')
+    visible_columns = ['model_name'] + visible_columns
+    display_df = dataframe[visible_columns].copy()
+
+    return gr.Dataframe(
+        value=display_df,
+        headers=visible_columns,
+        datatype=datatypes,  # Now using the correct format
         interactive=False,
-        render=True,
+        wrap=True,
+        elem_id="leaderboard-table",
+        row_count=len(display_df)
     )
 
 
+def search_filter_leaderboard(df, search_query="", model_types=None, version=CURRENT_VERSION):
+    """
+    Filter the leaderboard based on search query and model types.
+    """
+    if df is None or df.empty:
+        return df
+
+    filtered_df = df.copy()
+
+    # Add search dummy column if it doesn't exist
+    if 'search_dummy' not in filtered_df.columns:
+        filtered_df['search_dummy'] = filtered_df.apply(
+            lambda row: ' '.join(str(val) for val in row.values if pd.notna(val)),
+            axis=1
+        )
+
+    # Apply model type filter
+    if model_types and len(model_types) > 0:
+        filtered_df = filtered_df[filtered_df[GUARDBENCH_COLUMN.model_type.name].isin(model_types)]
+
+    # Apply search query
+    if search_query:
+        search_terms = [term.strip() for term in search_query.split(";") if term.strip()]
+        if search_terms:
+            combined_mask = None
+            for term in search_terms:
+                mask = filtered_df['search_dummy'].str.contains(term, case=False, na=False)
+                if combined_mask is None:
+                    combined_mask = mask
+                else:
+                    combined_mask = combined_mask | mask
+
+            if combined_mask is not None:
+                filtered_df = filtered_df[combined_mask]
+
+    # Drop the search dummy column before returning
+    visible_columns = [col for col in filtered_df.columns if col != 'search_dummy']
+    return filtered_df[visible_columns]
+
+
+def refresh_data_with_filters(version=CURRENT_VERSION, search_query="", model_types=None, selected_columns=None):
+    """
+    Refresh the leaderboard data and update all components with filtering.
+    Ensures we handle cases where dataframes might have limited columns.
+    """
+    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]
+
+        # Log the actual columns we have
+        logger.info(f"Main dataframe columns: {list(main_df.columns)}")
+
+        # Apply filters to each dataframe
+        filtered_main_df = search_filter_leaderboard(main_df, search_query, model_types, version)
+        filtered_category_dfs = [
+            search_filter_leaderboard(df, search_query, model_types, version)
+            for df in category_dfs
+        ]
+
+        # Get available columns from the dataframe
+        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()
+        else:
+            valid_selected_columns = available_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)
+            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
+
+    except Exception as e:
+        logger.error(f"Error in refresh with filters: {e}")
+        # Return the current leaderboards on error
+        return leaderboard, *[tab.children[0] for tab in category_tabs.children[1:len(CATEGORIES)+1]]
+
+
 def submit_results(
     model_name: str,
     base_model: str,
@@ -162,25 +358,25 @@ def refresh_data(version=CURRENT_VERSION):
         main_df = get_leaderboard_df(version=version)
         category_dfs = [get_category_leaderboard_df(category, version=version) for category in CATEGORIES]
 
-        # For Leaderboard components, we need to return just the dataframes
-        # The component will handle the update internally
-        return dict(
-            value=main_df
-        ), *[dict(value=df) for df in category_dfs]
+        # For gr.Dataframe, we return the actual dataframes
+        return main_df, *category_dfs
 
     except Exception as e:
         logger.error(f"Error in scheduled refresh: {e}")
-        return dict(value=leaderboard.value), *[dict(value=tab.children[0].value)
-               for tab in category_tabs.children[1:]]
+        return None, *[None for _ in CATEGORIES]
 
 
 def update_leaderboards(version):
     """
     Update all leaderboard components with data for the selected version.
     """
-    new_df = get_leaderboard_df(version=version)
-    category_dfs = [get_category_leaderboard_df(category, version=version) for category in CATEGORIES]
-    return [init_leaderboard(new_df)] + [init_leaderboard(df) for df in category_dfs]
+    try:
+        new_df = get_leaderboard_df(version=version)
+        category_dfs = [get_category_leaderboard_df(category, version=version) for category in CATEGORIES]
+        return new_df, *category_dfs
+    except Exception as e:
+        logger.error(f"Error updating leaderboards for version {version}: {e}")
+        return None, *[None for _ in CATEGORIES]
 
 
 def create_performance_plot(selected_models, category, metric="f1_binary", version=CURRENT_VERSION):
@@ -309,25 +505,132 @@ with demo:
                         scale=1
                     )
 
+                with gr.Row():
+                    search_input = gr.Textbox(
+                        placeholder="Search models (separate queries with ;)...",
+                        label="Search",
+                        elem_id="search-bar"
+                    )
+                    model_type_filter = gr.Dropdown(
+                        choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
+                        label="Filter by Model Type",
+                        multiselect=True,
+                        value=[],
+                        interactive=True
+                    )
+                    column_selector = gr.Dropdown(
+                        choices=get_all_column_choices(),
+                        label="Customize Columns",
+                        multiselect=True,
+                        value=get_initial_columns(),
+                        interactive=True
+                    )
+
                 # Create tabs for each category
                 with gr.Tabs(elem_classes="category-tabs") as category_tabs:
                     # First tab for average metrics across all categories
                     with gr.TabItem("📊 Overall Performance", elem_id="overall-tab"):
-                        print("LEADERBOARD_DF", LEADERBOARD_DF)
                         leaderboard = init_leaderboard(LEADERBOARD_DF)
 
                     # Create a tab for each category
                     for category in CATEGORIES:
                         with gr.TabItem(f"{category}", elem_id=f"category-{category.lower().replace(' ', '-')}-tab"):
-                            print("category DF", category)
                             category_df = get_category_leaderboard_df(category, version=CURRENT_VERSION)
-                            print("category DF", category_df)
                             category_leaderboard = init_leaderboard(category_df)
 
+                # Connect search and filter inputs to update function
+                def update_with_search_filters(version=CURRENT_VERSION, search_query="", model_types=None, selected_columns=None):
+                    """
+                    Update the leaderboards with search and filter settings.
+                    """
+                    return refresh_data_with_filters(version, search_query, model_types, selected_columns)
+
                 # Refresh button functionality
                 refresh_button.click(
-                    fn=refresh_data,
-                    inputs=[],
+                    fn=refresh_data_with_filters,
+                    inputs=[version_selector, search_input, model_type_filter, column_selector],
+                    outputs=[leaderboard] + [category_tabs.children[i].children[0] for i in range(1, len(CATEGORIES) + 1)]
+                )
+
+                # Search input functionality
+                search_input.change(
+                    fn=refresh_data_with_filters,
+                    inputs=[version_selector, search_input, model_type_filter, column_selector],
+                    outputs=[leaderboard] + [category_tabs.children[i].children[0] for i in range(1, len(CATEGORIES) + 1)]
+                )
+
+                # Model type filter functionality
+                model_type_filter.change(
+                    fn=refresh_data_with_filters,
+                    inputs=[version_selector, search_input, model_type_filter, column_selector],
+                    outputs=[leaderboard] + [category_tabs.children[i].children[0] for i in range(1, len(CATEGORIES) + 1)]
+                )
+
+                # Version selector functionality
+                version_selector.change(
+                    fn=refresh_data_with_filters,
+                    inputs=[version_selector, search_input, model_type_filter, column_selector],
+                    outputs=[leaderboard] + [category_tabs.children[i].children[0] for i in range(1, len(CATEGORIES) + 1)]
+                )
+
+                # Update the update_columns function to handle updating all tabs at once
+                def update_columns(selected_columns):
+                    """
+                    Update all leaderboards to show the selected columns.
+                    Ensures all selected columns are preserved in the update.
+
+                    """
+
+                    try:
+                        logger.info(f"Updating columns to show: {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}")
+
+                        selected_columns = [x.lower().replace(" ", "_").replace("(", "").replace(")", "").replace("_recall", "_recall_binary") for x in 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
+                        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))
+
+                        return main_leaderboard, *category_leaderboards
+
+                    except Exception as e:
+                        logger.error(f"Error updating columns: {e}")
+                        import traceback
+                        logger.error(traceback.format_exc())
+                        return leaderboard, *[tab.children[0] for tab in category_tabs.children[1:len(CATEGORIES)+1]]
+
+                # Connect column selector to update function
+                column_selector.change(
+                    fn=update_columns,
+                    inputs=[column_selector],
                     outputs=[leaderboard] + [category_tabs.children[i].children[0] for i in range(1, len(CATEGORIES) + 1)]
                 )
 
@@ -494,3 +797,5 @@ scheduler.start()
 if __name__ == "__main__":
 
     demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
+
+

src/display/utils.py

@@ -324,3 +324,32 @@ METRICS = [
     "error_ratio",
     "avg_runtime_ms"
 ]
+
+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
+
+def get_default_visible_columns():
+    """
+    Get the list of column names that should be visible by default.
+
+    Returns:
+        List of column names that are displayed by default.
+    """
+    return [getattr(GUARDBENCH_COLUMN, f.name).name for f in fields(GUARDBENCH_COLUMN)
+            if getattr(GUARDBENCH_COLUMN, f.name).displayed_by_default]