debug

app.py

@@ -128,58 +128,122 @@ from src.about import TasksMib_Subgraph
 
 
 
+def init_leaderboard_mib_subgraph(dataframe, track):
+    """Initialize the subgraph leaderboard with grouped column selection by benchmark."""
+    if dataframe is None or dataframe.empty:
+        raise ValueError("Leaderboard DataFrame is empty or None.")
+
+    print("\nDebugging DataFrame columns:", dataframe.columns.tolist())
+    
+    # Create groups of columns by benchmark
+    benchmark_groups = []
+    
+    # For each benchmark in our TasksMib_Subgraph enum...
+    for task in TasksMib_Subgraph:
+        benchmark = task.value.benchmark
+        # Get all valid columns for this benchmark's models
+        benchmark_cols = [
+            f"{benchmark}_{model}"
+            for model in task.value.models
+            if f"{benchmark}_{model}" in dataframe.columns
+        ]
+        if benchmark_cols:  # Only add if we have valid columns
+            benchmark_groups.append(benchmark_cols)
+            print(f"\nBenchmark group for {benchmark}:", benchmark_cols)
+
+    # Create model groups as well
+    model_groups = []
+    all_models = list(set(model for task in TasksMib_Subgraph for model in task.value.models))
+    
+    # For each unique model...
+    for model in all_models:
+        # Get all valid columns for this model across benchmarks
+        model_cols = [
+            f"{task.value.benchmark}_{model}"
+            for task in TasksMib_Subgraph
+            if model in task.value.models
+            and f"{task.value.benchmark}_{model}" in dataframe.columns
+        ]
+        if model_cols:  # Only add if we have valid columns
+            model_groups.append(model_cols)
+            print(f"\nModel group for {model}:", model_cols)
+
+    # Combine all groups
+    all_groups = benchmark_groups + model_groups
+    
+    # Flatten groups for default selection (show everything initially)
+    all_columns = [col for group in all_groups for col in group]
+    print("\nAll available columns:", all_columns)
+
+    return Leaderboard(
+        value=dataframe,
+        datatype=[c.type for c in fields(AutoEvalColumn_mib_subgraph)],
+        select_columns=SelectColumns(
+            default_selection=all_columns,  # Show all columns initially
+            label="Select Results:"
+        ),
+        search_columns=["Method"],
+        hide_columns=[],
+        interactive=False,
+    )
+
+
 # def init_leaderboard_mib_subgraph(dataframe, track):
-#     """Initialize the subgraph leaderboard with grouped column selection by benchmark."""
+#     """Initialize the subgraph leaderboard with display names for better readability."""
 #     if dataframe is None or dataframe.empty:
 #         raise ValueError("Leaderboard DataFrame is empty or None.")
 
 #     print("\nDebugging DataFrame columns:", dataframe.columns.tolist())
     
-#     # Create groups of columns by benchmark
+#     # First, create our display name mapping
+#     # This is like creating a translation dictionary between internal names and display names
+#     display_mapping = {}
+#     for task in TasksMib_Subgraph:
+#         for model in task.value.models:
+#             field_name = f"{task.value.benchmark}_{model}"
+#             display_name = f"{task.value.benchmark}({model})"
+#             display_mapping[field_name] = display_name
+
+#     # Now when creating benchmark groups, we'll use display names
 #     benchmark_groups = []
-    
-#     # For each benchmark in our TasksMib_Subgraph enum...
 #     for task in TasksMib_Subgraph:
 #         benchmark = task.value.benchmark
-#         # Get all valid columns for this benchmark's models
 #         benchmark_cols = [
-#             f"{benchmark}_{model}"
+#             display_mapping[f"{benchmark}_{model}"]  # Use display name from our mapping
 #             for model in task.value.models
 #             if f"{benchmark}_{model}" in dataframe.columns
 #         ]
