Simplify flow

app.py

@@ -6,11 +6,6 @@ import pandas as pd
 
 from src.about import TITLE, INTRODUCTION_TEXT
 from src.display.css_html_js import custom_css
-from src.leaderboard.read_evals import (
-    TabularLeaderboardEntry,
-    parse_tabular_leaderboard,
-    tabular_leaderboard_to_dataframe,
-)
 from src.utils import download_github_file_content
 
 # GitHub API endpoint for the file (handles Git LFS files)
@@ -29,16 +24,16 @@ DISPLAY_COLUMNS = [
 ]
 
 
-def download_leaderboard() -> list[TabularLeaderboardEntry]:
+def download_leaderboard() -> pd.DataFrame:
     """Download the remote leaderboard CSV from GitHub (handles Git LFS).
 
-    Returns a list of TabularLeaderboardEntry objects.
+    Returns a processed DataFrame ready for display.
     """
     csv_content = download_github_file_content(LEADERBOARD_API_URL, timeout=30)
 
     df = pd.read_csv(io.StringIO(csv_content))
     if df.empty:
-        return []
+        return pd.DataFrame(columns=DISPLAY_COLUMNS)
 
     missing_cols = [col for col in DISPLAY_COLUMNS if col not in df.columns]
     if missing_cols:
@@ -51,19 +46,15 @@ def download_leaderboard() -> list[TabularLeaderboardEntry]:
     df["sem_medal_pct"] = (df["sem_medal_pct"] * 100).round(1)
     df["Date"] = pd.to_datetime(df["Date"], errors="coerce").dt.strftime("%Y-%m-%d")
 
-    # Sort by mean_normalized_score before converting to data models
+    # Sort by mean_normalized_score
     df = df.sort_values(by="mean_normalized_score", ascending=False, ignore_index=True)
 
-    # Parse into data models
-    entries = parse_tabular_leaderboard(df)
-
-    return entries
+    return df
 
 
 def refresh_leaderboard():
     """Fetch the leaderboard and build the status message for the UI."""
