Update services/analytics_handlers.py

services/analytics_handlers.py

@@ -94,57 +94,75 @@ class AnalyticsHandlers:
         return outputs
 
     async def refresh_analytics_graphs_ui(self, current_token_state_val, date_filter_val, 
-                                          custom_start_val, custom_end_val, 
-                                          # chat_histories_st is a state, its value will be accessed via self.chat_histories_st.value
-                                          ):
+                                          custom_start_val, custom_end_val):
         logging.info(f"Refreshing analytics graph UI. Filter: {date_filter_val}. Token set: {'yes' if current_token_state_val.get('token') else 'no'}")
         start_time = time.time()
     
         # Call the function that generates plot figures and summaries
-        # Ensure update_analytics_plots_figures is adapted to return:
-        # status_msg (str), figures_dict (dict: {plot_id: fig}), summaries_dict (dict: {plot_id: summary_text})
         plot_gen_results = update_analytics_plots_figures(
             current_token_state_val, 
             date_filter_val, 
             custom_start_val, 
             custom_end_val, 
-            self.plot_configs # Pass plot_configs to it
+            self.plot_configs
         )
-        # Expected: status_msg, list_of_figures, dict_of_plot_summaries
-        # Original: status_msg, gen_figs (list), new_summaries (dict)
-    
-        status_msg = plot_gen_results[0]
-        gen_figs_result = plot_gen_results[1] # This might be a single figure or a list
-        new_summaries_dict = plot_gen_results[2] # This should be a dict {plot_id: summary}
-    
-        # Handle the case where gen_figs_result might be a single figure or a list
+        
+        # Debug: Log what we actually got back
+        logging.debug(f"plot_gen_results type: {type(plot_gen_results)}, length: {len(plot_gen_results) if hasattr(plot_gen_results, '__len__') else 'N/A'}")
+        
+        # Handle different possible return formats
+        if len(plot_gen_results) == 3:
+            # Expected format: (status_msg, figures_list, summaries_dict)
+            status_msg, gen_figs_result, new_summaries_dict = plot_gen_results
+        else:
+            # Fallback - try to parse based on old format
+            # Old format seemed to be: status_msg, *figures, summaries_dict
+            status_msg = plot_gen_results[0]
+            new_summaries_dict = plot_gen_results[-1]
+            gen_figs_result = plot_gen_results[1:-1]  # Everything between first and last
+        
+        # Ensure we have a list of figures
         if isinstance(gen_figs_result, list):
             gen_figs_list = gen_figs_result
         else:
-            # If it's a single figure, wrap it in a list
-            gen_figs_list = [gen_figs_result]
-            logging.warning(f"Expected list of figures but got single figure of type {type(gen_figs_result)}")
-    
-        all_updates = [gr.update(value=status_msg)] # For analytics_status_md
+            # If it's a single figure, we need to check if it should be replicated
+            # or if the function should return multiple figures
+            logging.warning(f"Got single figure of type {type(gen_figs_result)}, expected list of {len(self.plot_configs)} figures")
+            
+            # Option 1: If the single figure should be used for all plots (unlikely)
+            # gen_figs_list = [gen_figs_result] * len(self.plot_configs)
+            
+            # Option 2: If this indicates an error in the function (more likely)
+            gen_figs_list = [gen_figs_result]  # Keep as single item list for now
+        
+        all_updates = [gr.update(value=status_msg)]  # For analytics_status_md
     
         # Update plot components with new figures
         if len(gen_figs_list) == len(self.plot_configs):
+            # Perfect match - use figures as-is
             for fig in gen_figs_list:
-                all_updates.append(fig) # fig itself is the update for gr.Plot
+                all_updates.append(fig)
+        elif len(gen_figs_list) == 1 and len(self.plot_configs) > 1:
+            # Special case: one figure for multiple plots - check if this is intentional
+            logging.warning(f"Using single figure for {len(self.plot_configs)} plot components")
+            # Use the single figure for the first plot, placeholders for the rest
+            all_updates.append(gen_figs_list[0])
+            for i in range(1, len(self.plot_configs)):
+                all_updates.append(create_placeholder_plot("Info", f"Plot {i+1} - Data processing"))
         else:
+            # Length mismatch - pad with placeholders
             logging.error(f"Figure list length mismatch: got {len(gen_figs_list)}, expected {len(self.plot_configs)}")
-            # If we have fewer figures than expected, pad with placeholders
             for i in range(len(self.plot_configs)):
                 if i < len(gen_figs_list):
                     all_updates.append(gen_figs_list[i])
                 else:
                     all_updates.append(create_placeholder_plot("Error", "Figura mancante"))
     
-        # Reset action panel UI elements
+        # Reset action panel UI elements (same as before)
         all_updates.extend([
             gr.update(visible=False),  # global_actions_column_ui
-            gr.update(value=[], visible=False),  # insights_chatbot_ui (value and visibility)
-            gr.update(value="", visible=False),  # insights_chat_input_ui (value and visibility)
+            gr.update(value=[], visible=False),  # insights_chatbot_ui
+            gr.update(value="", visible=False),  # insights_chat_input_ui
             gr.update(visible=False),  # insights_suggestions_row_ui
             gr.update(value="S1"),  # insights_suggestion_1_btn
             gr.update(value="S2"),  # insights_suggestion_2_btn
@@ -157,8 +175,8 @@ class AnalyticsHandlers:
         all_updates.extend([
             None,  # active_panel_action_state
             None,  # current_chat_plot_id_st
-            {},    # chat_histories_st (reset to empty dict)
-            new_summaries_dict # plot_data_for_chatbot_st (update with new summaries)
+            {},    # chat_histories_st
+            new_summaries_dict  # plot_data_for_chatbot_st
         ])
         
         # Reset buttons and panel visibility for each plot
@@ -167,10 +185,10 @@ class AnalyticsHandlers:
                 gr.update(value=BOMB_ICON),      # bomb_button
                 gr.update(value=FORMULA_ICON),   # formula_button
                 gr.update(value=EXPLORE_ICON),   # explore_button
-                gr.update(visible=True)          # panel_component (plot visibility)
+                gr.update(visible=True)          # panel_component
             ])
             
-        all_updates.append(None) # explored_plot_id_state (reset)
+        all_updates.append(None)  # explored_plot_id_state
     
         # Reset section title visibility
         for _ in self.unique_ordered_sections:
@@ -181,10 +199,12 @@ class AnalyticsHandlers:
         
         expected_len = 1 + len(self.plot_configs) + 9 + 4 + (4 * len(self.plot_configs)) + 1 + self.num_unique_sections
         logging.info(f"Prepared {len(all_updates)} updates for graph refresh. Expected {expected_len}.")
+        
         if len(all_updates) != expected_len:
             logging.error(f"Output length mismatch in refresh_analytics_graphs_ui. Got {len(all_updates)}, expected {expected_len}")
-            # Pad with gr.update() if lengths don't match, to avoid Gradio errors, though this indicates a logic flaw.
-            all_updates.extend([gr.update()] * (expected_len - len(all_updates)))
+            # Pad with gr.update() to prevent Gradio errors
+            while len(all_updates) < expected_len:
+                all_updates.append(gr.update())
     
         return tuple(all_updates)