-#         if benchmark_cols:  # Only add if we have valid columns
+#         if benchmark_cols:
 #             benchmark_groups.append(benchmark_cols)
 #             print(f"\nBenchmark group for {benchmark}:", benchmark_cols)
 
-#     # Create model groups as well
+#     # Similarly for model groups
 #     model_groups = []
 #     all_models = list(set(model for task in TasksMib_Subgraph for model in task.value.models))
     
-#     # For each unique model...
 #     for model in all_models:
-#         # Get all valid columns for this model across benchmarks
 #         model_cols = [
-#             f"{task.value.benchmark}_{model}"
+#             display_mapping[f"{task.value.benchmark}_{model}"]  # Use display name
 #             for task in TasksMib_Subgraph
 #             if model in task.value.models
 #             and f"{task.value.benchmark}_{model}" in dataframe.columns
 #         ]
-#         if model_cols:  # Only add if we have valid columns
+#         if model_cols:
 #             model_groups.append(model_cols)
 #             print(f"\nModel group for {model}:", model_cols)
 
-#     # Combine all groups
+#     # Combine all groups using display names
 #     all_groups = benchmark_groups + model_groups
-    
-#     # Flatten groups for default selection (show everything initially)
 #     all_columns = [col for group in all_groups for col in group]
-#     print("\nAll available columns:", all_columns)
+
+#     # Important: We need to rename our DataFrame columns to match display names
+#     renamed_df = dataframe.rename(columns=display_mapping)
 
 #     return Leaderboard(
-#         value=dataframe,
+#         value=renamed_df,  # Use DataFrame with display names
 #         datatype=[c.type for c in fields(AutoEvalColumn_mib_subgraph)],
 #         select_columns=SelectColumns(
-#             default_selection=all_columns,  # Show all columns initially
+#             default_selection=all_columns,  # Now contains display names
 #             label="Select Results:"
 #         ),
 #         search_columns=["Method"],
@@ -188,71 +252,159 @@ from src.about import TasksMib_Subgraph
 #     )
 
 
-def init_leaderboard_mib_subgraph(dataframe, track):
-    """Initialize the subgraph leaderboard with display names for better readability."""
-    if dataframe is None or dataframe.empty:
-        raise ValueError("Leaderboard DataFrame is empty or None.")
 
-    print("\nDebugging DataFrame columns:", dataframe.columns.tolist())
-    
-    # First, create our display name mapping
-    # This is like creating a translation dictionary between internal names and display names
-    display_mapping = {}
-    for task in TasksMib_Subgraph:
-        for model in task.value.models:
-            field_name = f"{task.value.benchmark}_{model}"
-            display_name = f"{task.value.benchmark}({model})"
-            display_mapping[field_name] = display_name
 
-    # Now when creating benchmark groups, we'll use display names
-    benchmark_groups = []
-    for task in TasksMib_Subgraph:
-        benchmark = task.value.benchmark
-        benchmark_cols = [
-            display_mapping[f"{benchmark}_{model}"]  # Use display name from our mapping
-            for model in task.value.models
-            if f"{benchmark}_{model}" in dataframe.columns
-        ]
-        if benchmark_cols:
-            benchmark_groups.append(benchmark_cols)
-            print(f"\nBenchmark group for {benchmark}:", benchmark_cols)
+    class SmartSelectColumns(gr.SelectColumns):
+        """
+        Enhanced SelectColumns component for Gradio Leaderboard with smart filtering and mapping capabilities.
+        """
+        def __init__(
+            self,
+            column_filters: Optional[Dict[str, List[str]]] = None,
+            column_mapping: Optional[Dict[str, str]] = None,
+            initial_selected: Optional[List[str]] = None,
+            *args,
+            **kwargs
+        ):
+            """
+            Initialize SmartSelectColumns with enhanced functionality.
+            
+            Args:
+                column_filters: Dict mapping filter names to lists of substrings to match
+                column_mapping: Dict mapping actual column names to display names
+                initial_selected: List of column names to be initially selected
+                *args, **kwargs: Additional arguments passed to parent SelectColumns
+            """
+            super().__init__(*args, **kwargs)
+            self.column_filters = column_filters or {}
+            self.column_mapping = column_mapping or {}
+            self.reverse_mapping = {v: k for k, v in self.column_mapping.items()} if column_mapping else {}
+            self.initial_selected = initial_selected or []
+        
+        def preprocess(self, x: List[str]) -> List[str]:
+            """
+            Transform selected display names back to actual column names.
+            
+            Args:
+                x: List of selected display names
+                
+            Returns:
+                List of actual column names
+            """
+            return [self.reverse_mapping.get(col, col) for col in x]
+        
+        def postprocess(self, y: List[str]) -> List[str]:
+            """
+            Transform actual column names to display names.
+            
+            Args:
+                y: List of actual column names
+                
+            Returns:
+                List of display names
+            """
+            return [self.column_mapping.get(col, col) for col in y]
+        
+        def get_filtered_columns(self, df: pd.DataFrame) -> Dict[str, List[str]]:
+            """
+            Get columns filtered by substring matches.
+            
+            Args:
+                df: Input DataFrame
+                
+            Returns:
+                Dict mapping filter names to lists of matching display names
+            """
+            filtered_cols = {}
+            
+            for filter_name, substrings in self.column_filters.items():
+                matching_cols = []
+                for col in df.columns:
+                    if any(substr.lower() in col.lower() for substr in substrings):
+                        display_name = self.column_mapping.get(col, col)
+                        matching_cols.append(display_name)
+                filtered_cols[filter_name] = matching_cols
+                
+            return filtered_cols
+
+        def update(
+            self, 
+            value: Union[pd.DataFrame, Dict[str, List[str]], Any], 
+            interactive: Optional[bool] = None
+        ) -> Dict:
+            """
+            Update component with new values, supporting DataFrame fields.
+            
+            Args:
+                value: DataFrame, dict of columns, or fields object
+                interactive: Whether component should be interactive
+                
+            Returns:
+                Dict containing update configuration
+            """
+            if isinstance(value, pd.DataFrame):
+                filtered_cols = self.get_filtered_columns(value)
+                choices = [self.column_mapping.get(col, col) for col in value.columns]
+                
+                # Set initial selection if provided
+                value = self.initial_selected if self.initial_selected else choices
+                
+                return {
+                    "choices": choices,
+                    "value": value,
+                    "filtered_cols": filtered_cols,
+                    "interactive": interactive if interactive is not None else self.interactive
+                }
+            
+            # Handle fields object (e.g., from dataclass)
+            if hasattr(value, '__dataclass_fields__'):
+                field_names = [field.name for field in fields(value)]
+                choices = [self.column_mapping.get(name, name) for name in field_names]
+                return {
+                    "choices": choices,
+                    "value": self.initial_selected if self.initial_selected else choices,
+                    "interactive": interactive if interactive is not None else self.interactive
+                }
+                
+            return super().update(value, interactive)
+    
 
-    # Similarly for model groups
-    model_groups = []
-    all_models = list(set(model for task in TasksMib_Subgraph for model in task.value.models))
+    # Define filters and mappings
+    filters = {
+        "IOI Metrics": ["ioi"],
+        "Performance Metrics": ["performance"]
+    }
     
-    for model in all_models:
-        model_cols = [
-            display_mapping[f"{task.value.benchmark}_{model}"]  # Use display name
-            for task in TasksMib_Subgraph
-            if model in task.value.models
-            and f"{task.value.benchmark}_{model}" in dataframe.columns
-        ]
-        if model_cols:
-            model_groups.append(model_cols)
-            print(f"\nModel group for {model}:", model_cols)
+    mappings = {
+        "ioi_score_1": "IOI Score (Type 1)",
+        "ioi_score_2": "IOI Score (Type 2)",
+        "other_metric": "Other Metric",
+        "performance_1": "Performance Metric 1"
+    }
+    
+    column_filters = filters
+    column_mapping = mappings
+    initial_columns = renamed_df
 
