edit showing models ranking: show medals and line under second best model

leaderboard/leaderboard.py

@@ -307,23 +307,190 @@ class LeaderboardApp:
                 numeric_series_for_max = formatted_df[col_name_original].apply(to_numeric_for_max)
 
                 if not numeric_series_for_max.empty and numeric_series_for_max.notna().any() and \
-                   pd.api.types.is_numeric_dtype(numeric_series_for_max) and not numeric_series_for_max.eq(-np.inf).all():
-                    max_val_numeric = numeric_series_for_max.max(skipna=True) 
+                pd.api.types.is_numeric_dtype(numeric_series_for_max) and not numeric_series_for_max.eq(-np.inf).all():
+
+                    # Get unique scores and sort them in descending order to find the top 3
+                    unique_sorted_scores = numeric_series_for_max.dropna().unique()
+                    unique_sorted_scores = np.sort(unique_sorted_scores)[::-1]
+
+                    max_val_numeric = unique_sorted_scores[0] if len(unique_sorted_scores) > 0 else -np.inf
+                    second_max_numeric = unique_sorted_scores[1] if len(unique_sorted_scores) > 1 else -np.inf
+                    third_max_numeric = unique_sorted_scores[2] if len(unique_sorted_scores) > 2 else -np.inf
+
                     if pd.notna(max_val_numeric) and max_val_numeric != -np.inf:
                         for i in numeric_series_for_max.index:
                             current_numeric_val = numeric_series_for_max.loc[i]
-                            if pd.notna(current_numeric_val) and current_numeric_val == max_val_numeric:
-                                display_val_to_bold = formatted_df.loc[i, col_name_original]
-                                if not (isinstance(display_val_to_bold, str) and display_val_to_bold.startswith("**") and display_val_to_bold.endswith("**")):
-                                    formatted_df.loc[i, col_name_original] = f"**{display_val_to_bold}**"
+                            if pd.notna(current_numeric_val) and current_numeric_val >= -np.inf:
+                                display_val = formatted_df.loc[i, col_name_original]
+                                
+                                # Check for the top 3 values and apply the corresponding formatting
+                                if current_numeric_val == max_val_numeric:
+                                    formatted_df.loc[i, col_name_original] = f"**{display_val}**"
+                                elif current_numeric_val == second_max_numeric:
+                                    formatted_df.loc[i, col_name_original] = f"<ins>{display_val}</ins>"
+                                # No formatting for third place, so no elif statement is needed
+                                
                             elif pd.isna(current_numeric_val) or current_numeric_val == -np.inf:
                                 cell_content = formatted_df.loc[i, col_name_original]
                                 if cell_content is None or \
-                                   (isinstance(cell_content, str) and \
-                                    cell_content.strip().lower() in ["n/a", "", "unknown", "nan"]): # Standardize NA display
+                                (isinstance(cell_content, str) and \
+                                    cell_content.strip().lower() in ["n/a", "", "unknown", "nan"]):
                                     formatted_df.loc[i, col_name_original] = ""
         return formatted_df
 
+    # def _apply_markdown_and_bolding(self, df_with_general_formats: pd.DataFrame) -> pd.DataFrame:
+    #     if df_with_general_formats.empty: return df_with_general_formats
+    #     formatted_df = df_with_general_formats.copy()
+
+    #     model_id_col_original = self.model_identifier_column
+
+    #     if model_id_col_original in formatted_df.columns and 'model_url' in formatted_df.columns:
+    #         def create_markdown_link(row):
+    #             model_id_val = row[model_id_col_original]
+    #             url = row['model_url']
+
+    #             display_conf = self.model_display_configs.get(str(model_id_val), {})
+    #             display_name = display_conf.get('display_name', str(model_id_val))
+    #             url_for_link = display_conf.get('url', url if pd.notna(url) else 'https://google.com')
+    #             if not url_for_link or pd.isna(url_for_link): url_for_link = 'https://google.com'
+    #             return f"[{display_name}]({url_for_link})"
+    #         formatted_df[model_id_col_original] = formatted_df.apply(create_markdown_link, axis=1)
+
+    #     for col_name_original in self.numeric_score_columns_for_bolding:
+    #         if col_name_original in formatted_df.columns:
+    #             def to_numeric_for_max(val):
+    #                 if isinstance(val, str):
+    #                     try: return float(val) # Handles "88.00", "75.50", "100", "0"
+    #                     except ValueError: return -np.inf
+    #                 return val if pd.notna(val) else -np.inf
+
+    #             numeric_series_for_max = formatted_df[col_name_original].apply(to_numeric_for_max)
+
+    #             if not numeric_series_for_max.empty and numeric_series_for_max.notna().any() and \
+    #             pd.api.types.is_numeric_dtype(numeric_series_for_max) and not numeric_series_for_max.eq(-np.inf).all():
+
+    #                 # Get unique scores and sort them in descending order to find the top 3
+    #                 unique_sorted_scores = numeric_series_for_max.dropna().unique()
+    #                 unique_sorted_scores = np.sort(unique_sorted_scores)[::-1]
+
+    #                 max_val_numeric = unique_sorted_scores[0] if len(unique_sorted_scores) > 0 else -np.inf
+    #                 second_max_numeric = unique_sorted_scores[1] if len(unique_sorted_scores) > 1 else -np.inf
+    #                 third_max_numeric = unique_sorted_scores[2] if len(unique_sorted_scores) > 2 else -np.inf
+
+    #                 if pd.notna(max_val_numeric) and max_val_numeric != -np.inf:
+    #                     for i in numeric_series_for_max.index:
+    #                         current_numeric_val = numeric_series_for_max.loc[i]
+    #                         if pd.notna(current_numeric_val) and current_numeric_val >= -np.inf:
+    #                             display_val = formatted_df.loc[i, col_name_original]
+                                
+    #                             # Check for the top 3 values and apply the corresponding color
+    #                             if current_numeric_val == max_val_numeric:
+    #                                 formatted_df.loc[i, col_name_original] = f"<span style='color: gold;'>{display_val}</span>"
+    #                             elif current_numeric_val == second_max_numeric:
+    #                                 formatted_df.loc[i, col_name_original] = f"<span style='color: #C0C0C0;'>{display_val}</span>"
+    #                             elif current_numeric_val == third_max_numeric:
+    #                                 formatted_df.loc[i, col_name_original] = f"<span style='color: #CD7F32;'>{display_val}</span>" # Bronze hex code
+                                
+    #                         elif pd.isna(current_numeric_val) or current_numeric_val == -np.inf:
+    #                             cell_content = formatted_df.loc[i, col_name_original]
+    #                             if cell_content is None or \
+    #                             (isinstance(cell_content, str) and \
+    #                                 cell_content.strip().lower() in ["n/a", "", "unknown", "nan"]):
+    #                                 formatted_df.loc[i, col_name_original] = ""
+    #     return formatted_df
+    # def _apply_markdown_and_bolding(self, df_with_general_formats: pd.DataFrame) -> pd.DataFrame:
+    #     if df_with_general_formats.empty: return df_with_general_formats
+    #     formatted_df = df_with_general_formats.copy()
+
+    #     model_id_col_original = self.model_identifier_column
+
+    #     if model_id_col_original in formatted_df.columns and 'model_url' in formatted_df.columns:
+    #         def create_markdown_link(row):
+    #             model_id_val = row[model_id_col_original]
+    #             url = row['model_url']
+
+    #             display_conf = self.model_display_configs.get(str(model_id_val), {})
+    #             display_name = display_conf.get('display_name', str(model_id_val))
+    #             url_for_link = display_conf.get('url', url if pd.notna(url) else 'https://google.com')
+    #             if not url_for_link or pd.isna(url_for_link): url_for_link = 'https://google.com'
+    #             return f"[{display_name}]({url_for_link})"
+    #         formatted_df[model_id_col_original] = formatted_df.apply(create_markdown_link, axis=1)
+
+    #     for col_name_original in self.numeric_score_columns_for_bolding:
+    #         if col_name_original in formatted_df.columns:
+    #             def to_numeric_for_max(val):
+    #                 if isinstance(val, str):
+    #                     try: return float(val) # Handles "88.00", "75.50", "100", "0"
+    #                     except ValueError: return -np.inf
+    #                 return val if pd.notna(val) else -np.inf
+
+    #             numeric_series_for_max = formatted_df[col_name_original].apply(to_numeric_for_max)
+
+    #             if not numeric_series_for_max.empty and numeric_series_for_max.notna().any() and \
+    #             pd.api.types.is_numeric_dtype(numeric_series_for_max) and not numeric_series_for_max.eq(-np.inf).all():
+    #                 max_val_numeric = numeric_series_for_max.max(skipna=True)
+    #                 if pd.notna(max_val_numeric) and max_val_numeric != -np.inf:
+    #                     for i in numeric_series_for_max.index:
+    #                         current_numeric_val = numeric_series_for_max.loc[i]
+    #                         if pd.notna(current_numeric_val) and current_numeric_val == max_val_numeric:
+    #                             display_val_to_bold = formatted_df.loc[i, col_name_original]
+    #                             if not (isinstance(display_val_to_bold, str) and display_val_to_bold.startswith("<span style='color: gold;'>") and display_val_to_bold.endswith("</span>")):
+    #                                 # Changed from bolding to coloring
+    #                                 formatted_df.loc[i, col_name_original] = f"<span style='color: gold;'>{display_val_to_bold}</span>"
+    #                         elif pd.isna(current_numeric_val) or current_numeric_val == -np.inf:
+    #                             cell_content = formatted_df.loc[i, col_name_original]
+    #                             if cell_content is None or \
+    #                             (isinstance(cell_content, str) and \
+    #                                 cell_content.strip().lower() in ["n/a", "", "unknown", "nan"]): # Standardize NA display
+    #                                 formatted_df.loc[i, col_name_original] = ""
+    #     return formatted_df
+
+    # def _apply_markdown_and_bolding(self, df_with_general_formats: pd.DataFrame) -> pd.DataFrame:
+    #     if df_with_general_formats.empty: return df_with_general_formats
+    #     formatted_df = df_with_general_formats.copy()
+
+    #     model_id_col_original = self.model_identifier_column
+
+    #     if model_id_col_original in formatted_df.columns and 'model_url' in formatted_df.columns:
+    #         def create_markdown_link(row):
+    #             model_id_val = row[model_id_col_original]
+    #             url = row['model_url']
+
+    #             display_conf = self.model_display_configs.get(str(model_id_val), {})
+    #             display_name = display_conf.get('display_name', str(model_id_val))
+    #             url_for_link = display_conf.get('url', url if pd.notna(url) else 'https://google.com')
+    #             if not url_for_link or pd.isna(url_for_link): url_for_link = 'https://google.com'
+    #             return f"[{display_name}]({url_for_link})"
+    #         formatted_df[model_id_col_original] = formatted_df.apply(create_markdown_link, axis=1)
+
+    #     for col_name_original in self.numeric_score_columns_for_bolding:
+    #         if col_name_original in formatted_df.columns:
+    #             def to_numeric_for_max(val):
+    #                 if isinstance(val, str):
+    #                     try: return float(val) # Handles "88.00", "75.50", "100", "0"
+    #                     except ValueError: return -np.inf
+    #                 return val if pd.notna(val) else -np.inf
+
+    #             numeric_series_for_max = formatted_df[col_name_original].apply(to_numeric_for_max)
+
+    #             if not numeric_series_for_max.empty and numeric_series_for_max.notna().any() and \
+    #                pd.api.types.is_numeric_dtype(numeric_series_for_max) and not numeric_series_for_max.eq(-np.inf).all():
+    #                 max_val_numeric = numeric_series_for_max.max(skipna=True) 
+    #                 if pd.notna(max_val_numeric) and max_val_numeric != -np.inf:
+    #                     for i in numeric_series_for_max.index:
+    #                         current_numeric_val = numeric_series_for_max.loc[i]
+    #                         if pd.notna(current_numeric_val) and current_numeric_val == max_val_numeric:
+    #                             display_val_to_bold = formatted_df.loc[i, col_name_original]
+    #                             if not (isinstance(display_val_to_bold, str) and display_val_to_bold.startswith("**") and display_val_to_bold.endswith("**")):
+    #                                 formatted_df.loc[i, col_name_original] = f"**{display_val_to_bold}**"
+    #                         elif pd.isna(current_numeric_val) or current_numeric_val == -np.inf:
+    #                             cell_content = formatted_df.loc[i, col_name_original]
+    #                             if cell_content is None or \
+    #                                (isinstance(cell_content, str) and \
+    #                                 cell_content.strip().lower() in ["n/a", "", "unknown", "nan"]): # Standardize NA display
+    #                                 formatted_df.loc[i, col_name_original] = ""
+    #     return formatted_df
+
     @staticmethod
     def _get_gr_datatypes(df_with_original_cols: pd.DataFrame, model_id_col_original_name: str, score_cols_original_names: List[str]) -> List[str]:
         datatypes = []
@@ -342,6 +509,54 @@ class LeaderboardApp:
                 datatypes.append("str")
         return datatypes
 
+    # def get_prepared_dataframe(self, task_key: str, source_filter: str = "All", name_filter_query: str = "") -> pd.DataFrame:
+    #     original_df_for_task = self.raw_dataframes.get(task_key)
+    #     if original_df_for_task is None or original_df_for_task.empty:
+    #         return pd.DataFrame()
+
+    #     processed_df = original_df_for_task.copy()
+
+    #     parent_nlu_nlg_task_keys = ["persian_nlg", "persian_nlu"]
+    #     if task_key in parent_nlu_nlg_task_keys:
+    #         cols_to_drop_due_to_object = []
+    #         for col_name in processed_df.columns:
+    #             if processed_df[col_name].apply(lambda x: isinstance(x, dict)).any():
+    #                 cols_to_drop_due_to_object.append(col_name)
+    #         if cols_to_drop_due_to_object:
+    #             logger.info(f"For overview task '{task_key}', dropping object columns: {cols_to_drop_due_to_object}")
+    #             processed_df = processed_df.drop(columns=cols_to_drop_due_to_object, errors='ignore')
+
+    #     if 'source_type' in processed_df.columns and source_filter != "All":
+    #         processed_df = processed_df[processed_df['source_type'] == source_filter]
+    #         if processed_df.empty: return pd.DataFrame()
+
+    #     if name_filter_query and self.model_identifier_column in processed_df.columns:
+    #         try:
+    #             processed_df = processed_df[processed_df[self.model_identifier_column].astype(str).str.contains(name_filter_query, case=False, na=False)]
+    #         except Exception as e: logger.error(f"Name filter error: {e}")
+    #         if processed_df.empty: return pd.DataFrame()
+
+    #     if processed_df.empty: return pd.DataFrame()
+
+    #     processed_df = self._apply_general_formatting_to_cells(processed_df, task_key)
+    #     processed_df = self._apply_markdown_and_bolding(processed_df)
+
+    #     if self.columns_to_hide:
+    #         columns_to_drop_existing = [col for col in self.columns_to_hide if col in processed_df.columns]
+    #         if columns_to_drop_existing:
+    #             processed_df = processed_df.drop(columns=columns_to_drop_existing, errors='ignore')
+
+    #     if "Rank" in processed_df.columns:
+    #         cols_order = ["Rank"] + [col for col in processed_df.columns if col != "Rank"]
+    #         processed_df = processed_df[cols_order]
+        
+    #     if "Rank" in processed_df.columns:
+    #          processed_df["Rank"] = processed_df["Rank"].apply(lambda x: str(int(x)) if pd.notna(x) and isinstance(x, (float,int)) and x == int(x) else (str(x) if pd.notna(x) else ""))
+
+
+    #     processed_df = processed_df.fillna("") 
+    #     return processed_df
+
     def get_prepared_dataframe(self, task_key: str, source_filter: str = "All", name_filter_query: str = "") -> pd.DataFrame:
         original_df_for_task = self.raw_dataframes.get(task_key)
         if original_df_for_task is None or original_df_for_task.empty:
@@ -380,13 +595,28 @@ class LeaderboardApp:
                 processed_df = processed_df.drop(columns=columns_to_drop_existing, errors='ignore')
 
         if "Rank" in processed_df.columns:
+            # Define the function to replace ranks with medal emojis
+            def format_rank_with_medals(rank_value):
+                try:
+                    rank_int = int(rank_value)
+                    if rank_int == 1:
+                        return "🥇"
+                    elif rank_int == 2:
+                        return "🥈"
+                    elif rank_int == 3:
+                        return "🥉"
+                    else:
+                        return str(rank_int)
+                except (ValueError, TypeError):
+                    # Return original value for non-numeric or missing ranks
+                    return str(rank_value) if pd.notna(rank_value) else ""
+
+            # Apply the new formatting function to the "Rank" column
+            processed_df["Rank"] = processed_df["Rank"].apply(format_rank_with_medals)
+
             cols_order = ["Rank"] + [col for col in processed_df.columns if col != "Rank"]
             processed_df = processed_df[cols_order]
         
-        if "Rank" in processed_df.columns:
-             processed_df["Rank"] = processed_df["Rank"].apply(lambda x: str(int(x)) if pd.notna(x) and isinstance(x, (float,int)) and x == int(x) else (str(x) if pd.notna(x) else ""))
-
-
         processed_df = processed_df.fillna("") 
         return processed_df