Update app.py

app.py

@@ -5,7 +5,6 @@ import logging
 import matplotlib
 matplotlib.use('Agg') # Set backend for Matplotlib to avoid GUI conflicts with Gradio
 import matplotlib.pyplot as plt
-# from functools import partial # No longer needed if gr.State(value=plot_id) is used
 
 # --- Module Imports ---
 from gradio_utils import get_url_user_token
@@ -21,7 +20,7 @@ from ui_generators import (
     display_main_dashboard,
     run_mentions_tab_display,
     run_follower_stats_tab_display,
-    build_analytics_tab_ui_components # Import the new UI builder function
+    build_analytics_tab_plot_area # Import the updated UI builder
 )
 # Corrected import for analytics_data_processing
 from analytics_data_processing import prepare_filtered_analytics_data
@@ -34,7 +33,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, # For initializing plots
+    create_placeholder_plot, 
     generate_likes_over_time_plot,
     generate_clicks_over_time_plot,
     generate_shares_over_time_plot,
@@ -48,14 +47,10 @@ from analytics_plot_generator import (
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
 
-# --- Analytics Tab: Plot Update Function (Original, generates figures) ---
+# --- Analytics Tab: Plot Figure Generation Function ---
 def update_analytics_plots_figures(token_state_value, date_filter_option, custom_start_date, custom_end_date):
-    """
-    Prepares analytics data using external processing function and then generates plot figures.
-    This function is primarily responsible for returning the Matplotlib figure objects.
-    """
     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 the number of plots defined in plot_configs
+    num_expected_plots = 23 
 
     if not token_state_value or not token_state_value.get("token"):
         message = "❌ Access denied. No token. Cannot generate analytics."
@@ -83,20 +78,14 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
     media_type_col_name = token_state_value.get("config_media_type_col", "media_type")
     eb_labels_col_name = token_state_value.get("config_eb_labels_col", "eb_labels")
 
-    logging.info(f"Data for plotting - Filtered Merged Posts: {len(filtered_merged_posts_df)} rows, Filtered Mentions: {len(filtered_mentions_df)} rows.")
-    logging.info(f"Date-Filtered Follower Stats: {len(date_filtered_follower_stats_df)} rows, Raw Follower Stats: {len(raw_follower_stats_df)} rows.")
-
+    plot_figs = []
     try:
-        plot_figs = []
         plot_figs.append(generate_posts_activity_plot(filtered_merged_posts_df, date_column=date_column_posts))
         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)
-        
-        plot_figs.append(fig_mentions_activity_shared) # Original mention plot slot 1
-        plot_figs.append(fig_mention_sentiment_shared) # Original mention plot slot 2
-
+        plot_figs.append(fig_mentions_activity_shared)
+        plot_figs.append(fig_mention_sentiment_shared)
         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"))
@@ -114,10 +103,8 @@ 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))
-        
-        # For the "Mention Analysis" section, we reuse the figures generated earlier
-        plot_figs.append(fig_mentions_activity_shared) # New UI slot for mention volume, reuses figure
-        plot_figs.append(fig_mention_sentiment_shared) # New UI slot for mention sentiment, reuses figure
+        plot_figs.append(fig_mentions_activity_shared) 
+        plot_figs.append(fig_mention_sentiment_shared)
 
         message = f"📊 Analytics updated for period: {date_filter_option}"
         if date_filter_option == "Custom Range":
@@ -127,17 +114,16 @@ 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):
+            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 with placeholder. Expected {num_expected_plots}, got {len(final_plot_figs)}.")
+            logging.warning(f"Padding missing plot figure. Expected {num_expected_plots}, got {len(final_plot_figs)}.")
             final_plot_figs.append(create_placeholder_plot(title="Missing Plot", message="Plot figure could not be generated."))
         
-        logging.info(f"Successfully generated {len(final_plot_figs)} plot figures for {num_expected_plots} UI slots.")
         return [message] + final_plot_figs[:num_expected_plots]
 
     except Exception as e:
@@ -153,37 +139,31 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
     token_state = gr.State(value={
         "token": None, "client_id": None, "org_urn": None,
-        "bubble_posts_df": pd.DataFrame(),
-        "bubble_post_stats_df": pd.DataFrame(),
-        "bubble_mentions_df": pd.DataFrame(),
-        "bubble_follower_stats_df": pd.DataFrame(),
-        "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",
+        "bubble_posts_df": pd.DataFrame(), "bubble_post_stats_df": pd.DataFrame(),
+        "bubble_mentions_df": pd.DataFrame(), "bubble_follower_stats_df": pd.DataFrame(),
+        "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": "eb_labels"
     })
 
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
-    url_user_token_display = gr.Textbox(label="User Token (from URL - Hidden)", interactive=False, visible=False)
+    url_user_token_display = gr.Textbox(label="User Token (Hidden)", interactive=False, visible=False)
     status_box = gr.Textbox(label="Overall LinkedIn Token Status", interactive=False, value="Initializing...")
-    org_urn_display = gr.Textbox(label="Organization URN (from URL - Hidden)", interactive=False, visible=False)
+    org_urn_display = gr.Textbox(label="Organization URN (Hidden)", interactive=False, visible=False)
 
     app.load(fn=get_url_user_token, inputs=None, outputs=[url_user_token_display, org_urn_display], api_name="get_url_params", show_progress=False)
 
     def initial_load_sequence(url_token, org_urn_val, current_state):
-        logging.info(f"Initial load sequence triggered. Org URN: {org_urn_val}, URL Token: {'Present' if url_token else 'Absent'}")
         status_msg, new_state, btn_update = process_and_store_bubble_token(url_token, org_urn_val, current_state)
         dashboard_content = display_main_dashboard(new_state)
         return status_msg, new_state, btn_update, dashboard_content
 
     with gr.Tabs() as tabs:
         with gr.TabItem("1️⃣ Dashboard & Sync", id="tab_dashboard_sync"):
-            gr.Markdown("System checks for existing data from Bubble. The 'Sync' button activates if new data needs to be fetched from LinkedIn based on the last sync times and data availability.")
+            gr.Markdown("System checks for existing data from Bubble. 'Sync' activates if new data is needed.")
             sync_data_btn = gr.Button("🔄 Sync LinkedIn Data", variant="primary", visible=False, interactive=False)
-            sync_status_html_output = gr.HTML("<p style='text-align:center;'>Sync status will appear here.</p>")
+            sync_status_html_output = gr.HTML("<p style='text-align:center;'>Sync status...</p>")
             dashboard_display_html = gr.HTML("<p style='text-align:center;'>Dashboard loading...</p>")
 
             org_urn_display.change(
@@ -195,17 +175,18 @@ 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 to filter analytics. Click 💣 for insights.")
+            gr.Markdown("Select a date range. Click 💣 for insights.")
             
-            analytics_status_md = gr.Markdown("Analytics status will appear here...")
+            analytics_status_md = gr.Markdown("Analytics status...")
 
-            with gr.Row():
+            with gr.Row(): # Filters row
                 date_filter_selector = gr.Radio(
                     ["All Time", "Last 7 Days", "Last 30 Days", "Custom Range"],
-                    label="Select Date Range", value="Last 30 Days"
+                    label="Select Date Range", value="Last 30 Days", scale=3
                 )
-                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")
+                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")
             
             apply_filter_btn = gr.Button("🔍 Apply Filter & Refresh Analytics", variant="primary")
 
@@ -219,8 +200,7 @@ 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 the order of figures returned by update_analytics_plots_figures)
+            # --- 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"},
@@ -246,71 +226,67 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 {"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 number of plot configurations and expected plots."
-            
-            # --- Build Analytics Tab UI using the function from ui_generators ---
-            # This function will create the gr.Markdown for sections and rows for plots.
-            # It needs to be called within this gr.Blocks() context.
-            plot_ui_objects = build_analytics_tab_ui_components(plot_configs)
-            
-            active_insight_plot_id_state = gr.State(None) # Stores the plot_id of the currently open insight panel
+            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
+                    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.")
+
+            active_insight_plot_id_state = gr.State(None) 
 
             # --- Bomb Button Click Handler ---
-            def handle_bomb_click(plot_id_clicked, current_active_plot_id, current_token_state):
+            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}")
-                updates = [] 
-                new_active_id = None
-
-                if plot_id_clicked == current_active_plot_id:
-                    new_active_id = None # Toggle off
+                
+                # 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:
-                    new_active_id = plot_id_clicked # Activate new one
-                    logging.info(f"Opening insights for {plot_id_clicked}, closing others.")
-
-                for p_id_iter, ui_obj_dict in plot_ui_objects.items():
-                    is_target_one = (p_id_iter == new_active_id)
-                    updates.append(gr.update(visible=is_target_one)) # For insights_col visibility
-
-                    if is_target_one:
-                        # TODO: Implement actual insight generation logic here
-                        insight_text = f"**Insights for {ui_obj_dict['label']}**\n\n"
-                        insight_text += f"Plot ID: `{p_id_iter}`.\n"
-                        insight_text += "Detailed analysis would involve examining trends, anomalies, and correlations related to this specific chart.\n"
-                        insight_text += "For example, for 'Posts Activity', we might look for days with unusually high or low activity and correlate with external events or content types."
-                        updates.append(gr.update(value=insight_text))
-                    else:
-                        updates.append(gr.update(value=f"Click 💣 for insights on {ui_obj_dict['label']}...")) # Reset placeholder
+                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}")
                 
-                updates.append(new_active_id) # New value for active_insight_plot_id_state
-                logging.info(f"Returning {len(updates)-1} UI updates. New active ID: {new_active_id}")
-                return updates
+                return gr.update(visible=insights_col_visible), gr.update(value=insight_text_update), new_active_id
 
             # --- Connect Bomb Buttons ---
-            bomb_click_dynamic_outputs = []
-            # The order of items in bomb_click_dynamic_outputs must match the order of iteration
-            # in handle_bomb_click when it creates its `updates` list.
-            # plot_ui_objects is a dictionary, so .keys() gives an arbitrary order if not Python 3.7+
-            # To be safe, iterate based on plot_configs order for constructing outputs.
-            for config in plot_configs:
-                p_id_key = config["id"]
-                bomb_click_dynamic_outputs.append(plot_ui_objects[p_id_key]["insights_col"])
-                bomb_click_dynamic_outputs.append(plot_ui_objects[p_id_key]["insights_md"])
-            bomb_click_dynamic_outputs.append(active_insight_plot_id_state)
+            # 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"]
-                components_dict = plot_ui_objects[plot_id]
-                components_dict["bomb"].click(
-                    fn=handle_bomb_click,
-                    inputs=[gr.State(value=plot_id), active_insight_plot_id_state, token_state],
-                    outputs=bomb_click_dynamic_outputs,
-                    api_name=f"show_insights_{plot_id}" # Gradio handles None api_name if plot_id is None (though it shouldn't be)
-                )
+                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}" 
+                    )
             
-            # --- Function to Refresh All Analytics UI (Plots + Reset Insights) ---
+            # --- Function to Refresh All Analytics UI (Plots + Reset Global Insights) ---
             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.")
+                logging.info("Refreshing all analytics UI elements and resetting insights.")
                 plot_generation_results = update_analytics_plots_figures(
                     current_token_state, date_filter_val, custom_start_val, custom_end_val
                 )
@@ -318,37 +294,53 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 status_message_update = plot_generation_results[0]
                 generated_plot_figures = plot_generation_results[1:]
 
-                all_updates = [status_message_update]
+                all_updates = [status_message_update] # For analytics_status_md
 
                 # Plot figure updates - iterate based on plot_configs to ensure order
                 for i, config in enumerate(plot_configs):
                     p_id_key = config["id"]
-                    if i < len(generated_plot_figures):
-                        all_updates.append(generated_plot_figures[i])
+                    if p_id_key in plot_ui_objects: # Check if plot UI exists
+                        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:
-                        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}"))
-                
-                # Insight column visibility and markdown content reset - iterate based on plot_configs
-                for config in plot_configs:
-                    p_id_key = config["id"]
-                    ui_obj_dict_val = plot_ui_objects[p_id_key]
-                    all_updates.append(gr.update(visible=False)) # Hide insights_col
-                    all_updates.append(gr.update(value=f"Click 💣 for insights on {ui_obj_dict_val['label']}...")) # Reset insights_md
+                        # 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.")
+
 
+                # 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
+                
+                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]
-            # Iterate based on plot_configs to ensure order
-            for config in plot_configs: # Plot components
-                apply_filter_and_sync_outputs.append(plot_ui_objects[config["id"]]["plot"])
-            for config in plot_configs: # Insight column components
-                apply_filter_and_sync_outputs.append(plot_ui_objects[config["id"]]["insights_col"])
-            for config in plot_configs: # Insight markdown components
-                apply_filter_and_sync_outputs.append(plot_ui_objects[config["id"]]["insights_md"])
-            apply_filter_and_sync_outputs.append(active_insight_plot_id_state) # State component
+            # 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"])
+                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.")
+
+
+            # 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
+            ])
+            
+            logging.info(f"Total outputs for apply_filter/sync: {len(apply_filter_and_sync_outputs)}")
+
 
             # --- Connect Apply Filter Button ---
             apply_filter_btn.click(
@@ -359,6 +351,7 @@ 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.")
             mentions_sentiment_dist_plot = gr.Plot(label="Mention Sentiment Distribution")
@@ -369,6 +362,7 @@ 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.")
             with gr.Row():
@@ -383,7 +377,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 show_progress="full"
             )
     
-    # --- Define the full sync_click_event chain HERE, now that analytics outputs are known ---
+    # --- Define the full sync_click_event chain HERE ---
     sync_event_part1 = sync_data_btn.click(
         fn=sync_all_linkedin_data_orchestrator,
         inputs=[token_state],
@@ -402,6 +396,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         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], 
@@ -409,19 +404,17 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         show_progress="full"
     )
 
-
 if __name__ == "__main__":
     if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR):
-        logging.warning(f"WARNING: '{LINKEDIN_CLIENT_ID_ENV_VAR}' environment variable not set.")
+        logging.warning(f"WARNING: '{LINKEDIN_CLIENT_ID_ENV_VAR}' env var not set.")
     if not os.environ.get(BUBBLE_APP_NAME_ENV_VAR) or \
        not os.environ.get(BUBBLE_API_KEY_PRIVATE_ENV_VAR) or \
        not os.environ.get(BUBBLE_API_ENDPOINT_ENV_VAR):
-        logging.warning("WARNING: Bubble environment variables not fully set.")
+        logging.warning("WARNING: Bubble env vars not fully set.")
 
     try:
-        logging.info(f"Matplotlib version: {matplotlib.__version__} found. Backend: {matplotlib.get_backend()}")
+        logging.info(f"Matplotlib version: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
     except ImportError:
         logging.error("Matplotlib is not installed. Plots will not be generated.")
 
     app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
-