Update app.py

app.py

@@ -27,7 +27,7 @@ from ui_generators import (
 # Corrected import for analytics_data_processing
 from analytics_data_processing import prepare_filtered_analytics_data
 from analytics_plot_generator import (
-    generate_posts_activity_plot, # Make sure this is available if posts_activity is in map
+    generate_posts_activity_plot, 
     generate_mentions_activity_plot, generate_mention_sentiment_plot,
     generate_followers_count_over_time_plot,
     generate_followers_growth_rate_plot,
@@ -52,9 +52,9 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 
 # Mapping from plot_configs IDs to PLOT_FORMULAS keys
 PLOT_ID_TO_FORMULA_KEY_MAP = {
-    "posts_activity": "posts_activity", # Example, if you add it back to plot_configs
-    "mentions_activity": "mentions_activity", # Example, if you add it back
-    "mention_sentiment": "mention_sentiment", # Example, if you add it back
+    "posts_activity": "posts_activity", 
+    "mentions_activity": "mentions_activity", 
+    "mention_sentiment": "mention_sentiment", 
     "followers_count": "followers_count_over_time",
     "followers_growth_rate": "followers_growth_rate",
     "followers_by_location": "followers_by_demographics",
@@ -72,25 +72,20 @@ PLOT_ID_TO_FORMULA_KEY_MAP = {
     "post_frequency_cs": "post_frequency",
     "content_format_breakdown_cs": "content_format_breakdown",
     "content_topic_breakdown_cs": "content_topic_breakdown",
-    "mention_analysis_volume": "mentions_activity",
-    "mention_analysis_sentiment": "mention_sentiment"
+    "mention_analysis_volume": "mentions_activity", # Mapped to the general mentions_activity
+    "mention_analysis_sentiment": "mention_sentiment" # Mapped to the general mention_sentiment
 }
 
 
 # --- Analytics Tab: Plot Figure Generation Function ---
 def update_analytics_plots_figures(token_state_value, date_filter_option, custom_start_date, custom_end_date):
     logging.info(f"Updating analytics plot figures. Filter: {date_filter_option}, Custom Start: {custom_start_date}, Custom End: {custom_end_date}")
-    # This num_expected_plots should align with the number of gr.Plot components expected as output.
-    # The plot_configs list has 19 items.
-    # If generate_posts_activity_plot, generate_mentions_activity_plot, generate_mention_sentiment_plot
-    # are added back to the main list of plots directly, this number might change.
-    # For now, it seems the detailed mention plots are re-using figures.
-    num_expected_plots = 19 # Adjusted to match plot_configs length for clarity in this function's direct output list construction
+    num_expected_plots = 19 
 
     if not token_state_value or not token_state_value.get("token"):
-        message = "❌ Access denied. No token. Cannot generate analytics."
+        message = "❌ Accesso negato. Nessun token. Impossibile generare le analisi."
         logging.warning(message)
-        placeholder_figs = [create_placeholder_plot(title="Access Denied", message="No token.") for _ in range(num_expected_plots)]
+        placeholder_figs = [create_placeholder_plot(title="Accesso Negato", message="Nessun token.") for _ in range(num_expected_plots)]
         return [message] + placeholder_figs
 
     try:
@@ -103,31 +98,27 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
                 token_state_value, date_filter_option, custom_start_date, custom_end_date
             )
     except Exception as e:
-        error_msg = f"❌ Error preparing analytics data: {e}"
+        error_msg = f"❌ Errore durante la preparazione dei dati per le analisi: {e}"
         logging.error(error_msg, exc_info=True)
-        placeholder_figs = [create_placeholder_plot(title="Data Preparation Error", message=str(e)) for _ in range(num_expected_plots)]
+        placeholder_figs = [create_placeholder_plot(title="Errore Preparazione Dati", message=str(e)) for _ in range(num_expected_plots)]
         return [error_msg] + placeholder_figs
 
     date_column_posts = token_state_value.get("config_date_col_posts", "published_at")
     date_column_mentions = token_state_value.get("config_date_col_mentions", "date")
     media_type_col_name = token_state_value.get("config_media_type_col", "media_type")
-    eb_labels_col_name = token_state_value.get("config_eb_labels_col", "li_eb_label") # Corrected from li_eb_label to li_eb_labels if that's the actual key in formulas
+    eb_labels_col_name = token_state_value.get("config_eb_labels_col", "li_eb_labels")
 
     plot_figs = []
     try:
-        # These plots are generated once and potentially re-used if their IDs match later plot_configs
-        # However, the current plot_configs doesn't list these explicitly at the start,
-        # but "mention_analysis_volume" and "mention_analysis_sentiment" will use them.
         fig_mentions_activity_shared = generate_mentions_activity_plot(filtered_mentions_df, date_column=date_column_mentions)
         fig_mention_sentiment_shared = generate_mention_sentiment_plot(filtered_mentions_df)
 
-        # Order matters here, must match plot_configs
         plot_figs.append(generate_followers_count_over_time_plot(date_filtered_follower_stats_df, type_value='follower_gains_monthly'))
         plot_figs.append(generate_followers_growth_rate_plot(date_filtered_follower_stats_df, type_value='follower_gains_monthly'))
-        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_geo', plot_title="Followers by Location"))
-        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_function', plot_title="Followers by Role"))
-        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_industry', plot_title="Followers by Industry"))
-        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_seniority', plot_title="Followers by Seniority"))
+        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_geo', plot_title="Follower per Località"))
+        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_function', plot_title="Follower per Ruolo"))
+        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_industry', plot_title="Follower per Settore"))
+        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_seniority', plot_title="Follower per Anzianità"))
         plot_figs.append(generate_engagement_rate_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
         plot_figs.append(generate_reach_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
         plot_figs.append(generate_impressions_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
@@ -138,36 +129,34 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
         plot_figs.append(generate_comments_sentiment_breakdown_plot(filtered_merged_posts_df, sentiment_column='comment_sentiment'))
         plot_figs.append(generate_post_frequency_plot(filtered_merged_posts_df, date_column=date_column_posts))
         plot_figs.append(generate_content_format_breakdown_plot(filtered_merged_posts_df, format_col=media_type_col_name))
-        plot_figs.append(generate_content_topic_breakdown_plot(filtered_merged_posts_df, topics_col=eb_labels_col_name)) # Ensure eb_labels_col_name matches key in formulas if different from 'li_eb_labels'
-        plot_figs.append(fig_mentions_activity_shared) # For "mention_analysis_volume"
-        plot_figs.append(fig_mention_sentiment_shared) # For "mention_analysis_sentiment"
+        plot_figs.append(generate_content_topic_breakdown_plot(filtered_merged_posts_df, topics_col=eb_labels_col_name))
+        plot_figs.append(fig_mentions_activity_shared) 
+        plot_figs.append(fig_mention_sentiment_shared)
 
-        message = f"📊 Analytics updated for period: {date_filter_option}"
+        message = f"📊 Analisi aggiornate per il periodo: {date_filter_option}"
         if date_filter_option == "Custom Range":
-            s_display = start_dt_for_msg.strftime('%Y-%m-%d') if start_dt_for_msg else "Any"
-            e_display = end_dt_for_msg.strftime('%Y-%m-%d') if end_dt_for_msg else "Any"
-            message += f" (From: {s_display} To: {e_display})"
+            s_display = start_dt_for_msg.strftime('%Y-%m-%d') if start_dt_for_msg else "Qualsiasi"
+            e_display = end_dt_for_msg.strftime('%Y-%m-%d') if end_dt_for_msg else "Qualsiasi"
+            message += f" (Da: {s_display} A: {e_display})"
 
         final_plot_figs = []
         for i, p_fig in enumerate(plot_figs):
             if p_fig is not None and not isinstance(p_fig, str):
                 final_plot_figs.append(p_fig)
             else:
-                logging.warning(f"Plot figure generation failed or returned unexpected type for slot {i}, using placeholder. Figure: {p_fig}")
-                final_plot_figs.append(create_placeholder_plot(title="Plot Error", message="Failed to generate this plot figure."))
+                logging.warning(f"Generazione figura grafico fallita o tipo inatteso per slot {i}, uso placeholder. Figura: {p_fig}")
+                final_plot_figs.append(create_placeholder_plot(title="Errore Grafico", message="Impossibile generare questa figura."))
         
-        # Ensure the list has exactly num_expected_plots items.
-        # This padding should ideally not be needed if plot_figs is constructed correctly to match num_expected_plots.
         while len(final_plot_figs) < num_expected_plots:
-            logging.warning(f"Padding missing plot figure. Expected {num_expected_plots}, got {len(final_plot_figs)}.")
-            final_plot_figs.append(create_placeholder_plot(title="Missing Plot", message="Plot figure could not be generated."))
+            logging.warning(f"Aggiungo figura mancante. Previste {num_expected_plots}, ottenute {len(final_plot_figs)}.")
+            final_plot_figs.append(create_placeholder_plot(title="Grafico Mancante", message="Impossibile generare la figura del grafico."))
         
-        return [message] + final_plot_figs[:num_expected_plots] # Ensure correct number of plot figures are returned
+        return [message] + final_plot_figs[:num_expected_plots]
 
     except Exception as e:
-        error_msg = f"❌ Error generating analytics plot figures: {e}"
+        error_msg = f"❌ Errore durante la generazione delle figure dei grafici analitici: {e}"
         logging.error(error_msg, exc_info=True)
-        placeholder_figs = [create_placeholder_plot(title="Plot Generation Error", message=str(e)) for _ in range(num_expected_plots)]
+        placeholder_figs = [create_placeholder_plot(title="Errore Generazione Grafici", message=str(e)) for _ in range(num_expected_plots)]
         return [error_msg] + placeholder_figs
 
 
@@ -182,13 +171,13 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         "fetch_count_for_api": 0, "url_user_token_temp_storage": None,
         "config_date_col_posts": "published_at", "config_date_col_mentions": "date",
         "config_date_col_followers": "date", "config_media_type_col": "media_type",
-        "config_eb_labels_col": "li_eb_labels" # Ensure this matches the column name used in plot generator and formulas.py
+        "config_eb_labels_col": "li_eb_labels" 
     })
 
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
-    url_user_token_display = gr.Textbox(label="User Token (Hidden)", interactive=False, visible=False)
-    status_box = gr.Textbox(label="Overall LinkedIn Token Status", interactive=False, value="Initializing...")
-    org_urn_display = gr.Textbox(label="Organization URN (Hidden)", interactive=False, visible=False)
+    url_user_token_display = gr.Textbox(label="User Token (Nascosto)", interactive=False, visible=False)
+    status_box = gr.Textbox(label="Stato Generale Token LinkedIn", interactive=False, value="Inizializzazione...")
+    org_urn_display = gr.Textbox(label="URN Organizzazione (Nascosto)", interactive=False, visible=False)
 
     app.load(fn=get_url_user_token, inputs=None, outputs=[url_user_token_display, org_urn_display], api_name="get_url_params", show_progress=False)
 
@@ -199,10 +188,10 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
     with gr.Tabs() as tabs:
         with gr.TabItem("1️⃣ Dashboard & Sync", id="tab_dashboard_sync"):
-            gr.Markdown("System checks for existing data from Bubble. 'Sync' activates if new data is needed.")
-            sync_data_btn = gr.Button("🔄 Sync LinkedIn Data", variant="primary", visible=False, interactive=False)
-            sync_status_html_output = gr.HTML("<p style='text-align:center;'>Sync status...</p>")
-            dashboard_display_html = gr.HTML("<p style='text-align:center;'>Dashboard loading...</p>")
+            gr.Markdown("Il sistema controlla i dati esistenti da Bubble. 'Sincronizza' si attiva se sono necessari nuovi dati.")
+            sync_data_btn = gr.Button("🔄 Sincronizza Dati LinkedIn", variant="primary", visible=False, interactive=False)
+            sync_status_html_output = gr.HTML("<p style='text-align:center;'>Stato sincronizzazione...</p>")
+            dashboard_display_html = gr.HTML("<p style='text-align:center;'>Caricamento dashboard...</p>")
 
             org_urn_display.change(
                 fn=initial_load_sequence,
@@ -211,25 +200,25 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 show_progress="full"
             )
 
-        with gr.TabItem("2️⃣ Analytics", id="tab_analytics"):
-            gr.Markdown("## 📈 LinkedIn Performance Analytics")
-            gr.Markdown("Select a date range. Click buttons for actions.")
+        with gr.TabItem("2️⃣ Analisi", id="tab_analytics"):
+            gr.Markdown("## 📈 Analisi Performance LinkedIn")
+            gr.Markdown("Seleziona un intervallo di date. Clicca i pulsanti per le azioni.")
 
-            analytics_status_md = gr.Markdown("Analytics status...")
+            analytics_status_md = gr.Markdown("Stato analisi...")
 
             with gr.Row():
                 date_filter_selector = gr.Radio(
-                    ["All Time", "Last 7 Days", "Last 30 Days", "Custom Range"],
-                    label="Select Date Range", value="All Time", scale=3
+                    ["Sempre", "Ultimi 7 Giorni", "Ultimi 30 Giorni", "Intervallo Personalizzato"],
+                    label="Seleziona Intervallo Date", value="Sempre", scale=3
                 )
                 with gr.Column(scale=2):
-                    custom_start_date_picker = gr.DateTime(label="Start Date", visible=False, include_time=False, type="datetime")
-                    custom_end_date_picker = gr.DateTime(label="End Date", visible=False, include_time=False, type="datetime")
+                    custom_start_date_picker = gr.DateTime(label="Data Inizio", visible=False, include_time=False, type="datetime")
+                    custom_end_date_picker = gr.DateTime(label="Data Fine", visible=False, include_time=False, type="datetime")
 
-            apply_filter_btn = gr.Button("🔍 Apply Filter & Refresh Analytics", variant="primary")
+            apply_filter_btn = gr.Button("🔍 Applica Filtro & Aggiorna Analisi", variant="primary")
 
             def toggle_custom_date_pickers(selection):
-                is_custom = selection == "Custom Range"
+                is_custom = selection == "Intervallo Personalizzato"
                 return gr.update(visible=is_custom), gr.update(visible=is_custom)
 
             date_filter_selector.change(
@@ -239,27 +228,27 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
             plot_configs = [
-                {"label": "Followers Count Over Time", "id": "followers_count", "section": "Follower Dynamics"},
-                {"label": "Followers Growth Rate", "id": "followers_growth_rate", "section": "Follower Dynamics"},
-                {"label": "Followers by Location", "id": "followers_by_location", "section": "Follower Demographics"},
-                {"label": "Followers by Role (Function)", "id": "followers_by_role", "section": "Follower Demographics"},
-                {"label": "Followers by Industry", "id": "followers_by_industry", "section": "Follower Demographics"},
-                {"label": "Followers by Seniority", "id": "followers_by_seniority", "section": "Follower Demographics"},
-                {"label": "Engagement Rate Over Time", "id": "engagement_rate", "section": "Post Performance Insights"},
-                {"label": "Reach Over Time", "id": "reach_over_time", "section": "Post Performance Insights"},
-                {"label": "Impressions Over Time", "id": "impressions_over_time", "section": "Post Performance Insights"},
-                {"label": "Reactions (Likes) Over Time", "id": "likes_over_time", "section": "Post Performance Insights"},
-                {"label": "Clicks Over Time", "id": "clicks_over_time", "section": "Detailed Post Engagement Over Time"},
-                {"label": "Shares Over Time", "id": "shares_over_time", "section": "Detailed Post Engagement Over Time"},
-                {"label": "Comments Over Time", "id": "comments_over_time", "section": "Detailed Post Engagement Over Time"},
-                {"label": "Breakdown of Comments by Sentiment", "id": "comments_sentiment", "section": "Detailed Post Engagement Over Time"},
-                {"label": "Post Frequency", "id": "post_frequency_cs", "section": "Content Strategy Analysis"},
-                {"label": "Breakdown of Content by Format", "id": "content_format_breakdown_cs", "section": "Content Strategy Analysis"},
-                {"label": "Breakdown of Content by Topics", "id": "content_topic_breakdown_cs", "section": "Content Strategy Analysis"},
-                {"label": "Mentions Volume Over Time (Detailed)", "id": "mention_analysis_volume", "section": "Mention Analysis (Detailed)"},
-                {"label": "Breakdown of Mentions by Sentiment (Detailed)", "id": "mention_analysis_sentiment", "section": "Mention Analysis (Detailed)"}
+                {"label": "Numero di Follower nel Tempo", "id": "followers_count", "section": "Dinamiche dei Follower"},
+                {"label": "Tasso di Crescita Follower", "id": "followers_growth_rate", "section": "Dinamiche dei Follower"},
+                {"label": "Follower per Località", "id": "followers_by_location", "section": "Demografia Follower"},
+                {"label": "Follower per Ruolo (Funzione)", "id": "followers_by_role", "section": "Demografia Follower"},
+                {"label": "Follower per Settore", "id": "followers_by_industry", "section": "Demografia Follower"},
+                {"label": "Follower per Anzianità", "id": "followers_by_seniority", "section": "Demografia Follower"},
+                {"label": "Tasso di Engagement nel Tempo", "id": "engagement_rate", "section": "Approfondimenti Performance Post"},
+                {"label": "Copertura nel Tempo", "id": "reach_over_time", "section": "Approfondimenti Performance Post"},
+                {"label": "Visualizzazioni nel Tempo", "id": "impressions_over_time", "section": "Approfondimenti Performance Post"},
+                {"label": "Reazioni (Like) nel Tempo", "id": "likes_over_time", "section": "Approfondimenti Performance Post"},
+                {"label": "Click nel Tempo", "id": "clicks_over_time", "section": "Engagement Dettagliato Post nel Tempo"},
+                {"label": "Condivisioni nel Tempo", "id": "shares_over_time", "section": "Engagement Dettagliato Post nel Tempo"},
+                {"label": "Commenti nel Tempo", "id": "comments_over_time", "section": "Engagement Dettagliato Post nel Tempo"},
+                {"label": "Ripartizione Commenti per Sentiment", "id": "comments_sentiment", "section": "Engagement Dettagliato Post nel Tempo"},
+                {"label": "Frequenza Post", "id": "post_frequency_cs", "section": "Analisi Strategia Contenuti"},
+                {"label": "Ripartizione Contenuti per Formato", "id": "content_format_breakdown_cs", "section": "Analisi Strategia Contenuti"},
+                {"label": "Ripartizione Contenuti per Argomenti", "id": "content_topic_breakdown_cs", "section": "Analisi Strategia Contenuti"},
+                {"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)"}
             ]
-            assert len(plot_configs) == 19, "Mismatch in plot_configs and expected plots."
+            assert len(plot_configs) == 19, "Mancata corrispondenza in plot_configs e grafici attesi."
 
             active_panel_action_state = gr.State(None)
             explored_plot_id_state = gr.State(None)
@@ -271,19 +260,19 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     plot_ui_objects = build_analytics_tab_plot_area(plot_configs)
 
                 with gr.Column(scale=4, visible=False) as global_actions_column_ui:
-                    gr.Markdown("### 💡 Generated Content")
-                    global_actions_markdown_ui = gr.Markdown("Click a button (💣, ƒ) on a plot to see content here.")
+                    gr.Markdown("### 💡 Contenuto Generato")
+                    global_actions_markdown_ui = gr.Markdown("Clicca un pulsante (💣, ƒ) su un grafico per vedere il contenuto qui.")
 
             # --- Event Handler for Insights and Formula Buttons ---
             def handle_panel_action(plot_id_clicked, action_type, current_active_action_from_state, current_token_state_val):
-                logging.info(f"Action '{action_type}' for plot: {plot_id_clicked}. Current active from state: {current_active_action_from_state}")
+                logging.info(f"Azione '{action_type}' per grafico: {plot_id_clicked}. Attualmente attivo da stato: {current_active_action_from_state}")
 
                 if not plot_ui_objects or plot_id_clicked not in plot_ui_objects:
-                    logging.error(f"plot_ui_objects not populated or plot_id {plot_id_clicked} not found during handle_panel_action.")
-                    error_updates = [gr.update(visible=False), "Error: UI components not ready.", None] + [gr.update() for _ in range(2 * len(plot_configs))]
+                    logging.error(f"plot_ui_objects non popolato o plot_id {plot_id_clicked} non trovato durante handle_panel_action.")
+                    error_updates = [gr.update(visible=False), "Errore: Componenti UI non pronti.", None] + [gr.update() for _ in range(2 * len(plot_configs))]
                     return error_updates
 
-                clicked_plot_label = plot_ui_objects.get(plot_id_clicked, {}).get("label", "Selected Plot")
+                clicked_plot_label = plot_ui_objects.get(plot_id_clicked, {}).get("label", "Grafico Selezionato")
                 
                 hypothetical_new_active_state = {"plot_id": plot_id_clicked, "type": action_type}
                 is_toggling_off = current_active_action_from_state == hypothetical_new_active_state
@@ -294,28 +283,28 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
                 if is_toggling_off:
                     new_active_action_state_to_set = None
-                    content_text = f"{action_type.capitalize()} panel for '{clicked_plot_label}' closed."
+                    content_text = f"Pannello {action_type.capitalize()} per '{clicked_plot_label}' chiuso."
                     action_col_visible = False
-                    logging.info(f"Closing {action_type} panel for {plot_id_clicked}")
+                    logging.info(f"Chiusura pannello {action_type} per {plot_id_clicked}")
                 else:
                     new_active_action_state_to_set = hypothetical_new_active_state
                     action_col_visible = True
                     if action_type == "insights":
-                        # TODO: Implement actual insight generation
-                        content_text = f"**Insights for: {clicked_plot_label}**\n\nPlot ID: `{plot_id_clicked}`.\n(AI insights generation placeholder)"
+                        # TODO: Implementare generazione insight reali
+                        content_text = f"**Approfondimenti per: {clicked_plot_label}**\n\nID Grafico: `{plot_id_clicked}`.\n(Placeholder generazione insight AI)"
                     elif action_type == "formula":
                         formula_key = PLOT_ID_TO_FORMULA_KEY_MAP.get(plot_id_clicked)
                         if formula_key and formula_key in PLOT_FORMULAS:
                             formula_data = PLOT_FORMULAS[formula_key]
                             content_text = f"### {formula_data['title']}\n\n"
-                            content_text += f"**Description:**\n{formula_data['description']}\n\n"
-                            content_text += "**Calculation Steps:**\n"
+                            content_text += f"**Descrizione:**\n{formula_data['description']}\n\n"
+                            content_text += "**Come viene calcolato:**\n" # Titolo sezione in italiano
                             for step in formula_data['calculation_steps']:
-                                content_text += f"- {step}\n"
+                                content_text += f"{step}\n" # Rimosso il "-" per evitare doppio bullet point
                         else:
-                            content_text = f"**Formula/Methodology for: {clicked_plot_label}**\n\nPlot ID: `{plot_id_clicked}`.\n(No detailed formula information found for this plot ID in `formulas.py`)"
-                        logging.info(f"Displaying formula for {plot_id_clicked} (mapped to {formula_key})")
-                    logging.info(f"Opening/switching to {action_type} panel for {plot_id_clicked}")
+                            content_text = f"**Formula/Metodologia per: {clicked_plot_label}**\n\nID Grafico: `{plot_id_clicked}`.\n(Nessuna informazione dettagliata sulla formula trovata per questo ID grafico in `formulas.py`)"
+                        logging.info(f"Visualizzazione formula per {plot_id_clicked} (mappato a {formula_key})")
+                    logging.info(f"Apertura/passaggio a pannello {action_type} per {plot_id_clicked}")
 
                 all_button_updates = []
                 for cfg_item in plot_configs:
@@ -341,23 +330,22 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 
                 return final_updates
 
-            # --- Event Handler for Explore Button ---
             def handle_explore_click(plot_id_clicked, current_explored_plot_id_from_state):
-                logging.info(f"Explore clicked for: {plot_id_clicked}. Currently explored from state: {current_explored_plot_id_from_state}")
+                logging.info(f"Click su Esplora per: {plot_id_clicked}. Attualmente esplorato da stato: {current_explored_plot_id_from_state}")
 
                 if not plot_ui_objects:
-                    logging.error("plot_ui_objects not populated during handle_explore_click.")
-                    return [current_explored_plot_id_from_state] + [gr.update() for _ in range(2 * len(plot_configs))] # 2 updates per plot_config (panel, explore_button)
+                    logging.error("plot_ui_objects non popolato durante handle_explore_click.")
+                    return [current_explored_plot_id_from_state] + [gr.update() for _ in range(2 * len(plot_configs))] 
 
                 new_explored_id_to_set = None
                 is_toggling_off = (plot_id_clicked == current_explored_plot_id_from_state)
 
                 if is_toggling_off:
                     new_explored_id_to_set = None
-                    logging.info(f"Un-exploring plot: {plot_id_clicked}")
+                    logging.info(f"Interruzione esplorazione grafico: {plot_id_clicked}")
                 else:
                     new_explored_id_to_set = plot_id_clicked
-                    logging.info(f"Exploring plot: {plot_id_clicked}")
+                    logging.info(f"Esplorazione grafico: {plot_id_clicked}")
                 
                 panel_and_button_updates = []
                 for cfg in plot_configs:
@@ -425,33 +413,30 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                         api_name=f"action_explore_{plot_id}"
                     )
                 else:
-                    logging.warning(f"UI object for plot_id '{plot_id}' not found when trying to attach click handlers.")
+                    logging.warning(f"Oggetto UI per plot_id '{plot_id}' non trovato durante il tentativo di associare i gestori di click.")
 
             def refresh_all_analytics_ui_elements(current_token_state, date_filter_val, custom_start_val, custom_end_val):
-                logging.info("Refreshing all analytics UI elements and resetting actions.")
-                # The number of plots expected by update_analytics_plots_figures should match plot_configs length
-                # For this example, it's 19.
+                logging.info("Aggiornamento di tutti gli elementi UI delle analisi e reset delle azioni.")
                 plot_generation_results = update_analytics_plots_figures(
                     current_token_state, date_filter_val, custom_start_val, custom_end_val
                 )
 
                 status_message_update = plot_generation_results[0]
-                generated_plot_figures = plot_generation_results[1:] # Should be list of 19 figures
+                generated_plot_figures = plot_generation_results[1:] 
 
                 all_updates = [status_message_update]
 
-                # Updates for plot components (19 of them)
-                for i in range(len(plot_configs)): # Iterate 19 times
+                for i in range(len(plot_configs)): 
                     if i < len(generated_plot_figures):
                         all_updates.append(generated_plot_figures[i])
                     else:
-                        all_updates.append(create_placeholder_plot("Figure Error", f"Missing figure for plot {plot_configs[i]['id']}"))
+                        all_updates.append(create_placeholder_plot("Errore Figura", f"Figura mancante per grafico {plot_configs[i]['id']}"))
                 
                 all_updates.append(gr.update(visible=False))
-                all_updates.append(gr.update(value="Click a button (💣, ƒ) on a plot..."))
+                all_updates.append(gr.update(value="Clicca un pulsante (💣, ƒ) su un grafico..."))
                 all_updates.append(None)
 
-                for cfg in plot_configs: # 19 plots
+                for cfg in plot_configs: 
                     pid = cfg["id"]
                     if pid in plot_ui_objects:
                         all_updates.append(gr.update(value=BOMB_ICON))
@@ -462,12 +447,12 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                         all_updates.extend([None, None, None, None])
                 
                 all_updates.append(None)
-                logging.info(f"Prepared {len(all_updates)} updates for analytics refresh.")
+                logging.info(f"Preparati {len(all_updates)} aggiornamenti per il refresh delle analisi.")
                 return all_updates
 
             apply_filter_and_sync_outputs_list = [analytics_status_md]
             
-            for config_item_filter_sync in plot_configs: # 19 plots
+            for config_item_filter_sync in plot_configs: 
                 pid_filter_sync = config_item_filter_sync["id"]
                 if pid_filter_sync in plot_ui_objects and "plot_component" in plot_ui_objects[pid_filter_sync]:
                     apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync]["plot_component"])
@@ -480,7 +465,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 active_panel_action_state
             ])
             
-            for cfg_filter_sync_btns in plot_configs: # 19 plots
+            for cfg_filter_sync_btns in plot_configs: 
                 pid_filter_sync_btns = cfg_filter_sync_btns["id"]
                 if pid_filter_sync_btns in plot_ui_objects:
                     apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["bomb_button"])
@@ -492,7 +477,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
             apply_filter_and_sync_outputs_list.append(explored_plot_id_state)
             
-            logging.info(f"Total outputs for apply_filter/sync: {len(apply_filter_and_sync_outputs_list)}") # Expected: 1 + 19 + 3 + (19*4) + 1 = 1 + 19 + 3 + 76 + 1 = 100
+            logging.info(f"Output totali per apply_filter/sync: {len(apply_filter_and_sync_outputs_list)}")
 
             apply_filter_btn.click(
                 fn=refresh_all_analytics_ui_elements,
@@ -501,24 +486,24 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 show_progress="full"
             )
 
-        with gr.TabItem("3️⃣ Mentions", id="tab_mentions"):
-            refresh_mentions_display_btn = gr.Button("🔄 Refresh Mentions Display", variant="secondary")
-            mentions_html = gr.HTML("Mentions data...")
-            mentions_sentiment_dist_plot = gr.Plot(label="Mention Sentiment Distribution")
+        with gr.TabItem("3️⃣ Menzioni", id="tab_mentions"):
+            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")
             refresh_mentions_display_btn.click(
                 fn=run_mentions_tab_display, inputs=[token_state],
                 outputs=[mentions_html, mentions_sentiment_dist_plot],
                 show_progress="full"
             )
 
-        with gr.TabItem("4️⃣ Follower Stats", id="tab_follower_stats"):
-            refresh_follower_stats_btn = gr.Button("🔄 Refresh Follower Stats Display", variant="secondary")
-            follower_stats_html = gr.HTML("Follower statistics...")
+        with gr.TabItem("4️⃣ Statistiche Follower", id="tab_follower_stats"):
+            refresh_follower_stats_btn = gr.Button("🔄 Aggiorna Visualizzazione Statistiche Follower", variant="secondary")
+            follower_stats_html = gr.HTML("Statistiche follower...")
             with gr.Row():
-                fs_plot_monthly_gains = gr.Plot(label="Monthly Follower Gains")
+                fs_plot_monthly_gains = gr.Plot(label="Guadagni Mensili Follower")
             with gr.Row():
-                fs_plot_seniority = gr.Plot(label="Followers by Seniority (Top 10 Organic)")
-                fs_plot_industry = gr.Plot(label="Followers by Industry (Top 10 Organic)")
+                fs_plot_seniority = gr.Plot(label="Follower per Anzianità (Top 10 Organici)")
+                fs_plot_industry = gr.Plot(label="Follower per Settore (Top 10 Organici)")
 
             refresh_follower_stats_btn.click(
                 fn=run_follower_stats_tab_display, inputs=[token_state],
@@ -547,16 +532,16 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
 if __name__ == "__main__":
     if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR):
-        logging.warning(f"WARNING: '{LINKEDIN_CLIENT_ID_ENV_VAR}' env var not set.")
+        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("WARNING: Bubble env vars not fully set.")
+        logging.warning("ATTENZIONE: Variabili d'ambiente Bubble non completamente impostate.")
 
     try:
-        logging.info(f"Matplotlib version: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
+        logging.info(f"Versione Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
     except ImportError:
-        logging.error("Matplotlib is not installed. Plots will not be generated.")
+        logging.error("Matplotlib non è installato. I grafici non verranno generati.")
 
     app.launch(server_name="0.0.0.0", server_port=7860, debug=True)