Update app.py

app.py

@@ -10,6 +10,7 @@ import matplotlib.pyplot as plt
 import time # For profiling if needed
 from datetime import datetime, timedelta # Added timedelta
 import numpy as np
+from collections import OrderedDict # To maintain section order
 
 # --- Module Imports ---
 from gradio_utils import get_url_user_token
@@ -24,10 +25,11 @@ from ui_generators import (
     display_main_dashboard,
     run_mentions_tab_display,
     run_follower_stats_tab_display,
-    build_analytics_tab_plot_area,
-    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON
+    build_analytics_tab_plot_area, # EXPECTED TO RETURN: plot_ui_objects, section_titles_map
+    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON,
+    create_placeholder_plot # Assuming you have this or similar for error cases
 )
-from analytics_plot_generator import update_analytics_plots_figures, create_placeholder_plot
+from analytics_plot_generator import update_analytics_plots_figures
 from formulas import PLOT_FORMULAS
 
 # --- NEW CHATBOT MODULE IMPORTS ---
@@ -130,15 +132,42 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 {"label": "Ripartizione Menzioni per Sentiment (Dettaglio)", "id": "mention_analysis_sentiment", "section": "Analisi Menzioni (Dettaglio)"}
             ]
             assert len(plot_configs) == 19, "Mancata corrispondenza in plot_configs e grafici attesi."
+            
+            # Get unique section names in order of appearance in plot_configs
+            unique_ordered_sections = list(OrderedDict.fromkeys(pc["section"] for pc in plot_configs))
+            num_unique_sections = len(unique_ordered_sections)
 
             active_panel_action_state = gr.State(None)
             explored_plot_id_state = gr.State(None)
 
-            plot_ui_objects = {}
+            # plot_ui_objects will store plot-specific UI like panels and buttons
+            # section_titles_map will store Markdown components for section titles
+            plot_ui_objects = {} 
+            section_titles_map = {} # Expected to be populated by build_analytics_tab_plot_area
 
             with gr.Row(equal_height=False):
                 with gr.Column(scale=8) as plots_area_col:
-                    plot_ui_objects = build_analytics_tab_plot_area(plot_configs)
+                    # IMPORTANT ASSUMPTION: build_analytics_tab_plot_area now returns a tuple:
+                    # (dict_of_plot_ui_elements, dict_of_section_title_markdown_components)
+                    # Ensure ui_generators.py is updated accordingly.
+                    ui_elements_tuple = build_analytics_tab_plot_area(plot_configs)
+                    if isinstance(ui_elements_tuple, tuple) and len(ui_elements_tuple) == 2:
+                        plot_ui_objects = ui_elements_tuple[0]
+                        section_titles_map = ui_elements_tuple[1]
+                        # Verify section_titles_map contains all unique_ordered_sections
+                        if not all(sec_name in section_titles_map for sec_name in unique_ordered_sections):
+                            logging.error("section_titles_map from build_analytics_tab_plot_area is incomplete or missing keys for defined sections.")
+                            # Fallback for safety, though this indicates an issue in ui_generators
+                            for sec_name in unique_ordered_sections:
+                                if sec_name not in section_titles_map:
+                                     section_titles_map[sec_name] = gr.Markdown(f"## {sec_name} (Placeholder - Error)") # Placeholder
+                    else:
+                        logging.error("build_analytics_tab_plot_area did not return the expected tuple (plot_ui_objects, section_titles_map). Section titles will not work correctly.")
+                        plot_ui_objects = ui_elements_tuple # Old behavior, section titles won't work
+                        # Create placeholder section_titles_map to prevent crashes, but log error
+                        for sec_name in unique_ordered_sections:
+                            section_titles_map[sec_name] = gr.Markdown(f"## {sec_name} (Placeholder - Error)")
+
 
                 with gr.Column(scale=4, visible=False) as global_actions_column_ui:
                     gr.Markdown("### 💡 Azioni Contestuali Grafico")
@@ -162,12 +191,12 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
             async def handle_panel_action(
                 plot_id_clicked: str,
-                action_type: str, # "insights" or "formula"
+                action_type: str, 
                 current_active_action_from_state: dict,
                 current_chat_histories: dict,
                 current_chat_plot_id: str,
                 current_plot_data_for_chatbot: dict,
-                current_explored_plot_id: str # NEW: Current explore state
+                current_explored_plot_id: str 
             ):
                 logging.info(f"Azione '{action_type}' per grafico: {plot_id_clicked}. Attualmente attivo: {current_active_action_from_state}, Esplorato: {current_explored_plot_id}")
 
@@ -180,453 +209,286 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                         gr.update(visible=False), gr.update(visible=False), gr.update(), gr.update(), gr.update(),
                         gr.update(visible=False), gr.update(value=""),
                         current_active_action_from_state, current_chat_plot_id, current_chat_histories,
-                        current_explored_plot_id # Pass back existing explore state
+                        current_explored_plot_id 
                     ]
                     error_output_list.extend([gr.update()] * num_plots)  # Panel vis
                     error_output_list.extend([gr.update()] * (2 * num_plots))  # Bomb, Formula icons
                     error_output_list.extend([gr.update()] * num_plots)  # Explore icons
+                    error_output_list.extend([gr.update()] * num_unique_sections) # Section title vis
                     return error_output_list
 
                 clicked_plot_label = clicked_plot_config["label"]
+                clicked_plot_section = clicked_plot_config["section"]
                 hypothetical_new_active_state = {"plot_id": plot_id_clicked, "type": action_type}
                 is_toggling_off = current_active_action_from_state == hypothetical_new_active_state
 
-                # Initialize updates
                 action_col_visible_update = gr.update(visible=False)
-                insights_chatbot_visible_update = gr.update(visible=False)
-                insights_chat_input_visible_update = gr.update(visible=False)
-                insights_suggestions_row_visible_update = gr.update(visible=False)
+                insights_chatbot_visible_update, insights_chat_input_visible_update, insights_suggestions_row_visible_update = gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
                 formula_display_visible_update = gr.update(visible=False)
-                chatbot_content_update = gr.update()
-                suggestion_1_update, suggestion_2_update, suggestion_3_update = gr.update(), gr.update(), gr.update()
-                formula_content_update = gr.update()
+                chatbot_content_update, suggestion_1_update, suggestion_2_update, suggestion_3_update, formula_content_update = gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
                 
                 new_active_action_state_to_set = None
                 new_current_chat_plot_id = current_chat_plot_id
                 updated_chat_histories = current_chat_histories
-                new_explored_plot_id_to_set = current_explored_plot_id # Default to not changing explore state
+                new_explored_plot_id_to_set = current_explored_plot_id 
 
-                panel_visibility_component_updates = []
-                action_button_component_updates = [] # For bomb and formula buttons
-                explore_button_component_updates = []
+                panel_visibility_updates = []
+                action_button_updates = [] 
+                explore_button_updates = []
+                section_title_visibility_updates = [gr.update()] * num_unique_sections
 
 
                 if is_toggling_off:
                     new_active_action_state_to_set = None
                     action_col_visible_update = gr.update(visible=False)
-                    # new_explored_plot_id_to_set remains current_explored_plot_id
-                    
                     logging.info(f"Chiusura pannello {action_type} per {plot_id_clicked}.")
-                    if current_explored_plot_id: # If an explore view is active, keep it
+
+                    if current_explored_plot_id: 
+                        explored_plot_cfg = next((p for p in plot_configs if p["id"] == current_explored_plot_id), None)
+                        explored_section_to_show = explored_plot_cfg["section"] if explored_plot_cfg else None
+                        for i, sec_name in enumerate(unique_ordered_sections):
+                            section_title_visibility_updates[i] = gr.update(visible=(sec_name == explored_section_to_show))
                         for cfg_item_iter in plot_configs:
-                            p_id_iter = cfg_item_iter["id"]
-                            is_explored = (p_id_iter == current_explored_plot_id)
-                            panel_visibility_component_updates.append(gr.update(visible=is_explored))
-                            explore_button_component_updates.append(gr.update(value=ACTIVE_ICON if is_explored else EXPLORE_ICON))
-                    else: # No explore active, make all plots visible
+                            is_explored = (cfg_item_iter["id"] == current_explored_plot_id)
+                            panel_visibility_updates.append(gr.update(visible=is_explored))
+                            explore_button_updates.append(gr.update(value=ACTIVE_ICON if is_explored else EXPLORE_ICON))
+                    else: 
+                        for i in range(num_unique_sections): section_title_visibility_updates[i] = gr.update(visible=True)
                         for _ in plot_configs:
-                            panel_visibility_component_updates.append(gr.update(visible=True))
-                            explore_button_component_updates.append(gr.update(value=EXPLORE_ICON))
-                    
-                    # Reset bomb/formula icons for all plots to default
-                    for _ in plot_configs:
-                        action_button_component_updates.append(gr.update(value=BOMB_ICON))
-                        action_button_component_updates.append(gr.update(value=FORMULA_ICON))
+                            panel_visibility_updates.append(gr.update(visible=True))
+                            explore_button_updates.append(gr.update(value=EXPLORE_ICON))
                     
+                    for _ in plot_configs: # Reset bomb/formula icons
+                        action_button_updates.append(gr.update(value=BOMB_ICON))
+                        action_button_updates.append(gr.update(value=FORMULA_ICON))
                     if action_type == "insights": new_current_chat_plot_id = None
 
                 else: # Opening a new panel or switching
                     new_active_action_state_to_set = hypothetical_new_active_state
                     action_col_visible_update = gr.update(visible=True)
-                    
-                    # IMPORTANT: Cancel any active explore view when opening insight/formula
-                    new_explored_plot_id_to_set = None 
+                    new_explored_plot_id_to_set = None # Cancel explore
                     
                     logging.info(f"Apertura pannello {action_type} per {plot_id_clicked}. Solo questo grafico visibile. Esplorazione annullata.")
 
-                    for cfg_item_iter in plot_configs:
-                        p_id_iter = cfg_item_iter["id"]
-                        is_target_plot = (p_id_iter == plot_id_clicked)
-                        panel_visibility_component_updates.append(gr.update(visible=is_target_plot))
-                        # Reset all explore buttons to default as explore is cancelled
-                        explore_button_component_updates.append(gr.update(value=EXPLORE_ICON))
-
-                    # Set active icons for the clicked plot's bomb/formula buttons
-                    for cfg_item_btn_iter in plot_configs:
-                        p_id_btn_iter = cfg_item_btn_iter["id"]
-                        is_active_insights = new_active_action_state_to_set == {"plot_id": p_id_btn_iter, "type": "insights"}
-                        is_active_formula = new_active_action_state_to_set == {"plot_id": p_id_btn_iter, "type": "formula"}
-                        action_button_component_updates.append(gr.update(value=ACTIVE_ICON if is_active_insights else BOMB_ICON))
-                        action_button_component_updates.append(gr.update(value=ACTIVE_ICON if is_active_formula else FORMULA_ICON))
+                    for i, sec_name in enumerate(unique_ordered_sections): # Show only relevant section title
+                        section_title_visibility_updates[i] = gr.update(visible=(sec_name == clicked_plot_section))
+
+                    for cfg_item_iter in plot_configs: # Show only relevant plot panel
+                        panel_visibility_updates.append(gr.update(visible=(cfg_item_iter["id"] == plot_id_clicked)))
+                        explore_button_updates.append(gr.update(value=EXPLORE_ICON)) # Reset all explore buttons
+
+                    for cfg_item_btn_iter in plot_configs: # Set active icons for bomb/formula
+                        is_active_insights = new_active_action_state_to_set == {"plot_id": cfg_item_btn_iter["id"], "type": "insights"}
+                        is_active_formula = new_active_action_state_to_set == {"plot_id": cfg_item_btn_iter["id"], "type": "formula"}
+                        action_button_updates.append(gr.update(value=ACTIVE_ICON if is_active_insights else BOMB_ICON))
+                        action_button_updates.append(gr.update(value=ACTIVE_ICON if is_active_formula else FORMULA_ICON))
 
                     if action_type == "insights":
-                        insights_chatbot_visible_update = gr.update(visible=True)
-                        insights_chat_input_visible_update = gr.update(visible=True)
-                        insights_suggestions_row_visible_update = gr.update(visible=True)
+                        insights_chatbot_visible_update, insights_chat_input_visible_update, insights_suggestions_row_visible_update = gr.update(visible=True), gr.update(visible=True), gr.update(visible=True)
                         new_current_chat_plot_id = plot_id_clicked
                         chat_history_for_this_plot = current_chat_histories.get(plot_id_clicked, [])
                         plot_specific_data_summary = current_plot_data_for_chatbot.get(plot_id_clicked, f"Nessun sommario dati specifico disponibile per '{clicked_plot_label}'.")
-
                         if not chat_history_for_this_plot:
-                            initial_llm_prompt, suggestions = get_initial_insight_prompt_and_suggestions(
-                                plot_id_clicked, clicked_plot_label, plot_specific_data_summary
-                            )
+                            initial_llm_prompt, suggestions = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, plot_specific_data_summary)
                             history_for_llm_first_turn = [{"role": "user", "content": initial_llm_prompt}]
-                            initial_bot_response_text = await generate_llm_response(
-                                initial_llm_prompt, plot_id_clicked, clicked_plot_label,
-                                history_for_llm_first_turn, plot_specific_data_summary
-                            )
+                            initial_bot_response_text = await generate_llm_response(initial_llm_prompt, plot_id_clicked, clicked_plot_label, history_for_llm_first_turn, plot_specific_data_summary)
                             chat_history_for_this_plot = [{"role": "assistant", "content": initial_bot_response_text}]
-                            updated_chat_histories = current_chat_histories.copy()
-                            updated_chat_histories[plot_id_clicked] = chat_history_for_this_plot
+                            updated_chat_histories = {**current_chat_histories, plot_id_clicked: chat_history_for_this_plot}
                         else:
-                            _, suggestions = get_initial_insight_prompt_and_suggestions(
-                                plot_id_clicked, clicked_plot_label, plot_specific_data_summary
-                            )
-                        
+                            _, suggestions = get_initial_insight_prompt_and_suggestions(plot_id_clicked, clicked_plot_label, plot_specific_data_summary)
                         chatbot_content_update = gr.update(value=chat_history_for_this_plot)
-                        suggestion_1_update = gr.update(value=suggestions[0] if len(suggestions) > 0 else "N/A")
-                        suggestion_2_update = gr.update(value=suggestions[1] if len(suggestions) > 1 else "N/A")
-                        suggestion_3_update = gr.update(value=suggestions[2] if len(suggestions) > 2 else "N/A")
-
+                        suggestion_1_update, suggestion_2_update, suggestion_3_update = gr.update(value=suggestions[0] if suggestions else "N/A"), gr.update(value=suggestions[1] if len(suggestions) > 1 else "N/A"), gr.update(value=suggestions[2] if len(suggestions) > 2 else "N/A")
                     elif action_type == "formula":
                         formula_display_visible_update = gr.update(visible=True)
                         formula_key = PLOT_ID_TO_FORMULA_KEY_MAP.get(plot_id_clicked)
                         formula_text = f"**Formula/Metodologia per: {clicked_plot_label}**\n\nID Grafico: `{plot_id_clicked}`.\n\n"
-                        if formula_key and formula_key in PLOT_FORMULAS:
-                            formula_data = PLOT_FORMULAS[formula_key]
-                            formula_text += f"### {formula_data['title']}\n\n{formula_data['description']}\n\n**Come viene calcolato:**\n"
-                            formula_text += "\n".join([f"- {step}" for step in formula_data['calculation_steps']])
-                        else:
-                            formula_text += "(Nessuna informazione dettagliata sulla formula trovata)"
+                        formula_text += PLOT_FORMULAS.get(formula_key, {}).get('description', "(Nessuna descrizione dettagliata)") if formula_key else "(Formula non definita)"
                         formula_content_update = gr.update(value=formula_text)
-                        new_current_chat_plot_id = None # Ensure chat is cleared if formula is opened
+                        new_current_chat_plot_id = None
 
                 final_updates = [
-                    action_col_visible_update,
-                    insights_chatbot_visible_update, chatbot_content_update,
-                    insights_chat_input_visible_update,
-                    insights_suggestions_row_visible_update, suggestion_1_update, suggestion_2_update, suggestion_3_update,
+                    action_col_visible_update, insights_chatbot_visible_update, chatbot_content_update,
+                    insights_chat_input_visible_update, insights_suggestions_row_visible_update, 
+                    suggestion_1_update, suggestion_2_update, suggestion_3_update,
                     formula_display_visible_update, formula_content_update,
-                    new_active_action_state_to_set,
-                    new_current_chat_plot_id,
-                    updated_chat_histories,
-                    new_explored_plot_id_to_set # NEW: update explored_plot_id_state
+                    new_active_action_state_to_set, new_current_chat_plot_id, updated_chat_histories,
+                    new_explored_plot_id_to_set 
                 ]
-                final_updates.extend(panel_visibility_component_updates)
-                final_updates.extend(action_button_component_updates)
-                final_updates.extend(explore_button_component_updates)
-                
+                final_updates.extend(panel_visibility_updates)
+                final_updates.extend(action_button_updates)
+                final_updates.extend(explore_button_updates)
+                final_updates.extend(section_title_visibility_updates)
                 return final_updates
 
