Update src/leaderboard.py

src/leaderboard.py

@@ -82,13 +82,27 @@ def load_leaderboard() -> pd.DataFrame:
                 else:
                     df[col] = ""
         
-        # Ensure proper data types for numeric columns
+        # Ensure proper data types for numeric columns with robust conversion
         numeric_columns = [
             col for col in df.columns 
             if any(x in col for x in ["quality", "bleu", "chrf", "ci_", "samples", "pairs"])
         ]
+        
         for col in numeric_columns:
-            df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0.0)
+            try:
+                # Convert to numeric, coercing errors to NaN, then fill NaN with 0
+                df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0.0)
+                # Ensure it's float type for consistency
+                df[col] = df[col].astype(float)
+            except Exception as e:
+                print(f"Warning: Could not convert column {col} to numeric: {e}")
+                df[col] = 0.0
+        
+        # Ensure string columns are properly typed
+        string_columns = ["model_name", "author", "model_category", "description", "submission_date", "evaluation_date"]
+        for col in string_columns:
+            if col in df.columns:
+                df[col] = df[col].fillna("").astype(str)
         
         print(f"✅ Loaded leaderboard with {len(df)} entries")
         return df
@@ -270,31 +284,75 @@ def get_track_leaderboard(
 ) -> pd.DataFrame:
     """Get leaderboard for a specific track with filtering."""
     
+    print(f"Getting track leaderboard for {track}, input df has {len(df)} rows")
+    
     if df.empty:
+        print("Input DataFrame is empty")
         return df
     
     track_quality_col = f"{track}_{metric}"
     
     # Ensure columns exist
     if track_quality_col not in df.columns:
-        print(f"Warning: Missing column for track {track}")
+        print(f"Warning: Missing column {track_quality_col} for track {track}")
+        print(f"Available columns: {list(df.columns)}")
         return pd.DataFrame()
     
-    # Filter by category
-    if category_filter != "all":
-        df = df[df["model_category"] == category_filter]
-    
-    # Filter to models that have this track
-    quality_mask = pd.to_numeric(df[track_quality_col], errors='coerce') > 0
-    df = df[quality_mask]
-    
-    if df.empty:
-        return df
-    
-    # Sort by track-specific metric
-    df = df.sort_values(track_quality_col, ascending=False).reset_index(drop=True)
-    
-    return df
+    try:
+        # Make a copy to avoid modifying original
+        df_filtered = df.copy()
+        print(f"Created copy with {len(df_filtered)} rows")
+        
+        # Filter by category
+        if category_filter != "all":
+            original_count = len(df_filtered)
+            df_filtered = df_filtered[df_filtered["model_category"] == category_filter]
+            print(f"After category filter '{category_filter}': {len(df_filtered)} rows (was {original_count})")
+        
+        # Ensure numeric columns are properly typed
+        numeric_columns = [
+            f"{track}_quality", f"{track}_bleu", f"{track}_chrf",
+            f"{track}_ci_lower", f"{track}_ci_upper",
+            f"{track}_samples", f"{track}_pairs"
+        ]
+        
+        print(f"Converting numeric columns: {[col for col in numeric_columns if col in df_filtered.columns]}")
+        
+        for col in numeric_columns:
+            if col in df_filtered.columns:
+                try:
+                    # Check original data type
+                    print(f"Column {col} dtype: {df_filtered[col].dtype}, sample values: {df_filtered[col].head(3).tolist()}")
+                    
+                    # Convert to numeric
+                    df_filtered[col] = pd.to_numeric(df_filtered[col], errors='coerce').fillna(0.0)
+                    print(f"Column {col} converted successfully")
+                except Exception as e:
+                    print(f"Error converting column {col}: {e}")
+                    df_filtered[col] = 0.0
+        
+        # Filter to models that have this track
+        original_count = len(df_filtered)
+        quality_mask = df_filtered[track_quality_col] > 0
+        df_filtered = df_filtered[quality_mask]
+        print(f"After quality filter (>{track_quality_col} > 0): {len(df_filtered)} rows (was {original_count})")
+        
+        if df_filtered.empty:
+            print("No models found with quality > 0 for this track")
+            return df_filtered
+        
+        # Sort by track-specific metric
+        print(f"Sorting by {track_quality_col}")
+        df_filtered = df_filtered.sort_values(track_quality_col, ascending=False).reset_index(drop=True)
+        print(f"Sorted successfully, final result has {len(df_filtered)} rows")
+        
+        return df_filtered
+        
+    except Exception as e:
+        print(f"Error in get_track_leaderboard: {e}")
+        import traceback
+        traceback.print_exc()
+        return pd.DataFrame()
 
 
 def prepare_leaderboard_display(df: pd.DataFrame, track: str) -> pd.DataFrame:
@@ -320,20 +378,31 @@ def prepare_leaderboard_display(df: pd.DataFrame, track: str) -> pd.DataFrame:
     available_columns = [col for col in base_columns + track_columns if col in df.columns]
     display_df = df[available_columns].copy()
     
-    # Format numeric columns
-    numeric_format = {
-        f"{track}_quality": "{:.4f}",
-        f"{track}_bleu": "{:.2f}",
-        f"{track}_chrf": "{:.4f}",
-        f"{track}_ci_lower": "{:.4f}",
-        f"{track}_ci_upper": "{:.4f}",
-    }
+    # Format numeric columns safely
+    def safe_format(value, precision=4):
+        """Safely format numeric values."""
+        try:
+            if pd.isna(value) or value is None:
+                return "0.0000" if precision == 4 else "0.00"
+            return f"{float(value):.{precision}f}"
+        except (ValueError, TypeError):
+            return "0.0000" if precision == 4 else "0.00"
+    
+    # Apply formatting to numeric columns
+    if f"{track}_quality" in display_df.columns:
+        display_df[f"{track}_quality"] = display_df[f"{track}_quality"].apply(lambda x: safe_format(x, 4))
+    
+    if f"{track}_bleu" in display_df.columns:
+        display_df[f"{track}_bleu"] = display_df[f"{track}_bleu"].apply(lambda x: safe_format(x, 2))
+    
+    if f"{track}_chrf" in display_df.columns:
+        display_df[f"{track}_chrf"] = display_df[f"{track}_chrf"].apply(lambda x: safe_format(x, 4))
+    
+    if f"{track}_ci_lower" in display_df.columns:
+        display_df[f"{track}_ci_lower"] = display_df[f"{track}_ci_lower"].apply(lambda x: safe_format(x, 4))
     
-    for col, fmt in numeric_format.items():
-        if col in display_df.columns:
-            display_df[col] = display_df[col].apply(
-                lambda x: fmt.format(float(x)) if pd.notnull(x) else "0.0000"
-            )
+    if f"{track}_ci_upper" in display_df.columns:
+        display_df[f"{track}_ci_upper"] = display_df[f"{track}_ci_upper"].apply(lambda x: safe_format(x, 4))
     
     # Format confidence intervals
     if f"{track}_ci_lower" in display_df.columns and f"{track}_ci_upper" in display_df.columns: