Upload folder using huggingface_hub

app.py

@@ -2,12 +2,18 @@ import matplotlib.pyplot as plt
 import matplotlib
 import pandas as pd
 import gradio as gr
+from gradio_toggle import Toggle
 
 from data import CIResults
 from utils import logger
 from summary_page import create_summary_page
 from model_page import plot_model_stats
-from time_series_gradio import create_time_series_summary_gradio, create_model_time_series_gradio
+from time_series_gradio import (
+    create_time_series_summary_gradio,
+    create_model_time_series_gradio,
+    get_time_series_summary_dfs,
+    get_model_time_series_dfs,
+)
 
 
 # Configure matplotlib to prevent memory warnings and set dark background
@@ -20,6 +26,12 @@ plt.ioff()  # Turn off interactive mode to prevent figure accumulation
 # Load data once at startup
 Ci_results = CIResults()
 Ci_results.load_data()
+# Preload historical data at startup
+if Ci_results.available_dates:
+    start_date_val = Ci_results.available_dates[-1]  # Last date (oldest)
+    end_date_val = Ci_results.available_dates[0]     # First date (newest)
+    Ci_results.load_historical_data(start_date_val, end_date_val)
+    logger.info(f"Preloaded historical data: {len(Ci_results.historical_df)} records")
 # Start the auto-reload scheduler
 Ci_results.schedule_data_reload()
 
@@ -78,9 +90,19 @@ def load_css():
         logger.warning("styles.css not found, using minimal default styles")
         return "body { background: #000; color: #fff; }"
 
+js_func = """
+function refresh() {
+    const url = new URL(window.location);
+
+    if (url.searchParams.get('__theme') !== 'dark') {
+        url.searchParams.set('__theme', 'dark');
+        window.location.href = url.href;
+    }
+}
+"""
 
 # Create the Gradio interface with sidebar and dark theme
-with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
+with gr.Blocks(title="Model Test Results Dashboard", css=load_css(), js=js_func) as demo:
 
 
     with gr.Row():
@@ -92,50 +114,6 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
             description_text = get_description_text()
             description_display = gr.Markdown(description_text, elem_classes=["sidebar-description"])
 
-            # View toggle buttons
-            with gr.Row(elem_classes=["view-toggle-row"]):
-                current_view_button = gr.Button(
-                    "current\n📊",
-                    variant="primary",
-                    size="lg",
-                    elem_classes=["view-toggle-button", "view-toggle-active"]
-                )
-                historical_view_button = gr.Button(
-                    "history\n📈",
-                    variant="secondary",
-                    size="lg",
-                    elem_classes=["view-toggle-button"]
-                )
-
-            # Date selection toggle button (initially hidden)
-            date_toggle_button = gr.Button(
-                "► Date Selection",
-                variant="secondary",
-                elem_classes=["date-header"],
-                visible=False
-            )
-
-            # Date selection container (collapsible) - start folded
-            with gr.Column(visible=True, elem_classes=["date-selection", "date-selection-hidden"]) as date_selection:
-                start_date = gr.Dropdown(
-                    choices=Ci_results.available_dates,
-                    value=Ci_results.available_dates[-1] if Ci_results.available_dates else None,  # Last date (oldest)
-                    label="Start Date",
-                    elem_classes=["date-dropdown"]
-                )
-                end_date = gr.Dropdown(
-                    choices=Ci_results.available_dates,
-                    value=Ci_results.available_dates[0] if Ci_results.available_dates else None,  # First date (newest)
-                    label="End Date",
-                    elem_classes=["date-dropdown"]
-                )
-                load_historical_button = gr.Button(
-                    "Reload Historical Data",
-                    variant="primary",
-                    size="sm",
-                    elem_classes=["load-historical-button"]
-                )
-
             # Summary button (for current view)
             summary_button = gr.Button(
                 "summary\n📊",
@@ -144,6 +122,14 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
                 elem_classes=["summary-button"]
             )
 
+            history_view_button = Toggle(
+                label="History view",
+                value=False,
+                interactive=True,
+                elem_classes=["history-view-button"]
+            )
+
+
             # Model selection header (clickable toggle)
             model_toggle_button = gr.Button(
                 f"► Select model ({len(Ci_results.available_models)})",
@@ -192,14 +178,6 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
 
                 # Detailed view components (hidden by default)
                 with gr.Column(visible=False, elem_classes=["detail-view"]) as detail_view:
-                    # Back button for current view detail
-                    back_to_summary_current_button = gr.Button(
-                        "← Back to Summary",
-                        variant="secondary",
-                        size="sm",
-                        elem_classes=["back-button"]
-                    )
-                    
                     # Create the plot output
                     plot_output = gr.Plot(
                         label="",
@@ -235,51 +213,77 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
                 # Time-series summary displays (multiple Gradio plots)
                 time_series_failure_rates = gr.LinePlot(
                     label="",
+                    x="date",
+                    y="failure_rate",
+                    color="platform",
+                    color_map={"AMD": "#FF6B6B", "NVIDIA": "#4ECDC4"},
+                    title="Overall Failure Rates Over Time",
+                    tooltip=["failure_rate", "date", "change"],
+                    height=300,
+                    x_label_angle=45,
+                    y_title="Failure Rate (%)",
                     elem_classes=["plot-container"]
                 )
                 
                 time_series_amd_tests = gr.LinePlot(
                     label="",
+                    x="date",
+                    y="count",
+                    color="test_type",
+                    color_map={"Passed": "#4CAF50", "Failed": "#E53E3E", "Skipped": "#FFA500"},
+                    title="AMD Test Results Over Time",
+                    tooltip=["count", "date", "change"],
+                    height=300,
+                    x_label_angle=45,
+                    y_title="Number of Tests",
                     elem_classes=["plot-container"]
                 )
                 
                 time_series_nvidia_tests = gr.LinePlot(
                     label="",
+                    x="date",
+                    y="count",
+                    color="test_type",
+                    color_map={"Passed": "#4CAF50", "Failed": "#E53E3E", "Skipped": "#FFA500"},
+                    title="NVIDIA Test Results Over Time",
+                    tooltip=["count", "date", "change"],
+                    height=300,
+                    x_label_angle=45,
+                    y_title="Number of Tests",
                     elem_classes=["plot-container"]
                 )
 
                 # Time-series model view (hidden by default)
                 with gr.Column(visible=False, elem_classes=["time-series-detail-view"]) as time_series_detail_view:
-                    # Back button for time-series model view
-                    back_to_summary_button = gr.Button(
-                        "← Back to Summary",
-                        variant="secondary",
-                        size="sm",
-                        elem_classes=["back-button"]
-                    )
-                    
                     # Time-series plots for specific model (with spacing)
                     time_series_amd_model_plot = gr.LinePlot(
                         label="",
+                        x="date",
+                        y="count",
+                        color="test_type",
+                        color_map={"Passed": "#4CAF50", "Failed": "#E53E3E", "Skipped": "#FFA500"},
+                        title="AMD Results Over Time",
+                        tooltip=["count", "date", "change"],
+                        height=300,
+                        x_label_angle=45,
+                        y_title="Number of Tests",
                         elem_classes=["plot-container"]
                     )
                     
                     time_series_nvidia_model_plot = gr.LinePlot(
                         label="",
+                        x="date",
+                        y="count",
+                        color="test_type",
+                        color_map={"Passed": "#4CAF50", "Failed": "#E53E3E", "Skipped": "#FFA500"},
+                        title="NVIDIA Results Over Time",
+                        tooltip=["count", "date", "change"],
+                        height=300,
+                        x_label_angle=45,
+                        y_title="Number of Tests",
                         elem_classes=["plot-container"]
                     )
 
-    # Set up click handlers for model buttons
-    for i, btn in enumerate(model_buttons):
-        model_name = model_choices[i]
-        btn.click(
-            fn=lambda selected_model=model_name: plot_model_stats(Ci_results.df, selected_model),
-            outputs=[plot_output, amd_failed_tests_output, nvidia_failed_tests_output]
-        ).then(
-            fn=lambda: [gr.update(visible=False), gr.update(visible=True)],
-            outputs=[summary_display, detail_view]
-        )
-
     # Model toggle functionality
     def toggle_model_list(current_visible):
         """Toggle the visibility of the model list."""
@@ -298,6 +302,10 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
 
     # Track model list visibility state
     model_list_visible = gr.State(False)
+    # Track last selected model for mode switches
+    selected_model_state = gr.State(None)
+    # Track whether current view is model detail (True) or summary (False)
+    in_model_view_state = gr.State(False)
 
     model_toggle_button.click(
         fn=toggle_model_list,
@@ -305,42 +313,58 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
         outputs=[model_toggle_button, model_list_container, model_list_visible]
     )
 
-    # Date toggle functionality
-    def toggle_date_selection(current_visible):
-        """Toggle the visibility of the date selection."""
-        new_visible = not current_visible
-        arrow = "▼" if new_visible else "►"
-        button_text = f"{arrow} Date Selection"
-        
-        # Use CSS classes instead of Gradio visibility
-        css_classes = ["date-selection"]
-        if new_visible:
-            css_classes.append("date-selection-visible")
-        else:
-            css_classes.append("date-selection-hidden")
-            
-        return gr.update(value=button_text), gr.update(elem_classes=css_classes), new_visible
-
-    # Track date selection visibility state
-    date_selection_visible = gr.State(False)
-
-    date_toggle_button.click(
-        fn=toggle_date_selection,
-        inputs=[date_selection_visible],
-        outputs=[date_toggle_button, date_selection, date_selection_visible]
-    )
 
-    # Summary button click handler
-    def show_summary_and_update_links():
-        """Show summary page and update CI links."""
-        return create_summary_page(Ci_results.df, Ci_results.available_models), get_description_text(), get_ci_links()
+    # Unified summary handler: respects History toggle
+    def handle_summary_click(history_mode: bool):
+        description = get_description_text()
+        links = get_ci_links()
+        fr_plot, amd_plot, nvidia_plot = get_historical_summary_plots()
+        if history_mode:
+            return (
+                description,
+                links,
+                gr.update(visible=False),  # current_view
+                gr.update(visible=True),   # historical_view
+                gr.update(visible=False),  # summary_display
+                gr.update(visible=False),  # detail_view
+                fr_plot,
+                amd_plot,
+                nvidia_plot,
+                gr.update(visible=False),  # time_series_detail_view
+                False,                     # in_model_view_state
+            )
+        else:
+            fig = create_summary_page(Ci_results.df, Ci_results.available_models)
+            return (
+                description,
+                links,
+                gr.update(visible=True),   # current_view
+                gr.update(visible=False),  # historical_view
+                gr.update(value=fig, visible=True), # summary_display
+                gr.update(visible=False),  # detail_view
+                gr.update(visible=False),  # time_series_failure_rates
+                gr.update(visible=False),  # time_series_amd_tests
+                gr.update(visible=False),  # time_series_nvidia_tests
+                gr.update(visible=False),  # time_series_detail_view
+                False,                     # in_model_view_state
+            )
 
     summary_button.click(
-        fn=show_summary_and_update_links,
-        outputs=[summary_display, description_display, ci_links_display]
-    ).then(
-        fn=lambda: [gr.update(visible=True), gr.update(visible=False)],
-        outputs=[summary_display, detail_view]
+        fn=handle_summary_click,
+        inputs=[history_view_button],
+        outputs=[
+            description_display,
+            ci_links_display,
+            current_view,
+            historical_view,
+            summary_display,
+            detail_view,
+            time_series_failure_rates,
+            time_series_amd_tests,
+            time_series_nvidia_tests,
+            time_series_detail_view,
+            in_model_view_state,
+        ],
     )
 
     # Function to get CI job links
@@ -413,174 +437,185 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
             return "🔗 **CI Jobs:** *Error loading links*\n\n❓ **[FAQ](README.md)**"
 
 
-    # View toggle functionality
-    def toggle_to_current_view():
-        """Switch to current view."""
-        return [
-            gr.update(visible=True),   # current_view
-            gr.update(visible=False),  # historical_view
-            gr.update(visible=False),  # date_toggle_button
-            gr.update(visible=True),   # summary_button
-            gr.update(variant="primary", elem_classes=["view-toggle-button", "view-toggle-active"]),  # current_view_button
-            gr.update(variant="secondary", elem_classes=["view-toggle-button"])  # historical_view_button
-        ]
-
-    def toggle_to_historical_view():
-        """Switch to historical view first, then auto-load data."""
-        # First, just switch the view
-        return [
-            gr.update(visible=False),  # current_view
-            gr.update(visible=True),   # historical_view
-            gr.update(visible=True),   # date_toggle_button
-            gr.update(visible=False),  # summary_button
-            gr.update(variant="secondary", elem_classes=["view-toggle-button"]),  # current_view_button
-            gr.update(variant="primary", elem_classes=["view-toggle-button", "view-toggle-active"]),  # historical_view_button
-            gr.update(),  # time_series_failure_rates
-            gr.update(),  # time_series_amd_tests
-            gr.update(),  # time_series_nvidia_tests
-        ]
-
-    def auto_load_historical_data():
-        """Auto-load data for preselected dates after view switch."""
-        # Get the preselected dates
-        start_date_val = Ci_results.available_dates[-1] if Ci_results.available_dates else None
-        end_date_val = Ci_results.available_dates[0] if Ci_results.available_dates else None
-        
-        # Check if we already have data for these dates
-        if (hasattr(Ci_results, 'cached_start_date') and hasattr(Ci_results, 'cached_end_date') and
-            Ci_results.cached_start_date == start_date_val and Ci_results.cached_end_date == end_date_val and
-            not Ci_results.historical_df.empty):
-            # Use cached data - no loading indicator needed
-            plots = create_time_series_summary_gradio(Ci_results.historical_df)
-            return plots['failure_rates'], plots['amd_tests'], plots['nvidia_tests']
-        
-        # Auto-load historical data if dates are available
-        if start_date_val and end_date_val:
-            try:
-                Ci_results.load_historical_data(start_date_val, end_date_val)
-                
-                if not Ci_results.historical_df.empty:
-                    # Cache the loaded data
-                    Ci_results.cached_start_date = start_date_val
-                    Ci_results.cached_end_date = end_date_val
-                    
-                    plots = create_time_series_summary_gradio(Ci_results.historical_df)
-                    return plots['failure_rates'], plots['amd_tests'], plots['nvidia_tests']
-                else:
-                    return gr.update(), gr.update(), gr.update()
-            except Exception as e:
-                logger.error(f"Error auto-loading historical data: {e}")
-                return gr.update(), gr.update(), gr.update()
+ 
+
+    def get_historical_summary_plots():
+        """Get historical summary plots from preloaded data."""
+        dfs = get_time_series_summary_dfs(Ci_results.historical_df)
+        return (
+            gr.update(value=dfs['failure_rates_df'], visible=True),
+            gr.update(value=dfs['amd_tests_df'], visible=True),
+            gr.update(value=dfs['nvidia_tests_df'], visible=True),
+        )
+    
+    def handle_history_toggle(history_mode, last_selected_model, in_model_view):
+        if history_mode:
+            # If currently in model view and valid model, show historical model detail
+            if in_model_view and last_selected_model:
+                amd_ts, nvidia_ts = show_time_series_model(last_selected_model)
+                return (
+                    gr.update(visible=False),   # current_view
+                    gr.update(visible=True),    # historical_view
+                    gr.update(visible=False),   # summary_display
+                    gr.update(visible=False),   # detail_view
+                    gr.update(visible=False),   # time_series_failure_rates
+                    gr.update(visible=False),   # time_series_amd_tests
+                    gr.update(visible=False),   # time_series_nvidia_tests
+                    amd_ts,                     # time_series_amd_model_plot
+                    nvidia_ts,                  # time_series_nvidia_model_plot
+                    gr.update(visible=True),    # time_series_detail_view
+                    gr.update(),                # plot_output
+                    gr.update(),                # amd_failed_tests_output
+                    gr.update(),                # nvidia_failed_tests_output
+                    True,                       # in_model_view_state (still in model view)
+                )
+            # Otherwise show historical summary
+            fr_plot, amd_plot, nvidia_plot = get_historical_summary_plots()
+            return (
+                gr.update(visible=False),   # current_view
+                gr.update(visible=True),    # historical_view
+                gr.update(visible=False),   # summary_display
+                gr.update(visible=False),   # detail_view
+                fr_plot,                    # time_series_failure_rates (value + keep visibility)
+                amd_plot,                   # time_series_amd_tests
+                nvidia_plot,                # time_series_nvidia_tests
+                gr.update(),                # time_series_amd_model_plot
+                gr.update(),                # time_series_nvidia_model_plot
+                gr.update(visible=False),   # time_series_detail_view
+                gr.update(),                # plot_output
+                gr.update(),                # amd_failed_tests_output
+                gr.update(),                # nvidia_failed_tests_output
+                False,                      # in_model_view_state
+            )
         else:
-            return gr.update(), gr.update(), gr.update()
+            # Switch to current mode: show model if selected; otherwise summary
+            if last_selected_model and Ci_results.df is not None and not Ci_results.df.empty and last_selected_model in Ci_results.df.index:
+                fig, amd_txt, nvidia_txt = plot_model_stats(Ci_results.df, last_selected_model)
+                return (
+                    gr.update(visible=True),    # current_view
+                    gr.update(visible=False),   # historical_view
+                    gr.update(visible=False),   # summary_display
+                    gr.update(visible=True),    # detail_view
+                    gr.update(visible=False),   # time_series_failure_rates
+                    gr.update(visible=False),   # time_series_amd_tests
+                    gr.update(visible=False),   # time_series_nvidia_tests
+                    gr.update(),                # time_series_amd_model_plot
+                    gr.update(),                # time_series_nvidia_model_plot
+                    gr.update(visible=False),   # time_series_detail_view
+                    fig,                        # plot_output
+                    amd_txt,                    # amd_failed_tests_output
+                    nvidia_txt,                 # nvidia_failed_tests_output
+                    True,                       # in_model_view_state
+                )
+            else:
+                fig = create_summary_page(Ci_results.df, Ci_results.available_models)
+                return (
+                    gr.update(visible=True),    # current_view
+                    gr.update(visible=False),   # historical_view
+                    gr.update(value=fig, visible=True),  # summary_display
+                    gr.update(visible=False),   # detail_view
+                    gr.update(visible=False),   # time_series_failure_rates
+                    gr.update(visible=False),   # time_series_amd_tests
+                    gr.update(visible=False),   # time_series_nvidia_tests
+                    gr.update(),                # time_series_amd_model_plot
+                    gr.update(),                # time_series_nvidia_model_plot
+                    gr.update(visible=False),   # time_series_detail_view
+                    gr.update(),                # plot_output
+                    gr.update(),                # amd_failed_tests_output
+                    gr.update(),                # nvidia_failed_tests_output
+                    False,                      # in_model_view_state
+                )
 
-    current_view_button.click(
-        fn=toggle_to_current_view,
-        outputs=[current_view, historical_view, date_toggle_button, summary_button, current_view_button, historical_view_button]
+    history_view_button.change(
+        fn=handle_history_toggle,
+        inputs=[history_view_button, selected_model_state, in_model_view_state],
+        outputs=[
+            current_view,
+            historical_view,
+            summary_display,
+            detail_view,
+            time_series_failure_rates,
+            time_series_amd_tests,
+            time_series_nvidia_tests,
+            time_series_amd_model_plot,
+            time_series_nvidia_model_plot,
+            time_series_detail_view,
+            plot_output,
+            amd_failed_tests_output,
+            nvidia_failed_tests_output,
+            in_model_view_state,
+        ],
     )
 
-    historical_view_button.click(
-        fn=toggle_to_historical_view,
-        outputs=[current_view, historical_view, date_toggle_button, summary_button, current_view_button, historical_view_button, time_series_failure_rates, time_series_amd_tests, time_series_nvidia_tests]
-    ).then(
-        fn=auto_load_historical_data,
-        outputs=[time_series_failure_rates, time_series_amd_tests, time_series_nvidia_tests]
-    )
-
-    # Historical data loading functionality
-    def load_historical_data(start_date, end_date):
-        """Load and display historical data."""
-        if not start_date or not end_date:
-            logger.error("No start or end date provided")
-            return gr.update(), gr.update(), gr.update()
-        
-        try:
-            Ci_results.load_historical_data(start_date, end_date)
-            
-            if Ci_results.historical_df.empty:
-                logger.error("No historical data found for the selected date range")
-                return gr.update(), gr.update(), gr.update()
-            
-            # Create time-series summary plots
-            plots = create_time_series_summary_gradio(Ci_results.historical_df)
-            
-            # Cache the loaded data
-            Ci_results.cached_start_date = start_date
-            Ci_results.cached_end_date = end_date
-            
-            return plots['failure_rates'], plots['amd_tests'], plots['nvidia_tests']
-            
-        except Exception as e:
-            logger.error(f"Error loading historical data: {e}")
-            return gr.update(), gr.update(), gr.update()
-
-    load_historical_button.click(
-        fn=load_historical_data,
-        inputs=[start_date, end_date],
-        outputs=[time_series_failure_rates, time_series_amd_tests, time_series_nvidia_tests]
-    )
 
     # Time-series model selection functionality
     def show_time_series_model(selected_model):
         """Show time-series view for a specific model."""
-        if Ci_results.historical_df.empty:
-            return gr.update(), gr.update()
-        
-        try:
-            plots = create_model_time_series_gradio(Ci_results.historical_df, selected_model)
-            return plots['amd_plot'], plots['nvidia_plot']
-        except Exception as e:
-            logger.error(f"Error creating time-series for model {selected_model}: {e}")
-            return gr.update(), gr.update()
-
-    # Back button functionality
-    def back_to_summary():
-        """Return from model time-series view to summary time-series view."""
-        return [
-            gr.update(visible=True),   # time_series_failure_rates
-            gr.update(visible=True),   # time_series_amd_tests
-            gr.update(visible=True),   # time_series_nvidia_tests
-            gr.update(visible=False)   # time_series_detail_view
-        ]
-
-    back_to_summary_button.click(
-        fn=back_to_summary,
-        outputs=[time_series_failure_rates, time_series_amd_tests, time_series_nvidia_tests, time_series_detail_view]
-    )
+        dfs = get_model_time_series_dfs(Ci_results.historical_df, selected_model)
+        return (
+            gr.update(value=dfs['amd_df'], visible=True, title=f"{selected_model.upper()} - AMD Results Over Time"),
+            gr.update(value=dfs['nvidia_df'], visible=True, title=f"{selected_model.upper()} - NVIDIA Results Over Time"),
+        )
 
-    # Back button functionality for current view
-    def back_to_summary_current():
-        """Return from model detail view to summary view in current view."""
-        return [
-            gr.update(visible=True),   # summary_display
-            gr.update(visible=False)   # detail_view
-        ]
-
-    back_to_summary_current_button.click(
-        fn=back_to_summary_current,
-        outputs=[summary_display, detail_view]
-    )
+    # Unified model click handler: respects History toggle
+    def handle_model_click(selected_model: str, history_mode: bool):
+        if history_mode:
+            amd_ts, nvidia_ts = show_time_series_model(selected_model)
+            return (
+                gr.update(),                 # plot_output
+                gr.update(),                 # amd_failed_tests_output
+                gr.update(),                 # nvidia_failed_tests_output
+                gr.update(visible=False),    # current_view
+                gr.update(visible=True),     # historical_view
+                gr.update(visible=False),    # summary_display
+                gr.update(visible=False),    # detail_view
+                gr.update(visible=False),    # time_series_failure_rates
+                gr.update(visible=False),    # time_series_amd_tests
+                gr.update(visible=False),    # time_series_nvidia_tests
+                amd_ts,                      # time_series_amd_model_plot
+                nvidia_ts,                   # time_series_nvidia_model_plot
+                gr.update(visible=True),     # time_series_detail_view
+            selected_model, True)            # selected_model_state, in_model_view_state
+        else:
+            fig, amd_txt, nvidia_txt = plot_model_stats(Ci_results.df, selected_model)
+            return (
+                fig,
+                amd_txt,
+                nvidia_txt,
+                gr.update(visible=True),     # current_view
+                gr.update(visible=False),    # historical_view
+                gr.update(visible=False),    # summary_display
+                gr.update(visible=True),     # detail_view
+                gr.update(),                 # time_series_failure_rates
+                gr.update(),                 # time_series_amd_tests
+                gr.update(),                 # time_series_nvidia_tests
+                gr.update(),                 # time_series_amd_model_plot
+                gr.update(),                 # time_series_nvidia_model_plot
+                gr.update(visible=False),    # time_series_detail_view
+            selected_model, True)            # selected_model_state, in_model_view_state
 
-    # Update model button handlers to work with both views
     for i, btn in enumerate(model_buttons):
         model_name = model_choices[i]
-        
-        # Current view handler (existing functionality)
-        btn.click(
-            fn=lambda selected_model=model_name: plot_model_stats(Ci_results.df, selected_model),
-            outputs=[plot_output, amd_failed_tests_output, nvidia_failed_tests_output]
-        ).then(
-            fn=lambda: [gr.update(visible=False), gr.update(visible=True)],
-            outputs=[summary_display, detail_view]
-        )
-        
-        # Historical view handler (new functionality)
         btn.click(
-            fn=lambda selected_model=model_name: show_time_series_model(selected_model),
-            outputs=[time_series_amd_model_plot, time_series_nvidia_model_plot]
-        ).then(
-            fn=lambda: [gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)],
-            outputs=[time_series_failure_rates, time_series_amd_tests, time_series_nvidia_tests, time_series_detail_view]
+            fn=lambda history_mode, m=model_name: handle_model_click(m, history_mode),
+            inputs=[history_view_button],
+            outputs=[
+                plot_output,
+                amd_failed_tests_output,
+                nvidia_failed_tests_output,
+                current_view,
+                historical_view,
+                summary_display,
+                detail_view,
+                time_series_failure_rates,
+                time_series_amd_tests,
+                time_series_nvidia_tests,
+                time_series_amd_model_plot,
+                time_series_nvidia_model_plot,
+                time_series_detail_view,
+                selected_model_state,
+                in_model_view_state,
+            ],
         )
 
     # Auto-update CI links when the interface loads

data.py

@@ -57,6 +57,8 @@ def log_dataframe_link(link: str) -> str:
     Adds the link to the dataset in the logs, modifies it to get a clockable link and then returns the date of the 
     report.
     """
+    if link.startswith("sample_"):
+        return "9999-99-99"
     logger.info(f"Reading df located at {link}")
     # Make sure the links starts with an http adress
     if link.startswith("hf://"):
@@ -231,8 +233,10 @@ def get_data_for_date(target_date: str) -> tuple[pd.DataFrame, str]:
         return pd.DataFrame(), target_date
 
 
-def get_historical_data(start_date: str, end_date: str) -> pd.DataFrame:
+def get_historical_data(start_date: str, end_date: str, sample_data = False) -> pd.DataFrame:
     """Get historical data for a date range."""
+    if sample_data:
+        return get_fake_historical_data(start_date, end_date)
     try:
         start_dt = datetime.strptime(start_date, "%Y-%m-%d")
         end_dt = datetime.strptime(end_date, "%Y-%m-%d")
@@ -256,11 +260,6 @@ def get_historical_data(start_date: str, end_date: str) -> pd.DataFrame:
             
             current_dt += timedelta(days=1)
         
-        if not historical_data:
-            logger.warning("No historical data found for the specified range, falling back to fake data")
-            # Fall back to fake data when no real data is available
-            return get_fake_historical_data(start_date, end_date)
-        
         # Combine all dataframes
         combined_df = pd.concat(historical_data, ignore_index=False)
         return combined_df
@@ -418,6 +417,7 @@ class CIResults:
         self.available_dates = []
         self.historical_df = pd.DataFrame()
         self.all_historical_data = pd.DataFrame()  # Store all historical data at startup
+        self.sample_data = False
 
     def load_data(self) -> None:
         """Load data from the data source."""
@@ -442,16 +442,10 @@ class CIResults:
                 "Falling back on sample data."
             ]
             logger.error("\n".join(error_msg))
+            self.sample_data = True
             new_df, latest_update_msg = get_sample_data()
             self.latest_update_msg = latest_update_msg
-            # Generate fake dates when no real dates are available
-            fake_dates = []
-            today = datetime.now()
-            for i in range(7):
-                date = today - timedelta(days=i)
-                fake_dates.append(date.strftime("%Y-%m-%d"))
-            self.available_dates = fake_dates
-            logger.info(f"Generated {len(self.available_dates)} fake dates: {self.available_dates[:3]}...")
+            self.available_dates = None
         
         # Update attributes
         self.df = new_df
@@ -481,15 +475,20 @@ class CIResults:
         """Load all available historical data at startup."""
         try:
             if not self.available_dates:
-                logger.warning("No available dates found, skipping historical data loading")
-                self.all_historical_data = pd.DataFrame()
-                return
+                # Generate fake dates when no real dates are available
+                fake_dates = []
+                today = datetime.now()
+                for i in range(7):
+                    date = today - timedelta(days=i)
+                    fake_dates.append(date.strftime("%Y-%m-%d"))
+                self.available_dates = fake_dates
+                logger.info(f"No available dates found, generated {len(self.available_dates)} sample dates.")
                 
             logger.info(f"Loading all historical data for {len(self.available_dates)} dates...")
             start_date = self.available_dates[-1]  # Oldest date
             end_date = self.available_dates[0]     # Newest date
             
-            self.all_historical_data = get_historical_data(start_date, end_date)
+            self.all_historical_data = get_historical_data(start_date, end_date, self.sample_data)
             logger.info(f"All historical data loaded: {len(self.all_historical_data)} records")
         except Exception as e:
             logger.error(f"Error loading all historical data: {e}")

requirements.txt

@@ -1 +1,2 @@
 matplotlib>=3.8
+gradio_toggle

styles.css

@@ -175,6 +175,25 @@ div[data-testid="column"]:has(.sidebar) {
     transition: max-height 0.3s ease !important;
 }
 
+.history-view-button {
+    background: linear-gradient(135deg, #2a2a2a, #1e1e1e) !important;
+    color: white !important;
+    margin: 0px 0px !important;
+    padding: 8px 12px !important;
+    font-weight: 600 !important;
+    font-size: 14px !important;
+    text-transform: uppercase !important;
+    letter-spacing: 0.3px !important;
+    font-family: monospace !important;
+    width: 100% !important;
+    max-width: 100% !important;
+    white-space: nowrap !important;
+    text-overflow: ellipsis !important;
+    display: block !important;
+    cursor: pointer !important;
+    transition: all 0.3s ease !important;
+}
+
 
 /* Model button styling */
 .model-button {
@@ -373,53 +392,28 @@ div[data-testid="column"]:has(.sidebar) {
 
 /* Plot container with smooth transitions and controlled scrolling */
 .plot-container {
-    background-color: #000000 !important;
     border: none !important;
     transition: opacity 0.6s ease-in-out !important;
     flex: 1 1 auto !important;
     min-height: 0 !important;
     overflow-y: auto !important;
     scrollbar-width: thin !important;
-    scrollbar-color: #333333 #000000 !important;
     padding: 0 !important;
 }
 
 /* Custom scrollbar for plot container */
 .plot-container::-webkit-scrollbar {
     width: 8px !important;
-    background: #000000 !important;
-}
-
-.plot-container::-webkit-scrollbar-track {
-    background: #000000 !important;
-}
-
-.plot-container::-webkit-scrollbar-thumb {
-    background-color: #333333 !important;
-    border-radius: 4px !important;
-}
-
-.plot-container::-webkit-scrollbar-thumb:hover {
-    background-color: #555555 !important;
 }
 
-/* Gradio plot component styling */
-.gr-plot {
-    background-color: #000000 !important;
-    transition: opacity 0.6s ease-in-out !important;
-}
 
-.gr-plot .gradio-plot {
-    background-color: #000000 !important;
-    transition: opacity 0.6s ease-in-out !important;
-}
 
 .gr-plot img {
     transition: opacity 0.6s ease-in-out !important;
 }
 
 /* Target the plot wrapper */
-div[data-testid="plot"] {
+div[data-testid="matplotlib"] {
     background-color: #000000 !important;
 }
 
@@ -430,11 +424,6 @@ div[data-testid="plot"] {
     background-color: #000000 !important;
 }
 
-/* Ensure plot area background */
-.gr-plot > div,
-.plot-container > div {
-    background-color: #000000 !important;
-}
 
 /* Prevent white flash during plot updates */
 .plot-container::before {
@@ -448,24 +437,26 @@ div[data-testid="plot"] {
     z-index: -1;
 }
 
-/* Force all plot elements to have black background */
-.plot-container *,
-.gr-plot *,
-div[data-testid="plot"] * {
-    background-color: #000000 !important;
+.vega-embed {
+    position: absolute !important;
 }
 
-/* Override any white backgrounds in matplotlib */
-.plot-container canvas,
-.gr-plot canvas {
-    background-color: #000000 !important;
-}
 
 /* Text elements */
 h1, h2, h3, p, .markdown {
     color: white !important;
 }
 
+.toggle {
+    margin: 0 auto !important;
+}
+
+.toggle-label {
+    color: white !important;
+    font-family: monospace !important;
+    font-size: 14px !important;
+}
+
 /* Sidebar header enhancement */
 .sidebar h1 {
     background: linear-gradient(45deg, #74b9ff, #a29bfe) !important;

time_series_gradio.py

@@ -4,6 +4,126 @@ 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)."""
+
+    # 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]
+        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
+
+        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
+        nvidia_total = nvidia_passed + nvidia_failed + nvidia_skipped
+        nvidia_failure_rate = (nvidia_failed / nvidia_total * 100) if nvidia_total > 0 else 0
+
+        daily_stats.append({
+            'date': date,
+            'amd_failure_rate': amd_failure_rate,
+            'nvidia_failure_rate': nvidia_failure_rate,
+            'amd_passed': amd_passed,
+            'amd_failed': amd_failed,
+            'amd_skipped': amd_skipped,
+            'nvidia_passed': nvidia_passed,
+            'nvidia_failed': nvidia_failed,
+            '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
+        nvidia_change = stat['nvidia_failure_rate'] - daily_stats[i-1]['nvidia_failure_rate'] if i > 0 else 0
+        failure_rate_data.extend([
+            {'date': stat['date'], 'failure_rate': stat['amd_failure_rate'], 'platform': 'AMD', 'change': amd_change},
+            {'date': stat['date'], 'failure_rate': stat['nvidia_failure_rate'], 'platform': 'NVIDIA', 'change': nvidia_change}
+        ])
+    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
+        failed_change = stat['amd_failed'] - daily_stats[i-1]['amd_failed'] if i > 0 else 0
+        skipped_change = stat['amd_skipped'] - daily_stats[i-1]['amd_skipped'] if i > 0 else 0
+        amd_data.extend([
+            {'date': stat['date'], 'count': stat['amd_passed'], 'test_type': 'Passed', 'change': passed_change},
+            {'date': stat['date'], 'count': stat['amd_failed'], 'test_type': 'Failed', 'change': failed_change},
+            {'date': stat['date'], 'count': stat['amd_skipped'], 'test_type': 'Skipped', 'change': skipped_change}
+        ])
+    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
+        failed_change = stat['nvidia_failed'] - daily_stats[i-1]['nvidia_failed'] if i > 0 else 0
+        skipped_change = stat['nvidia_skipped'] - daily_stats[i-1]['nvidia_skipped'] if i > 0 else 0
+        nvidia_data.extend([
+            {'date': stat['date'], 'count': stat['nvidia_passed'], 'test_type': 'Passed', 'change': passed_change},
+            {'date': stat['date'], 'count': stat['nvidia_failed'], 'test_type': 'Failed', 'change': failed_change},
+            {'date': stat['date'], 'count': stat['nvidia_skipped'], 'test_type': 'Skipped', 'change': skipped_change}
+        ])
+    nvidia_df = pd.DataFrame(nvidia_data)
+
+    return {
+        'failure_rates_df': failure_rate_df,
+        'amd_tests_df': amd_df,
+        'nvidia_tests_df': nvidia_df,
+    }
+
+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:
+        empty_df = pd.DataFrame({'date': [], 'count': [], 'test_type': [], 'change': []})
+        return {'amd_df': empty_df.copy(), 'nvidia_df': empty_df.copy()}
+
+    dates = sorted(model_data['date'].unique())
+    amd_data = []
+    nvidia_data = []
+    for i, date in enumerate(dates):
+        date_data = model_data[model_data['date'] == date]
+        row = date_data.iloc[0]
+
+        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)
+        prev_row = model_data[model_data['date'] == dates[i-1]].iloc[0] if i > 0 and not model_data[model_data['date'] == dates[i-1]].empty else None
+        amd_passed_change = amd_passed - (prev_row.get('success_amd', 0) if prev_row is not None else 0)
+        amd_failed_change = amd_failed - (prev_row.get('failed_multi_no_amd', 0) + prev_row.get('failed_single_no_amd', 0) if prev_row is not None else 0)
+        amd_skipped_change = amd_skipped - (prev_row.get('skipped_amd', 0) if prev_row is not None else 0)
+        amd_data.extend([
+            {'date': date, 'count': amd_passed, 'test_type': 'Passed', 'change': amd_passed_change},
+            {'date': date, 'count': amd_failed, 'test_type': 'Failed', 'change': amd_failed_change},
+            {'date': date, 'count': amd_skipped, 'test_type': 'Skipped', 'change': amd_skipped_change}
+        ])
+
+        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)
+        if prev_row is not None:
+            prev_nvidia_passed = prev_row.get('success_nvidia', 0)
+            prev_nvidia_failed = prev_row.get('failed_multi_no_nvidia', 0) + prev_row.get('failed_single_no_nvidia', 0)
+            prev_nvidia_skipped = prev_row.get('skipped_nvidia', 0)
+        else:
+            prev_nvidia_passed = prev_nvidia_failed = prev_nvidia_skipped = 0
+        nvidia_data.extend([
+            {'date': date, 'count': nvidia_passed, 'test_type': 'Passed', 'change': nvidia_passed - prev_nvidia_passed},
+            {'date': date, 'count': nvidia_failed, 'test_type': 'Failed', 'change': nvidia_failed - prev_nvidia_failed},
+            {'date': date, 'count': nvidia_skipped, 'test_type': 'Skipped', 'change': nvidia_skipped - prev_nvidia_skipped}
+        ])
+
+    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: