Upload folder using huggingface_hub

app.py

@@ -231,12 +231,6 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
             # Historical view components (hidden by default)
             with gr.Column(visible=False, elem_classes=["historical-view"]) as historical_view:
                 
-                # Loading indicator
-                loading_indicator = gr.Markdown(
-                    "⏳ Loading historical data...",
-                    visible=False,
-                    elem_classes=["loading-indicator"]
-                )
                 
                 # Time-series summary displays (multiple Gradio plots)
                 time_series_failure_rates = gr.LinePlot(
@@ -456,20 +450,13 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
         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 - show loading briefly then update plots
-            yield (gr.update(visible=True), gr.update(), gr.update(), gr.update())
-            yield (gr.update(visible=False), gr.update(), gr.update(), gr.update())
-            
+            # Use cached data - no loading indicator needed
             plots = create_time_series_summary_gradio(Ci_results.historical_df)
-            yield (gr.update(visible=False), plots['failure_rates'], plots['amd_tests'], plots['nvidia_tests'])
-            return
+            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:
-                # Show loading indicator
-                yield (gr.update(visible=True), gr.update(), gr.update(), gr.update())
-                
                 Ci_results.load_historical_data(start_date_val, end_date_val)
                 
                 if not Ci_results.historical_df.empty:
@@ -477,18 +464,15 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
                     Ci_results.cached_start_date = start_date_val
                     Ci_results.cached_end_date = end_date_val
                     
-                    # Hide loading indicator and show plots
-                    yield (gr.update(visible=False), gr.update(), gr.update(), gr.update())
-                    
                     plots = create_time_series_summary_gradio(Ci_results.historical_df)
-                    yield (gr.update(visible=False), plots['failure_rates'], plots['amd_tests'], plots['nvidia_tests'])
+                    return plots['failure_rates'], plots['amd_tests'], plots['nvidia_tests']
                 else:
-                    yield (gr.update(visible=False), gr.update(), gr.update(), gr.update())
+                    return gr.update(), gr.update(), gr.update()
             except Exception as e:
                 logger.error(f"Error auto-loading historical data: {e}")
-                yield (gr.update(visible=False), gr.update(), gr.update(), gr.update())
+                return gr.update(), gr.update(), gr.update()
         else:
-            yield (gr.update(visible=False), gr.update(), gr.update(), gr.update())
+            return gr.update(), gr.update(), gr.update()
 
     current_view_button.click(
         fn=toggle_to_current_view,
@@ -500,29 +484,22 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
         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=[loading_indicator, time_series_failure_rates, time_series_amd_tests, time_series_nvidia_tests]
+        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 indication."""
+        """Load and display historical data."""
         if not start_date or not end_date:
             logger.error("No start or end date provided")
-            return (gr.update(visible=False), gr.update(), gr.update(), gr.update())
+            return gr.update(), gr.update(), gr.update()
         
         try:
-            # Show loading indicator
-            yield (gr.update(visible=True), gr.update(), gr.update(), gr.update())
-            
             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")
-                yield (gr.update(visible=False), gr.update(), gr.update(), gr.update())
-                return
-            
-            # Hide loading indicator and show plots
-            yield (gr.update(visible=False), gr.update(), gr.update(), gr.update())
+                return gr.update(), gr.update(), gr.update()
             
             # Create time-series summary plots
             plots = create_time_series_summary_gradio(Ci_results.historical_df)
@@ -531,16 +508,16 @@ with gr.Blocks(title="Model Test Results Dashboard", css=load_css()) as demo:
             Ci_results.cached_start_date = start_date
             Ci_results.cached_end_date = end_date
             
-            yield (gr.update(visible=False), plots['failure_rates'], plots['amd_tests'], plots['nvidia_tests'])
+            return plots['failure_rates'], plots['amd_tests'], plots['nvidia_tests']
             
         except Exception as e:
             logger.error(f"Error loading historical data: {e}")
-            yield (gr.update(visible=False), gr.update(), gr.update(), gr.update())
+            return gr.update(), gr.update(), gr.update()
 
     load_historical_button.click(
         fn=load_historical_data,
         inputs=[start_date, end_date],
-        outputs=[loading_indicator, time_series_failure_rates, time_series_amd_tests, time_series_nvidia_tests]
+        outputs=[time_series_failure_rates, time_series_amd_tests, time_series_nvidia_tests]
     )
 
     # Time-series model selection functionality

data.py

@@ -417,6 +417,7 @@ class CIResults:
         self.latest_update_msg = ""
         self.available_dates = []
         self.historical_df = pd.DataFrame()
+        self.all_historical_data = pd.DataFrame()  # Store all historical data at startup
 
     def load_data(self) -> None:
         """Load data from the data source."""
@@ -455,6 +456,10 @@ class CIResults:
         # Update attributes
         self.df = new_df
         self.available_models = new_df.index.tolist()
+        
+        # Load all historical data at startup
+        self.load_all_historical_data()
+        
         # Log and return distant load status
         logger.info(f"Data loaded successfully: {len(self.available_models)} models")
         logger.info(f"Models: {self.available_models[:5]}{'...' if len(self.available_models) > 5 else ''}")
@@ -472,14 +477,55 @@ class CIResults:
                 msg[model][col] = value
         logger.info(json.dumps(msg, indent=4))
 
+    def load_all_historical_data(self) -> None:
+        """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
+                
+            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)
+            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}")
+            self.all_historical_data = pd.DataFrame()
+
     def load_historical_data(self, start_date: str, end_date: str) -> None:
-        """Load historical data for a date range."""
+        """Load historical data for a date range from pre-loaded data."""
         try:
-            logger.info(f"Loading historical data from {start_date} to {end_date}")
-            self.historical_df = get_historical_data(start_date, end_date)
-            logger.info(f"Historical data loaded: {len(self.historical_df)} records")
+            logger.info(f"Filtering historical data from {start_date} to {end_date}")
+            
+            if self.all_historical_data.empty:
+                logger.warning("No pre-loaded historical data available")
+                self.historical_df = pd.DataFrame()
+                return
+            
+            # Filter the pre-loaded data by date range
+            start_dt = datetime.strptime(start_date, "%Y-%m-%d")
+            end_dt = datetime.strptime(end_date, "%Y-%m-%d")
+            
+            # Filter data within the date range
+            filtered_data = []
+            for date_str in self.all_historical_data['date'].unique():
+                date_dt = datetime.strptime(date_str, "%Y-%m-%d")
+                if start_dt <= date_dt <= end_dt:
+                    date_data = self.all_historical_data[self.all_historical_data['date'] == date_str]
+                    filtered_data.append(date_data)
+            
+            if filtered_data:
+                self.historical_df = pd.concat(filtered_data, ignore_index=False)
+                logger.info(f"Historical data filtered: {len(self.historical_df)} records for {start_date} to {end_date}")
+            else:
+                self.historical_df = pd.DataFrame()
+                logger.warning(f"No historical data found for date range {start_date} to {end_date}")
+                
         except Exception as e:
-            logger.error(f"Error loading historical data: {e}")
+            logger.error(f"Error filtering historical data: {e}")
             self.historical_df = pd.DataFrame()
 
     def schedule_data_reload(self):

styles.css

@@ -3,17 +3,7 @@
     --main-content-bottom-margin: 10px; /* Configurable bottom margin for main content */
 }
 
-/* Loading indicator styling */
-.loading-indicator {
-    text-align: center !important;
-    padding: 20px !important;
-    font-size: 16px !important;
-    color: #ffa500 !important;
-    background: rgba(255, 165, 0, 0.1) !important;
-    border-radius: 8px !important;
-    margin: 10px 0 !important;
-    border: 1px solid rgba(255, 165, 0, 0.3) !important;
-}
+
 
 .gradio-container {
     background-color: #000000 !important;