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,
+    generate_posts_activity_plot, # Make sure this is available if posts_activity is in map
     generate_mentions_activity_plot, generate_mention_sentiment_plot,
     generate_followers_count_over_time_plot,
     generate_followers_growth_rate_plot,
@@ -45,14 +45,47 @@ from analytics_plot_generator import (
     generate_content_format_breakdown_plot,
     generate_content_topic_breakdown_plot
 )
+from formulas import PLOT_FORMULAS # Import the formula descriptions
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)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
+    "followers_count": "followers_count_over_time",
+    "followers_growth_rate": "followers_growth_rate",
+    "followers_by_location": "followers_by_demographics",
+    "followers_by_role": "followers_by_demographics",
+    "followers_by_industry": "followers_by_demographics",
+    "followers_by_seniority": "followers_by_demographics",
+    "engagement_rate": "engagement_rate_over_time",
+    "reach_over_time": "reach_over_time",
+    "impressions_over_time": "impressions_over_time",
+    "likes_over_time": "likes_over_time",
+    "clicks_over_time": "clicks_over_time",
+    "shares_over_time": "shares_over_time",
+    "comments_over_time": "comments_over_time",
+    "comments_sentiment": "comments_sentiment_breakdown",
+    "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"
+}
+
+
 # --- 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 = 23 # This should match len(plot_configs)
+    # 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
 
     if not token_state_value or not token_state_value.get("token"):
         message = "❌ Access denied. No token. Cannot generate analytics."
@@ -61,8 +94,6 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
         return [message] + placeholder_figs
 
     try:
-        # Optional: Start profiling data preparation
-        # data_prep_start_time = time.time()
         (filtered_merged_posts_df,
          filtered_mentions_df,
          date_filtered_follower_stats_df,
@@ -71,7 +102,6 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
             prepare_filtered_analytics_data(
                 token_state_value, date_filter_option, custom_start_date, custom_end_date
             )
-        # logging.info(f"Data preparation took {time.time() - data_prep_start_time:.2f}s")
     except Exception as e:
         error_msg = f"❌ Error preparing analytics data: {e}"
         logging.error(error_msg, exc_info=True)
@@ -81,26 +111,17 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
     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")
+    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
 
     plot_figs = []
-    # Optional: For detailed profiling of each plot
-    # individual_plot_times = {}
-    # total_plot_gen_start_time = time.time()
     try:
-        # Example for profiling one plot:
-        # plot_name = "posts_activity"
-        # plot_start_time = time.time()
-        #plot_figs.append(generate_posts_activity_plot(filtered_merged_posts_df, date_column=date_column_posts))
-        # individual_plot_times[plot_name] = time.time() - plot_start_time
-        # logging.info(f"Generated {plot_name} in {individual_plot_times[plot_name]:.2f}s")
-
-        # plot_figs.append(generate_engagement_type_plot(filtered_merged_posts_df))
+        # 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)
-        # plot_figs.append(fig_mentions_activity_shared)
-        
-        # plot_figs.append(fig_mention_sentiment_shared)
+
+        # 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"))
@@ -108,7 +129,7 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
         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_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)) # Assuming this is intended, though label says "Clicks"
+        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))
         plot_figs.append(generate_clicks_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
@@ -117,12 +138,9 @@ 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))
-        plot_figs.append(fig_mentions_activity_shared) # Re-adding shared plot for "Mention Analysis (Detailed)"
-        plot_figs.append(fig_mention_sentiment_shared) # Re-adding shared plot for "Mention Analysis (Detailed)"
-
-        # logging.info(f"All plots generated in {time.time() - total_plot_gen_start_time:.2f}s")
-        # logging.info(f"Individual plot generation times: {individual_plot_times}")
+        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"
 
         message = f"📊 Analytics updated for period: {date_filter_option}"
         if date_filter_option == "Custom Range":
@@ -132,17 +150,19 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
 
         final_plot_figs = []
         for i, p_fig in enumerate(plot_figs):
