Rework of model page

model_page.py

@@ -38,60 +38,6 @@ MODEL_TITLE_Y = 1
 MAX_FAILURE_ITEMS = 10
 
 
-def _process_failure_category(failures_obj: dict, category: str, info_lines: list) -> None:
-    """Process a single failure category (multi or single) and add to info_lines."""
-    if category in failures_obj and failures_obj[category]:
-        info_lines.append(generate_underlined_line(f"{category.title()} GPU failure details:"))
-        if isinstance(failures_obj[category], list):
-            # Handle list of failures (could be strings or dicts)
-            for i, failure in enumerate(failures_obj[category][:MAX_FAILURE_ITEMS]):
-                if isinstance(failure, dict):
-                    # Extract meaningful info from dict (e.g., test name, line, etc.)
-                    failure_str = failure.get('line', failure.get('test', 
-                                            failure.get('name', str(failure))))
-                    info_lines.append(f"  {i+1}. {failure_str}")
-                else:
-                    info_lines.append(f"  {i+1}. {str(failure)}")
-            if len(failures_obj[category]) > MAX_FAILURE_ITEMS:
-                remaining = len(failures_obj[category]) - MAX_FAILURE_ITEMS
-                info_lines.append(f"... and {remaining} more")
-        else:
-            info_lines.append(str(failures_obj[category]))
-        info_lines.append("")
-
-
-def extract_failure_info(failures_obj, device: str, multi_count: int, single_count: int) -> str:
-    """Extract failure information from failures object."""
-    if (not failures_obj or pd.isna(failures_obj)) and multi_count == 0 and single_count == 0:
-        return f"No failures on {device}"
-    
-    info_lines = []
-    
-    # Add counts summary
-    if multi_count > 0 or single_count > 0:
-        info_lines.append(generate_underlined_line(f"Failure Summary for {device}:"))
-        if multi_count > 0:
-            info_lines.append(f"Multi GPU failures: {multi_count}")
-        if single_count > 0:
-            info_lines.append(f"Single GPU failures: {single_count}")
-        info_lines.append("")
-    
-    # Try to extract detailed failure information
-    try:
-        if isinstance(failures_obj, dict):
-            _process_failure_category(failures_obj, 'multi', info_lines)
-            _process_failure_category(failures_obj, 'single', info_lines)
-        
-        return "\n".join(info_lines) if info_lines else f"No detailed failure info for {device}"
-    
-    except Exception as e:
-        if multi_count > 0 or single_count > 0:
-            error_msg = (f"Failures detected on {device} (Multi: {multi_count}, Single: {single_count})\n"
-                        f"Details unavailable: {str(e)}")
-            return error_msg
-        return f"Error processing failure info for {device}: {str(e)}"
-
-
 def _create_pie_chart(ax: plt.Axes, device_label: str, filtered_stats: dict) -> None:
     """Create a pie chart for device statistics."""
     if not filtered_stats:
@@ -111,7 +57,7 @@ def _create_pie_chart(ax: plt.Axes, device_label: str, filtered_stats: dict) ->
         filtered_stats.values(), 
         labels=[label.lower() for label in filtered_stats.keys()],  # Lowercase for minimal look
         colors=chart_colors,
-        autopct=lambda pct: f'{int(pct/100*sum(filtered_stats.values()))}',
+        autopct=lambda pct: f'{int(pct * sum(filtered_stats.values()) / 100)}',
         startangle=PIE_START_ANGLE,
         explode=None,  # No separation
         shadow=False,
@@ -146,22 +92,23 @@ def plot_model_stats(df: pd.DataFrame, model_name: str) -> tuple[plt.Figure, str
         # Create empty stats for both devices
         amd_filtered = {}
         nvidia_filtered = {}
-        failed_multi_amd = failed_single_amd = failed_multi_nvidia = failed_single_nvidia = 0
         failures_amd = failures_nvidia = {}
     else:
         row = df.loc[model_name]
         
         # Extract and process model data
-        amd_stats, nvidia_stats, failed_multi_amd, failed_single_amd, failed_multi_nvidia, failed_single_nvidia = \
-            extract_model_data(row)
+        amd_stats, nvidia_stats = extract_model_data(row)[:2]
         
         # Filter out categories with 0 values for cleaner visualization
         amd_filtered = {k: v for k, v in amd_stats.items() if v > 0}
         nvidia_filtered = {k: v for k, v in nvidia_stats.items() if v > 0}
         
         # Generate failure info directly from dataframe
-        failures_amd = row.get('failures_amd', {})
-        failures_nvidia = row.get('failures_nvidia', {})
+        failures_amd = dict(row.get('failures_amd', {}))
+        failures_nvidia = dict(row.get('failures_nvidia', {}))
+
+    # failure_xxx = {"single": [test, ...], "multi": [...]}
+    # test = {"line": test_name. "trace": error_msg}
     
     # Always create figure with two subplots side by side with padding
     fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(FIGURE_WIDTH_DUAL, FIGURE_HEIGHT_DUAL), facecolor=BLACK)
@@ -186,7 +133,46 @@ def plot_model_stats(df: pd.DataFrame, model_name: str) -> tuple[plt.Figure, str
     plt.tight_layout()
     plt.subplots_adjust(top=SUBPLOT_TOP, wspace=SUBPLOT_WSPACE)
     
-    amd_failed_info = extract_failure_info(failures_amd, 'AMD', failed_multi_amd, failed_single_amd)
-    nvidia_failed_info = extract_failure_info(failures_nvidia, 'NVIDIA', failed_multi_nvidia, failed_single_nvidia)
+    amd_failed_info = prepare_textbox_content(failures_amd, 'AMD', bool(amd_filtered))
+    nvidia_failed_info = prepare_textbox_content(failures_nvidia, 'NVIDIA', bool(nvidia_filtered))
     
     return fig, amd_failed_info, nvidia_failed_info
+
+
+def prepare_textbox_content(failures: dict[str, list], device: str, data_available: bool) -> str:
+    """Extract failure information from failures object."""
+    # Catch the case where there is no data
+    if not data_available:
+        return generate_underlined_line(f"No data for {device}")
+    # Catch the case where there are no failures
+    if not failures:
+        return generate_underlined_line(f"No failures for {device}")
+    
+    # Summary of failures
+    single_failures = failures.get("single", [])
+    multi_failures = failures.get("multi", [])
+    info_lines = [
+        generate_underlined_line(f"Failure summary for {device}:"),
+        f"Single GPU failures: {len(single_failures)}",
+        f"Multi GPU failures: {len(multi_failures)}",
+        ""
+    ]
+
+    # Add single-gpu failures
+    if single_failures:
+        info_lines.append(generate_underlined_line("Single GPU failures:"))
+        for test in single_failures:
+            name = test.get("line", "::*could not find name*")
+            name = name.split("::")[-1]
+            info_lines.append(name)
+        info_lines.append("\n")
+    
+    # Add multi-gpu failures
+    if multi_failures:
+        info_lines.append(generate_underlined_line("Multi GPU failures:"))
+        for test in multi_failures:
+            name = test.get("line", "::*could not find name*")
+            name = name.split("::")[-1]
+            info_lines.append(name)
+
+    return "\n".join(info_lines)

styles.css

@@ -539,8 +539,9 @@ h1, h2, h3, p, .markdown {
     resize: none !important;
     scrollbar-width: thin !important;
     scrollbar-color: #333333 #000000 !important;
-    scroll-behavior: auto;
+    scroll-behavior: auto !important;
     transition: opacity 0.5s ease-in-out !important;
+    scroll-padding-top: 0 !important;
 }
 
 /* WebKit scrollbar styling for failed tests */

utils.py

@@ -48,4 +48,4 @@ logger = setup_logger()
 
 
 def generate_underlined_line(text: str) -> str:
-    return text + "\n" + "─" * len(text) + "\n"
+    return text + "\n" + "─" * len(text)