Update app.py

app.py

@@ -20,7 +20,8 @@ from ui_generators import (
     display_main_dashboard,
     run_mentions_tab_display,
     run_follower_stats_tab_display,
-    build_analytics_tab_plot_area # Import the updated UI builder
+    build_analytics_tab_plot_area, # Import the updated UI builder
+    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON # Import icons
 )
 # Corrected import for analytics_data_processing
 from analytics_data_processing import prepare_filtered_analytics_data
@@ -114,7 +115,7 @@ 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}")
@@ -175,11 +176,11 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             
         with gr.TabItem("2️⃣ Analytics", id="tab_analytics"):
             gr.Markdown("## 📈 LinkedIn Performance Analytics")
-            gr.Markdown("Select a date range. Click 💣 for insights.")
+            gr.Markdown("Select a date range. Click buttons for actions.")
             
             analytics_status_md = gr.Markdown("Analytics status...")
 
-            with gr.Row(): # Filters 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
@@ -200,7 +201,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 outputs=[custom_start_date_picker, custom_end_date_picker]
             )
 
-            # --- Define plot configurations (Order must match figure generation) ---
             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"},
@@ -228,65 +228,219 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             ]
             assert len(plot_configs) == 23, "Mismatch in plot_configs and expected plots."
 
-            # --- Main layout for Analytics Tab: Plots Area and Global Insights Column ---
-            with gr.Row(equal_height=False): # Main row for plots area and insights column
-                with gr.Column(scale=8): # Column to hold all plot rows and section headers
-                    # Build the plot area (section headers and rows of plot panels)
-                    # This function is defined in ui_generators.py
-                    # It will create gr.Markdown for sections and gr.Row for plot pairs
+            # --- 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) 
+
+            with gr.Row(equal_height=False): 
+                with gr.Column(scale=8) as plots_area_col: 
                     plot_ui_objects = build_analytics_tab_plot_area(plot_configs)
                 
-                # Global Insights Column (initially hidden)
-                with gr.Column(scale=4, visible=False) as global_insights_column_ui:
-                    gr.Markdown("### 💡 Generated Insights")
-                    global_insights_markdown_ui = gr.Markdown("Click 💣 on a plot to see insights here.")
+                with gr.Column(scale=4, visible=False) as global_actions_column_ui: # Renamed for clarity
+                    gr.Markdown("### 💡 Generated Content") # More generic title
+                    global_actions_markdown_ui = gr.Markdown("Click a button (💣, ƒ) on a plot to see content here.")
 
-            active_insight_plot_id_state = gr.State(None) 
 
-            # --- Bomb Button Click Handler ---
-            def handle_bomb_click(plot_id_clicked, current_active_plot_id, token_state_val): # Added token_state_val
-                logging.info(f"Bomb clicked for: {plot_id_clicked}. Currently active: {current_active_plot_id}")
+            # --- 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}")
                 
-                # Retrieve the label for the clicked plot
-                clicked_plot_label = "Selected Plot" # Default
-                if plot_id_clicked and plot_id_clicked in plot_ui_objects:
-                    clicked_plot_label = plot_ui_objects[plot_id_clicked]["label"]
-
-                if plot_id_clicked == current_active_plot_id: # Toggle off
-                    new_active_id = None
-                    insight_text_update = f"Insights for {clicked_plot_label} hidden. Click 💣 to show."
-                    insights_col_visible = False
-                    logging.info(f"Closing insights for {plot_id_clicked}")
-                else: # Activate new one or switch
-                    new_active_id = plot_id_clicked
-                    # TODO: Implement actual insight generation logic here using plot_id_clicked and token_state_val
-                    insight_text_update = f"**Insights for: {clicked_plot_label}**\n\n"
-                    insight_text_update += f"Plot ID: `{plot_id_clicked}`.\n"
-                    insight_text_update += "This is where detailed, AI-generated insights for this specific chart would appear, based on its data and trends.\n"
-                    insight_text_update += "For instance, if this were 'Post Engagement Types', we might analyze which type is dominant and suggest content strategies."
-                    insights_col_visible = True
-                    logging.info(f"Opening insights for {plot_id_clicked}")
+                clicked_plot_label = plot_ui_objects.get(plot_id_clicked, {}).get("label", "Selected Plot")
                 
