Update app.py

app.py

@@ -5,6 +5,7 @@ import logging
 import matplotlib
 matplotlib.use('Agg') # Set backend for Matplotlib to avoid GUI conflicts with Gradio
 import matplotlib.pyplot as plt
+import time # For profiling if needed
 
 # --- Module Imports ---
 from gradio_utils import get_url_user_token
@@ -34,7 +35,7 @@ from analytics_plot_generator import (
     generate_engagement_rate_over_time_plot,
     generate_reach_over_time_plot,
     generate_impressions_over_time_plot,
-    create_placeholder_plot, 
+    create_placeholder_plot,
     generate_likes_over_time_plot,
     generate_clicks_over_time_plot,
     generate_shares_over_time_plot,
@@ -51,7 +52,7 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 # --- 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 
+    num_expected_plots = 23 # This should match len(plot_configs)
 
     if not token_state_value or not token_state_value.get("token"):
         message = "❌ Access denied. No token. Cannot generate analytics."
@@ -60,6 +61,8 @@ 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,
@@ -68,6 +71,7 @@ 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)
@@ -80,8 +84,17 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
     eb_labels_col_name = token_state_value.get("config_eb_labels_col", "eb_labels")
 
     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))
         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)
@@ -94,7 +107,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))
+        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_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))
@@ -104,27 +117,30 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
         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) 
-        plot_figs.append(fig_mention_sentiment_shared)
+        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}")
 
         message = f"📊 Analytics updated for period: {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})"
-        
+
         final_plot_figs = []
         for i, p_fig in enumerate(plot_figs):
-            if p_fig is not None and not isinstance(p_fig, str): 
+            if p_fig is not None and not isinstance(p_fig, str): # Check if it's a Matplotlib figure
                 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."))
-        
+
         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]
 
     except Exception as e:
@@ -173,22 +189,22 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 outputs=[status_box, token_state, sync_data_btn, dashboard_display_html],
                 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.")
-            
+
             analytics_status_md = gr.Markdown("Analytics status...")
 
-            with gr.Row(): 
+            with gr.Row():
                 date_filter_selector = gr.Radio(
                     ["All Time", "Last 7 Days", "Last 30 Days", "Custom Range"],
                     label="Select Date Range", value="Last 30 Days", 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="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"
+
             apply_filter_btn = gr.Button("🔍 Apply Filter & Refresh Analytics", variant="primary")
 
             def toggle_custom_date_pickers(selection):
@@ -204,8 +220,8 @@ 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": "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"},
@@ -213,7 +229,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 (Clicks)", "id": "reach_over_time", "section": "Post Performance Insights"},
+                {"label": "Reach Over Time", "id": "reach_over_time", "section": "Post Performance Insights"}, # Corrected label based on function
                 {"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"},
@@ -223,218 +239,196 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 {"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": "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)"}
             ]
             assert len(plot_configs) == 23, "Mismatch in plot_configs and expected plots."
 
-            # --- State for Analytics Tab interactivity ---
-            # Stores {"plot_id": "action_type"} e.g. {"posts_activity": "insights"} or None
-            active_panel_action_state = gr.State(None) 
-            # Stores plot_id of the currently explored plot, or None
-            explored_plot_id_state = gr.State(None) 
+            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
+
+            plot_ui_objects = {} # Will be populated by build_analytics_tab_plot_area
 
-            with gr.Row(equal_height=False): 
-                with gr.Column(scale=8) as plots_area_col: 
+            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: # Renamed for clarity
-                    gr.Markdown("### 💡 Generated Content") # More generic title
+
+                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, token_state_val):
-                logging.info(f"Action '{action_type}' for plot: {plot_id_clicked}. Current active: {current_active_action}")
-                
+            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")
                 
-                # Determine new state for the action panel
-                new_active_action_state = {"plot_id": plot_id_clicked, "type": action_type}
-                is_toggling_off = current_active_action == new_active_action_state
+                hypothetical_new_active_state = {"plot_id": plot_id_clicked, "type": action_type}
+                is_toggling_off = current_active_action_from_state == hypothetical_new_active_state
                 
+                new_active_action_state_to_set = None
                 content_text = ""
                 action_col_visible = False
-                
-                # Button icon updates - prepare a list of gr.update for all buttons
-                button_updates = {} # Dict to hold updates for gr.Button objects
 
                 if is_toggling_off:
-                    new_active_action_state = None
-                    content_text = f"{action_type.capitalize()} for {clicked_plot_label} hidden."
+                    new_active_action_state_to_set = None # Closing the panel
+                    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}")
-                    # Reset the clicked button to its original icon
-                    if action_type == "insights":
-                        button_updates[plot_ui_objects[plot_id_clicked]["bomb_button"]] = gr.update(value=BOMB_ICON)
-                    elif action_type == "formula":
-                        button_updates[plot_ui_objects[plot_id_clicked]["formula_button"]] = gr.update(value=FORMULA_ICON)
                 else: # Activating or switching
+                    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}`.\nDetailed AI insights here."
-                        button_updates[plot_ui_objects[plot_id_clicked]["bomb_button"]] = gr.update(value=ACTIVE_ICON)
+                        # TODO: Implement actual insight generation using current_token_state_val if needed
+                        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}`.\nMethodology details here."
-                        button_updates[plot_ui_objects[plot_id_clicked]["formula_button"]] = gr.update(value=ACTIVE_ICON)
-                    
-                    logging.info(f"Opening {action_type} panel for {plot_id_clicked}")
-
-                # Reset other action buttons for the *same* plot if a new action is chosen for it
-                # And reset all buttons if switching plots or toggling off
-                for pid, ui_obj in plot_ui_objects.items():
-                    is_current_plot_active_bomb = new_active_action_state == {"plot_id": pid, "type": "insights"}
-                    is_current_plot_active_formula = new_active_action_state == {"plot_id": pid, "type": "formula"}
-
-                    if ui_obj["bomb_button"] not in button_updates: # Avoid overwriting the primary clicked button's update
-                        button_updates[ui_obj["bomb_button"]] = gr.update(value=BOMB_ICON if not is_current_plot_active_bomb else ACTIVE_ICON)
-                    if ui_obj["formula_button"] not in button_updates:
-                        button_updates[ui_obj["formula_button"]] = gr.update(value=FORMULA_ICON if not is_current_plot_active_formula else ACTIVE_ICON)
+                        content_text = f"**Formula/Methodology for: {clicked_plot_label}**\n\nPlot ID: `{plot_id_clicked}`.\n(Methodology details placeholder)"
+                    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()]) 
                 
-                # Construct the list of updates for Gradio
-                # Order: global_actions_column_ui, global_actions_markdown_ui, active_panel_action_state, then all button updates
                 final_updates = [
-                    gr.update(visible=action_col_visible), 
-                    gr.update(value=content_text), 
-                    new_active_action_state
-                ]
-                # Add button updates in a consistent order (e.g., order of plot_configs)
-                for cfg in plot_configs:
-                    p_id = cfg["id"]
-                    if p_id in plot_ui_objects: # Check if plot_id exists in UI objects
-                        if plot_ui_objects[p_id]["bomb_button"] in button_updates:
-                            final_updates.append(button_updates[plot_ui_objects[p_id]["bomb_button"]])
-                        else: 
-                            final_updates.append(gr.update(value=BOMB_ICON))
-                        
-                        if plot_ui_objects[p_id]["formula_button"] in button_updates:
-                            final_updates.append(button_updates[plot_ui_objects[p_id]["formula_button"]])
-                        else: 
-                            final_updates.append(gr.update(value=FORMULA_ICON))
-                    else: # Should not happen if plot_ui_objects is complete
-                        final_updates.extend([gr.update(), gr.update()]) # Add empty updates to maintain length
+                    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
+                ] + all_button_updates
                 
                 return final_updates
 
             # --- Event Handler for Explore Button ---
-            def handle_explore_click(plot_id_clicked, current_explored_plot_id):
-                logging.info(f"Explore clicked for: {plot_id_clicked}. Currently explored: {current_explored_plot_id}")
-                
-                panel_visibility_updates = {} 
-                button_icon_updates = {}    
-                new_explored_id = None
+            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
+                    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))]
 
-                is_toggling_off = (plot_id_clicked == current_explored_plot_id)
+
+                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 = None
-                    button_icon_updates[plot_ui_objects[plot_id_clicked]["explore_button"]] = gr.update(value=EXPLORE_ICON)
+                    new_explored_id_to_set = None # Un-exploring
                     logging.info(f"Un-exploring plot: {plot_id_clicked}")
                 else:
-                    new_explored_id = plot_id_clicked
-                    button_icon_updates[plot_ui_objects[plot_id_clicked]["explore_button"]] = gr.update(value=ACTIVE_ICON)
-                    if current_explored_plot_id and current_explored_plot_id != plot_id_clicked:
-                        button_icon_updates[plot_ui_objects[current_explored_plot_id]["explore_button"]] = gr.update(value=EXPLORE_ICON)
+                    new_explored_id_to_set = plot_id_clicked # Exploring this plot
                     logging.info(f"Exploring plot: {plot_id_clicked}")
                 
-                for i in range(0, len(plot_configs), 2):
-                    config1_id = plot_configs[i]["id"]
-                    if config1_id not in plot_ui_objects: continue # Skip if panel doesn't exist
-                    panel1 = plot_ui_objects[config1_id]["panel_component"]
-                    
-                    show_panel1 = not new_explored_id or (config1_id == new_explored_id)
-                    panel_visibility_updates[panel1] = gr.update(visible=show_panel1)
-
-                    if i + 1 < len(plot_configs):
-                        config2_id = plot_configs[i+1]["id"]
-                        if config2_id not in plot_ui_objects: continue # Skip if panel doesn't exist
-
-                        if plot_configs[i+1]["section"] == plot_configs[i]["section"]:
-                            panel2 = plot_ui_objects[config2_id]["panel_component"]
-                            show_panel2 = not new_explored_id or (config2_id == new_explored_id)
-                            
-                            if new_explored_id: # If a plot is being explored
-                                if config1_id == new_explored_id: show_panel2 = False # Hide sibling if first is explored
-                                elif config2_id == new_explored_id: show_panel1 = False # Hide sibling if second is explored
-                            
-                            panel_visibility_updates[panel1] = gr.update(visible=show_panel1) # Re-update panel1 if changed
-                            panel_visibility_updates[panel2] = gr.update(visible=show_panel2)
-
-                final_updates = [new_explored_id]
+                # 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 = plot_ui_objects[p_id]["panel_component"]
-                        final_updates.append(panel_visibility_updates.get(panel, gr.update(visible=not new_explored_id or (p_id == new_explored_id) ))) 
+                        panel_visible = not new_explored_id_to_set or (p_id == new_explored_id_to_set)
+                        
+                        # 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_btn = plot_ui_objects[p_id]["explore_button"]
-                        final_updates.append(button_icon_updates.get(explore_btn, gr.update(value=EXPLORE_ICON if p_id != new_explored_id else ACTIVE_ICON)))
+                        # Explore button icon update
+                        if p_id == new_explored_id_to_set: # If this plot is the one being explored (or just became explored)
+                            panel_and_button_updates.append(gr.update(value=ACTIVE_ICON))
+                        else: # All other plots, or if un-exploring
+                            panel_and_button_updates.append(gr.update(value=EXPLORE_ICON))
                     else: # Should not happen
-                        final_updates.extend([gr.update(), gr.update()])
+                        panel_and_button_updates.extend([gr.update(), gr.update()])
                 
+                final_updates = [new_explored_id_to_set] + panel_and_button_updates
                 return final_updates
 
-            # --- Connect Action Buttons ---
-            action_buttons_outputs = [
-                global_actions_column_ui, 
-                global_actions_markdown_ui, 
-                active_panel_action_state
+            # --- 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
             ]
-            for cfg in plot_configs:
-                pid = cfg["id"]
-                if pid in plot_ui_objects: # Important check
-                    action_buttons_outputs.append(plot_ui_objects[pid]["bomb_button"])
-                    action_buttons_outputs.append(plot_ui_objects[pid]["formula_button"])
-                else: # Maintain list length if a plot_ui_object is unexpectedly missing
-                    action_buttons_outputs.extend([None, None]) # This could cause issues if None is not handled by Gradio outputs
-
-            explore_buttons_outputs = [explored_plot_id_state]
-            for cfg in plot_configs:
-                pid = cfg["id"]
-                if pid in plot_ui_objects: # Important check
-                    explore_buttons_outputs.append(plot_ui_objects[pid]["panel_component"])
-                    explore_buttons_outputs.append(plot_ui_objects[pid]["explore_button"])
-                else: # Maintain list length
-                    explore_buttons_outputs.extend([None, None])
+            for cfg_item_action in plot_configs: # Iterate in defined order
+                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
+
+            # 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
+                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.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
+
             for config_item in plot_configs:
                 plot_id = config_item["id"]
-                if plot_id in plot_ui_objects: # Ensure component exists before trying to attach event
+                if plot_id in plot_ui_objects: # Ensure component exists
                     ui_obj = plot_ui_objects[plot_id]
-                    
-                    current_action_outputs = [
-                        global_actions_column_ui, 
-                        global_actions_markdown_ui, 
-                        active_panel_action_state
-                    ] + [plot_ui_objects[c["id"]]["bomb_button"] for c in plot_configs if c["id"] in plot_ui_objects] \
-                      + [plot_ui_objects[c["id"]]["formula_button"] for c in plot_configs if c["id"] in plot_ui_objects]
-
-                    current_explore_outputs = [explored_plot_id_state] \
-                                            + [plot_ui_objects[c["id"]]["panel_component"] for c in plot_configs if c["id"] in plot_ui_objects] \
-                                            + [plot_ui_objects[c["id"]]["explore_button"] for c in plot_configs if c["id"] in plot_ui_objects]
-
 
                     ui_obj["bomb_button"].click(
-                        fn=lambda p_id=plot_id: handle_panel_action(p_id, "insights", active_panel_action_state.value, token_state.value), 
-                        inputs=None, 
-                        outputs=current_action_outputs, # Use dynamically scoped list
+                        fn=lambda current_active_val, current_token_val, p_id=plot_id: handle_panel_action(p_id, "insights", current_active_val, current_token_val),
+                        inputs=action_click_inputs,
+                        outputs=action_buttons_outputs_list,
                         api_name=f"action_insights_{plot_id}"
                     )
                     ui_obj["formula_button"].click(
-                        fn=lambda p_id=plot_id: handle_panel_action(p_id, "formula", active_panel_action_state.value, token_state.value),
-                        inputs=None,
-                        outputs=current_action_outputs, # Use dynamically scoped list
+                        fn=lambda current_active_val, current_token_val, p_id=plot_id: handle_panel_action(p_id, "formula", current_active_val, current_token_val),
+                        inputs=action_click_inputs,
+                        outputs=action_buttons_outputs_list,
                         api_name=f"action_formula_{plot_id}"
                     )
                     ui_obj["explore_button"].click(
-                        fn=lambda p_id=plot_id: handle_explore_click(p_id, explored_plot_id_state.value),
-                        inputs=None,
-                        outputs=current_explore_outputs, # Use dynamically scoped list
+                        fn=lambda current_explored_val, p_id=plot_id: handle_explore_click(p_id, current_explored_val),
+                        inputs=explore_click_inputs,
+                        outputs=explore_buttons_outputs_list,
                         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.")
+
 
             # --- Function to Refresh All Analytics UI ---
             def refresh_all_analytics_ui_elements(current_token_state, date_filter_val, custom_start_val, custom_end_val):
@@ -442,88 +436,90 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 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:]
 
-                all_updates = [status_message_update] 
+                status_message_update = plot_generation_results[0]
+                generated_plot_figures = plot_generation_results[1:] # Should be list of 23 figures or placeholders
 
-                for i, config in enumerate(plot_configs):
-                    p_id_key = config["id"]
-                    if p_id_key in plot_ui_objects:
-                        if i < len(generated_plot_figures):
-                            all_updates.append(generated_plot_figures[i])
-                        else:
-                            all_updates.append(create_placeholder_plot("Figure Error", f"No figure for {p_id_key}"))
-                    else:
-                         all_updates.append(None) 
+                all_updates = [status_message_update] # For analytics_status_md
 
-                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 plot components
+                for i in range(len(plot_configs)):
+                    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}"))
                 
