Update app.py

app.py

@@ -98,6 +98,14 @@ def initialize_data():
         print("🏆 Loading leaderboard...")
         current_leaderboard = load_leaderboard()
         
+        # Debug leaderboard content
+        print(f"Leaderboard loaded with {len(current_leaderboard)} entries")
+        if not current_leaderboard.empty:
+            print(f"Leaderboard columns: {list(current_leaderboard.columns)}")
+            print(f"Sample row types: {current_leaderboard.dtypes.to_dict()}")
+        else:
+            print("Leaderboard is empty - will show empty interface")
+        
         print(f"✅ Initialization complete!")
         print(f"   - Test set: {len(public_test_set):,} samples")
         print(f"   - Current models: {len(current_leaderboard)}")
@@ -106,6 +114,7 @@ def initialize_data():
         
     except Exception as e:
         print(f"❌ Initialization failed: {e}")
+        import traceback
         traceback.print_exc()
         return False
 
@@ -263,42 +272,102 @@ def evaluate_submission(
 def refresh_track_leaderboard(track: str, search_query: str = "", category_filter: str = "all") -> Tuple[pd.DataFrame, object, object, str]:
     """Refresh leaderboard for a specific track with filters."""
     try:
+        print(f"Refreshing {track} leaderboard...")
+        
         global current_leaderboard
         if current_leaderboard is None:
+            print("Loading leaderboard...")
             current_leaderboard = load_leaderboard()
         
-        track_leaderboard = get_track_leaderboard(current_leaderboard, track, category_filter=category_filter)
+        print(f"Leaderboard loaded with {len(current_leaderboard)} entries")
+        
+        # Get track leaderboard with robust error handling
+        try:
+            print(f"Getting track leaderboard for {track}...")
+            track_leaderboard = get_track_leaderboard(current_leaderboard, track, category_filter=category_filter)
+            print(f"Track leaderboard has {len(track_leaderboard)} entries")
+        except Exception as e:
+            print(f"Error getting track leaderboard: {e}")
+            track_leaderboard = pd.DataFrame()
         
         # Apply search filter
         if search_query and not track_leaderboard.empty:
-            query_lower = search_query.lower()
-            mask = (
-                track_leaderboard['model_name'].str.lower().str.contains(query_lower, na=False) |
-                track_leaderboard['author'].str.lower().str.contains(query_lower, na=False)
-            )
-            track_leaderboard = track_leaderboard[mask]
-        
-        display_df = prepare_leaderboard_display(track_leaderboard, track)
-        ranking_plot = create_leaderboard_plot(track_leaderboard, track)
-        comparison_plot = create_performance_comparison_plot(track_leaderboard, track)
-        
-        track_config = EVALUATION_TRACKS[track]
-        stats_text = f"""
+            try:
+                print(f"Applying search filter: {search_query}")
+                query_lower = search_query.lower()
+                mask = (
+                    track_leaderboard['model_name'].str.lower().str.contains(query_lower, na=False) |
+                    track_leaderboard['author'].str.lower().str.contains(query_lower, na=False)
+                )
+                track_leaderboard = track_leaderboard[mask]
+                print(f"After search filter: {len(track_leaderboard)} entries")
+            except Exception as e:
+                print(f"Error applying search filter: {e}")
+        
+        # Prepare display with error handling
+        try:
+            print("Preparing display...")
+            display_df = prepare_leaderboard_display(track_leaderboard, track)
+            print(f"Display prepared with {len(display_df)} rows")
+        except Exception as e:
+            print(f"Error preparing display: {e}")
+            display_df = pd.DataFrame()
+        
+        # Create plots with error handling
+        try:
+            print("Creating ranking plot...")
+            ranking_plot = create_leaderboard_plot(track_leaderboard, track)
+        except Exception as e:
+            print(f"Error creating ranking plot: {e}")
+            ranking_plot = None
+        
+        try:
+            print("Creating comparison plot...")
+            comparison_plot = create_performance_comparison_plot(track_leaderboard, track)
+        except Exception as e:
+            print(f"Error creating comparison plot: {e}")
+            comparison_plot = None
+        
+        # Generate stats text with safe formatting
+        try:
+            print("Generating stats...")
+            track_config = EVALUATION_TRACKS[track]
+            best_model = "None"
+            best_score = 0.0
+            
+            if not track_leaderboard.empty:
+                best_model = str(track_leaderboard.iloc[0]['model_name'])
+                quality_col = f'{track}_quality'
+                if quality_col in track_leaderboard.columns:
+                    try:
+                        score_val = track_leaderboard.iloc[0][quality_col]
+                        best_score = float(score_val) if pd.notnull(score_val) else 0.0
+                    except (ValueError, TypeError):
+                        best_score = 0.0
+            
+            stats_text = f"""
 ### 📊 {track_config['name']} Statistics
 
 - **Total Models**: {len(track_leaderboard)}
-- **Best Model**: {track_leaderboard.iloc[0]['model_name'] if not track_leaderboard.empty else 'None'}
-- **Best Score**: {track_leaderboard.iloc[0][f'{track}_quality']:.4f if not track_leaderboard.empty else 0.0}
+- **Best Model**: {best_model}
+- **Best Score**: {best_score:.4f}
 
 ### 🔬 Track Information:
-{track_config['description']}
-        """
-        
+{track_config.get('description', 'No description available')}
+            """
+            print("Stats generated successfully")
+        except Exception as e:
+            print(f"Error generating stats: {e}")
+            stats_text = f"Error loading {track} statistics: {str(e)}"
+        
+        print("Track refresh completed successfully")
         return display_df, ranking_plot, comparison_plot, stats_text
         
     except Exception as e:
         error_msg = f"Error loading {track} leaderboard: {str(e)}"
-        print(error_msg)
+        print(f"MAIN ERROR: {error_msg}")
+        import traceback
+        traceback.print_exc()
         return pd.DataFrame(), None, None, error_msg
 
 def get_language_pair_comparison(track: str) -> Tuple[pd.DataFrame, object]:
@@ -726,10 +795,33 @@ with gr.Blocks(
         outputs=[pairs_table, pairs_comparison_plot]
     )
     
-    # Load initial data
+    # Load initial data and update dropdowns
     def load_initial_data():
-        google_data = refresh_track_leaderboard("google_comparable", "", "all")
-        return google_data
+        try:
+            print("Loading initial data...")
+            global current_leaderboard
+            
+            # Make sure we have a leaderboard
+            if current_leaderboard is None:
+                current_leaderboard = load_leaderboard()
+            
+            print(f"Current leaderboard has {len(current_leaderboard)} entries")
+            
+            # Try to load Google track data
+            try:
+                google_data = refresh_track_leaderboard("google_comparable", "", "all")
+                print("Successfully loaded Google track data")
+                return google_data
+            except Exception as e:
+                print(f"Error loading Google track: {e}")
+                # Return empty data if there's an error
+                empty_df = pd.DataFrame()
+                return (empty_df, None, None, "No data available")
+                
+        except Exception as e:
+            print(f"Error in load_initial_data: {e}")
+            empty_df = pd.DataFrame()
+            return (empty_df, None, None, "Error loading data")
     
     demo.load(
         fn=load_initial_data,