-                return gr.update(visible=insights_col_visible), gr.update(value=insight_text_update), new_active_id
-
-            # --- Connect Bomb Buttons ---
-            # Outputs for each bomb click: global insights column visibility, its markdown content, and the state
-            bomb_click_outputs = [global_insights_column_ui, global_insights_markdown_ui, active_insight_plot_id_state]
-
-            for config in plot_configs:
-                plot_id = config["id"]
-                if plot_id in plot_ui_objects: # Ensure the UI object was created
-                    components_dict = plot_ui_objects[plot_id]
-                    components_dict["bomb_button"].click(
-                        fn=handle_bomb_click,
-                        inputs=[gr.State(value=plot_id), active_insight_plot_id_state, token_state], # Pass token_state
-                        outputs=bomb_click_outputs,
-                        api_name=f"show_insights_{plot_id}" 
-                    )
+                # 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
+                
+                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."
+                    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
+                    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)
+                    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)
+                
+                # 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:
+                        # Append updates for bomb, explore, formula buttons for this plot_id
+                        # Ensure explore button is handled by its own handler or reset here if needed
+                        if plot_ui_objects[p_id]["bomb_button"] in button_updates:
+                            final_updates.append(button_updates[plot_ui_objects[p_id]["bomb_button"]])
+                        else: # Default reset if not specifically handled
+                            final_updates.append(gr.update(value=BOMB_ICON))
+                        
+                        # Explore button is handled separately, but ensure it's in the output list
+                        # For now, we'll let its own handler manage its state, or reset it if another action occurs.
+                        # This part needs careful thought for interactions between explore and other actions.
+                        # Let's assume for now that activating insights/formula doesn't auto-close explore.
+                        # We will need to add explore_button to the output list.
+                        # For now, this handler focuses on insights/formula buttons.
+                        # We'll need to expand the output list.
+
+                        if plot_ui_objects[p_id]["formula_button"] in button_updates:
+                            final_updates.append(button_updates[plot_ui_objects[p_id]["formula_button"]])
+                        else: # Default reset
+                            final_updates.append(gr.update(value=FORMULA_ICON))
+                
+                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 = {} # {panel_component: gr.update}
+                button_icon_updates = {}    # {button_component: gr.update}
+                new_explored_id = None
+
+                is_toggling_off = (plot_id_clicked == current_explored_plot_id)
+
+                if is_toggling_off:
+                    new_explored_id = None
+                    button_icon_updates[plot_ui_objects[plot_id_clicked]["explore_button"]] = gr.update(value=EXPLORE_ICON)
+                    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 another plot was explored, reset its button
+                    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)
+                    logging.info(f"Exploring plot: {plot_id_clicked}")
+                
+                # Determine visibility for all panels
+                for i in range(0, len(plot_configs), 2):
+                    config1_id = plot_configs[i]["id"]
+                    panel1 = plot_ui_objects[config1_id]["panel_component"]
+                    
+                    show_panel1 = True
+                    if new_explored_id: # If any plot is explored
+                        show_panel1 = (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"]
+                        # Only process second panel if it's in the same section as the first
+                        if plot_configs[i+1]["section"] == plot_configs[i]["section"]:
+                            panel2 = plot_ui_objects[config2_id]["panel_component"]
+                            show_panel2 = True
+                            if new_explored_id: # If any plot is explored
+                                show_panel2 = (config2_id == new_explored_id)
+                            # If panel1 is explored, panel2 in the same row should be hidden unless panel2 is the one being explored
+                            if config1_id == new_explored_id and config2_id != new_explored_id :
+                                show_panel2 = False
+                            elif config2_id == new_explored_id and config1_id != new_explored_id:
+                                show_panel1 = False # Re-evaluate panel1 if panel2 is explored
+                                panel_visibility_updates[panel1] = gr.update(visible=show_panel1)
+
+
+                            panel_visibility_updates[panel2] = gr.update(visible=show_panel2)
+                        # else: panel2 is in a new section, will be handled when its turn comes as config1_id
+
+                # Construct final updates list
+                # Order: explored_plot_id_state, then all panel visibility, then all explore button icons
+                final_updates = [new_explored_id]
+                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())) # Default no change if not in updates
+                        
+                        explore_btn = plot_ui_objects[p_id]["explore_button"]
+                        final_updates.append(button_icon_updates.get(explore_btn, gr.update(value=EXPLORE_ICON))) # Default to original icon
+                
+                return final_updates
+
+            # --- Connect Action Buttons ---
+            # Outputs for Insights/Formula: global_actions_column_ui, global_actions_markdown_ui, active_panel_action_state, + all bomb_buttons, + all formula_buttons
+            action_buttons_outputs = [
+                global_actions_column_ui, 
+                global_actions_markdown_ui, 
+                active_panel_action_state
+            ]
+            # Add all bomb and formula buttons to the output list for icon updates
+            for cfg in plot_configs:
+                pid = cfg["id"]
+                if pid in plot_ui_objects:
+                    action_buttons_outputs.append(plot_ui_objects[pid]["bomb_button"])
+                    action_buttons_outputs.append(plot_ui_objects[pid]["formula_button"])
             
-            # --- Function to Refresh All Analytics UI (Plots + Reset Global Insights) ---
+            # Outputs for Explore: explored_plot_id_state, + all panel_components, + all explore_buttons
+            explore_buttons_outputs = [explored_plot_id_state]
+            for cfg in plot_configs:
+                pid = cfg["id"]
+                if pid in plot_ui_objects:
+                    explore_buttons_outputs.append(plot_ui_objects[pid]["panel_component"])
+                    explore_buttons_outputs.append(plot_ui_objects[pid]["explore_button"])
+
+
+            for config_item in plot_configs:
+                plot_id = config_item["id"]
+                if plot_id in plot_ui_objects:
+                    ui_obj = plot_ui_objects[plot_id]
+                    
+                    ui_obj["bomb_button"].click(
+                        fn=lambda p_id=plot_id: handle_panel_action(p_id, "insights", active_panel_action_state.value, token_state.value), # Use .value for state in lambda
+                        inputs=None, # Inputs are passed via lambda closure and state.value
+                        outputs=action_buttons_outputs,
+                        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=action_buttons_outputs,
+                        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=explore_buttons_outputs,
+                        api_name=f"action_explore_{plot_id}"
+                    )
+
+            # --- 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 insights.")
+                logging.info("Refreshing all analytics UI elements and resetting actions.")
                 plot_generation_results = update_analytics_plots_figures(
                     current_token_state, date_filter_val, custom_start_val, custom_end_val
                 )
@@ -296,53 +450,67 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
                 all_updates = [status_message_update] # For analytics_status_md
 
-                # Plot figure updates - iterate based on plot_configs to ensure order
+                # Plot figure updates
                 for i, config in enumerate(plot_configs):
                     p_id_key = config["id"]
-                    if p_id_key in plot_ui_objects: # Check if plot UI exists
+                    if p_id_key in plot_ui_objects:
                         if i < len(generated_plot_figures):
                             all_updates.append(generated_plot_figures[i])
                         else:
-                            logging.error(f"Mismatch: Expected figure for {p_id_key} but not enough figures generated.")
                             all_updates.append(create_placeholder_plot("Figure Error", f"No figure for {p_id_key}"))
                     else:
-                        # This case should ideally not happen if plot_configs and plot_ui_objects are in sync
-                        logging.warning(f"Plot UI object for id {p_id_key} not found during refresh. Skipping its figure update.")
-
+                         all_updates.append(None) # Placeholder if UI object doesn't exist
 
