Update app.py

app.py

@@ -22,7 +22,7 @@ from ui_generators import (
     build_analytics_tab_plot_area, 
     BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON 
 )
-from analytics_data_processing import prepare_filtered_analytics_data
+from analytics_data_processing import prepare_filtered_analytics_data # This is key for data structure
 from analytics_plot_generator import (
     generate_posts_activity_plot, 
     generate_mentions_activity_plot, generate_mention_sentiment_plot,
@@ -81,17 +81,19 @@ PLOT_ID_TO_FORMULA_KEY_MAP = {
 # --- 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}")
-    num_expected_plots = 19 
+    num_expected_plots = 19 # Ensure this matches the number of plots generated
+    
     if not token_state_value or not token_state_value.get("token"):
         message = "❌ Accesso negato. Nessun token. Impossibile generare le analisi."
         logging.warning(message)
         placeholder_figs = [create_placeholder_plot(title="Accesso Negato", message="Nessun token.") for _ in range(num_expected_plots)]
         return [message] + placeholder_figs
     try:
+        # This call is crucial. The structure of these DataFrames determines if plots work.
         (filtered_merged_posts_df, 
          filtered_mentions_df, 
-         date_filtered_follower_stats_df, 
-         raw_follower_stats_df, 
+         date_filtered_follower_stats_df, # For time-based follower plots
+         raw_follower_stats_df,         # For demographic follower plots
          start_dt_for_msg, end_dt_for_msg) = \
             prepare_filtered_analytics_data(
                 token_state_value, date_filter_option, custom_start_date, custom_end_date
@@ -107,82 +109,94 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
     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")
     
-    plot_figs = []
+    plot_figs = [] # Initialize list to hold plot figures
+    
+    # Titles for error reporting, matching the order in plot_configs
+    plot_titles_for_errors = [p_cfg["label"] for p_cfg in plot_configs] 
+
     try:
-        # Define plot functions and their arguments
-        # Order matters and must match plot_configs
-        plot_definitions = [
-            {"func": generate_followers_count_over_time_plot, "args": [date_filtered_follower_stats_df, 'follower_gains_monthly'], "is_demographic": False},
-            {"func": generate_followers_growth_rate_plot, "args": [date_filtered_follower_stats_df, 'follower_gains_monthly'], "is_demographic": False},
-            {"func": generate_followers_by_demographics_plot, "args": [raw_follower_stats_df, 'follower_geo', "Follower per Località"], "type_value_key": "follower_geo", "is_demographic": True},
-            {"func": generate_followers_by_demographics_plot, "args": [raw_follower_stats_df, 'follower_function', "Follower per Ruolo"], "type_value_key": "follower_function", "is_demographic": True},
-            {"func": generate_followers_by_demographics_plot, "args": [raw_follower_stats_df, 'follower_industry', "Follower per Settore"], "type_value_key": "follower_industry", "is_demographic": True},
-            {"func": generate_followers_by_demographics_plot, "args": [raw_follower_stats_df, 'follower_seniority', "Follower per Anzianità"], "type_value_key": "follower_seniority", "is_demographic": True},
-            {"func": generate_engagement_rate_over_time_plot, "args": [filtered_merged_posts_df, date_column_posts], "is_demographic": False},
-            {"func": generate_reach_over_time_plot, "args": [filtered_merged_posts_df, date_column_posts], "is_demographic": False},
-            {"func": generate_impressions_over_time_plot, "args": [filtered_merged_posts_df, date_column_posts], "is_demographic": False},
-            {"func": generate_likes_over_time_plot, "args": [filtered_merged_posts_df, date_column_posts], "is_demographic": False},
-            {"func": generate_clicks_over_time_plot, "args": [filtered_merged_posts_df, date_column_posts], "is_demographic": False},
-            {"func": generate_shares_over_time_plot, "args": [filtered_merged_posts_df, date_column_posts], "is_demographic": False},
-            {"func": generate_comments_over_time_plot, "args": [filtered_merged_posts_df, date_column_posts], "is_demographic": False},
-            {"func": generate_comments_sentiment_breakdown_plot, "args": [filtered_merged_posts_df, 'comment_sentiment'], "is_demographic": False},
-            {"func": generate_post_frequency_plot, "args": [filtered_merged_posts_df, date_column_posts], "is_demographic": False},
-            {"func": generate_content_format_breakdown_plot, "args": [filtered_merged_posts_df, media_type_col_name], "is_demographic": False},
-            {"func": generate_content_topic_breakdown_plot, "args": [filtered_merged_posts_df, eb_labels_col_name], "is_demographic": False},
-            {"func": generate_mentions_activity_plot, "args": [filtered_mentions_df, date_column_mentions], "is_demographic": False},
-            {"func": generate_mention_sentiment_plot, "args": [filtered_mentions_df], "is_demographic": False}
-        ]
-
-        for i, plot_def in enumerate(plot_definitions):
-            plot_fn = plot_def["func"]
-            args = plot_def["args"]
-            plot_title_for_error = args[2] if plot_def["is_demographic"] else plot_fn.__name__
-            try:
-                # Specific check for demographic plots if raw_follower_stats_df is empty or missing key columns
-                if plot_def["is_demographic"]:
-                    df_arg = args[0] # raw_follower_stats_df
-                    type_val_col = plot_def["type_value_key"]
-                    if df_arg is None or df_arg.empty:
-                        logging.warning(f"raw_follower_stats_df is empty. Cannot generate demographic plot: {plot_title_for_error}")
-                        raise ValueError(f"Dati demografici mancanti (raw_follower_stats_df vuoto).")
-                    if type_val_col not in df_arg.columns:
-                        logging.warning(f"Colonna '{type_val_col}' mancante in raw_follower_stats_df per il grafico '{plot_title_for_error}'. Colonne disponibili: {df_arg.columns.tolist()}")
-                        raise KeyError(f"Colonna dati '{type_val_col}' non trovata.")
-                
-                fig = plot_fn(*args)
-                plot_figs.append(fig)
-            except (KeyError, ValueError) as plot_e: # Catch KeyError for missing columns, ValueError for other data issues
-                logging.error(f"Errore generazione grafico '{plot_title_for_error}' (slot {i}): {plot_e}", exc_info=False) # Set exc_info to False for cleaner logs for known data issues
-                plot_figs.append(create_placeholder_plot(title=f"Errore Dati: {plot_title_for_error}", message=f"Impossibile generare: {str(plot_e)}"))
-            except Exception as plot_e: # Catch other unexpected errors
-                logging.error(f"Errore imprevisto generazione grafico '{plot_title_for_error}' (slot {i}): {plot_e}", exc_info=True)
-                plot_figs.append(create_placeholder_plot(title=f"Errore Grafico: {plot_title_for_error}", message=f"Dettaglio: {str(plot_e)[:100]}"))
+        # Attempt to generate plots. If DataFrames are not as expected by generator functions,
+        # KeyErrors for missing columns or other ValueErrors might occur.
+        # The order of appends MUST match the order in plot_configs for UI updates.
 
+        # Dinamiche dei Follower (2 plots)
+        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'))
+        
+        # Demografia Follower (4 plots)
+        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à"))
+
+        # Approfondimenti Performance Post (4 plots)
+        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))
+        plot_figs.append(generate_likes_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
+        
+        # Engagement Dettagliato Post nel Tempo (4 plots)
+        plot_figs.append(generate_clicks_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
+        plot_figs.append(generate_shares_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
+        plot_figs.append(generate_comments_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
+        plot_figs.append(generate_comments_sentiment_breakdown_plot(filtered_merged_posts_df, sentiment_column='comment_sentiment'))
+        
+        # Analisi Strategia Contenuti (3 plots)
+        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))
+        
+        # Analisi Menzioni (Dettaglio) (2 plots) - These might use pre-generated figs if logic was complex
+        # For simplicity here, assuming direct calls. If they were shared, that logic would be here.
+        plot_figs.append(generate_mentions_activity_plot(filtered_mentions_df, date_column=date_column_mentions))
+        plot_figs.append(generate_mention_sentiment_plot(filtered_mentions_df))
+
+        if len(plot_figs) != num_expected_plots:
+            logging.warning(f"Mismatch in generated plots. Expected {num_expected_plots}, got {len(plot_figs)}. This will cause UI update issues.")
+            # Fill with placeholders if not enough plots were generated due to an early exit or logic error
+            while len(plot_figs) < num_expected_plots:
+                plot_figs.append(create_placeholder_plot(title="Grafico Non Generato", message="Logica di generazione incompleta."))
+        
         message = f"📊 Analisi aggiornate per il periodo: {date_filter_option}"
         if date_filter_option == "Intervallo Personalizzato": 
             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})"
         
+        # Ensure all plot_figs are actual plot objects, not None or error strings
         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)
+        for i, p_fig_candidate in enumerate(plot_figs):
+            if p_fig_candidate is not None and not isinstance(p_fig_candidate, str): # Basic check for a plot object
+                final_plot_figs.append(p_fig_candidate)
             else:
-                logging.warning(f"Plot generation failed or unexpected type for slot {i}, using placeholder. Figure: {p_fig}")
-                final_plot_figs.append(create_placeholder_plot(title="Errore Grafico", message="Impossibile generare questa figura."))
+                err_title = plot_titles_for_errors[i] if i < len(plot_titles_for_errors) else f"Grafico {i+1}"
+                logging.warning(f"Plot {err_title} (index {i}) non è una figura valida: {p_fig_candidate}. Uso placeholder.")
+                final_plot_figs.append(create_placeholder_plot(title=f"Errore: {err_title}", message="Impossibile generare figura."))
         
-        while len(final_plot_figs) < num_expected_plots:
-            logging.warning(f"Adding missing plot placeholder. Expected {num_expected_plots}, got {len(final_plot_figs)}.")
-            final_plot_figs.append(create_placeholder_plot(title="Grafico Mancante", message="Figura non generata."))
-            
-        return [message] + final_plot_figs[:num_expected_plots]
+        return [message] + final_plot_figs[:num_expected_plots] # Slice to ensure correct number
+
+    except (KeyError, ValueError) as e_plot_data:
+        # This catches errors if a specific plot function fails due to missing columns or bad data
+        logging.error(f"Errore dati durante la generazione di un grafico specifico: {e_plot_data}", exc_info=True)
+        # We don't know which plot failed, so fill all with placeholders after this point
+        # Or, more robustly, identify which plot failed and insert placeholder there.
+        # For now, this will likely result in fewer than num_expected_plots if it happens mid-way.
+        # The loop below will fill remaining with placeholders.
+        error_msg_display = f"Errore dati in un grafico: {str(e_plot_data)[:100]}"
+        
+        # Fill remaining plot_figs with placeholders
+        num_already_generated = len(plot_figs)
+        for i in range(num_already_generated, num_expected_plots):
+            err_title_fill = plot_titles_for_errors[i] if i < len(plot_titles_for_errors) else f"Grafico {i+1}"
+            plot_figs.append(create_placeholder_plot(title=f"Errore Dati: {err_title_fill}", message=f"Precedente errore: {str(e_plot_data)[:50]}"))
+        
+        return [error_msg_display] + plot_figs[:num_expected_plots]
 
-    except Exception as e:
-        error_msg = f"❌ Errore durante la generazione delle figure dei grafici analitici: {e}"
+    except Exception as e_general:
+        error_msg = f"❌ Errore generale durante la generazione dei grafici: {e_general}"
         logging.error(error_msg, exc_info=True)
-        placeholder_figs = [create_placeholder_plot(title="Errore Generazione Grafici", message=str(e)) for _ in range(num_expected_plots)]
-        return [error_msg] + placeholder_figs
+        placeholder_figs_general = [create_placeholder_plot(title=plot_titles_for_errors[i] if i < len(plot_titles_for_errors) else f"Grafico {i+1}", message=str(e_general)) for i in range(num_expected_plots)]
+        return [error_msg] + placeholder_figs_general
 
 
 # --- Gradio UI Blocks ---
@@ -540,29 +554,31 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             ]
             explore_click_inputs = [explored_plot_id_state]
 
-            # --- Define async wrapper functions for click handlers ---
-            async def insights_click_wrapper(current_active_val, current_chats_val, current_chat_pid, p_id):
-                return await handle_panel_action(p_id, "insights", current_active_val, current_chats_val, current_chat_pid)
-
-            async def formula_click_wrapper(current_active_val, current_chats_val, current_chat_pid, p_id):
-                return await handle_panel_action(p_id, "formula", current_active_val, current_chats_val, current_chat_pid)
-            # --- End async wrapper functions ---
+            # --- Define "creator" functions for async click handlers ---
+            def create_panel_action_handler(p_id, action_type_str):
+                # This inner function is what Gradio will call. It's async.
+                async def _handler(current_active_val, current_chats_val, current_chat_pid):
+                    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)
+                    logging.debug(f"_handler for plot_id: {p_id}, action: {action_type_str} completed.")
+                    return result
+                return _handler # Return the async handler function itself
+            # --- End "creator" functions ---
 
             for config_item in plot_configs:
                 plot_id = config_item["id"]
-                # plot_label = config_item["label"] # Not needed here anymore
                 if plot_id in plot_ui_objects:
                     ui_obj = plot_ui_objects[plot_id]
                     
-                    # Use a standard lambda to call the async wrapper, capturing p_id
+                    # The 'fn' passed to .click() is the async function returned by the creator
                     ui_obj["bomb_button"].click(
-                        fn=lambda cav, ccv, ccpid, p=plot_id: insights_click_wrapper(cav, ccv, ccpid, p),
+                        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=lambda cav, ccv, ccpid, p=plot_id: formula_click_wrapper(cav, ccv, ccpid, p),
+                        fn=create_panel_action_handler(plot_id, "formula"), 
                         inputs=action_click_inputs,
                         outputs=action_panel_outputs_list,
                         api_name=f"action_formula_{plot_id}"
@@ -645,7 +661,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 
                 all_updates.append(None) 
                 
-                logging.info(f"Preparati {len(all_updates)} aggiornamenti per il refresh completo delle analisi.")
+                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] 
@@ -747,6 +763,6 @@ if __name__ == "__main__":
     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.")
+        logging.warning("Matplotlib non trovato direttamente, ma potrebbe essere usato dai generatori di grafici.") # Changed from error to warning
         
     app.launch(server_name="0.0.0.0", server_port=7860, debug=True)