-            async def handle_chat_message_submission(
-                user_message: str,
-                current_plot_id: str,
-                chat_histories: dict,
-                current_plot_data_for_chatbot: dict
-            ):
+            async def handle_chat_message_submission(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():
-                    history_for_plot = chat_histories.get(current_plot_id, [])
-                    yield history_for_plot, gr.update(value=""), chat_histories
+                    yield chat_histories.get(current_plot_id, []), gr.update(value=""), chat_histories
                     return
-
                 plot_config = next((p for p in plot_configs if p["id"] == current_plot_id), None)
                 plot_label = plot_config["label"] if plot_config else "Grafico Selezionato"
                 plot_specific_data_summary = current_plot_data_for_chatbot.get(current_plot_id, f"Nessun sommario dati specifico disponibile per '{plot_label}'.")
-                history_for_plot = chat_histories.get(current_plot_id, []).copy()
-                history_for_plot.append({"role": "user", "content": user_message})
+                history_for_plot = chat_histories.get(current_plot_id, []).copy() + [{"role": "user", "content": user_message}]
                 yield history_for_plot, gr.update(value=""), chat_histories
-
-                bot_response_text = await generate_llm_response(
-                    user_message, current_plot_id, plot_label, history_for_plot, plot_specific_data_summary
-                )
+                bot_response_text = await generate_llm_response(user_message, current_plot_id, plot_label, history_for_plot, plot_specific_data_summary)
                 history_for_plot.append({"role": "assistant", "content": bot_response_text})
-                updated_chat_histories = chat_histories.copy()
-                updated_chat_histories[current_plot_id] = history_for_plot
-                yield history_for_plot, "", updated_chat_histories
-
-            async def handle_suggested_question_click(
-                suggestion_text: str,
-                current_plot_id: str,
-                chat_histories: dict,
-                current_plot_data_for_chatbot: dict
-            ):
+                yield history_for_plot, "", {**chat_histories, current_plot_id: history_for_plot}
+
+            async def handle_suggested_question_click(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():
-                    history_for_plot = chat_histories.get(current_plot_id, [])
-                    yield history_for_plot, gr.update(value=""), chat_histories
+                    yield chat_histories.get(current_plot_id, []), gr.update(value=""), chat_histories
                     return
-                async for update in handle_chat_message_submission(
-                    suggestion_text, current_plot_id, chat_histories, current_plot_data_for_chatbot
-                ):
+                async for update in handle_chat_message_submission(suggestion_text, current_plot_id, chat_histories, current_plot_data_for_chatbot):
                     yield update
 
-            def handle_explore_click(
-                plot_id_clicked, 
-                current_explored_plot_id_from_state,
-                current_active_panel_action_state # NEW: current insight/formula state
-            ):
-                logging.info(f"Click su Esplora per: {plot_id_clicked}. Attualmente esplorato: {current_explored_plot_id_from_state}. Pannello Azioni Attivo: {current_active_panel_action_state}")
-                if not plot_ui_objects:
-                    logging.error("plot_ui_objects non popolato durante handle_explore_click.")
-                    num_plots = len(plot_configs)
-                    error_updates = [current_explored_plot_id_from_state, gr.update(visible=False), current_active_panel_action_state]
-                    error_updates.extend([gr.update()] * num_plots) # Panel vis
-                    error_updates.extend([gr.update()] * num_plots) # Explore icons
-                    error_updates.extend([gr.update()] * (2 * num_plots)) # Bomb, Formula icons
+            def handle_explore_click(plot_id_clicked, current_explored_plot_id_from_state, current_active_panel_action_state):
+                logging.info(f"Click Esplora: {plot_id_clicked}. Esplorato: {current_explored_plot_id_from_state}. Pannello Attivo: {current_active_panel_action_state}")
+                num_plots = len(plot_configs)
+                if not plot_ui_objects: # Should use plot_ui_objects here
+                    logging.error("plot_ui_objects non popolato.")
+                    error_updates = [current_explored_plot_id_from_state, gr.update(visible=False), current_active_panel_action_state] + \
+                                    [gr.update()] * (num_plots + num_plots + 2 * num_plots + num_unique_sections)
                     return error_updates
 
                 new_explored_id_to_set = None
                 is_toggling_off_explore = (plot_id_clicked == current_explored_plot_id_from_state)
-
                 action_col_update = gr.update() 
                 new_active_panel_action_state_update = current_active_panel_action_state
                 
-                panel_vis_updates = []
-                explore_btn_updates = []
-                bomb_btn_icon_upds = []
-                formula_btn_icon_upds = []
+                panel_vis_updates, explore_btn_updates, bomb_btn_icon_upds, formula_btn_icon_upds = [], [], [], []
+                section_title_vis_updates = [gr.update()] * num_unique_sections
+                
+                clicked_plot_cfg = next((p for p in plot_configs if p["id"] == plot_id_clicked), None)
+                section_of_clicked_plot = clicked_plot_cfg["section"] if clicked_plot_cfg else None
 
                 if is_toggling_off_explore:
                     new_explored_id_to_set = None
-                    logging.info(f"Interruzione esplorazione grafico: {plot_id_clicked}. Tutti i grafici diventano visibili.")
-                    # All plots become visible
+                    logging.info(f"Stop esplorazione: {plot_id_clicked}. Tutti i grafici/titoli visibili.")
+                    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_btn_updates.append(gr.update(value=EXPLORE_ICON))
-                    # Insight/formula buttons remain as they were (no change)
-                    for _ in plot_configs:
-                        bomb_btn_icon_upds.append(gr.update())
-                        formula_btn_icon_upds.append(gr.update())
-                else: # Activating explore for plot_id_clicked or switching explore
+                        bomb_btn_icon_upds.append(gr.update()) # No change if not active
+                        formula_btn_icon_upds.append(gr.update()) # No change if not active
+                else: 
                     new_explored_id_to_set = plot_id_clicked
-                    logging.info(f"Esplorazione grafico: {plot_id_clicked}. Altri grafici nascosti.")
-                    # Make only explored plot visible
+                    logging.info(f"Esplorazione: {plot_id_clicked}. Altri grafici/titoli nascosti.")
+                    for i, sec_name in enumerate(unique_ordered_sections):
+                        section_title_vis_updates[i] = gr.update(visible=(sec_name == section_of_clicked_plot))
                     for cfg in plot_configs:
-                        p_id = cfg["id"]
-                        is_target_plot = (p_id == new_explored_id_to_set)
-                        panel_vis_updates.append(gr.update(visible=is_target_plot))
-                        explore_btn_updates.append(gr.update(value=ACTIVE_ICON if is_target_plot else EXPLORE_ICON))
-                    
-                    # If activating explore, close any active insight/formula panel
-                    if current_active_panel_action_state:
-                        logging.info("Chiusura pannello azioni (insight/formula) a causa dell'attivazione dell'esplorazione.")
+                        is_target = (cfg["id"] == new_explored_id_to_set)
+                        panel_vis_updates.append(gr.update(visible=is_target))
+                        explore_btn_updates.append(gr.update(value=ACTIVE_ICON if is_target else EXPLORE_ICON))
+                    if current_active_panel_action_state: # Close insight/formula if explore is activated
+                        logging.info("Chiusura pannello azioni per attivazione esplorazione.")
                         action_col_update = gr.update(visible=False)
                         new_active_panel_action_state_update = None
-                        # Reset all insight/formula button icons
                         for _ in plot_configs:
                             bomb_btn_icon_upds.append(gr.update(value=BOMB_ICON))
                             formula_btn_icon_upds.append(gr.update(value=FORMULA_ICON))
-                    else: # No insight/formula panel active, no change to their buttons
-                         for _ in plot_configs:
-                            bomb_btn_icon_upds.append(gr.update())
-                            formula_btn_icon_upds.append(gr.update())
+                    else:
+                        for _ in plot_configs: bomb_btn_icon_upds.append(gr.update()); formula_btn_icon_upds.append(gr.update())
                 
-                final_updates = [
-                    new_explored_id_to_set,
-                    action_col_update,
-                    new_active_panel_action_state_update
-                ]
-                final_updates.extend(panel_vis_updates)
-                final_updates.extend(explore_btn_updates)
-                final_updates.extend(bomb_btn_icon_upds)
-                final_updates.extend(formula_btn_icon_upds)
-                return final_updates
+                return [new_explored_id_to_set, action_col_update, new_active_panel_action_state_update] + \
+                       panel_vis_updates + explore_btn_updates + bomb_btn_icon_upds + formula_btn_icon_upds + section_title_vis_updates
 
             # --- Define Output Lists for Event Handlers ---
-            action_panel_outputs_list = [
-                global_actions_column_ui,
-                insights_chatbot_ui, insights_chatbot_ui, 
-                insights_chat_input_ui,
-                insights_suggestions_row_ui, insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn,
-                formula_display_markdown_ui, formula_display_markdown_ui,
-                active_panel_action_state,
-                current_chat_plot_id_st,
-                chat_histories_st,
-                explored_plot_id_state # NEW: output for explore state
-            ]
-            for cfg_item_action_out in plot_configs:
-                pid_action_out = cfg_item_action_out["id"]
-                ui_obj_ref = plot_ui_objects.get(pid_action_out)
-                action_panel_outputs_list.append(ui_obj_ref["panel_component"] if ui_obj_ref else gr.update()) # Panel visibility
-            for cfg_item_action_out in plot_configs:
-                pid_action_out = cfg_item_action_out["id"]
-                ui_obj_ref = plot_ui_objects.get(pid_action_out)
-                action_panel_outputs_list.append(ui_obj_ref["bomb_button"] if ui_obj_ref else gr.update())    # Bomb icon
-                action_panel_outputs_list.append(ui_obj_ref["formula_button"] if ui_obj_ref else gr.update()) # Formula icon
-            for cfg_item_action_out in plot_configs:
-                pid_action_out = cfg_item_action_out["id"]
-                ui_obj_ref = plot_ui_objects.get(pid_action_out)
-                action_panel_outputs_list.append(ui_obj_ref["explore_button"] if ui_obj_ref else gr.update()) # Explore icon
-
-            explore_outputs_list = [
-                explored_plot_id_state,
-                global_actions_column_ui, # NEW: output for action column
-                active_panel_action_state # NEW: output for active panel state
-            ]
-            for cfg_item_explore_out in plot_configs: # Panel visibility
-                pid_explore_out = cfg_item_explore_out["id"]
-                ui_obj_ref = plot_ui_objects.get(pid_explore_out)
-                explore_outputs_list.append(ui_obj_ref["panel_component"] if ui_obj_ref else gr.update())
-            for cfg_item_explore_out in plot_configs: # Explore button icons
-                pid_explore_out = cfg_item_explore_out["id"]
-                ui_obj_ref = plot_ui_objects.get(pid_explore_out)
-                explore_outputs_list.append(ui_obj_ref["explore_button"] if ui_obj_ref else gr.update())
-            for cfg_item_explore_out in plot_configs: # Bomb button icons
-                pid_explore_out = cfg_item_explore_out["id"]
-                ui_obj_ref = plot_ui_objects.get(pid_explore_out)
-                explore_outputs_list.append(ui_obj_ref["bomb_button"] if ui_obj_ref else gr.update())
-            for cfg_item_explore_out in plot_configs: # Formula button icons
-                pid_explore_out = cfg_item_explore_out["id"]
-                ui_obj_ref = plot_ui_objects.get(pid_explore_out)
-                explore_outputs_list.append(ui_obj_ref["formula_button"] if ui_obj_ref else gr.update())
-
-
-            # --- Define Input Lists for Event Handlers ---
-            action_click_inputs = [
-                active_panel_action_state,
-                chat_histories_st,
-                current_chat_plot_id_st,
-                plot_data_for_chatbot_st,
-                explored_plot_id_state # NEW: input explore state
-            ]
-            explore_click_inputs = [
-                explored_plot_id_state,
-                active_panel_action_state # NEW: input active panel state
+            # Base UI elements for action panel
+            _base_action_panel_ui_outputs = [
+                global_actions_column_ui, insights_chatbot_ui, insights_chatbot_ui, 
+                insights_chat_input_ui, insights_suggestions_row_ui, 
+                insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn,
+                formula_display_markdown_ui, formula_display_markdown_ui
             ]
+            _action_panel_state_outputs = [active_panel_action_state, current_chat_plot_id_st, chat_histories_st, explored_plot_id_state]
+            
+            action_panel_outputs_list = _base_action_panel_ui_outputs + _action_panel_state_outputs
+            action_panel_outputs_list.extend([plot_ui_objects[pid]["panel_component"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Panel vis
+            action_panel_outputs_list.extend([plot_ui_objects[pid]["bomb_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]])    # Bomb icon
+            action_panel_outputs_list.extend([plot_ui_objects[pid]["formula_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Formula icon
+            action_panel_outputs_list.extend([plot_ui_objects[pid]["explore_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Explore icon
+            action_panel_outputs_list.extend([section_titles_map[s_name] if s_name in section_titles_map else gr.update() for s_name in unique_ordered_sections]) # Section Titles
+
+            _explore_state_outputs = [explored_plot_id_state, global_actions_column_ui, active_panel_action_state]
+            explore_outputs_list = _explore_state_outputs
+            explore_outputs_list.extend([plot_ui_objects[pid]["panel_component"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Panel vis
+            explore_outputs_list.extend([plot_ui_objects[pid]["explore_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Explore icon
+            explore_outputs_list.extend([plot_ui_objects[pid]["bomb_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]])    # Bomb icon
+            explore_outputs_list.extend([plot_ui_objects[pid]["formula_button"] if pid in plot_ui_objects else gr.update() for pid in [pc["id"] for pc in plot_configs]]) # Formula icon
+            explore_outputs_list.extend([section_titles_map[s_name] if s_name in section_titles_map else gr.update() for s_name in unique_ordered_sections]) # Section Titles
+
+            action_click_inputs = [active_panel_action_state, chat_histories_st, current_chat_plot_id_st, plot_data_for_chatbot_st, explored_plot_id_state]
+            explore_click_inputs = [explored_plot_id_state, active_panel_action_state]
 
-            # --- Register Event Handlers ---
             def create_panel_action_handler(p_id, action_type_str):
-                async def _handler(current_active_val, current_chats_val, current_chat_pid, current_plot_data_summaries, current_explored_id_val): # Added current_explored_id_val
-                    logging.debug(f"Entering _handler for plot_id: {p_id}, action: {action_type_str}")
-                    result = await handle_panel_action(p_id, action_type_str, current_active_val, current_chats_val, current_chat_pid, current_plot_data_summaries, current_explored_id_val) # Pass current_explored_id_val
-                    logging.debug(f"_handler for plot_id: {p_id}, action: {action_type_str} completed with {len(result)} updates.")
-                    return result
+                async def _handler(curr_active_val, curr_chats_val, curr_chat_pid, curr_plot_data, curr_explored_id):
+                    return await 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
 
             for config_item in plot_configs:
                 plot_id = config_item["id"]
                 if plot_id in plot_ui_objects:
                     ui_obj = plot_ui_objects[plot_id]
-                    ui_obj["bomb_button"].click(
-                        fn=create_panel_action_handler(plot_id, "insights"),
-                        inputs=action_click_inputs,
-                        outputs=action_panel_outputs_list,
-                        api_name=f"action_insights_{plot_id}"
-                    )
-                    ui_obj["formula_button"].click(
-                        fn=create_panel_action_handler(plot_id, "formula"),
-                        inputs=action_click_inputs,
-                        outputs=action_panel_outputs_list,
-                        api_name=f"action_formula_{plot_id}"
-                    )
-                    ui_obj["explore_button"].click(
-                        fn=lambda current_explored_val, current_active_panel_val, p_id=plot_id: handle_explore_click(p_id, current_explored_val, current_active_panel_val),
-                        inputs=explore_click_inputs, # Uses updated explore_click_inputs
-                        outputs=explore_outputs_list, # Uses updated explore_outputs_list
-                        api_name=f"action_explore_{plot_id}"
-                    )
-                else:
-                    logging.warning(f"Oggetto UI per plot_id '{plot_id}' non trovato durante il tentativo di associare i gestori di click.")
+                    ui_obj["bomb_button"].click(fn=create_panel_action_handler(plot_id, "insights"), inputs=action_click_inputs, outputs=action_panel_outputs_list, api_name=f"action_insights_{plot_id}")
+                    ui_obj["formula_button"].click(fn=create_panel_action_handler(plot_id, "formula"), inputs=action_click_inputs, outputs=action_panel_outputs_list, api_name=f"action_formula_{plot_id}")
+                    ui_obj["explore_button"].click(fn=lambda current_explored_val, current_active_panel_val, p_id=plot_id: handle_explore_click(p_id, current_explored_val, current_active_panel_val), inputs=explore_click_inputs, outputs=explore_outputs_list, api_name=f"action_explore_{plot_id}")
+                else: logging.warning(f"UI object for plot_id '{plot_id}' not found for click handlers.")
 
             chat_submission_outputs = [insights_chatbot_ui, insights_chat_input_ui, chat_histories_st]
             chat_submission_inputs = [insights_chat_input_ui, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st]
-
-            insights_chat_input_ui.submit(
-                fn=handle_chat_message_submission,
-                inputs=chat_submission_inputs,
-                outputs=chat_submission_outputs,
-                api_name="submit_chat_message"
-            )
-
+            insights_chat_input_ui.submit(fn=handle_chat_message_submission, inputs=chat_submission_inputs, outputs=chat_submission_outputs, api_name="submit_chat_message")
             suggestion_click_inputs = [current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st]
-            insights_suggestion_1_btn.click(
-                fn=handle_suggested_question_click,
-                inputs=[insights_suggestion_1_btn] + suggestion_click_inputs,
-                outputs=chat_submission_outputs, api_name="click_suggestion_1"
-            )
-            insights_suggestion_2_btn.click(
-                fn=handle_suggested_question_click,
-                inputs=[insights_suggestion_2_btn] + suggestion_click_inputs,
-                outputs=chat_submission_outputs, api_name="click_suggestion_2"
-            )
-            insights_suggestion_3_btn.click(
-                fn=handle_suggested_question_click,
-                inputs=[insights_suggestion_3_btn] + suggestion_click_inputs,
-                outputs=chat_submission_outputs, api_name="click_suggestion_3"
-            )
+            insights_suggestion_1_btn.click(fn=handle_suggested_question_click, inputs=[insights_suggestion_1_btn] + suggestion_click_inputs, outputs=chat_submission_outputs, api_name="click_suggestion_1")
+            insights_suggestion_2_btn.click(fn=handle_suggested_question_click, inputs=[insights_suggestion_2_btn] + suggestion_click_inputs, outputs=chat_submission_outputs, api_name="click_suggestion_2")
+            insights_suggestion_3_btn.click(fn=handle_suggested_question_click, inputs=[insights_suggestion_3_btn] + suggestion_click_inputs, outputs=chat_submission_outputs, api_name="click_suggestion_3")
 
             def refresh_all_analytics_ui_elements(current_token_state, date_filter_val, custom_start_val, custom_end_val, current_chat_histories):
-                logging.info("Aggiornamento di tutti gli elementi UI delle analisi e reset delle azioni/chat.")
-                plot_generation_results = update_analytics_plots_figures(
-                    current_token_state, date_filter_val, custom_start_val, custom_end_val, plot_configs
-                )
-                status_message_update = plot_generation_results[0]
-                generated_plot_figures = plot_generation_results[1:-1]
-                new_plot_data_summaries = plot_generation_results[-1]
-
-                all_updates = [status_message_update]
-                for i in range(len(plot_configs)):
-                    if i < len(generated_plot_figures):
-                        all_updates.append(generated_plot_figures[i])
-                    else:
-                        # Ensure create_placeholder_plot is defined or handle appropriately
-                        all_updates.append(create_placeholder_plot("Errore Figura", f"Figura mancante per grafico {plot_configs[i]['id']}"))
+                logging.info("Refreshing all analytics UI elements and resetting actions/chat.")
+                plot_generation_results = update_analytics_plots_figures(current_token_state, date_filter_val, custom_start_val, custom_end_val, plot_configs)
+                status_msg, generated_figs, new_plot_data_summaries = plot_generation_results[0], plot_generation_results[1:-1], plot_generation_results[-1]
                 
-                all_updates.extend([
-                    gr.update(visible=False), # global_actions_column_ui
-                    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="Suggerimento 1"), gr.update(value="Suggerimento 2"), gr.update(value="Suggerimento 3"),
-                    gr.update(value="I dettagli sulla formula/metodologia appariranno qui.", visible=False), # formula_display_markdown_ui
-                    None, # active_panel_action_state
-                    None, # current_chat_plot_id_st
-                    {},   # chat_histories_st (reset)
-                    new_plot_data_summaries # plot_data_for_chatbot_st
-                ])
-
-                for cfg in plot_configs:
-                    pid = cfg["id"]
-                    # Reset button icons
-                    all_updates.append(gr.update(value=BOMB_ICON))
-                    all_updates.append(gr.update(value=FORMULA_ICON))
-                    all_updates.append(gr.update(value=EXPLORE_ICON))
-                    # Make all plot panels visible
-                    all_updates.append(gr.update(visible=True)) # panel_component visibility
+                all_updates = [status_msg]
+                all_updates.extend(generated_figs if len(generated_figs) == len(plot_configs) else [create_placeholder_plot("Error", f"Fig missing {i}") for i in range(len(plot_configs))])
                 
-                all_updates.append(None) # explored_plot_id_state (reset)
-                logging.info(f"Preparati {len(all_updates)} aggiornamenti per il refresh delle analisi.")
+                all_updates.extend([ # Reset action panel UI
+                    gr.update(visible=False), gr.update(value=[], visible=False), gr.update(value="", visible=False),
+                    gr.update(visible=False), gr.update(value="S1"), gr.update(value="S2"), gr.update(value="S3"),
+                    gr.update(value="Formula details here.", visible=False),
+                    None, None, {}, new_plot_data_summaries # Reset states
+                ])
+                for _ in plot_configs: # Reset button icons & panel visibility
+                    all_updates.extend([gr.update(value=BOMB_ICON), gr.update(value=FORMULA_ICON), gr.update(value=EXPLORE_ICON), gr.update(visible=True)])
+                all_updates.append(None) # Reset explored_plot_id_state
+                all_updates.extend([gr.update(visible=True)] * num_unique_sections) # Make all section titles visible
+                logging.info(f"Prepared {len(all_updates)} updates for analytics refresh.")
                 return all_updates
 
-            apply_filter_and_sync_outputs_list = [analytics_status_md]
-            for config_item_filter_sync in plot_configs: # Plot components
-                pid = config_item_filter_sync["id"]
-                apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid]["plot_component"] if pid in plot_ui_objects and "plot_component" in plot_ui_objects[pid] else gr.update())
-            
-            apply_filter_and_sync_outputs_list.extend([ # UI elements to reset
+            apply_filter_and_sync_outputs_list = [analytics_status_md] # Status
+            apply_filter_and_sync_outputs_list.extend([plot_ui_objects[pc["id"]]["plot_component"] if pc["id"] in plot_ui_objects and "plot_component" in plot_ui_objects[pc["id"]] else gr.update() for pc in plot_configs]) # Plot figures
+            apply_filter_and_sync_outputs_list.extend([ # Action panel UI reset
                 global_actions_column_ui, insights_chatbot_ui, insights_chat_input_ui,
                 insights_suggestions_row_ui, insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn,
                 formula_display_markdown_ui,
-                active_panel_action_state, current_chat_plot_id_st, chat_histories_st,
-                plot_data_for_chatbot_st
+                active_panel_action_state, current_chat_plot_id_st, chat_histories_st, plot_data_for_chatbot_st
             ])
-            for cfg_filter_sync_btns in plot_configs: # Button icons and panel visibility
-                pid = cfg_filter_sync_btns["id"]
-                apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid]["bomb_button"] if pid in plot_ui_objects else gr.update())
-                apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid]["formula_button"] if pid in plot_ui_objects else gr.update())
-                apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid]["explore_button"] if pid in plot_ui_objects else gr.update())
-                apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid]["panel_component"] if pid in plot_ui_objects else gr.update())
-            
+            for pc in plot_configs: # Button icons and panel visibility
+                pid = pc["id"]
+                apply_filter_and_sync_outputs_list.extend([
+                    plot_ui_objects[pid]["bomb_button"] if pid in plot_ui_objects else gr.update(),
+                    plot_ui_objects[pid]["formula_button"] if pid in plot_ui_objects else gr.update(),
+                    plot_ui_objects[pid]["explore_button"] if pid in plot_ui_objects else gr.update(),
+                    plot_ui_objects[pid]["panel_component"] if pid in plot_ui_objects else gr.update()
+                ])
             apply_filter_and_sync_outputs_list.append(explored_plot_id_state) # Reset explored state
+            apply_filter_and_sync_outputs_list.extend([section_titles_map[s_name] if s_name in section_titles_map else gr.update() for s_name in unique_ordered_sections]) # Section Titles
             
             apply_filter_btn.click(
                 fn=refresh_all_analytics_ui_elements,
                 inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st],
-                outputs=apply_filter_and_sync_outputs_list,
-                show_progress="full"
+                outputs=apply_filter_and_sync_outputs_list, show_progress="full"
             )
 
         with gr.TabItem("3️⃣ Menzioni", id="tab_mentions"):
+            # ... (rest of the tab unchanged) ...
             refresh_mentions_display_btn = gr.Button("🔄 Aggiorna Visualizzazione Menzioni", variant="secondary")
             mentions_html = gr.HTML("Dati menzioni...")
             mentions_sentiment_dist_plot = gr.Plot(label="Distribuzione Sentiment Menzioni")
@@ -637,6 +499,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
         with gr.TabItem("4️⃣ Statistiche Follower", id="tab_follower_stats"):
+            # ... (rest of the tab unchanged) ...
             refresh_follower_stats_btn = gr.Button("🔄 Aggiorna Visualizzazione Statistiche Follower", variant="secondary")
             follower_stats_html = gr.HTML("Statistiche follower...")
             with gr.Row():
@@ -651,37 +514,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 show_progress="full"
             )
             
-    sync_event_part1 = sync_data_btn.click(
-        fn=sync_all_linkedin_data_orchestrator,
-        inputs=[token_state], outputs=[sync_status_html_output, token_state], show_progress="full"
-    )
-    sync_event_part2 = sync_event_part1.then(
-        fn=process_and_store_bubble_token,
-        inputs=[url_user_token_display, org_urn_display, token_state],
-        outputs=[status_box, token_state, sync_data_btn], show_progress=False
-    )
-    sync_event_part3 = sync_event_part2.then(
-        fn=display_main_dashboard,
-        inputs=[token_state], outputs=[dashboard_display_html], show_progress=False
-    )
-    sync_event_final = sync_event_part3.then(
-        fn=refresh_all_analytics_ui_elements, 
-        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st],
-        outputs=apply_filter_and_sync_outputs_list,
-        show_progress="full"
-    )
+    sync_event_part1 = sync_data_btn.click(fn=sync_all_linkedin_data_orchestrator, inputs=[token_state], outputs=[sync_status_html_output, token_state], show_progress="full")
+    sync_event_part2 = sync_event_part1.then(fn=process_and_store_bubble_token, inputs=[url_user_token_display, org_urn_display, token_state], outputs=[status_box, token_state, sync_data_btn], show_progress=False)
+    sync_event_part3 = sync_event_part2.then(fn=display_main_dashboard, inputs=[token_state], outputs=[dashboard_display_html], show_progress=False)
+    sync_event_final = sync_event_part3.then(fn=refresh_all_analytics_ui_elements, inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st], outputs=apply_filter_and_sync_outputs_list, show_progress="full")
 
 if __name__ == "__main__":
-    if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR):
-        logging.warning(f"ATTENZIONE: Variabile d'ambiente '{LINKEDIN_CLIENT_ID_ENV_VAR}' non impostata.")
-    if not os.environ.get(BUBBLE_APP_NAME_ENV_VAR) or \
-       not os.environ.get(BUBBLE_API_KEY_PRIVATE_ENV_VAR) or \
-       not os.environ.get(BUBBLE_API_ENDPOINT_ENV_VAR):
-        logging.warning("ATTENZIONE: Variabili d'ambiente Bubble non completamente impostate.")
-    
-    try:
-        logging.info(f"Versione Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
-    except ImportError:
-        logging.warning("Matplotlib non trovato direttamente, ma potrebbe essere usato dai generatori di grafici.")
-        
+    if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR): logging.warning(f"ATTENZIONE: '{LINKEDIN_CLIENT_ID_ENV_VAR}' non impostata.")
+    if not all(os.environ.get(var) for var in [BUBBLE_APP_NAME_ENV_VAR, BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR]):
+        logging.warning("ATTENZIONE: Variabili Bubble non impostate.")
+    try: logging.info(f"Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
+    except ImportError: logging.warning("Matplotlib non trovato.")
     app.launch(server_name="0.0.0.0", server_port=7860, debug=True)