Resolve merge conflict in data.py

app.py

@@ -216,7 +216,7 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css(), js=js_func)
                     x="date",
                     y="failure_rate",
                     color="platform",
-                    color_map={"AMD": "#FF6B6B", "NVIDIA": "#4ECDC4"},
+                    color_map={"AMD": "#FF6B6B", "NVIDIA": "#76B900"},
                     title="Overall Failure Rates Over Time",
                     tooltip=["failure_rate", "date", "change"],
                     height=300,

data.py

@@ -8,8 +8,8 @@ import json
 import re
 from typing import List, Tuple, Optional
 
-# NOTE: Disable caching to ensure fresh data on each request
-fs = HfFileSystem(use_listings_cache=False)
+# NOTE: if caching is an issue, try adding `use_listings_cache=False`
+fs = HfFileSystem()
 
 IMPORTANT_MODELS = [
     "auto",
@@ -20,10 +20,13 @@ IMPORTANT_MODELS = [
     "vit",  # old (vision) - fixed comma
     "clip",  # old but dominant (vision)
     "detr",  # objection detection, segmentation (vision)
-    "table-transformer",  # objection detection (visioin) - maybe just detr?
+    "table_transformer",  # objection detection (visioin) - maybe just detr?
     "got_ocr2",  # ocr (vision)
     "whisper",  # old but dominant (audio)
     "wav2vec2",  # old (audio)
+    "qwen2_audio",  # (audio)
+    "speech_t5",  # (audio)
+    "csm",  # (audio)
     "llama",  # new and dominant (meta)
     "gemma3",  # new (google)
     "qwen2",  # new (Alibaba)
@@ -34,6 +37,8 @@ IMPORTANT_MODELS = [
     "internvl",  # new (video)
     "gemma3n",  # new (omnimodal models)
     "qwen2_5_omni",  # new (omnimodal models)
+    # "gpt_oss",  # new (quite used)
+    "qwen2_5_omni",  # new (omnimodal models)
 ]
 
 KEYS_TO_KEEP = [

model_page.py

@@ -42,11 +42,11 @@ def _create_pie_chart(ax: plt.Axes, device_label: str, filtered_stats: dict) ->
     """Create a pie chart for device statistics."""
     if not filtered_stats:
         ax.text(0.5, 0.5, 'No test results',
-               horizontalalignment='center', verticalalignment='center',
-               transform=ax.transAxes, fontsize=14, color='#888888',
-               fontfamily='monospace', weight='normal')
+                horizontalalignment='center', verticalalignment='center',
+                transform=ax.transAxes, fontsize=14, color='#888888',
+                fontfamily='monospace', weight='normal')
         ax.set_title(device_label, fontsize=DEVICE_TITLE_FONT_SIZE, weight='bold',
-                    pad=DEVICE_TITLE_PAD, color=TITLE_COLOR, fontfamily='monospace')
+                     pad=DEVICE_TITLE_PAD, color=TITLE_COLOR, fontfamily='monospace')
         ax.axis('off')
         return
 
@@ -63,7 +63,7 @@ def _create_pie_chart(ax: plt.Axes, device_label: str, filtered_stats: dict) ->
         shadow=False,
         wedgeprops=dict(edgecolor='#1a1a1a', linewidth=BORDER_LINE_WIDTH),  # Minimal borders
         textprops={'fontsize': 12, 'weight': 'normal',
-                  'color': LABEL_COLOR, 'fontfamily': 'monospace'}
+                   'color': LABEL_COLOR, 'fontfamily': 'monospace'}
     )
 
     # Enhanced percentage text styling for better readability
@@ -82,7 +82,7 @@ def _create_pie_chart(ax: plt.Axes, device_label: str, filtered_stats: dict) ->
 
     # Device label closer to chart and bigger
     ax.set_title(device_label, fontsize=DEVICE_TITLE_FONT_SIZE, weight='normal',
-                pad=DEVICE_TITLE_PAD, color=TITLE_COLOR, fontfamily='monospace')
+                 pad=DEVICE_TITLE_PAD, color=TITLE_COLOR, fontfamily='monospace')
 
 
 def plot_model_stats(df: pd.DataFrame, model_name: str, historical_df: pd.DataFrame = None) -> tuple[plt.Figure, str, str]:
@@ -124,12 +124,12 @@ def plot_model_stats(df: pd.DataFrame, model_name: str, historical_df: pd.DataFr
     # Add subtle separation line between charts - stops at device labels level
     line_x = 0.5
     fig.add_artist(plt.Line2D([line_x, line_x], [0.0, SEPARATOR_LINE_Y_END],
-                              color='#333333', linewidth=SEPARATOR_LINE_WIDTH,
-                              alpha=SEPARATOR_ALPHA, transform=fig.transFigure))
+                             color='#333333', linewidth=SEPARATOR_LINE_WIDTH,
+                             alpha=SEPARATOR_ALPHA, transform=fig.transFigure))
 
     # Add central shared title for model name
     fig.suptitle(f'{model_name.lower()}', fontsize=32, weight='bold',
-                color='#CCCCCC', fontfamily='monospace', y=MODEL_TITLE_Y)
+                 color='#CCCCCC', fontfamily='monospace', y=MODEL_TITLE_Y)
 
     # Clean layout with padding and space for central title
     plt.tight_layout()
@@ -199,4 +199,4 @@ def prepare_textbox_content(failures: dict[str, list], device: str, data_availab
         for test in multi_failures:
             info_lines.append(format_failure_line(test, "multi"))
 
-    return "\n".join(info_lines)
+    return "\n".join(info_lines)

time_series.py

@@ -4,32 +4,29 @@ import numpy as np
 from datetime import datetime
 from data import extract_model_data
 
-# Colors matching the existing theme
 COLORS = {
     'passed': '#4CAF50',
     'failed': '#E53E3E',
     'skipped': '#FFD54F',
-    'error': '#8B0000'
+    'error': '#8B0000',
+    'amd': '#ED1C24',
+    'nvidia': '#76B900'
 }
 
-# Figure dimensions
 FIGURE_WIDTH = 20
 FIGURE_HEIGHT = 12
 
-# Styling constants
 BLACK = '#000000'
 LABEL_COLOR = '#CCCCCC'
 TITLE_COLOR = '#FFFFFF'
 GRID_COLOR = '#333333'
 
-# Font sizes
 TITLE_FONT_SIZE = 24
 LABEL_FONT_SIZE = 14
 LEGEND_FONT_SIZE = 12
 
 
 def create_time_series_summary(historical_df: pd.DataFrame) -> plt.Figure:
-    """Create time-series visualization for overall failure rates over time."""
     if historical_df.empty or 'date' not in historical_df.columns:
         fig, ax = plt.subplots(figsize=(FIGURE_WIDTH, FIGURE_HEIGHT), facecolor=BLACK)
         ax.set_facecolor(BLACK)
@@ -40,23 +37,17 @@ def create_time_series_summary(historical_df: pd.DataFrame) -> plt.Figure:
         ax.axis('off')
         return fig
     
-    # Convert date column to datetime
     historical_df['date_dt'] = pd.to_datetime(historical_df['date'])
     historical_df = historical_df.sort_values('date_dt')
     
-    # Group by date and calculate overall statistics
     daily_stats = []
     dates = []
     
     for date in historical_df['date_dt'].unique():
         date_data = historical_df[historical_df['date_dt'] == date]
         
-        total_amd_passed = 0
-        total_amd_failed = 0
-        total_amd_skipped = 0
-        total_nvidia_passed = 0
-        total_nvidia_failed = 0
-        total_nvidia_skipped = 0
+        total_amd_passed = total_amd_failed = total_amd_skipped = 0
+        total_nvidia_passed = total_nvidia_failed = total_nvidia_skipped = 0
         
         for _, row in date_data.iterrows():
             amd_stats, nvidia_stats = extract_model_data(row)[:2]
@@ -64,12 +55,10 @@ def create_time_series_summary(historical_df: pd.DataFrame) -> plt.Figure:
             total_amd_passed += amd_stats['passed']
             total_amd_failed += amd_stats['failed']
             total_amd_skipped += amd_stats['skipped']
-            
             total_nvidia_passed += nvidia_stats['passed']
             total_nvidia_failed += nvidia_stats['failed']
             total_nvidia_skipped += nvidia_stats['skipped']
         
-        # Calculate failure rates
         amd_total = total_amd_passed + total_amd_failed
         nvidia_total = total_nvidia_passed + total_nvidia_failed
         
@@ -88,95 +77,113 @@ def create_time_series_summary(historical_df: pd.DataFrame) -> plt.Figure:
         })
         dates.append(date)
     
-    # Create the plot with 3 subplots: failure rates, AMD stacked, NVIDIA stacked
-    fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(FIGURE_WIDTH, FIGURE_HEIGHT + 4), facecolor=BLACK)
-    ax1.set_facecolor(BLACK)
-    ax2.set_facecolor(BLACK)
-    ax3.set_facecolor(BLACK)
+    fig = plt.figure(figsize=(FIGURE_WIDTH, FIGURE_HEIGHT + 4), facecolor=BLACK)
+    gs = fig.add_gridspec(3, 2, height_ratios=[1.2, 1, 1], width_ratios=[2, 1], 
+                          hspace=0.3, wspace=0.25)
+    
+    ax1 = fig.add_subplot(gs[0, :])
+    ax2 = fig.add_subplot(gs[1, 0])
+    ax3 = fig.add_subplot(gs[2, 0])
+    ax4 = fig.add_subplot(gs[1:, 1])
+    
+    for ax in [ax1, ax2, ax3, ax4]:
+        ax.set_facecolor(BLACK)
     
-    # Plot 1: Failure rates over time
     dates_array = np.array(dates)
     amd_rates = [stat['amd_failure_rate'] for stat in daily_stats]
     nvidia_rates = [stat['nvidia_failure_rate'] for stat in daily_stats]
     
-    ax1.plot(dates_array, amd_rates, color='#FF6B6B', linewidth=3, label='AMD', marker='o', markersize=6)
-    ax1.plot(dates_array, nvidia_rates, color='#4ECDC4', linewidth=3, label='NVIDIA', marker='s', markersize=6)
+    ax1.fill_between(dates_array, 0, amd_rates, color=COLORS['amd'], alpha=0.15)
+    ax1.fill_between(dates_array, 0, nvidia_rates, color=COLORS['nvidia'], alpha=0.15)
+    ax1.plot(dates_array, amd_rates, color=COLORS['amd'], linewidth=3, 
+             label='AMD', marker='o', markersize=7, markeredgewidth=2, markeredgecolor=BLACK)
+    ax1.plot(dates_array, nvidia_rates, color=COLORS['nvidia'], linewidth=3, 
+             label='NVIDIA', marker='s', markersize=7, markeredgewidth=2, markeredgecolor=BLACK)
+    
+    if len(amd_rates) > 2:
+        z_amd = np.polyfit(range(len(amd_rates)), amd_rates, 1)
+        p_amd = np.poly1d(z_amd)
+        ax1.plot(dates_array, p_amd(range(len(amd_rates))), 
+                color=COLORS['amd'], linestyle='--', alpha=0.5, linewidth=2)
+        
+        z_nvidia = np.polyfit(range(len(nvidia_rates)), nvidia_rates, 1)
+        p_nvidia = np.poly1d(z_nvidia)
+        ax1.plot(dates_array, p_nvidia(range(len(nvidia_rates))), 
+                color=COLORS['nvidia'], linestyle='--', alpha=0.5, linewidth=2)
     
-    ax1.set_title('Overall Failure Rates Over Time', fontsize=TITLE_FONT_SIZE, color=TITLE_COLOR, 
-                  fontfamily='monospace', fontweight='bold', pad=20)
+    ax1.set_title('Overall Failure Rates Over Time', fontsize=TITLE_FONT_SIZE, 
+                  color=TITLE_COLOR, fontfamily='monospace', fontweight='bold', pad=20)
     ax1.set_ylabel('Failure Rate (%)', fontsize=LABEL_FONT_SIZE, color=LABEL_COLOR, fontfamily='monospace')
     ax1.grid(True, color=GRID_COLOR, alpha=0.3, linestyle='-', linewidth=0.5)
     ax1.legend(fontsize=LEGEND_FONT_SIZE, loc='upper right', frameon=False, 
                labelcolor=LABEL_COLOR, prop={'family': 'monospace'})
+    ax1.tick_params(colors=LABEL_COLOR, labelsize=LABEL_FONT_SIZE, axis='x', rotation=45)
     
-    # Format x-axis
-    ax1.tick_params(colors=LABEL_COLOR, labelsize=LABEL_FONT_SIZE)
-    ax1.xaxis.label.set_color(LABEL_COLOR)
-    ax1.yaxis.label.set_color(LABEL_COLOR)
-    
-    # Plot 2: AMD Test counts over time (stacked area chart)
     amd_passed = [stat['amd_passed'] for stat in daily_stats]
     amd_failed = [stat['amd_failed'] for stat in daily_stats]
     amd_skipped = [stat['amd_skipped'] for stat in daily_stats]
     
-    ax2.fill_between(dates_array, 0, amd_passed, color=COLORS['passed'], alpha=0.7, label='Passed')
-    ax2.fill_between(dates_array, amd_passed, np.array(amd_passed) + np.array(amd_failed), 
-                     color=COLORS['failed'], alpha=0.7, label='Failed')
-    ax2.fill_between(dates_array, np.array(amd_passed) + np.array(amd_failed), 
-                     np.array(amd_passed) + np.array(amd_failed) + np.array(amd_skipped),
-                     color=COLORS['skipped'], alpha=0.7, label='Skipped')
+    ax2.stackplot(dates_array, amd_passed, amd_failed, amd_skipped,
+                  colors=[COLORS['passed'], COLORS['failed'], COLORS['skipped']],
+                  alpha=0.8, labels=['Passed', 'Failed', 'Skipped'])
     
-    ax2.set_title('AMD Test Results Over Time', fontsize=TITLE_FONT_SIZE, color=TITLE_COLOR, 
-                  fontfamily='monospace', fontweight='bold', pad=20)
-    ax2.set_ylabel('Number of Tests', fontsize=LABEL_FONT_SIZE, color=LABEL_COLOR, fontfamily='monospace')
+    ax2.set_title('AMD Test Results', fontsize=TITLE_FONT_SIZE - 2, 
+                  color=TITLE_COLOR, fontfamily='monospace', fontweight='bold', pad=15)
+    ax2.set_ylabel('Tests', fontsize=LABEL_FONT_SIZE, color=LABEL_COLOR, fontfamily='monospace')
     ax2.grid(True, color=GRID_COLOR, alpha=0.3, linestyle='-', linewidth=0.5)
-    ax2.legend(fontsize=LEGEND_FONT_SIZE, loc='upper right', frameon=False, 
-               labelcolor=LABEL_COLOR, prop={'family': 'monospace'})
-    
-    # Format x-axis
-    ax2.tick_params(colors=LABEL_COLOR, labelsize=LABEL_FONT_SIZE)
-    ax2.xaxis.label.set_color(LABEL_COLOR)
-    ax2.yaxis.label.set_color(LABEL_COLOR)
+    ax2.tick_params(colors=LABEL_COLOR, labelsize=LABEL_FONT_SIZE - 1, axis='x', rotation=45)
     
-    # Plot 3: NVIDIA Test counts over time (stacked area chart)
     nvidia_passed = [stat['nvidia_passed'] for stat in daily_stats]
     nvidia_failed = [stat['nvidia_failed'] for stat in daily_stats]
     nvidia_skipped = [stat['nvidia_skipped'] for stat in daily_stats]
     
-    ax3.fill_between(dates_array, 0, nvidia_passed, color=COLORS['passed'], alpha=0.7, label='Passed')
-    ax3.fill_between(dates_array, nvidia_passed, np.array(nvidia_passed) + np.array(nvidia_failed), 
-                     color=COLORS['failed'], alpha=0.7, label='Failed')
-    ax3.fill_between(dates_array, np.array(nvidia_passed) + np.array(nvidia_failed), 
-                     np.array(nvidia_passed) + np.array(nvidia_failed) + np.array(nvidia_skipped),
-                     color=COLORS['skipped'], alpha=0.7, label='Skipped')
+    ax3.stackplot(dates_array, nvidia_passed, nvidia_failed, nvidia_skipped,
+                  colors=[COLORS['passed'], COLORS['failed'], COLORS['skipped']],
+                  alpha=0.8, labels=['Passed', 'Failed', 'Skipped'])
     
-    ax3.set_title('NVIDIA Test Results Over Time', fontsize=TITLE_FONT_SIZE, color=TITLE_COLOR, 
-                  fontfamily='monospace', fontweight='bold', pad=20)
-    ax3.set_ylabel('Number of Tests', fontsize=LABEL_FONT_SIZE, color=LABEL_COLOR, fontfamily='monospace')
+    ax3.set_title('NVIDIA Test Results', fontsize=TITLE_FONT_SIZE - 2, 
+                  color=TITLE_COLOR, fontfamily='monospace', fontweight='bold', pad=15)
+    ax3.set_ylabel('Tests', fontsize=LABEL_FONT_SIZE, color=LABEL_COLOR, fontfamily='monospace')
     ax3.set_xlabel('Date', fontsize=LABEL_FONT_SIZE, color=LABEL_COLOR, fontfamily='monospace')
     ax3.grid(True, color=GRID_COLOR, alpha=0.3, linestyle='-', linewidth=0.5)
-    ax3.legend(fontsize=LEGEND_FONT_SIZE, loc='upper right', frameon=False, 
-               labelcolor=LABEL_COLOR, prop={'family': 'monospace'})
-    
-    # Format x-axis
-    ax3.tick_params(colors=LABEL_COLOR, labelsize=LABEL_FONT_SIZE)
-    ax3.xaxis.label.set_color(LABEL_COLOR)
-    ax3.yaxis.label.set_color(LABEL_COLOR)
-    
-    # Rotate x-axis labels for better readability
-    for ax in [ax1, ax2, ax3]:
-        ax.tick_params(axis='x', rotation=45)
-    
-    plt.tight_layout()
+    ax3.tick_params(colors=LABEL_COLOR, labelsize=LABEL_FONT_SIZE - 1, axis='x', rotation=45)
+    
+    latest = daily_stats[-1]
+    metrics = [
+        ('Latest AMD Failure Rate', f"{latest['amd_failure_rate']:.1f}%", COLORS['amd']),
+        ('Latest NVIDIA Failure Rate', f"{latest['nvidia_failure_rate']:.1f}%", COLORS['nvidia']),
+        ('', '', None),
+        ('Total AMD Tests', str(latest['amd_passed'] + latest['amd_failed'] + latest['amd_skipped']), '#888888'),
+        ('Total NVIDIA Tests', str(latest['nvidia_passed'] + latest['nvidia_failed'] + latest['nvidia_skipped']), '#888888'),
+    ]
+    
+    ax4.axis('off')
+    y_pos = 0.9
+    ax4.text(0.5, 0.95, 'SUMMARY', ha='center', va='top', fontsize=TITLE_FONT_SIZE - 2,
+             color=TITLE_COLOR, fontfamily='monospace', fontweight='bold',
+             transform=ax4.transAxes)
+    
+    for label, value, color in metrics:
+        if label:
+            ax4.text(0.1, y_pos, label, ha='left', va='center', fontsize=LABEL_FONT_SIZE,
+                    color=LABEL_COLOR, fontfamily='monospace', transform=ax4.transAxes)
+            ax4.text(0.9, y_pos, value, ha='right', va='center', fontsize=LABEL_FONT_SIZE + 2,
+                    color=color or LABEL_COLOR, fontfamily='monospace', fontweight='bold',
+                    transform=ax4.transAxes)
+        y_pos -= 0.15
+    
+    handles = [plt.Rectangle((0,0),1,1, fc=COLORS['passed'], alpha=0.8),
+               plt.Rectangle((0,0),1,1, fc=COLORS['failed'], alpha=0.8),
+               plt.Rectangle((0,0),1,1, fc=COLORS['skipped'], alpha=0.8)]
+    ax4.legend(handles, ['Passed', 'Failed', 'Skipped'], 
+              loc='lower center', fontsize=LEGEND_FONT_SIZE,
+              frameon=False, labelcolor=LABEL_COLOR, prop={'family': 'monospace'})
     
-    # Close any existing figures to prevent memory issues
     plt.close('all')
-    
     return fig
 
 
 def create_model_time_series(historical_df: pd.DataFrame, model_name: str) -> plt.Figure:
-    """Create time-series visualization for a specific model."""
     if historical_df.empty or 'date' not in historical_df.columns:
         fig, ax = plt.subplots(figsize=(FIGURE_WIDTH, FIGURE_HEIGHT), facecolor=BLACK)
         ax.set_facecolor(BLACK)
@@ -187,7 +194,6 @@ def create_model_time_series(historical_df: pd.DataFrame, model_name: str) -> pl
         ax.axis('off')
         return fig
     
-    # Filter data for the specific model
     model_data = historical_df[historical_df.index.str.lower() == model_name.lower()]
     
     if model_data.empty:
@@ -200,12 +206,10 @@ def create_model_time_series(historical_df: pd.DataFrame, model_name: str) -> pl
         ax.axis('off')
         return fig
     
-    # Convert date column to datetime and sort
     model_data = model_data.copy()
     model_data['date_dt'] = pd.to_datetime(model_data['date'])
     model_data = model_data.sort_values('date_dt')
     
-    # Extract statistics for each date
     dates = model_data['date_dt'].values
     amd_stats_list = []
     nvidia_stats_list = []
@@ -215,54 +219,98 @@ def create_model_time_series(historical_df: pd.DataFrame, model_name: str) -> pl
         amd_stats_list.append(amd_stats)
         nvidia_stats_list.append(nvidia_stats)
     
-    # Create the plot
-    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(FIGURE_WIDTH, FIGURE_HEIGHT), facecolor=BLACK)
-    ax1.set_facecolor(BLACK)
-    ax2.set_facecolor(BLACK)
+    fig = plt.figure(figsize=(FIGURE_WIDTH, FIGURE_HEIGHT), facecolor=BLACK)
+    gs = fig.add_gridspec(2, 2, height_ratios=[1, 1], width_ratios=[3, 1], 
+                          hspace=0.3, wspace=0.2)
+    
+    ax1 = fig.add_subplot(gs[0, 0])
+    ax2 = fig.add_subplot(gs[1, 0])
+    ax3 = fig.add_subplot(gs[:, 1])
+    
+    for ax in [ax1, ax2, ax3]:
+        ax.set_facecolor(BLACK)
     
-    # Plot 1: AMD results over time
     amd_passed = [stats['passed'] for stats in amd_stats_list]
     amd_failed = [stats['failed'] for stats in amd_stats_list]
     amd_skipped = [stats['skipped'] for stats in amd_stats_list]
     
-    ax1.plot(dates, amd_passed, color=COLORS['passed'], linewidth=3, label='Passed', marker='o', markersize=6)
-    ax1.plot(dates, amd_failed, color=COLORS['failed'], linewidth=3, label='Failed', marker='s', markersize=6)
-    ax1.plot(dates, amd_skipped, color=COLORS['skipped'], linewidth=3, label='Skipped', marker='^', markersize=6)
+    ax1.stackplot(dates, amd_passed, amd_failed, amd_skipped,
+                  colors=[COLORS['passed'], COLORS['failed'], COLORS['skipped']],
+                  alpha=0.7, labels=['Passed', 'Failed', 'Skipped'])
+    
+    ax1.plot(dates, amd_failed, color=COLORS['failed'], linewidth=2.5, 
+             marker='o', markersize=7, markeredgewidth=2, markeredgecolor=BLACK,
+             linestyle='-', label='_nolegend_')
     
-    ax1.set_title(f'{model_name.upper()} - AMD Results Over Time', fontsize=TITLE_FONT_SIZE, color=TITLE_COLOR, 
-                  fontfamily='monospace', fontweight='bold', pad=20)
+    ax1.set_title(f'{model_name.upper()} - AMD Results', fontsize=TITLE_FONT_SIZE, 
+                  color=TITLE_COLOR, fontfamily='monospace', fontweight='bold', pad=20)
     ax1.set_ylabel('Number of Tests', fontsize=LABEL_FONT_SIZE, color=LABEL_COLOR, fontfamily='monospace')
     ax1.grid(True, color=GRID_COLOR, alpha=0.3, linestyle='-', linewidth=0.5)
-    ax1.legend(fontsize=LEGEND_FONT_SIZE, loc='upper right', frameon=False, 
+    ax1.legend(fontsize=LEGEND_FONT_SIZE, loc='upper left', frameon=False, 
                labelcolor=LABEL_COLOR, prop={'family': 'monospace'})
+    ax1.tick_params(colors=LABEL_COLOR, labelsize=LABEL_FONT_SIZE, axis='x', rotation=45)
     
-    # Plot 2: NVIDIA results over time
     nvidia_passed = [stats['passed'] for stats in nvidia_stats_list]
     nvidia_failed = [stats['failed'] for stats in nvidia_stats_list]
     nvidia_skipped = [stats['skipped'] for stats in nvidia_stats_list]
     
-    ax2.plot(dates, nvidia_passed, color=COLORS['passed'], linewidth=3, label='Passed', marker='o', markersize=6)
-    ax2.plot(dates, nvidia_failed, color=COLORS['failed'], linewidth=3, label='Failed', marker='s', markersize=6)
-    ax2.plot(dates, nvidia_skipped, color=COLORS['skipped'], linewidth=3, label='Skipped', marker='^', markersize=6)
+    ax2.stackplot(dates, nvidia_passed, nvidia_failed, nvidia_skipped,
+                  colors=[COLORS['passed'], COLORS['failed'], COLORS['skipped']],
+                  alpha=0.7, labels=['Passed', 'Failed', 'Skipped'])
     
-    ax2.set_title(f'{model_name.upper()} - NVIDIA Results Over Time', fontsize=TITLE_FONT_SIZE, color=TITLE_COLOR, 
-                  fontfamily='monospace', fontweight='bold', pad=20)
+    ax2.plot(dates, nvidia_failed, color=COLORS['failed'], linewidth=2.5, 
+             marker='s', markersize=7, markeredgewidth=2, markeredgecolor=BLACK,
+             linestyle='-', label='_nolegend_')
+    
+    ax2.set_title(f'{model_name.upper()} - NVIDIA Results', fontsize=TITLE_FONT_SIZE, 
+                  color=TITLE_COLOR, fontfamily='monospace', fontweight='bold', pad=20)
     ax2.set_ylabel('Number of Tests', fontsize=LABEL_FONT_SIZE, color=LABEL_COLOR, fontfamily='monospace')
     ax2.set_xlabel('Date', fontsize=LABEL_FONT_SIZE, color=LABEL_COLOR, fontfamily='monospace')
     ax2.grid(True, color=GRID_COLOR, alpha=0.3, linestyle='-', linewidth=0.5)
-    ax2.legend(fontsize=LEGEND_FONT_SIZE, loc='upper right', frameon=False, 
-               labelcolor=LABEL_COLOR, prop={'family': 'monospace'})
-    
-    # Format axes
-    for ax in [ax1, ax2]:
-        ax.tick_params(colors=LABEL_COLOR, labelsize=LABEL_FONT_SIZE)
-        ax.xaxis.label.set_color(LABEL_COLOR)
-        ax.yaxis.label.set_color(LABEL_COLOR)
-        ax.tick_params(axis='x', rotation=45)
-    
-    plt.tight_layout()
+    ax2.tick_params(colors=LABEL_COLOR, labelsize=LABEL_FONT_SIZE, axis='x', rotation=45)
+    
+    ax3.axis('off')
+    latest_amd = amd_stats_list[-1]
+    latest_nvidia = nvidia_stats_list[-1]
+    
+    amd_total = latest_amd['passed'] + latest_amd['failed']
+    nvidia_total = latest_nvidia['passed'] + latest_nvidia['failed']
+    amd_fail_rate = (latest_amd['failed'] / amd_total * 100) if amd_total > 0 else 0
+    nvidia_fail_rate = (latest_nvidia['failed'] / nvidia_total * 100) if nvidia_total > 0 else 0
+    
+    ax3.text(0.5, 0.95, 'LATEST RESULTS', ha='center', va='top', 
+             fontsize=TITLE_FONT_SIZE - 4, color=TITLE_COLOR, fontfamily='monospace',
+             fontweight='bold', transform=ax3.transAxes)
+    
+    y = 0.80
+    sections = [
+        ('AMD', [
+            ('Pass Rate', f"{(latest_amd['passed']/amd_total*100) if amd_total > 0 else 0:.1f}%", COLORS['passed']),
+            ('Fail Rate', f"{amd_fail_rate:.1f}%", COLORS['failed']),
+            ('Total', str(latest_amd['passed'] + latest_amd['failed'] + latest_amd['skipped']), '#888888'),
+        ]),
+        ('NVIDIA', [
+            ('Pass Rate', f"{(latest_nvidia['passed']/nvidia_total*100) if nvidia_total > 0 else 0:.1f}%", COLORS['passed']),
+            ('Fail Rate', f"{nvidia_fail_rate:.1f}%", COLORS['failed']),
+            ('Total', str(latest_nvidia['passed'] + latest_nvidia['failed'] + latest_nvidia['skipped']), '#888888'),
+        ])
+    ]
+    
+    for section_name, metrics in sections:
+        ax3.text(0.5, y, section_name, ha='center', va='center',
+                fontsize=LABEL_FONT_SIZE + 2, color=TITLE_COLOR,
+                fontfamily='monospace', fontweight='bold', transform=ax3.transAxes)
+        y -= 0.08
+        
+        for label, value, color in metrics:
+            ax3.text(0.15, y, label, ha='left', va='center',
+                    fontsize=LABEL_FONT_SIZE - 1, color=LABEL_COLOR,
+                    fontfamily='monospace', transform=ax3.transAxes)
+            ax3.text(0.85, y, value, ha='right', va='center',
+                    fontsize=LABEL_FONT_SIZE, color=color,
+                    fontfamily='monospace', fontweight='bold', transform=ax3.transAxes)
+            y -= 0.07
+        y -= 0.05
     
-    # Close any existing figures to prevent memory issues
     plt.close('all')
-    
-    return fig
+    return fig

time_series_gradio.py

@@ -4,10 +4,16 @@ from datetime import datetime
 from data import extract_model_data
 import gradio as gr
 
-def get_time_series_summary_dfs(historical_df: pd.DataFrame) -> dict:
-    """Return dataframes for historical summary plots (failure rates, AMD tests, NVIDIA tests)."""
+COLORS = {
+    'passed': '#4CAF50',
+    'failed': '#E53E3E',
+    'skipped': '#FFD54F',
+    'error': '#8B0000',
+    'amd': '#ED1C24',
+    'nvidia': '#76B900'
+}
 
-    # Group by date to get daily statistics
+def get_time_series_summary_dfs(historical_df: pd.DataFrame) -> dict:
     daily_stats = []
     dates = sorted(historical_df['date'].unique())
     for date in dates:
@@ -36,7 +42,6 @@ def get_time_series_summary_dfs(historical_df: pd.DataFrame) -> dict:
             'nvidia_skipped': nvidia_skipped
         })
 
-    # Failure rate dataframe
     failure_rate_data = []
     for i, stat in enumerate(daily_stats):
         amd_change = stat['amd_failure_rate'] - daily_stats[i-1]['amd_failure_rate'] if i > 0 else 0
@@ -47,7 +52,6 @@ def get_time_series_summary_dfs(historical_df: pd.DataFrame) -> dict:
         ])
     failure_rate_df = pd.DataFrame(failure_rate_data)
 
-    # AMD tests dataframe
     amd_data = []
     for i, stat in enumerate(daily_stats):
         passed_change = stat['amd_passed'] - daily_stats[i-1]['amd_passed'] if i > 0 else 0
@@ -60,7 +64,6 @@ def get_time_series_summary_dfs(historical_df: pd.DataFrame) -> dict:
         ])
     amd_df = pd.DataFrame(amd_data)
 
-    # NVIDIA tests dataframe
     nvidia_data = []
     for i, stat in enumerate(daily_stats):
         passed_change = stat['nvidia_passed'] - daily_stats[i-1]['nvidia_passed'] if i > 0 else 0
@@ -80,7 +83,6 @@ def get_time_series_summary_dfs(historical_df: pd.DataFrame) -> dict:
     }
 
 def get_model_time_series_dfs(historical_df: pd.DataFrame, model_name: str) -> dict:
-    """Return dataframes for a specific model's historical plots (AMD, NVIDIA)."""
     model_data = historical_df[historical_df.index.str.lower() == model_name.lower()]
     
     if model_data.empty:
@@ -125,9 +127,7 @@ def get_model_time_series_dfs(historical_df: pd.DataFrame, model_name: str) -> d
     return {'amd_df': pd.DataFrame(amd_data), 'nvidia_df': pd.DataFrame(nvidia_data)}
 
 def create_time_series_summary_gradio(historical_df: pd.DataFrame) -> dict:
-    """Create time-series visualization for overall failure rates over time using Gradio native plots."""
     if historical_df.empty or 'date' not in historical_df.columns:
-        # Return empty plots
         empty_df = pd.DataFrame({'date': [], 'failure_rate': [], 'platform': []})
         return {
             'failure_rates': gr.LinePlot(empty_df, x="date", y="failure_rate", color="platform", title="No historical data available", tooltip=["failure_rate", "date", "change"]),
@@ -135,21 +135,18 @@ def create_time_series_summary_gradio(historical_df: pd.DataFrame) -> dict:
             'nvidia_tests': gr.LinePlot(empty_df, x="date", y="failure_rate", color="platform", title="No historical data available", tooltip=["count", "date", "change"])
         }
     
-    # Group by date to get daily statistics
     daily_stats = []
     dates = sorted(historical_df['date'].unique())
     
     for date in dates:
         date_data = historical_df[historical_df['date'] == date]
         
-        # Calculate AMD stats - use the correct column names from the data structure
         amd_passed = date_data['success_amd'].sum() if 'success_amd' in date_data.columns else 0
         amd_failed = (date_data['failed_multi_no_amd'].sum() + date_data['failed_single_no_amd'].sum()) if 'failed_multi_no_amd' in date_data.columns else 0
         amd_skipped = date_data['skipped_amd'].sum() if 'skipped_amd' in date_data.columns else 0
         amd_total = amd_passed + amd_failed + amd_skipped
         amd_failure_rate = (amd_failed / amd_total * 100) if amd_total > 0 else 0
         
-        # Calculate NVIDIA stats - use the correct column names from the data structure
         nvidia_passed = date_data['success_nvidia'].sum() if 'success_nvidia' in date_data.columns else 0
         nvidia_failed = (date_data['failed_multi_no_nvidia'].sum() + date_data['failed_single_no_nvidia'].sum()) if 'failed_multi_no_nvidia' in date_data.columns else 0
         nvidia_skipped = date_data['skipped_nvidia'].sum() if 'skipped_nvidia' in date_data.columns else 0
@@ -168,12 +165,9 @@ def create_time_series_summary_gradio(historical_df: pd.DataFrame) -> dict:
             'nvidia_skipped': nvidia_skipped
         })
     
-    # Create failure rate data
     failure_rate_data = []
     for i, stat in enumerate(daily_stats):
-        # Calculate change from previous point
-        amd_change = 0
-        nvidia_change = 0
+        amd_change = nvidia_change = 0
         if i > 0:
             amd_change = stat['amd_failure_rate'] - daily_stats[i-1]['amd_failure_rate']
             nvidia_change = stat['nvidia_failure_rate'] - daily_stats[i-1]['nvidia_failure_rate']
@@ -185,13 +179,9 @@ def create_time_series_summary_gradio(historical_df: pd.DataFrame) -> dict:
     
     failure_rate_df = pd.DataFrame(failure_rate_data)
     
-    # Create AMD test results data
     amd_data = []
     for i, stat in enumerate(daily_stats):
-        # Calculate change from previous point for each test type
-        passed_change = 0
-        failed_change = 0
-        skipped_change = 0
+        passed_change = failed_change = skipped_change = 0
         if i > 0:
             passed_change = stat['amd_passed'] - daily_stats[i-1]['amd_passed']
             failed_change = stat['amd_failed'] - daily_stats[i-1]['amd_failed']
@@ -205,13 +195,9 @@ def create_time_series_summary_gradio(historical_df: pd.DataFrame) -> dict:
     
     amd_df = pd.DataFrame(amd_data)
     
-    # Create NVIDIA test results data
     nvidia_data = []
     for i, stat in enumerate(daily_stats):
-        # Calculate change from previous point for each test type
-        passed_change = 0
-        failed_change = 0
-        skipped_change = 0
+        passed_change = failed_change = skipped_change = 0
         if i > 0:
             passed_change = stat['nvidia_passed'] - daily_stats[i-1]['nvidia_passed']
             failed_change = stat['nvidia_failed'] - daily_stats[i-1]['nvidia_failed']
@@ -231,10 +217,10 @@ def create_time_series_summary_gradio(historical_df: pd.DataFrame) -> dict:
             x="date",
             y="failure_rate",
             color="platform",
-            color_map={"AMD": "#FF6B6B", "NVIDIA": "#4ECDC4"},
+            color_map={"AMD": COLORS['amd'], "NVIDIA": COLORS['nvidia']},
             title="Overall Failure Rates Over Time",
             tooltip=["failure_rate", "date", "change"],
-            height=300,
+            height=350,
             x_label_angle=45,
             y_title="Failure Rate (%)"
         ),
@@ -243,10 +229,10 @@ def create_time_series_summary_gradio(historical_df: pd.DataFrame) -> dict:
             x="date",
             y="count",
             color="test_type",
-            color_map={"Passed": "#4CAF50", "Failed": "#E53E3E", "Skipped": "#FFA500"},
+            color_map={"Passed": COLORS['passed'], "Failed": COLORS['failed'], "Skipped": COLORS['skipped']},
             title="AMD Test Results Over Time",
             tooltip=["count", "date", "change"],
-            height=300,
+            height=350,
             x_label_angle=45,
             y_title="Number of Tests"
         ),
@@ -255,10 +241,10 @@ def create_time_series_summary_gradio(historical_df: pd.DataFrame) -> dict:
             x="date",
             y="count",
             color="test_type",
-            color_map={"Passed": "#4CAF50", "Failed": "#E53E3E", "Skipped": "#FFA500"},
+            color_map={"Passed": COLORS['passed'], "Failed": COLORS['failed'], "Skipped": COLORS['skipped']},
             title="NVIDIA Test Results Over Time",
             tooltip=["count", "date", "change"],
-            height=300,
+            height=350,
             x_label_angle=45,
             y_title="Number of Tests"
         )
@@ -266,27 +252,22 @@ def create_time_series_summary_gradio(historical_df: pd.DataFrame) -> dict:
 
 
 def create_model_time_series_gradio(historical_df: pd.DataFrame, model_name: str) -> dict:
-    """Create time-series visualization for a specific model using Gradio native plots."""
     if historical_df.empty or 'date' not in historical_df.columns:
-        # Return empty plots
         empty_df = pd.DataFrame({'date': [], 'count': [], 'test_type': []})
         return {
             'amd_plot': gr.LinePlot(empty_df, x="date", y="count", color="test_type", title=f"{model_name.upper()} - AMD Results Over Time", tooltip=["count", "date", "change"]),
             'nvidia_plot': gr.LinePlot(empty_df, x="date", y="count", color="test_type", title=f"{model_name.upper()} - NVIDIA Results Over Time", tooltip=["count", "date", "change"])
         }
     
-    # Filter data for the specific model (model_name is the index)
     model_data = historical_df[historical_df.index.str.lower() == model_name.lower()]
     
     if model_data.empty:
-        # Return empty plots
         empty_df = pd.DataFrame({'date': [], 'count': [], 'test_type': []})
         return {
             'amd_plot': gr.LinePlot(empty_df, x="date", y="count", color="test_type", title=f"{model_name.upper()} - AMD Results Over Time", tooltip=["count", "date", "change"]),
             'nvidia_plot': gr.LinePlot(empty_df, x="date", y="count", color="test_type", title=f"{model_name.upper()} - NVIDIA Results Over Time", tooltip=["count", "date", "change"])
         }
     
-    # Group by date
     dates = sorted(model_data['date'].unique())
     
     amd_data = []
@@ -296,18 +277,13 @@ def create_model_time_series_gradio(historical_df: pd.DataFrame, model_name: str
         date_data = model_data[model_data['date'] == date]
         
         if not date_data.empty:
-            # Get the first row for this date (should be only one)
             row = date_data.iloc[0]
             
-            # AMD data - use the correct column names from the data structure
             amd_passed = row.get('success_amd', 0)
             amd_failed = row.get('failed_multi_no_amd', 0) + row.get('failed_single_no_amd', 0)
             amd_skipped = row.get('skipped_amd', 0)
             
-            # Calculate change from previous point
-            passed_change = 0
-            failed_change = 0
-            skipped_change = 0
+            passed_change = failed_change = skipped_change = 0
             if i > 0:
                 prev_date_data = model_data[model_data['date'] == dates[i-1]]
                 if not prev_date_data.empty:
@@ -326,15 +302,11 @@ def create_model_time_series_gradio(historical_df: pd.DataFrame, model_name: str
                 {'date': date, 'count': amd_skipped, 'test_type': 'Skipped', 'change': skipped_change}
             ])
             
-            # NVIDIA data - use the correct column names from the data structure
             nvidia_passed = row.get('success_nvidia', 0)
             nvidia_failed = row.get('failed_multi_no_nvidia', 0) + row.get('failed_single_no_nvidia', 0)
             nvidia_skipped = row.get('skipped_nvidia', 0)
             
-            # Calculate change from previous point for NVIDIA
-            nvidia_passed_change = 0
-            nvidia_failed_change = 0
-            nvidia_skipped_change = 0
+            nvidia_passed_change = nvidia_failed_change = nvidia_skipped_change = 0
             if i > 0:
                 prev_date_data = model_data[model_data['date'] == dates[i-1]]
                 if not prev_date_data.empty:
@@ -362,11 +334,11 @@ def create_model_time_series_gradio(historical_df: pd.DataFrame, model_name: str
             x="date",
             y="count",
             color="test_type",
-            color_map={"Passed": "#4CAF50", "Failed": "#E53E3E", "Skipped": "#FFA500"},
+            color_map={"Passed": COLORS['passed'], "Failed": COLORS['failed'], "Skipped": COLORS['skipped']},
             title=f"{model_name.upper()} - AMD Results Over Time",
             x_label_angle=45,
             y_title="Number of Tests",
-            height=300,
+            height=350,
             tooltip=["count", "date", "change"]
         ),
         'nvidia_plot': gr.LinePlot(
@@ -374,11 +346,11 @@ def create_model_time_series_gradio(historical_df: pd.DataFrame, model_name: str
             x="date",
             y="count",
             color="test_type",
-            color_map={"Passed": "#4CAF50", "Failed": "#E53E3E", "Skipped": "#FFA500"},
+            color_map={"Passed": COLORS['passed'], "Failed": COLORS['failed'], "Skipped": COLORS['skipped']},
             title=f"{model_name.upper()} - NVIDIA Results Over Time",
             x_label_angle=45,
             y_title="Number of Tests",
-            height=300,
+            height=350,
             tooltip=["count", "date", "change"]
         )
-    }
+    }