Board fixes

app_local.py

@@ -47,24 +47,27 @@ def init_leaderboard(dataframe):
         
     # Get all fields from AutoEvalColumn
     auto_eval_fields = fields(AutoEvalColumn)
+    print(f"AutoEvalColumn fields: {[f.name for f in auto_eval_fields]}")
     
-    # Find the model and license fields
-    model_field = next((f for f in auto_eval_fields if f.name == "Model"), None)
-    license_field = next((f for f in auto_eval_fields if f.name == "Hub License"), None)
+    # Create a mapping from display names to field names
+    field_mapping = {f.name: f for f in auto_eval_fields}
+    print(f"Field mapping: {field_mapping}")
     
-    if not model_field or not license_field:
-        raise ValueError("Required fields not found in AutoEvalColumn")
+    # Verify all required columns are present
+    for col in dataframe.columns:
+        if col not in field_mapping:
+            print(f"Warning: Column {col} not found in field mapping")
     
     return Leaderboard(
         value=dataframe,
-        datatype=[c.type for c in auto_eval_fields],
+        datatype=["str" if col not in field_mapping else field_mapping[col].type for col in dataframe.columns],
         select_columns=SelectColumns(
-            default_selection=[c.name for c in auto_eval_fields if c.displayed_by_default],
-            cant_deselect=[c.name for c in auto_eval_fields if c.never_hidden],
+            default_selection=[col for col in dataframe.columns if col in field_mapping and field_mapping[col].displayed_by_default],
+            cant_deselect=[col for col in dataframe.columns if col in field_mapping and field_mapping[col].never_hidden],
             label="Select Columns to Display:",
         ),
-        search_columns=[model_field.name, license_field.name],
-        hide_columns=[c.name for c in auto_eval_fields if c.hidden],
+        search_columns=["Model", "Hub License"],
+        hide_columns=[col for col in dataframe.columns if col in field_mapping and field_mapping[col].hidden],
         filter_columns=[
             ColumnFilter("Type", type="checkboxgroup", label="Model types"),
             ColumnFilter("Weight Format", type="checkboxgroup", label="Weight Format"),

src/display/utils.py

@@ -1,11 +1,8 @@
-from dataclasses import dataclass, make_dataclass, field
+from dataclasses import dataclass, make_dataclass, field, fields as dataclass_fields
 from enum import Enum
 
 from src.about import Tasks
 
-def fields(raw_class):
-    return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
-
 @dataclass
 class ColumnContent:
     name: str
@@ -14,46 +11,56 @@ class ColumnContent:
     hidden: bool = False
     never_hidden: bool = False
 
+def fields(raw_class):
+    """Get all fields from a dataclass instance."""
+    return [getattr(raw_class, field.name) for field in dataclass_fields(raw_class)]
+
 ## Leaderboard columns
 def create_column_field(name: str, type: str, displayed_by_default: bool, hidden: bool = False, never_hidden: bool = False):
     return field(default_factory=lambda: ColumnContent(name, type, displayed_by_default, hidden, never_hidden))
 
-auto_eval_column_dict = [
-    # Init
-    ("model_type_symbol", ColumnContent, create_column_field("T", "str", True, never_hidden=True)),
-    ("model", ColumnContent, create_column_field("Model", "markdown", True, never_hidden=True)),
-    # Scores
-    ("average", ColumnContent, create_column_field("Security Score ⬆️", "number", True))
-]
-
-# Add task-specific columns
-for task in Tasks:
-    if task.name == "safetensors":
-        auto_eval_column_dict.append((task.name, ColumnContent, create_column_field("Safetensors ✓", "bool", True)))
-    else:
-        auto_eval_column_dict.append((task.name, ColumnContent, create_column_field(task.value.col_name, "number", True)))
+# Create a list of tuples for the dataclass fields
+auto_eval_column_dict = []
 
-# Model information
+# Add model information columns
 model_info_columns = [
-    ("model_type", "Type", "str", False),
-    ("architecture", "Architecture", "str", False),
-    ("weight_type", "Weight Format", "str", True),
-    ("precision", "Precision", "str", False),
-    ("license", "Hub License", "str", True),
-    ("params", "#Params (B)", "number", False),
-    ("likes", "Hub ❤️", "number", False),
-    ("still_on_hub", "Available on Hub", "bool", False),
-    ("revision", "Model SHA", "str", False)
+    ("T", "str", True, False, True),  # name, type, displayed_by_default, hidden, never_hidden
+    ("Model", "markdown", True, False, True),
+    ("Security Score ⬆️", "number", True, False, False),
+    ("Safetensors", "bool", True, False, False),
+    ("Type", "str", True, False, False),
+    ("Architecture", "str", False, False, False),
+    ("Weight Format", "str", True, False, False),
+    ("Precision", "str", True, False, False),
+    ("Hub License", "str", True, False, False),
+    ("Hub ❤️", "number", True, False, False),
+    ("#Params (B)", "number", True, False, False),
+    ("Available on Hub", "bool", True, False, False),
+    ("Model SHA", "str", True, False, False)
 ]
 
-for field_name, display_name, field_type, displayed_by_default in model_info_columns:
+def make_valid_identifier(name):
+    # Replace invalid characters with underscores and make lowercase
+    valid = name.lower().replace(" ", "_").replace("-", "_")
+    valid = "".join(c if c.isalnum() or c == "_" else "" for c in valid)
+    # Ensure it starts with a letter
+    if valid[0].isdigit():
+        valid = "n" + valid
+    return valid
+
+# Create fields for each column
+for name, type_, displayed, hidden, never_hidden in model_info_columns:
+    field_name = make_valid_identifier(name)
     auto_eval_column_dict.append(
-        (field_name, ColumnContent, create_column_field(display_name, field_type, displayed_by_default))
+        (field_name, ColumnContent, create_column_field(name, type_, displayed, hidden, never_hidden))
     )
 
 # We use make dataclass to dynamically fill the scores from Tasks
 AutoEvalColumn = make_dataclass("AutoEvalColumn", auto_eval_column_dict, frozen=True)
 
+# Create an instance of AutoEvalColumn with default values
+auto_eval_column_instance = AutoEvalColumn()
+
 ## For the queue columns in the submission tab
 @dataclass(frozen=True)
 class EvalQueueColumn:  # Queue column
@@ -112,9 +119,13 @@ class Precision(Enum):
         return Precision.Unknown
 
 # Column selection
-COLS = [c.name for c in fields(AutoEvalColumn) if not c.hidden]
+COLS = [
+    "T", "Model", "Security Score ⬆️", "Safetensors", "Type", "Architecture", 
+    "Weight Format", "Precision", "Hub License", "Hub ❤️", "#Params (B)", 
+    "Available on Hub", "Model SHA"
+]
 
-EVAL_COLS = [c.name for c in fields(EvalQueueColumn)]
-EVAL_TYPES = [c.type for c in fields(EvalQueueColumn)]
+EVAL_COLS = [c.name for c in fields(EvalQueueColumn())]
+EVAL_TYPES = [c.type for c in fields(EvalQueueColumn())]
 
-BENCHMARK_COLS = [t.value.col_name for t in Tasks]
+BENCHMARK_COLS = ["Security Score ⬆️", "Safetensors"]

src/populate.py

@@ -19,9 +19,11 @@ def get_leaderboard_df(results_path: str, requests_path: str, cols: list, benchm
 
     all_data_json = [v.to_dict() for v in raw_data]
     print(f"Converted {len(all_data_json)} results to dict")
+    print(f"Data before DataFrame creation: {all_data_json}")
 
     df = pd.DataFrame.from_records(all_data_json)
     print(f"Created DataFrame with columns: {df.columns.tolist()}")
+    print(f"DataFrame before filtering:\n{df}")
 
     # Ensure all required columns exist before filtering
     for col in benchmark_cols:
@@ -31,8 +33,13 @@ def get_leaderboard_df(results_path: str, requests_path: str, cols: list, benchm
 
     # Filter out if any of the benchmarks have not been produced
     df = df[has_no_nan_values(df, benchmark_cols)]
+    print(f"DataFrame after benchmark filtering:\n{df}")
+    
     df = df.sort_values(by="Security Score ⬆️", ascending=False)
+    print(f"DataFrame after sorting:\n{df}")
+    
     df = df[cols].round(decimals=2)
+    print(f"DataFrame after column selection:\n{df}")
 
     print(f"Final DataFrame has {len(df)} rows")
     return df