-    # Combine all groups using display names
-    all_groups = benchmark_groups + model_groups
-    all_columns = [col for group in all_groups for col in group]
 
-    # Important: We need to rename our DataFrame columns to match display names
-    renamed_df = dataframe.rename(columns=display_mapping)
+    # Initialize SmartSelectColumns
+    smart_columns = SmartSelectColumns(
+        column_filters=filters,
+        column_mapping=mappings,
+        initial_selected=initial_columns,
+        multiselect=True
+    )
 
-    return Leaderboard(
-        value=renamed_df,  # Use DataFrame with display names
-        datatype=[c.type for c in fields(AutoEvalColumn_mib_subgraph)],
-        select_columns=SelectColumns(
-            default_selection=all_columns,  # Now contains display names
-            label="Select Results:"
-        ),
+    return gr.Leaderboard(
+        value=renamed_df,
+        datatype=[c.type for c in fields(column_class)],
+        select_columns=smart_columns,
         search_columns=["Method"],
         hide_columns=[],
-        interactive=False,
+        interactive=False
     )
 
 
-
 # def init_leaderboard_mib_subgraph(dataframe, track):
 #     """Initialize the subgraph leaderboard with group-based column selection."""
 #     if dataframe is None or dataframe.empty:

custom-select-columns.py

@@ -0,0 +1,345 @@
+import gradio as gr
+import pandas as pd
+from typing import List, Dict, Union, Optional
+
+class SmartSelectColumns(gr.SelectColumns):
+    """
+    Enhanced SelectColumns component that supports substring matching and column mapping.
+    Inherits from gr.SelectColumns but adds additional filtering capabilities.
+    """
+    def __init__(
+        self,
+        *args,
+        column_filters: Optional[Dict[str, List[str]]] = None,
+        column_mapping: Optional[Dict[str, str]] = None,
+        **kwargs
+    ):
+        """
+        Initialize the SmartSelectColumns component.
+        
+        Args:
+            column_filters: Dict mapping filter names to lists of substrings to match
+            column_mapping: Dict mapping display names to actual column names
+            *args, **kwargs: Arguments passed to parent SelectColumns
+        """
+        super().__init__(*args, **kwargs)
+        self.column_filters = column_filters or {}
+        self.column_mapping = column_mapping or {}
+        
+    def preprocess(self, x: List[str]) -> List[str]:
+        """Transform selected display names back to actual column names."""
+        if self.column_mapping:
+            reverse_mapping = {v: k for k, v in self.column_mapping.items()}
+            return [reverse_mapping.get(col, col) for col in x]
+        return x
+    
+    def get_filtered_columns(self, df: pd.DataFrame) -> Dict[str, List[str]]:
+        """
+        Get columns filtered by substring matches.
+        
+        Args:
+            df: Input DataFrame
+            
+        Returns:
+            Dict mapping filter names to lists of matching columns
+        """
+        filtered_cols = {}
+        
+        for filter_name, substrings in self.column_filters.items():
+            matching_cols = []
+            for col in df.columns:
+                if any(substr.lower() in col.lower() for substr in substrings):
+                    matching_cols.append(col)
+            filtered_cols[filter_name] = matching_cols
+            
+        return filtered_cols
+
+    def update(
+        self, 
+        value: Union[pd.DataFrame, Dict[str, List[str]]], 
+        interactive: Optional[bool] = None
+    ) -> Dict:
+        """
+        Update the component with new values.
+        
+        Args:
+            value: Either a DataFrame or dict of predefined column groups
+            interactive: Whether the component should be interactive
+        
+        Returns:
+            Dict containing the update configuration
+        """
+        if isinstance(value, pd.DataFrame):
+            # Get filtered column groups
+            filtered_cols = self.get_filtered_columns(value)
+            
+            # Create display names for columns if mapping exists
+            choices = list(value.columns)
+            if self.column_mapping:
+                choices = [self.column_mapping.get(col, col) for col in choices]
+                
+            return {
+                "choices": choices,
+                "filtered_cols": filtered_cols,
+                "interactive": interactive if interactive is not None else self.interactive
+            }
+        return super().update(value, interactive)
+
+# Example usage
+if __name__ == "__main__":
+    df = pd.DataFrame({
+        "ioi_score_1": [1, 2, 3],
+        "ioi_score_2": [4, 5, 6],
+        "other_metric": [7, 8, 9],
+        "performance_1": [10, 11, 12]
+    })
+    
+    # Define filters and mappings
+    column_filters = {
+        "IOI Metrics": ["ioi"],
+        "Performance Metrics": ["performance"]
+    }
+    
+    column_mapping = {
+        "ioi_score_1": "IOI Score (Type 1)",
+        "ioi_score_2": "IOI Score (Type 2)",
+        "other_metric": "Other Metric",
+        "performance_1": "Performance Metric 1"
+    }
+    
+    # Create interface
+    with gr.Blocks() as demo:
+        select_cols = SmartSelectColumns(
+            column_filters=column_filters,
+            column_mapping=column_mapping,
+            multiselect=True
+        )
+        
+        # Update component with DataFrame
+        select_cols.update(df)
+        
+    demo.launch()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import gradio as gr
+import pandas as pd
+from typing import List, Dict, Union, Optional, Any
+from dataclasses import fields
+
+class SmartSelectColumns(gr.SelectColumns):
+    """
+    Enhanced SelectColumns component for Gradio Leaderboard with smart filtering and mapping capabilities.
+    """
+    def __init__(
+        self,
+        column_filters: Optional[Dict[str, List[str]]] = None,
+        column_mapping: Optional[Dict[str, str]] = None,
+        initial_selected: Optional[List[str]] = None,
+        *args,
+        **kwargs
+    ):
+        """
+        Initialize SmartSelectColumns with enhanced functionality.
+        
+        Args:
+            column_filters: Dict mapping filter names to lists of substrings to match
+            column_mapping: Dict mapping actual column names to display names
+            initial_selected: List of column names to be initially selected
+            *args, **kwargs: Additional arguments passed to parent SelectColumns
+        """
+        super().__init__(*args, **kwargs)
+        self.column_filters = column_filters or {}
+        self.column_mapping = column_mapping or {}
+        self.reverse_mapping = {v: k for k, v in self.column_mapping.items()} if column_mapping else {}
+        self.initial_selected = initial_selected or []
+        
+    def preprocess(self, x: List[str]) -> List[str]:
+        """
+        Transform selected display names back to actual column names.
+        
+        Args:
+            x: List of selected display names
+            
+        Returns:
+            List of actual column names
+        """
+        return [self.reverse_mapping.get(col, col) for col in x]
+    
+    def postprocess(self, y: List[str]) -> List[str]:
+        """
+        Transform actual column names to display names.
+        
+        Args:
+            y: List of actual column names
+            
+        Returns:
+            List of display names
+        """
+        return [self.column_mapping.get(col, col) for col in y]
+    
+    def get_filtered_columns(self, df: pd.DataFrame) -> Dict[str, List[str]]:
+        """
+        Get columns filtered by substring matches.
+        
+        Args:
+            df: Input DataFrame
+            
+        Returns:
+            Dict mapping filter names to lists of matching display names
+        """
+        filtered_cols = {}
+        
+        for filter_name, substrings in self.column_filters.items():
+            matching_cols = []
+            for col in df.columns:
+                if any(substr.lower() in col.lower() for substr in substrings):
+                    display_name = self.column_mapping.get(col, col)
+                    matching_cols.append(display_name)
+            filtered_cols[filter_name] = matching_cols
+            
+        return filtered_cols
+
+    def update(
+        self, 
+        value: Union[pd.DataFrame, Dict[str, List[str]], Any], 
+        interactive: Optional[bool] = None
+    ) -> Dict:
+        """
+        Update component with new values, supporting DataFrame fields.
+        
+        Args:
+            value: DataFrame, dict of columns, or fields object
+            interactive: Whether component should be interactive
+            
+        Returns:
+            Dict containing update configuration
+        """
+        if isinstance(value, pd.DataFrame):
+            filtered_cols = self.get_filtered_columns(value)
+            choices = [self.column_mapping.get(col, col) for col in value.columns]
+            
+            # Set initial selection if provided
+            value = self.initial_selected if self.initial_selected else choices
+            
+            return {
+                "choices": choices,
+                "value": value,
+                "filtered_cols": filtered_cols,
+                "interactive": interactive if interactive is not None else self.interactive
+            }
+        
+        # Handle fields object (e.g., from dataclass)
+        if hasattr(value, '__dataclass_fields__'):
+            field_names = [field.name for field in fields(value)]
+            choices = [self.column_mapping.get(name, name) for name in field_names]
+            return {
+                "choices": choices,
+                "value": self.initial_selected if self.initial_selected else choices,
+                "interactive": interactive if interactive is not None else self.interactive
+            }
+            
+        return super().update(value, interactive)
+
+def initialize_leaderboard(df: pd.DataFrame, column_class: Any, 
+                         filters: Dict[str, List[str]], 
+                         mappings: Dict[str, str],
+                         initial_columns: Optional[List[str]] = None) -> gr.Leaderboard:
+    """
+    Initialize a Gradio Leaderboard with SmartSelectColumns.
+    
+    Args:
+        df: Input DataFrame
+        column_class: Class containing column definitions (e.g., AutoEvalColumn_mib_subgraph)
+        filters: Column filters for substring matching
+        mappings: Column name mappings (actual -> display)
+        initial_columns: List of columns to show initially
+        
+    Returns:
+        Configured Leaderboard instance
+    """
+    # Create renamed DataFrame with display names
+    renamed_df = df.rename(columns=mappings)
+    
+    # Initialize SmartSelectColumns
+    smart_columns = SmartSelectColumns(
+        column_filters=filters,
+        column_mapping=mappings,
+        initial_selected=initial_columns,
+        multiselect=True
+    )
+    
+    return gr.Leaderboard(
+        value=renamed_df,
+        datatype=[c.type for c in fields(column_class)],
+        select_columns=smart_columns,
+        search_columns=["Method"],
+        hide_columns=[],
+        interactive=False
+    )
+
+# Example usage
+if __name__ == "__main__":
+    # Sample data
+    df = pd.DataFrame({
+        "ioi_score_1": [1, 2, 3],
+        "ioi_score_2": [4, 5, 6],
+        "other_metric": [7, 8, 9],
+        "performance_1": [10, 11, 12],
+        "Method": ["A", "B", "C"]
+    })
+    
+    # Define filters and mappings
+    filters = {
+        "IOI Metrics": ["ioi"],
+        "Performance Metrics": ["performance"]
+    }
+    
+    mappings = {
+        "ioi_score_1": "IOI Score (Type 1)",
+        "ioi_score_2": "IOI Score (Type 2)",
+        "other_metric": "Other Metric",
+        "performance_1": "Performance Metric 1"
+    }
+    
+    # Create demo interface
+    with gr.Blocks() as demo:
+        # Initialize leaderboard with smart columns
+        leaderboard = initialize_leaderboard(
+            df=df,
+            column_class=None,  # Replace with your actual column class
+            filters=filters,
+            mappings=mappings,
+            initial_columns=["Method", "IOI Score (Type 1)"]
+        )
+        
+    demo.launch()