-    entries = download_leaderboard()
-    df = tabular_leaderboard_to_dataframe(entries)
+    df = download_leaderboard()
     status = (
         f"Showing data from [GitHub]({LEADERBOARD_GITHUB_URL}). "
         f"Last refreshed: {datetime.now(timezone.utc):%Y-%m-%d %H:%M UTC}."

tests/test_leaderboard.py

@@ -5,7 +5,6 @@ import pytest
 import requests
 
 from app import DISPLAY_COLUMNS, download_leaderboard, refresh_leaderboard
-from src.leaderboard.read_evals import TabularLeaderboardEntry
 
 
 @pytest.fixture
@@ -49,12 +48,12 @@ class TestDownloadLeaderboard:
         mock_download.return_value = sample_csv_data
 
         # Execute
-        entries = download_leaderboard()
+        df = download_leaderboard()
 
         # Assertions
-        assert isinstance(entries, list)
-        assert len(entries) == 3
-        assert all(isinstance(entry, TabularLeaderboardEntry) for entry in entries)
+        assert isinstance(df, pd.DataFrame)
+        assert len(df) == 3
+        assert list(df.columns) == DISPLAY_COLUMNS
         mock_download.assert_called_once()
 
     @patch("app.download_github_file_content")
@@ -62,68 +61,67 @@ class TestDownloadLeaderboard:
         """Test that numeric columns are properly rounded."""
         mock_download.return_value = sample_csv_data
 
-        entries = download_leaderboard()
+        df = download_leaderboard()
 
-        # Check rounding - entries are sorted by score descending
-        assert entries[0].mean_normalized_score == 0.912
-        assert entries[1].mean_normalized_score == 0.854
-        assert entries[2].mean_normalized_score == 0.789
+        # Check rounding - df is sorted by score descending
+        assert df.iloc[0]["mean_normalized_score"] == 0.912
+        assert df.iloc[1]["mean_normalized_score"] == 0.854
+        assert df.iloc[2]["mean_normalized_score"] == 0.789
         # Check that scores are floats
-        assert isinstance(entries[0].mean_normalized_score, float)
-        assert isinstance(entries[0].std_normalized_score, float)
+        assert isinstance(df.iloc[0]["mean_normalized_score"], float)
+        assert isinstance(df.iloc[0]["std_normalized_score"], float)
 
     @patch("app.download_github_file_content")
     def test_percentage_conversion(self, mock_download, sample_csv_data):
         """Test that medal percentages are converted from decimal to percentage."""
         mock_download.return_value = sample_csv_data
 
-        entries = download_leaderboard()
+        df = download_leaderboard()
 
         # Check percentage conversion (0.876543 * 100 = 87.6543, rounded to 87.7)
-        # Entries are sorted by score descending: exp_003 (92.3), exp_001 (87.7), exp_002 (76.5)
-        assert entries[0].mean_medal_pct == 92.3  # exp_003
-        assert entries[1].mean_medal_pct == 87.7  # exp_001
-        assert entries[2].mean_medal_pct == 76.5  # exp_002
+        # df is sorted by score descending: exp_003 (92.3), exp_001 (87.7), exp_002 (76.5)
+        assert df.iloc[0]["mean_medal_pct"] == 92.3  # exp_003
+        assert df.iloc[1]["mean_medal_pct"] == 87.7  # exp_001
+        assert df.iloc[2]["mean_medal_pct"] == 76.5  # exp_002
 
     @patch("app.download_github_file_content")
     def test_date_formatting(self, mock_download, sample_csv_data):
         """Test that dates are properly formatted."""
         mock_download.return_value = sample_csv_data
 
-        entries = download_leaderboard()
+        df = download_leaderboard()
 
-        # Check date formatting - entries sorted by score descending
+        # Check date formatting - df sorted by score descending
         # exp_003 (2024-02-01), exp_001 (2024-01-15), exp_002 (2024-01-20)
-        assert entries[0].date == "2024-02-01"
-        assert entries[1].date == "2024-01-15"
-        assert entries[2].date == "2024-01-20"
+        assert df.iloc[0]["Date"] == "2024-02-01"
+        assert df.iloc[1]["Date"] == "2024-01-15"
+        assert df.iloc[2]["Date"] == "2024-01-20"
 
     @patch("app.download_github_file_content")
     def test_sorting(self, mock_download, sample_csv_data):
-        """Test that entries are sorted by mean_normalized_score descending."""
+        """Test that df is sorted by mean_normalized_score descending."""
         mock_download.return_value = sample_csv_data
 
-        entries = download_leaderboard()
+        df = download_leaderboard()
 
         # Check sorting (highest score first)
-        scores = [entry.mean_normalized_score for entry in entries]
+        scores = df["mean_normalized_score"].tolist()
         assert scores == sorted(scores, reverse=True)
-        assert entries[0].experiment_id == "exp_003"  # Highest score
-        assert entries[2].experiment_id == "exp_002"  # Lowest score
+        assert df.iloc[0]["experiment_id"] == "exp_003"  # Highest score
+        assert df.iloc[2]["experiment_id"] == "exp_002"  # Lowest score
 
     @patch("app.download_github_file_content")
     def test_extra_columns_filtered(self, mock_download, sample_csv_with_extra_columns):
         """Test that extra columns are filtered out."""
         mock_download.return_value = sample_csv_with_extra_columns
 
-        entries = download_leaderboard()
+        df = download_leaderboard()
 
-        # Check that entries are created correctly (extra columns should be filtered before parsing)
-        assert len(entries) == 2
-        assert all(isinstance(entry, TabularLeaderboardEntry) for entry in entries)
-        # Verify the data model doesn't have extra columns by converting to dict
-        entry_dict = entries[0].to_dict()
-        assert "extra_col" not in entry_dict
+        # Check that df is created correctly (extra columns should be filtered)
+        assert len(df) == 2
+        assert list(df.columns) == DISPLAY_COLUMNS
+        # Verify the df doesn't have extra columns
+        assert "extra_col" not in df.columns
 
     @patch("app.download_github_file_content")
     def test_missing_columns_error(self, mock_download, sample_csv_missing_columns):
@@ -172,10 +170,11 @@ class TestDownloadLeaderboard:
         csv_data = ",".join(DISPLAY_COLUMNS)  # Header only
         mock_download.return_value = csv_data
 
-        entries = download_leaderboard()
+        df = download_leaderboard()
 
-        assert isinstance(entries, list)
-        assert len(entries) == 0
+        assert isinstance(df, pd.DataFrame)
+        assert len(df) == 0
+        assert list(df.columns) == DISPLAY_COLUMNS
 
     @patch("app.download_github_file_content")
     def test_invalid_date_handling(self, mock_download):
@@ -188,13 +187,14 @@ class TestDownloadLeaderboard:
         )
         mock_download.return_value = csv_with_invalid_date
 
-        entries = download_leaderboard()
+        df = download_leaderboard()
 
-        # Invalid dates should become NaT and then empty string
-        # Find entries by experiment_id since order may vary
-        entry_dict = {entry.experiment_id: entry for entry in entries}
-        assert entry_dict["exp_001"].date == "nan"
-        assert entry_dict["exp_002"].date == "2024-01-20"
+        # Invalid dates should become NaT and then "nan" string
+        # Find rows by experiment_id since order may vary
+        row_001 = df[df["experiment_id"] == "exp_001"].iloc[0]
+        row_002 = df[df["experiment_id"] == "exp_002"].iloc[0]
+        assert pd.isna(row_001["Date"])
+        assert row_002["Date"] == "2024-01-20"
 
     @patch("app.download_github_file_content")
     def test_git_lfs_pointer_file(self, mock_download, sample_csv_data):
@@ -202,12 +202,12 @@ class TestDownloadLeaderboard:
         # The utility function handles LFS internally, so we just return the content
         mock_download.return_value = sample_csv_data
 
-        entries = download_leaderboard()
+        df = download_leaderboard()
 
         # Should successfully download via download_url
-        assert isinstance(entries, list)
-        assert len(entries) == 3
-        assert all(isinstance(entry, TabularLeaderboardEntry) for entry in entries)
+        assert isinstance(df, pd.DataFrame)
+        assert len(df) == 3
+        assert list(df.columns) == DISPLAY_COLUMNS
         mock_download.assert_called_once()
 
     @patch("app.download_github_file_content")
@@ -216,33 +216,21 @@ class TestDownloadLeaderboard:
         # The utility function handles download_url internally, so we just return the content
         mock_download.return_value = sample_csv_data
 
-        entries = download_leaderboard()
+        df = download_leaderboard()
 
-        assert isinstance(entries, list)
-        assert len(entries) == 3
-        assert all(isinstance(entry, TabularLeaderboardEntry) for entry in entries)
+        assert isinstance(df, pd.DataFrame)
+        assert len(df) == 3
+        assert list(df.columns) == DISPLAY_COLUMNS
         mock_download.assert_called_once()
 
 
 class TestRefreshLeaderboard:
     """Tests for refresh_leaderboard function."""
 
-    @patch("app.tabular_leaderboard_to_dataframe")
     @patch("app.download_leaderboard")
-    def test_refresh_leaderboard_success(self, mock_download, mock_to_df):
+    def test_refresh_leaderboard_success(self, mock_download):
         """Test that refresh_leaderboard returns dataframe and status message."""
         # Setup mocks
-        mock_entry = TabularLeaderboardEntry(
-            experiment_id="exp_001",
-            agent="Agent A",
-            llms_used="GPT-4",
-            mean_normalized_score=0.85,
-            std_normalized_score=0.01,
-            mean_medal_pct=87.0,
-            sem_medal_pct=1.0,
-            date="2024-01-15",
-        )
-        mock_entries = [mock_entry]
         mock_df = pd.DataFrame(
             {
                 "experiment_id": ["exp_001"],
@@ -250,8 +238,7 @@ class TestRefreshLeaderboard:
                 "Agent": ["Agent A"],
             }
         )
-        mock_download.return_value = mock_entries
-        mock_to_df.return_value = mock_df
+        mock_download.return_value = mock_df
 
         # Execute
         df, status = refresh_leaderboard()
@@ -269,16 +256,12 @@ class TestRefreshLeaderboard:
         timestamp_pattern = r"\d{4}-\d{2}-\d{2} \d{2}:\d{2} UTC"
         assert re.search(timestamp_pattern, status) is not None
         mock_download.assert_called_once()
-        mock_to_df.assert_called_once_with(mock_entries)
 
-    @patch("app.tabular_leaderboard_to_dataframe")
     @patch("app.download_leaderboard")
-    def test_refresh_leaderboard_includes_url(self, mock_download, mock_to_df):
+    def test_refresh_leaderboard_includes_url(self, mock_download):
         """Test that status message includes the GitHub URL."""
-        mock_entries = []
         mock_df = pd.DataFrame()
-        mock_download.return_value = mock_entries
-        mock_to_df.return_value = mock_df
+        mock_download.return_value = mock_df
 
         df, status = refresh_leaderboard()