-                # Reset Global Insights Column
-                all_updates.append(gr.update(visible=False)) # Hide global_insights_column_ui
-                all_updates.append(gr.update(value="Click 💣 on a plot to see insights here.")) # Reset global_insights_markdown_ui
-                all_updates.append(None) # Reset active_insight_plot_id_state
+                # Reset Global Action Column
+                all_updates.append(gr.update(visible=False)) 
+                all_updates.append(gr.update(value="Click a button (💣, ƒ) on a plot...")) 
+                all_updates.append(None) # Reset active_panel_action_state
+                
+                # Reset all button icons (bomb, formula, explore) and panel visibility for explore
+                for cfg in plot_configs:
+                    pid = cfg["id"]
+                    if pid in plot_ui_objects:
+                        all_updates.append(gr.update(value=BOMB_ICON))    # bomb_button
+                        all_updates.append(gr.update(value=FORMULA_ICON)) # formula_button
+                        all_updates.append(gr.update(value=EXPLORE_ICON)) # explore_button
+                        all_updates.append(gr.update(visible=True))       # panel_component (for explore reset)
+                    else: # Add placeholders if UI object doesn't exist to keep list length
+                        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]
-            # Add plot components (must be in the order of plot_configs)
-            for config in plot_configs:
-                p_id_key = config["id"]
-                if p_id_key in plot_ui_objects:
-                     apply_filter_and_sync_outputs.append(plot_ui_objects[p_id_key]["plot_component"])
+            for config in plot_configs: # Plot components
+                pid = config["id"]
+                apply_filter_and_sync_outputs.append(plot_ui_objects[pid]["plot_component"] if pid in plot_ui_objects else None)
+            
+            apply_filter_and_sync_outputs.extend([ # Global action column and its state
+                global_actions_column_ui, 
+                global_actions_markdown_ui, 
+                active_panel_action_state
+            ])
+            
+            # Add all button components and panel components for reset
+            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:
-                    # Add a placeholder None if a plot component wasn't created, to maintain output list length.
-                    # This helps prevent errors if plot_ui_objects somehow doesn't contain an expected key.
-                    apply_filter_and_sync_outputs.append(None) 
-                    logging.error(f"Plot component for {p_id_key} missing in plot_ui_objects for apply_filter_outputs.")
+                    apply_filter_and_sync_outputs.extend([None,None,None,None])
 
 
-            # Add global insights components and state
-            apply_filter_and_sync_outputs.extend([
-                global_insights_column_ui, 
-                global_insights_markdown_ui, 
-                active_insight_plot_id_state
-            ])
+            apply_filter_and_sync_outputs.append(explored_plot_id_state)
             
             logging.info(f"Total outputs for apply_filter/sync: {len(apply_filter_and_sync_outputs)}")
 
-
-            # --- Connect Apply Filter Button ---
             apply_filter_btn.click(
                 fn=refresh_all_analytics_ui_elements,
                 inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker],
@@ -351,9 +519,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
         with gr.TabItem("3️⃣ Mentions", id="tab_mentions"):
-            # ... (Mentions tab content remains the same) ...
-            refresh_mentions_display_btn = gr.Button("🔄 Refresh Mentions Display (from local data)", variant="secondary")
-            mentions_html = gr.HTML("Mentions data loads from Bubble after sync. Click refresh to view current local data.")
+            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")
             refresh_mentions_display_btn.click(
                 fn=run_mentions_tab_display, inputs=[token_state],
@@ -362,9 +529,8 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
         with gr.TabItem("4️⃣ Follower Stats", id="tab_follower_stats"):
-            # ... (Follower Stats tab content remains the same) ...
-            refresh_follower_stats_btn = gr.Button("🔄 Refresh Follower Stats Display (from local data)", variant="secondary")
-            follower_stats_html = gr.HTML("Follower statistics load from Bubble after sync. Click refresh to view current local data.")
+            refresh_follower_stats_btn = gr.Button("🔄 Refresh Follower Stats Display", variant="secondary")
+            follower_stats_html = gr.HTML("Follower statistics...")
             with gr.Row():
                 fs_plot_monthly_gains = gr.Plot(label="Monthly Follower Gains")
             with gr.Row():
@@ -377,31 +543,23 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 show_progress="full"
             )
     
-    # --- Define the full sync_click_event chain HERE ---
     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"
+        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
+        outputs=[status_box, token_state, sync_data_btn], show_progress=False
     )
     sync_event_part3 = sync_event_part2.then(
         fn=display_main_dashboard,
-        inputs=[token_state], 
-        outputs=[dashboard_display_html],
-        show_progress=False
+        inputs=[token_state], outputs=[dashboard_display_html], show_progress=False
     )
-    # Connect to refresh analytics UI after sync
     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"
+        outputs=apply_filter_and_sync_outputs, show_progress="full"
     )
 
 if __name__ == "__main__":
@@ -418,3 +576,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)
+