Update services/analytics_tab_module.py

services/analytics_tab_module.py

@@ -34,11 +34,7 @@ PLOT_CONFIGS = [
     {"label": "Volume Menzioni nel Tempo (Dettaglio)", "id": "mention_analysis_volume", "section": "Analisi Menzioni (Dettaglio)"},
     {"label": "Ripartizione Menzioni per Sentiment (Dettaglio)", "id": "mention_analysis_sentiment", "section": "Analisi Menzioni (Dettaglio)"}
 ]
-# IMPORTANT: Review if 'mention_analysis_volume' and 'mention_analysis_sentiment' plots
-# can still be generated without the dedicated mentions data processing.
-# If not, they should also be removed from plot_configs.
-# For now, I am assuming they might draw from a general data pool in token_state.
-assert len(PLOT_CONFIGS) == 19, "Mancata corrispondenza in PLOT_CONFIGS e grafici attesi. (If mentions plots were removed, adjust this number)"
+assert len(PLOT_CONFIGS) == 19, "Mancata corrispondenza in PLOT_CONFIGS e grafici attesi."
 
 UNIQUE_ORDERED_SECTIONS = list(OrderedDict.fromkeys(pc["section"] for pc in PLOT_CONFIGS))
 NUM_UNIQUE_SECTIONS = len(UNIQUE_ORDERED_SECTIONS)
@@ -118,9 +114,9 @@ class AnalyticsTab:
             error_list = [gr.update()] * error_list_len
             # Fill specific indices if needed, matching the expected output structure
             error_list[11] = current_active_action_from_state # active_panel_action_state
-            error_list[12] = current_chat_plot_id          # current_chat_plot_id_st
-            error_list[13] = current_chat_histories        # chat_histories_st
-            error_list[14] = current_explored_plot_id      # explored_plot_id_state
+            error_list[12] = current_chat_plot_id         # current_chat_plot_id_st
+            error_list[13] = current_chat_histories       # chat_histories_st
+            error_list[14] = current_explored_plot_id     # explored_plot_id_state
             return error_list
 
         clicked_plot_label = clicked_plot_config["label"]
@@ -232,12 +228,12 @@ class AnalyticsTab:
 
         # Order of updates must match self.action_panel_outputs_list
         final_updates = [
-            action_col_visible_update,          # global_actions_column_ui
+            action_col_visible_update,        # global_actions_column_ui
             insights_chatbot_visible_update,    # insights_chatbot_ui (visibility)
             chatbot_content_update,             # insights_chatbot_ui (content)
             insights_chat_input_visible_update, # insights_chat_input_ui
             insights_suggestions_row_visible_update, # insights_suggestions_row_ui
-            s1_upd, s2_upd, s3_upd,             # suggestion buttons
+            s1_upd, s2_upd, s3_upd,              # suggestion buttons
             formula_display_visible_update,     # formula_display_markdown_ui (visibility)
             formula_content_update,             # formula_display_markdown_ui (content)
             formula_close_hint_visible_update,  # formula_close_hint_md
@@ -258,8 +254,6 @@ class AnalyticsTab:
     async def _handle_chat_message_submission(self, user_message: str, current_plot_id: str, chat_histories: dict, current_plot_data_for_chatbot: dict):
         if not current_plot_id or not user_message.strip():
             current_history_for_plot = chat_histories.get(current_plot_id, [])
-            # Ensure history is in the format Gradio Chatbot expects (list of lists/tuples or specific dicts)
-            # Assuming it's already [{"role": "user/assistant", "content": "..."}]
             yield current_history_for_plot, gr.update(value=""), chat_histories
             return
 
@@ -267,20 +261,14 @@ class AnalyticsTab:
         plot_label = clicked_plot_config["label"] if clicked_plot_config else "Selected Plot"
         summary_data = current_plot_data_for_chatbot.get(current_plot_id, f"No summary available for '{plot_label}'.")
 
-        # Ensure history is a list of dicts {"role": ..., "content": ...} for the API
-        history_for_api = chat_histories.get(current_plot_id, []).copy() # Get a mutable copy
-        if not isinstance(history_for_api, list): history_for_api = [] # Should not happen if initialized correctly
+        history_for_api = chat_histories.get(current_plot_id, []).copy()
+        if not isinstance(history_for_api, list): history_for_api = []
 
         history_for_api.append({"role": "user", "content": user_message})
         
-        # Update Gradio chatbot UI immediately with user message
-        # Gradio Chatbot expects list of (user_msg, assistant_msg) tuples or specific dicts.
-        # If current_chat_histories stores [{"role": "user", "content": "..."}], convert for display if needed,
-        # or ensure generate_llm_response and initial prompt also use this dict format.
-        # For simplicity, let's assume chat_histories_st stores a list of such dicts.
-        current_display_history = history_for_api.copy() # This is what will be displayed
+        current_display_history = history_for_api.copy()
 
-        yield current_display_history, gr.update(value=""), chat_histories # Update UI, clear input, pass original histories
+        yield current_display_history, gr.update(value=""), chat_histories
 
         assistant_response = await self.generate_llm_response(user_message, current_plot_id, plot_label, history_for_api, summary_data)
         history_for_api.append({"role": "assistant", "content": assistant_response})
@@ -288,44 +276,39 @@ class AnalyticsTab:
         updated_chat_histories = {**chat_histories, current_plot_id: history_for_api}
         current_display_history.append({"role": "assistant", "content": assistant_response})
 
-
         yield current_display_history, "", updated_chat_histories
 
-
     async def _handle_suggested_question_click(self, suggestion_text: str, current_plot_id: str, chat_histories: dict, current_plot_data_for_chatbot: dict):
         if not current_plot_id or not suggestion_text.strip() or suggestion_text == "N/A":
             current_history_for_plot = chat_histories.get(current_plot_id, [])
             yield current_history_for_plot, gr.update(value=""), chat_histories
             return
         
-        # Use async for to stream updates from _handle_chat_message_submission
         async for update_chunk in self._handle_chat_message_submission(suggestion_text, current_plot_id, chat_histories, current_plot_data_for_chatbot):
             yield update_chunk
 
-
     def _handle_explore_click(self, plot_id_clicked, current_explored_plot_id_from_state, current_active_panel_action_state):
         logging.info(f"Explore Click: Plot '{plot_id_clicked}'. Current Explored: {current_explored_plot_id_from_state}. Active Panel: {current_active_panel_action_state}")
         num_plots = len(PLOT_CONFIGS)
 
-        if not self.plot_ui_objects: # Check if plot UI objects are populated
+        if not self.plot_ui_objects:
             logging.error("plot_ui_objects not populated for handle_explore_click.")
-            # Prepare a list of gr.update() of the correct length
             error_list_len = 4 + (4 * num_plots) + NUM_UNIQUE_SECTIONS
             error_list = [gr.update()] * error_list_len
-            error_list[0] = current_explored_plot_id_from_state # explored_plot_id_state
-            error_list[2] = current_active_panel_action_state   # active_panel_action_state
+            error_list[0] = current_explored_plot_id_from_state
+            error_list[2] = current_active_panel_action_state
             return error_list
 
         new_explored_id_to_set = None
         is_toggling_off_explore = (plot_id_clicked == current_explored_plot_id_from_state)
 
-        action_col_upd = gr.update() # Default to no change
-        new_active_panel_state_upd = current_active_panel_action_state # Default to no change
-        formula_hint_upd = gr.update(visible=False) # Hide by default, only shown by formula panel
+        action_col_upd = gr.update()
+        new_active_panel_state_upd = current_active_panel_action_state
+        formula_hint_upd = gr.update(visible=False)
 
         panel_vis_updates = []
         explore_btns_updates = []
-        bomb_btns_updates = [gr.update()] * num_plots # Default to no change for bomb/formula unless panel closes
+        bomb_btns_updates = [gr.update()] * num_plots
         formula_btns_updates = [gr.update()] * num_plots
         section_title_vis_updates = [gr.update()] * NUM_UNIQUE_SECTIONS
 
@@ -333,16 +316,14 @@ class AnalyticsTab:
         section_of_clicked_plot = clicked_cfg["section"] if clicked_cfg else None
 
         if is_toggling_off_explore:
-            new_explored_id_to_set = None # Clear explore state
+            new_explored_id_to_set = None
             logging.info(f"Stopping explore for {plot_id_clicked}. All plots/sections to be visible.")
             for i in range(NUM_UNIQUE_SECTIONS):
                 section_title_vis_updates[i] = gr.update(visible=True)
             for _ in PLOT_CONFIGS:
                 panel_vis_updates.append(gr.update(visible=True))
                 explore_btns_updates.append(gr.update(value=self.EXPLORE_ICON))
-            # If an action panel was open, it remains open. Its visibility is tied to active_panel_action_state.
-            # Bomb and formula buttons don't change unless an action panel is closed.
-        else: # Exploring a new plot or switching explore
+        else:
             new_explored_id_to_set = plot_id_clicked
             logging.info(f"Exploring {plot_id_clicked}. Hiding other plots/sections.")
 
@@ -354,55 +335,75 @@ class AnalyticsTab:
                 panel_vis_updates.append(gr.update(visible=is_target_plot))
                 explore_btns_updates.append(gr.update(value=self.ACTIVE_ICON if is_target_plot else self.EXPLORE_ICON))
 
-            if current_active_panel_action_state: # If an insights/formula panel was open, close it
+            if current_active_panel_action_state:
                 logging.info("Closing active insight/formula panel due to explore click.")
                 action_col_upd = gr.update(visible=False)
-                new_active_panel_state_upd = None # This will be set to the state
-                # Reset bomb and formula buttons to their default icons
+                new_active_panel_state_upd = None
                 bomb_btns_updates = [gr.update(value=self.BOMB_ICON) for _ in PLOT_CONFIGS]
                 formula_btns_updates = [gr.update(value=self.FORMULA_ICON) for _ in PLOT_CONFIGS]
-                formula_hint_upd = gr.update(visible=False) # Ensure hint is hidden
+                formula_hint_upd = gr.update(visible=False)
 
-        # Order of updates must match self.explore_outputs_list
         final_explore_updates = [
-            new_explored_id_to_set,         # explored_plot_id_state
-            action_col_upd,                 # global_actions_column_ui
-            new_active_panel_state_upd,     # active_panel_action_state
-            formula_hint_upd                # formula_close_hint_md
+            new_explored_id_to_set,
+            action_col_upd,
+            new_active_panel_state_upd,
+            formula_hint_upd
         ]
-        final_explore_updates.extend(panel_vis_updates)         # Plot panel visibilities
-        final_explore_updates.extend(explore_btns_updates)      # Explore button icons
-        final_explore_updates.extend(bomb_btns_updates)         # Bomb button icons
-        final_explore_updates.extend(formula_btns_updates)      # Formula button icons
-        final_explore_updates.extend(section_title_vis_updates) # Section title visibilities
+        final_explore_updates.extend(panel_vis_updates)
+        final_explore_updates.extend(explore_btns_updates)
+        final_explore_updates.extend(bomb_btns_updates)
+        final_explore_updates.extend(formula_btns_updates)
+        final_explore_updates.extend(section_title_vis_updates)
 
         logging.debug(f"handle_explore_click returning {len(final_explore_updates)} updates. Expected {4 + 4*len(PLOT_CONFIGS) + NUM_UNIQUE_SECTIONS}.")
         return final_explore_updates
 
     def _create_panel_action_handler(self, p_id, action_type_str):
-        # This wrapper is needed because Gradio's .click() fn doesn't easily pass extra args fixed at definition time
-        # without using lambdas that might have late binding issues in loops, or functools.partial.
-        # An inner async def is a clean way for this specific pattern with async handlers.
         async def _handler(curr_active_val, curr_chats_val, curr_chat_pid, curr_plot_data, curr_explored_id):
             return await self._handle_panel_action(p_id, action_type_str, curr_active_val, curr_chats_val, curr_chat_pid, curr_plot_data, curr_explored_id)
         return _handler
-
+    
+    # =========================================================================
+    # == MODIFIED FUNCTION: _refresh_analytics_graphs_ui
+    # =========================================================================
     async def _refresh_analytics_graphs_ui(self, current_token_state_val, date_filter_val, custom_start_val, custom_end_val, current_chat_histories_val):
         logging.info("Refreshing analytics graph UI elements and resetting actions/chat (within module).")
         start_time = time.time()
 
+        # --- FIX STARTS HERE ---
+        # The original code used complex slicing (plot_gen_results[1:-1]) which is brittle.
+        # It assumes the figures are returned as a flat list. If update_analytics_plots_figures
+        # returns a more standard (status, [list_of_figs], summary) tuple, the slicing fails.
+        # This new unpacking is more robust and assumes update_analytics_plots_figures returns
+        # a 3-element tuple/list where the second element is the list of figures.
         plot_gen_results = self.update_analytics_plots_figures(current_token_state_val, date_filter_val, custom_start_val, custom_end_val, PLOT_CONFIGS)
-        status_msg, gen_figs, new_summaries_for_chatbot = plot_gen_results[0], plot_gen_results[1:-1], plot_gen_results[-1]
+        
+        # This direct unpacking is safer than slicing.
+        # It assumes `update_analytics_plots_figures` returns a 3-element structure like:
+        # (status_string, list_of_figure_objects, summaries_dict)
+        try:
+            status_msg, gen_figs, new_summaries_for_chatbot = plot_gen_results
+        except (ValueError, TypeError) as e:
+            logging.error(f"Could not unpack results from update_analytics_plots_figures. Error: {e}")
+            logging.error(f"Expected 3 elements (status, figs_list, summaries), but received {len(plot_gen_results)} elements.")
+            # Fallback to error state
+            status_msg = f"Errore: L'aggiornamento dei grafici non è riuscito a causa di un formato di dati imprevisto."
+            gen_figs = [self.create_placeholder_plot("Error", f"Dati non validi {i}") for i in range(len(PLOT_CONFIGS))]
+            new_summaries_for_chatbot = {}
+
+        # --- FIX ENDS HERE ---
 
         all_updates = []
         # 1. Status Markdown
         all_updates.append(status_msg) # For self.analytics_status_md
 
         # 2. Plot components
-        if len(gen_figs) == len(PLOT_CONFIGS):
+        # This check is now more likely to succeed with the corrected unpacking.
+        if isinstance(gen_figs, list) and len(gen_figs) == len(PLOT_CONFIGS):
             all_updates.extend(gen_figs)
         else:
-            logging.error(f"Mismatch in generated figures ({len(gen_figs)}) and plot_configs ({len(PLOT_CONFIGS)})")
+            logging.error(f"Mismatch in generated figures ({len(gen_figs) if isinstance(gen_figs, list) else 'N/A'}) and plot_configs ({len(PLOT_CONFIGS)})")
+            # If there's still a mismatch, create placeholders to avoid crashing Gradio
             all_updates.extend([self.create_placeholder_plot("Error", f"Figura mancante {i}") for i in range(len(PLOT_CONFIGS))])
 
         # 3. UI Resets for Action Panel (9 components)
@@ -420,12 +421,10 @@ class AnalyticsTab:
         all_updates.extend([
             None,  # active_panel_action_state (reset)
             None,  # current_chat_plot_id_st (reset)
-            current_chat_histories_val, # chat_histories_st (pass through, or {} to reset all chats) - original code implies reset with {}
+            {},    # chat_histories_st (reset all chats on refresh)
             new_summaries_for_chatbot  # plot_data_for_chatbot_st (update with new summaries)
         ])
-        # If chat_histories_st should be fully reset on graph refresh:
-        # all_updates[-2] = {} # This would reset all chat histories
-
+        
         # 5. Plot-specific UI Resets (4 components per plot)
         for _ in PLOT_CONFIGS:
             all_updates.extend([
@@ -505,13 +504,12 @@ class AnalyticsTab:
         self.explore_outputs_list.extend([self.plot_ui_objects.get(pc["id"], {}).get("formula_button", gr.update()) for pc in PLOT_CONFIGS])# For resetting if panel closes
         self.explore_outputs_list.extend([self.section_titles_map.get(s_name, gr.update()) for s_name in UNIQUE_ORDERED_SECTIONS])
 
-
     def _setup_callbacks(self):
         # Apply filter button
         graph_refresh_inputs = [
             self.token_state, self.date_filter_selector,
             self.custom_start_date_picker, self.custom_end_date_picker,
-            self.chat_histories_st # Pass the state object itself
+            self.chat_histories_st 
         ]
         self.apply_filter_btn.click(
             fn=self._refresh_analytics_graphs_ui,
@@ -548,7 +546,6 @@ class AnalyticsTab:
                         api_name=f"action_formula_{plot_id}_module"
                     )
                 if ui_obj.get("explore_button"):
-                    # Lambda is okay here as p_id is captured correctly due to loop variable usage
                     ui_obj["explore_button"].click(
                         fn=lambda current_explored_val, current_active_panel_val, p_id=plot_id: self._handle_explore_click(p_id, current_explored_val, current_active_panel_val),
                         inputs=explore_click_inputs,
@@ -577,7 +574,7 @@ class AnalyticsTab:
         ]
         self.insights_suggestion_1_btn.click(
             fn=self._handle_suggested_question_click,
-            inputs=[self.insights_suggestion_1_btn] + suggestion_click_inputs_base, # Pass the button itself for its value
+            inputs=[self.insights_suggestion_1_btn] + suggestion_click_inputs_base,
             outputs=chat_submission_outputs,
             api_name="click_suggestion_1_module"
         )
@@ -595,8 +592,7 @@ class AnalyticsTab:
         )
 
     def create_tab_ui(self):
-        # This method is called by the main app to build the UI for this tab
-        with gr.TabItem("📊 Grafici", id="tab_analytics_module"): # Changed id to avoid conflict if old tab exists temporarily
+        with gr.TabItem("📊 Grafici", id="tab_analytics_module"):
 
             gr.Markdown("## 📈 Analisi Performance LinkedIn")
             gr.Markdown("Seleziona un intervallo di date per i grafici. Clicca i pulsanti (💣 Insights, ƒ Formula, 🧭 Esplora) su un grafico per azioni.")
@@ -619,28 +615,22 @@ class AnalyticsTab:
                 outputs=[self.custom_start_date_picker, self.custom_end_date_picker]
             )
 
-            # Plot area and actions column
             with gr.Row(equal_height=False):
                 with gr.Column(scale=8) as self.plots_area_col:
-                    # Dynamically build plot UI objects and section titles
-                    ui_elements_tuple = self.build_analytics_tab_plot_area(PLOT_CONFIGS) # Call injected function
+                    ui_elements_tuple = self.build_analytics_tab_plot_area(PLOT_CONFIGS)
                     if isinstance(ui_elements_tuple, tuple) and len(ui_elements_tuple) == 2:
                         self.plot_ui_objects, self.section_titles_map = ui_elements_tuple
-                        # Verify section_titles_map completeness (optional, good for debugging)
                         if not all(sec_name in self.section_titles_map for sec_name in UNIQUE_ORDERED_SECTIONS):
                             logging.error("section_titles_map from build_analytics_tab_plot_area is incomplete in module.")
-                            # Create placeholders if missing, to prevent errors with output lists
                             for sec_name in UNIQUE_ORDERED_SECTIONS:
                                 if sec_name not in self.section_titles_map:
                                     logging.warning(f"Creating fallback Markdown for missing section title: {sec_name}")
                                     self.section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)")
                     else:
                         logging.error("build_analytics_tab_plot_area did not return a tuple of (plot_ui_objects, section_titles_map). Using fallback.")
-                        # Fallback: try to use the result if it's a dict, otherwise empty
                         self.plot_ui_objects = ui_elements_tuple if isinstance(ui_elements_tuple, dict) else {}
-                        for sec_name in UNIQUE_ORDERED_SECTIONS: # Ensure section_titles_map has entries
-                             self.section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)")
-
+                        for sec_name in UNIQUE_ORDERED_SECTIONS:
+                           self.section_titles_map[sec_name] = gr.Markdown(f"### {sec_name} (Error Placeholder)")
 
                 with gr.Column(scale=4, visible=False) as self.global_actions_column_ui:
                     gr.Markdown("### 💡 Azioni Contestuali Grafico")
@@ -666,10 +656,5 @@ class AnalyticsTab:
                         visible=False
                     )
             
-            # After all UI components are defined, populate the output lists
             self._define_callback_outputs()
-            # Then, set up the callbacks that use these components and output lists
             self._setup_callbacks()
-
-        # The method doesn't need to return anything as it modifies the Gradio app context directly.
-        # The main app will access necessary components via the instance attributes if needed (e.g., for .then() inputs).