+                # 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
+
+                # Updates for all action buttons (bomb, formula), explore buttons, and panel visibility
                 for cfg in plot_configs:
                     pid = cfg["id"]
                     if pid in plot_ui_objects:
-                        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) 
+                        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.extend([None, None, None, None])
                 
+                all_updates.append(None)  # Reset explored_plot_id_state
+
                 logging.info(f"Prepared {len(all_updates)} updates for analytics refresh.")
                 return all_updates
 
             # --- Define outputs for the apply_filter_btn and sync.then() ---
-            apply_filter_and_sync_outputs = [analytics_status_md]
-            for config in plot_configs: 
-                pid = config["id"]
-                if pid in plot_ui_objects and "plot_component" in plot_ui_objects[pid]:
-                    apply_filter_and_sync_outputs.append(plot_ui_objects[pid]["plot_component"])
-                else:
-                    apply_filter_and_sync_outputs.append(None) # Must add placeholder if component might be missing
+            # 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.extend([ 
-                global_actions_column_ui, 
-                global_actions_markdown_ui, 
-                active_panel_action_state
+            # 2. Plot components (23 of them)
+            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"])
+                else: # Should not happen
+                    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
             ])
             
-            for cfg in plot_configs:
-                pid = cfg["id"]
-                if pid in plot_ui_objects:
-                    apply_filter_and_sync_outputs.append(plot_ui_objects[pid]["bomb_button"])
-                    apply_filter_and_sync_outputs.append(plot_ui_objects[pid]["formula_button"])
-                    apply_filter_and_sync_outputs.append(plot_ui_objects[pid]["explore_button"])
-                    apply_filter_and_sync_outputs.append(plot_ui_objects[pid]["panel_component"])
-                else:
-                    # This case indicates a mismatch and will likely cause errors if not handled.
-                    # Forcing list length for now, but root cause would be plot_ui_objects incompleteness.
-                    apply_filter_and_sync_outputs.extend([None, None, None, None])
-
-
-            apply_filter_and_sync_outputs.append(explored_plot_id_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:
+                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.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
             
-            logging.info(f"Total outputs for apply_filter/sync: {len(apply_filter_and_sync_outputs)}")
+            logging.info(f"Total outputs for apply_filter/sync: {len(apply_filter_and_sync_outputs_list)}")
+
 
             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,
+                outputs=apply_filter_and_sync_outputs_list, # Use the carefully constructed 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")
+            mentions_sentiment_dist_plot = gr.Plot(label="Mention Sentiment Distribution") # This is a gr.Plot component
             refresh_mentions_display_btn.click(
                 fn=run_mentions_tab_display, inputs=[token_state],
-                outputs=[mentions_html, mentions_sentiment_dist_plot],
+                outputs=[mentions_html, mentions_sentiment_dist_plot], # run_mentions_tab_display returns (html_str, fig_object)
                 show_progress="full"
             )
 
@@ -541,24 +537,24 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 outputs=[follower_stats_html, fs_plot_monthly_gains, fs_plot_seniority, fs_plot_industry],
                 show_progress="full"
             )
-    
+
     sync_event_part1 = sync_data_btn.click(
         fn=sync_all_linkedin_data_orchestrator,
         inputs=[token_state], outputs=[sync_status_html_output, token_state], show_progress="full"
     )
     sync_event_part2 = sync_event_part1.then(
-        fn=process_and_store_bubble_token,
-        inputs=[url_user_token_display, org_urn_display, token_state], 
-        outputs=[status_box, token_state, sync_data_btn], show_progress=False
+        fn=process_and_store_bubble_token, # This fn returns (status_msg, new_state, btn_update)
+        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
     )
     sync_event_part3 = sync_event_part2.then(
-        fn=display_main_dashboard,
+        fn=display_main_dashboard, # This fn returns html_string
         inputs=[token_state], outputs=[dashboard_display_html], show_progress=False
     )
     sync_event_final = sync_event_part3.then(
-        fn=refresh_all_analytics_ui_elements,
-        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker], 
-        outputs=apply_filter_and_sync_outputs, show_progress="full"
+        fn=refresh_all_analytics_ui_elements, # This fn returns a list of updates
+        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
     )
 
 if __name__ == "__main__":
@@ -575,4 +571,3 @@ 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)
-