-            if p_fig is not None and not isinstance(p_fig, str): # Check if it's a Matplotlib figure
+            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."))
-
+        
+        # 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."))
-
-        return [message] + final_plot_figs[:num_expected_plots]
+        
+        return [message] + final_plot_figs[:num_expected_plots] # Ensure correct number of plot figures are returned
 
     except Exception as e:
         error_msg = f"❌ Error generating analytics plot figures: {e}"
@@ -162,7 +182,7 @@ 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_label"
+        "config_eb_labels_col": "li_eb_labels" # Ensure this matches the column name used in plot generator and formulas.py
     })
 
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
@@ -203,8 +223,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     label="Select Date Range", value="All Time", scale=3
                 )
                 with gr.Column(scale=2):
-                    custom_start_date_picker = gr.DateTime(label="Start Date", visible=False, include_time=False, type="datetime") # type="date" might be better if time not used
-                    custom_end_date_picker = gr.DateTime(label="End Date", visible=False, include_time=False, type="datetime") # type="date"
+                    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")
 
             apply_filter_btn = gr.Button("🔍 Apply Filter & Refresh Analytics", variant="primary")
 
@@ -219,10 +239,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
             plot_configs = [
-                # {"label": "Posts Activity Over Time", "id": "posts_activity", "section": "Posts & Engagement Overview"},
-                # {"label": "Post Engagement Types", "id": "engagement_type", "section": "Posts & Engagement Overview"},
-                # {"label": "Mentions Activity Over Time", "id": "mentions_activity", "section": "Mentions Overview"},
-                # {"label": "Mention Sentiment Distribution", "id": "mention_sentiment", "section": "Mentions Overview"},
                 {"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"},
@@ -230,7 +246,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 {"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"}, # Corrected label based on function
+                {"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"},
@@ -245,35 +261,28 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             ]
             assert len(plot_configs) == 19, "Mismatch in plot_configs and expected plots."
 
-            active_panel_action_state = gr.State(None) # Stores {"plot_id": "action_type"} e.g. {"posts_activity": "insights"} or None
-            explored_plot_id_state = gr.State(None) # Stores plot_id of the currently explored plot, or None
+            active_panel_action_state = gr.State(None)
+            explored_plot_id_state = gr.State(None)
 
-            plot_ui_objects = {} # Will be populated by build_analytics_tab_plot_area
+            plot_ui_objects = {}
 
             with gr.Row(equal_height=False):
                 with gr.Column(scale=8) as plots_area_col:
-                    # Call the UI builder function and store its results
                     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.")
 
-
             # --- 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}")
 
-                # This check is crucial: plot_ui_objects must be populated before this handler is effectively used.
-                # It should be, as this handler is tied to buttons created by build_analytics_tab_plot_area.
                 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.")
-                    # Return updates that don't crash, perhaps just an error message or no-ops.
-                    # Number of outputs for this handler: 3 (global_col_vis, global_md_val, active_state_val) + 2 * len(plot_configs) (buttons)
                     error_updates = [gr.update(visible=False), "Error: UI components not ready.", 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")
                 
                 hypothetical_new_active_state = {"plot_id": plot_id_clicked, "type": action_type}
@@ -284,44 +293,50 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 action_col_visible = False
 
                 if is_toggling_off:
-                    new_active_action_state_to_set = None # Closing the panel
+                    new_active_action_state_to_set = None
                     content_text = f"{action_type.capitalize()} panel for '{clicked_plot_label}' closed."
                     action_col_visible = False
                     logging.info(f"Closing {action_type} panel for {plot_id_clicked}")
-                else: # Activating or switching
+                else:
                     new_active_action_state_to_set = hypothetical_new_active_state
                     action_col_visible = True
                     if action_type == "insights":
-                        # TODO: Implement actual insight generation using current_token_state_val if needed
+                        # TODO: Implement actual insight generation
                         content_text = f"**Insights for: {clicked_plot_label}**\n\nPlot ID: `{plot_id_clicked}`.\n(AI insights generation placeholder)"
                     elif action_type == "formula":
-                        # TODO: Implement actual formula display
-                        content_text = f"**Formula/Methodology for: {clicked_plot_label}**\n\nPlot ID: `{plot_id_clicked}`.\n(Methodology details placeholder)"
+                        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"
+                            for step in formula_data['calculation_steps']:
+                                content_text += f"- {step}\n"
+                        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}")
 
-                # Prepare updates for ALL buttons based on new_active_action_state_to_set
                 all_button_updates = []
                 for cfg_item in plot_configs:
                     p_id_iter = cfg_item["id"]
                     if p_id_iter in plot_ui_objects:
-                        # Bomb button state for this p_id_iter
                         if new_active_action_state_to_set == {"plot_id": p_id_iter, "type": "insights"}:
                             all_button_updates.append(gr.update(value=ACTIVE_ICON))
                         else:
                             all_button_updates.append(gr.update(value=BOMB_ICON))
 
-                        # Formula button state for this p_id_iter
                         if new_active_action_state_to_set == {"plot_id": p_id_iter, "type": "formula"}:
                             all_button_updates.append(gr.update(value=ACTIVE_ICON))
                         else:
                             all_button_updates.append(gr.update(value=FORMULA_ICON))
-                    else: # Should not happen if plot_ui_objects is complete
-                        all_button_updates.extend([gr.update(), gr.update()]) 
+                    else:
+                        all_button_updates.extend([gr.update(), gr.update()])
                 
                 final_updates = [
                     gr.update(visible=action_col_visible),
                     gr.update(value=content_text),
-                    new_active_action_state_to_set # This is the new value for active_panel_action_state
+                    new_active_action_state_to_set
                 ] + all_button_updates
                 
                 return final_updates
@@ -330,83 +345,65 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             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}")
 
-                if not plot_ui_objects: # Safeguard
+                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))]
-
+                    return [current_explored_plot_id_from_state] + [gr.update() for _ in range(2 * len(plot_configs))] # 2 updates per plot_config (panel, explore_button)
 
                 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 # Un-exploring
+                    new_explored_id_to_set = None
                     logging.info(f"Un-exploring plot: {plot_id_clicked}")
                 else:
-                    new_explored_id_to_set = plot_id_clicked # Exploring this plot
+                    new_explored_id_to_set = plot_id_clicked
                     logging.info(f"Exploring plot: {plot_id_clicked}")
                 
-                # Prepare updates for panel visibility and explore button icons
                 panel_and_button_updates = []
                 for cfg in plot_configs:
                     p_id = cfg["id"]
                     if p_id in plot_ui_objects:
                         panel_visible = not new_explored_id_to_set or (p_id == new_explored_id_to_set)
+                        panel_and_button_updates.append(gr.update(visible=panel_visible))
                         
-                        # Special handling for paired plots in the same section when one is explored
-                        # This logic might need refinement based on how build_analytics_tab_plot_area structures rows
-                        # For now, the basic logic is: if new_explored_id_to_set is active, only that panel is visible.
-                        # If new_explored_id_to_set is None, all panels are visible.
-
-                        panel_and_button_updates.append(gr.update(visible=panel_visible)) # Panel visibility update
-                        
-                        # Explore button icon update
-                        if p_id == new_explored_id_to_set: # If this plot is the one being explored (or just became explored)
+                        if p_id == new_explored_id_to_set:
                             panel_and_button_updates.append(gr.update(value=ACTIVE_ICON))
-                        else: # All other plots, or if un-exploring
+                        else:
                             panel_and_button_updates.append(gr.update(value=EXPLORE_ICON))
-                    else: # Should not happen
+                    else:
                         panel_and_button_updates.extend([gr.update(), gr.update()])
                 
                 final_updates = [new_explored_id_to_set] + panel_and_button_updates
                 return final_updates
 
-            # --- Define outputs for event handlers ---
-            # These lists define which Gradio components will receive updates from the handlers.
-            # The order and number of components must match the list of updates returned by the handler.
-
-            # Outputs for handle_panel_action (Insights/Formula buttons)
             action_buttons_outputs_list = [
                 global_actions_column_ui,
                 global_actions_markdown_ui,
-                active_panel_action_state # The gr.State object itself
+                active_panel_action_state
             ]
-            for cfg_item_action in plot_configs: # Iterate in defined order
+            for cfg_item_action in plot_configs:
                 pid_action = cfg_item_action["id"]
                 if pid_action in plot_ui_objects:
                     action_buttons_outputs_list.append(plot_ui_objects[pid_action]["bomb_button"])
                     action_buttons_outputs_list.append(plot_ui_objects[pid_action]["formula_button"])
-                else: # Should not happen if plot_ui_objects is correctly populated
-                    action_buttons_outputs_list.extend([None, None]) # Add placeholders to maintain length
+                else:
+                    action_buttons_outputs_list.extend([None, None])
 
-            # Outputs for handle_explore_click
-            explore_buttons_outputs_list = [explored_plot_id_state] # The gr.State object
-            for cfg_item_explore in plot_configs: # Iterate in defined order
+            explore_buttons_outputs_list = [explored_plot_id_state]
+            for cfg_item_explore in plot_configs:
                 pid_explore = cfg_item_explore["id"]
                 if pid_explore in plot_ui_objects:
-                    explore_buttons_outputs_list.append(plot_ui_objects[pid_explore]["panel_component"]) # For visibility
-                    explore_buttons_outputs_list.append(plot_ui_objects[pid_explore]["explore_button"])   # For icon
-                else: # Should not happen
+                    explore_buttons_outputs_list.append(plot_ui_objects[pid_explore]["panel_component"])
+                    explore_buttons_outputs_list.append(plot_ui_objects[pid_explore]["explore_button"])
+                else:
                     explore_buttons_outputs_list.extend([None, None])
 
-
-            # --- Connect Action Buttons ---
-            # Inputs for the click handlers that need current state values
             action_click_inputs = [active_panel_action_state, token_state]
-            explore_click_inputs = [explored_plot_id_state] # Only needs explored_plot_id_state
+            explore_click_inputs = [explored_plot_id_state]
 
             for config_item in plot_configs:
                 plot_id = config_item["id"]
-                if plot_id in plot_ui_objects: # Ensure component exists
+                if plot_id in plot_ui_objects:
                     ui_obj = plot_ui_objects[plot_id]
 
                     ui_obj["bomb_button"].click(
@@ -428,99 +425,89 @@ 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. This might lead to issues.")
+                    logging.warning(f"UI object for plot_id '{plot_id}' not found when trying to attach click handlers.")
 
-
-            # --- Function to Refresh All Analytics UI ---
             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.
                 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 23 figures or placeholders
+                generated_plot_figures = plot_generation_results[1:] # Should be list of 19 figures
 
-                all_updates = [status_message_update] # For analytics_status_md
+                all_updates = [status_message_update]
 
-                # Updates for plot components
-                for i in range(len(plot_configs)):
+                # Updates for plot components (19 of them)
+                for i in range(len(plot_configs)): # Iterate 19 times
                     if i < len(generated_plot_figures):
                         all_updates.append(generated_plot_figures[i])
-                    else: # Should not happen if update_analytics_plots_figures pads correctly
-                        all_updates.append(create_placeholder_plot("Figure Error", f"Missing figure for plot {i}"))
+                    else:
+                        all_updates.append(create_placeholder_plot("Figure Error", f"Missing figure for plot {plot_configs[i]['id']}"))
                 
-                # Updates for global action column and its content, and active_panel_action_state
-                all_updates.append(gr.update(visible=False))  # global_actions_column_ui
-                all_updates.append(gr.update(value="Click a button (💣, ƒ) on a plot...")) # global_actions_markdown_ui
-                all_updates.append(None)  # Reset active_panel_action_state
+                all_updates.append(gr.update(visible=False))
+                all_updates.append(gr.update(value="Click a button (💣, ƒ) on a plot..."))
+                all_updates.append(None)
 
-                # Updates for all action buttons (bomb, formula), explore buttons, and panel visibility
-                for cfg in plot_configs:
+                for cfg in plot_configs: # 19 plots
                     pid = cfg["id"]
                     if pid in plot_ui_objects:
-                        all_updates.append(gr.update(value=BOMB_ICON))    # Reset bomb_button
-                        all_updates.append(gr.update(value=FORMULA_ICON)) # Reset formula_button
-                        all_updates.append(gr.update(value=EXPLORE_ICON)) # Reset explore_button
-                        all_updates.append(gr.update(visible=True))       # Reset panel_component visibility (all visible initially)
-                    else: # Should not happen
+                        all_updates.append(gr.update(value=BOMB_ICON))
+                        all_updates.append(gr.update(value=FORMULA_ICON))
+                        all_updates.append(gr.update(value=EXPLORE_ICON))
+                        all_updates.append(gr.update(visible=True))
+                    else:
                         all_updates.extend([None, None, None, None])
                 
-                all_updates.append(None)  # Reset explored_plot_id_state
-
+                all_updates.append(None)
                 logging.info(f"Prepared {len(all_updates)} updates for analytics refresh.")
                 return all_updates
 
-            # --- Define outputs for the apply_filter_btn and sync.then() ---
-            # This list must exactly match the structure of updates returned by refresh_all_analytics_ui_elements
-            apply_filter_and_sync_outputs_list = [analytics_status_md] # 1. Status MD
+            apply_filter_and_sync_outputs_list = [analytics_status_md]
             
-            # 2. Plot components (23 of them)
-            for config_item_filter_sync in plot_configs:
+            for config_item_filter_sync in plot_configs: # 19 plots
                 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"])
-                else: # Should not happen
-                    apply_filter_and_sync_outputs_list.append(None) 
+                else:
+                    apply_filter_and_sync_outputs_list.append(None)
             
-            # 3. Global action column, its markdown, and its state (3 items)
             apply_filter_and_sync_outputs_list.extend([
                 global_actions_column_ui,
                 global_actions_markdown_ui,
-                active_panel_action_state # The State object itself
+                active_panel_action_state
             ])
             
-            # 4. Action buttons (bomb, formula), explore buttons, and panel visibility for each plot (23 * 4 = 92 items)
-            for cfg_filter_sync_btns in plot_configs:
+            for cfg_filter_sync_btns in plot_configs: # 19 plots
                 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"])
                     apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["formula_button"])
                     apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["explore_button"])
-                    apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["panel_component"]) # For panel visibility
-                else: # Should not happen
+                    apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["panel_component"])
+                else:
                     apply_filter_and_sync_outputs_list.extend([None, None, None, None])
 
-            # 5. Explored plot ID state (1 item)
-            apply_filter_and_sync_outputs_list.append(explored_plot_id_state) # The State object itself
+            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)}")
-
+            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
 
             apply_filter_btn.click(
                 fn=refresh_all_analytics_ui_elements,
                 inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker],
-                outputs=apply_filter_and_sync_outputs_list, # Use the carefully constructed list
+                outputs=apply_filter_and_sync_outputs_list,
                 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") # This is a gr.Plot component
+            mentions_sentiment_dist_plot = gr.Plot(label="Mention Sentiment Distribution")
             refresh_mentions_display_btn.click(
                 fn=run_mentions_tab_display, inputs=[token_state],
-                outputs=[mentions_html, mentions_sentiment_dist_plot], # run_mentions_tab_display returns (html_str, fig_object)
+                outputs=[mentions_html, mentions_sentiment_dist_plot],
                 show_progress="full"
             )
 
@@ -544,18 +531,18 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         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, # This fn returns (status_msg, new_state, btn_update)
+        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 # btn_update is for sync_data_btn
+        outputs=[status_box, token_state, sync_data_btn], show_progress=False
     )
     sync_event_part3 = sync_event_part2.then(
-        fn=display_main_dashboard, # This fn returns html_string
+        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, # This fn returns a list of updates
+        fn=refresh_all_analytics_ui_elements,
         inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker],
-        outputs=apply_filter_and_sync_outputs_list, show_progress="full" # Use the carefully constructed list
+        outputs=apply_filter_and_sync_outputs_list, show_progress="full"
     )
 
 if __name__ == "__main__":
@@ -572,3 +559,4 @@ if __name__ == "__main__":
         logging.error("Matplotlib is not installed. Plots will not be generated.")
 
     app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+