Update app.py

app.py

@@ -2,11 +2,14 @@ import gradio as gr
 import pandas as pd
 import os
 import logging
+import matplotlib
+matplotlib.use('Agg') # Set backend for Matplotlib to avoid GUI conflicts with Gradio
+import matplotlib.pyplot as plt 
+# No longer need timedelta here if all date logic is in analytics_data_processing
+# from datetime import datetime, timedelta 
 
 # --- Module Imports ---
-# Functions from your existing/provided custom modules
-from analytics_fetch_and_rendering import fetch_and_render_analytics # Assuming this exists
-from gradio_utils import get_url_user_token # For fetching URL parameters
+from gradio_utils import get_url_user_token 
 
 # Functions from newly created/refactored modules
 from config import (
@@ -20,139 +23,198 @@ from ui_generators import (
     run_mentions_tab_display,
     run_follower_stats_tab_display
 )
+import analytics_plot_generators 
+# NEW: Import for data processing functions
+import analytics_data_processing
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# --- Guarded Analytics Fetch ---
-def guarded_fetch_analytics(token_state):
-    """Guarded call to fetch_and_render_analytics, ensuring token and basic data structures."""
-    if not token_state or not token_state.get("token"):
-        logging.warning("Analytics fetch: Access denied. No token.")
-        # Ensure the number of returned Nones matches the expected number of outputs for the plots
-        return ("❌ Access denied. No token.", None, None, None, None, None, None, None)
+# --- Analytics Tab: Plot Update Function ---
+def update_analytics_plots(token_state_value, date_filter_option, custom_start_date, custom_end_date):
+    """
+    Prepares analytics data using external processing function and then generates plots.
+    """
+    logging.info(f"Updating analytics plots. Filter: {date_filter_option}, Custom Start: {custom_start_date}, Custom End: {custom_end_date}")
 
-    # Ensure DataFrames are passed, even if empty, to avoid errors in the analytics function
-    posts_df_analytics = token_state.get("bubble_posts_df", pd.DataFrame())
-    mentions_df_analytics = token_state.get("bubble_mentions_df", pd.DataFrame())
-    follower_stats_df_analytics = token_state.get("bubble_follower_stats_df", pd.DataFrame())
+    if not token_state_value or not token_state_value.get("token"):
+        message = "❌ Access denied. No token. Cannot generate analytics."
+        logging.warning(message)
+        return message, None, None, None, None, None 
 
-    logging.info("Calling fetch_and_render_analytics with current token_state data.")
+    # --- Prepare Data (Moved to analytics_data_processing) ---
     try:
-        return fetch_and_render_analytics(
-            token_state.get("client_id"),
-            token_state.get("token"),
-            token_state.get("org_urn"),
-            posts_df_analytics,
-            mentions_df_analytics,
-            follower_stats_df_analytics
-        )
+        filtered_posts_df, filtered_mentions_df, follower_stats_df, start_dt_for_msg, end_dt_for_msg = \
+            analytics_data_processing.prepare_filtered_analytics_data(
+                token_state_value, date_filter_option, custom_start_date, custom_end_date
+            )
+    except Exception as e:
+        error_msg = f"❌ Error preparing analytics data: {e}"
+        logging.error(error_msg, exc_info=True)
+        return error_msg, None, None, None, None, None
+
+    # Date column names (still needed for plot generators)
+    date_column_posts = token_state_value.get("config_date_col_posts", "published_at")
+    date_column_mentions = token_state_value.get("config_date_col_mentions", "date")
+    date_column_followers = token_state_value.get("config_date_col_followers", "date") 
+
+    logging.info(f"Data for plotting - Filtered posts: {len(filtered_posts_df)} rows, Filtered Mentions: {len(filtered_mentions_df)} rows.")
+    logging.info(f"Follower stats (unfiltered by global range): {len(follower_stats_df)} rows.")
+
+    # --- Generate Plots ---
+    try:
+        plot_posts_activity = analytics_plot_generators.generate_posts_activity_plot(filtered_posts_df, date_column_posts)
+        plot_engagement_type = analytics_plot_generators.generate_engagement_type_plot(filtered_posts_df) 
+        plot_mentions_activity = analytics_plot_generators.generate_mentions_activity_plot(filtered_mentions_df, date_column_mentions)
+        plot_mention_sentiment = analytics_plot_generators.generate_mention_sentiment_plot(filtered_mentions_df) 
+        plot_follower_growth = analytics_plot_generators.generate_follower_growth_plot(follower_stats_df, date_column_followers)
+
+        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})"
+        
+        num_plots_generated = sum(1 for p in [plot_posts_activity, plot_engagement_type, plot_mentions_activity, plot_mention_sentiment, plot_follower_growth] if p is not None)
+        logging.info(f"Successfully generated {num_plots_generated} plots.")
+
+        return message, plot_posts_activity, plot_engagement_type, plot_mentions_activity, plot_mention_sentiment, plot_follower_growth
     except Exception as e:
-        logging.error(f"Error in guarded_fetch_analytics calling fetch_and_render_analytics: {e}", exc_info=True)
-        return (f"❌ Error fetching analytics: {e}", None, None, None, None, None, None, None)
+        error_msg = f"❌ Error generating analytics plots: {e}"
+        logging.error(error_msg, exc_info=True)
+        return error_msg, None, None, None, None, None
 
 
 # --- Gradio UI Blocks ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                title="LinkedIn Organization Dashboard") as app:
 
-    # Central state for holding token, client_id, org_urn, and fetched dataframes
     token_state = gr.State(value={
         "token": None, "client_id": None, "org_urn": None,
         "bubble_posts_df": pd.DataFrame(), "fetch_count_for_api": 0,
         "bubble_mentions_df": pd.DataFrame(),
         "bubble_follower_stats_df": pd.DataFrame(),
-        "url_user_token_temp_storage": None
+        "url_user_token_temp_storage": None,
+        "config_date_col_posts": "published_at", 
+        "config_date_col_mentions": "date",      
+        "config_date_col_followers": "date"    
     })
 
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
-    # Hidden textboxes to capture URL parameters
     url_user_token_display = gr.Textbox(label="User Token (from URL - 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)
 
-    # Load URL parameters when the Gradio app loads
     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)
 
-    # This function will run after URL params are loaded and org_urn_display changes
     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'}")
-        # Process token, fetch Bubble data, determine sync needs
         status_msg, new_state, btn_update = process_and_store_bubble_token(url_token, org_urn_val, current_state)
-        # Display initial dashboard content based on (potentially empty) Bubble data
         dashboard_content = display_main_dashboard(new_state)
         return status_msg, new_state, btn_update, dashboard_content
 
-    with gr.Tabs():
-        with gr.TabItem("1️⃣ Dashboard & Sync"):
+    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.")
             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>")
             dashboard_display_html = gr.HTML("<p style='text-align:center;'>Dashboard loading...</p>")
 
-            # Chain of events for initial load:
             org_urn_display.change(
                 fn=initial_load_sequence,
                 inputs=[url_user_token_display, org_urn_display, token_state],
                 outputs=[status_box, token_state, sync_data_btn, dashboard_display_html],
                 show_progress="full"
             )
-            # Also trigger initial_load_sequence if url_user_token_display changes (e.g. if it loads after org_urn)
-            # This helps ensure it runs once both are potentially available.
-            # Note: `org_urn_display.change` might be sufficient if `get_url_user_token` updates both nearly simultaneously.
-            # Adding this for robustness, but ensure it doesn't cause unwanted multiple runs if state isn't managed carefully.
-            # Consider using a flag in token_state if multiple triggers become an issue.
-            # For now, relying on org_urn_display.change as the primary trigger post-load.
-
-            # When Sync button is clicked:
-            sync_data_btn.click(
+            
+            sync_click_event = sync_data_btn.click(
                 fn=sync_all_linkedin_data_orchestrator,
                 inputs=[token_state],
-                outputs=[sync_status_html_output, token_state], # token_state is updated here
+                outputs=[sync_status_html_output, token_state], 
                 show_progress="full"
             ).then(
-                fn=process_and_store_bubble_token, # Re-check sync status and update button
-                inputs=[url_user_token_display, org_urn_display, token_state], # Pass current token_state
-                outputs=[status_box, token_state, sync_data_btn], # token_state updated again
-                show_progress=False # Typically "full" for user-initiated actions, "minimal" or False for quick updates
+                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 
             ).then(
-                fn=display_main_dashboard, # Refresh dashboard display
+                fn=display_main_dashboard, 
                 inputs=[token_state],
                 outputs=[dashboard_display_html],
                 show_progress=False
             )
 
-        with gr.TabItem("2️⃣ Analytics"):
-            fetch_analytics_btn = gr.Button("📈 Fetch/Refresh Full Analytics", variant="primary")
-            follower_count_md = gr.Markdown("Analytics data will load here...")
-            with gr.Row(): follower_plot, growth_plot = gr.Plot(label="Follower Demographics"), gr.Plot(label="Follower Growth")
-            with gr.Row(): eng_rate_plot = gr.Plot(label="Engagement Rate")
-            with gr.Row(): interaction_plot = gr.Plot(label="Post Interactions")
-            with gr.Row(): eb_plot = gr.Plot(label="Engagement Benchmark")
-            with gr.Row(): mentions_vol_plot, mentions_sentiment_plot = gr.Plot(label="Mentions Volume"), gr.Plot(label="Mentions Sentiment")
-
-            fetch_analytics_btn.click(
-                fn=guarded_fetch_analytics, inputs=[token_state],
-                outputs=[follower_count_md, follower_plot, growth_plot, eng_rate_plot,
-                         interaction_plot, eb_plot, mentions_vol_plot, mentions_sentiment_plot],
+
+        with gr.TabItem("2️⃣ Analytics", id="tab_analytics"):
+            gr.Markdown("## 📈 LinkedIn Performance Analytics")
+            gr.Markdown("Select a date range to filter Posts and Mentions analytics. Follower analytics show overall trends and are not affected by this date filter.")
+            
+            analytics_status_md = gr.Markdown("Analytics status will appear here...")
+
+            with gr.Row():
+                date_filter_selector = gr.Radio(
+                    ["All Time", "Last 7 Days", "Last 30 Days", "Custom Range"],
+                    label="Select Date Range (for Posts & Mentions)",
+                    value="Last 30 Days"
+                )
+                custom_start_date_picker = gr.DatePicker(label="Start Date (Custom)", visible=False)
+                custom_end_date_picker = gr.DatePicker(label="End Date (Custom)", visible=False)
+            
+            apply_filter_btn = gr.Button("🔍 Apply Filter & Refresh Analytics", variant="primary")
+
+            def toggle_custom_date_pickers(selection):
+                return gr.update(visible=selection == "Custom Range"), gr.update(visible=selection == "Custom Range")
+
+            date_filter_selector.change(
+                fn=toggle_custom_date_pickers,
+                inputs=[date_filter_selector],
+                outputs=[custom_start_date_picker, custom_end_date_picker]
+            )
+
+            gr.Markdown("### Posts & Engagement Overview (Filtered by Date)")
+            with gr.Row():
+                posts_activity_plot = gr.Plot(label="Posts Activity Over Time")
+                engagement_type_plot = gr.Plot(label="Post Engagement Types")
+            
+            gr.Markdown("### Mentions Overview (Filtered by Date)")
+            with gr.Row():
+                mentions_activity_plot = gr.Plot(label="Mentions Activity Over Time")
+                mention_sentiment_plot = gr.Plot(label="Mention Sentiment Distribution")
+
+            gr.Markdown("### Follower Overview (Not Filtered by Date Range Selector)")
+            with gr.Row():
+                follower_growth_plot = gr.Plot(label="Follower Growth Over Time")
+
+            apply_filter_btn.click(
+                fn=update_analytics_plots,
+                inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker],
+                outputs=[analytics_status_md, posts_activity_plot, engagement_type_plot, mentions_activity_plot, mention_sentiment_plot, follower_growth_plot],
+                show_progress="full"
+            )
+            
+            sync_click_event.then(
+                fn=update_analytics_plots,
+                inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker],
+                outputs=[analytics_status_md, posts_activity_plot, engagement_type_plot, mentions_activity_plot, mention_sentiment_plot, follower_growth_plot],
                 show_progress="full"
             )
 
-        with gr.TabItem("3️⃣ Mentions"):
+
+        with gr.TabItem("3️⃣ Mentions", id="tab_mentions"):
             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")
+            mentions_sentiment_dist_plot = gr.Plot(label="Mention Sentiment Distribution") 
             refresh_mentions_display_btn.click(
                 fn=run_mentions_tab_display, inputs=[token_state],
                 outputs=[mentions_html, mentions_sentiment_dist_plot],
                 show_progress="full"
             )
 
-        with gr.TabItem("4️⃣ Follower Stats"):
+        with gr.TabItem("4️⃣ Follower Stats", id="tab_follower_stats"):
             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():
-                fs_plot_monthly_gains = gr.Plot(label="Monthly Follower Gains")
+                fs_plot_monthly_gains = gr.Plot(label="Monthly Follower Gains") 
             with gr.Row():
                 fs_plot_seniority = gr.Plot(label="Followers by Seniority (Top 10 Organic)")
                 fs_plot_industry = gr.Plot(label="Followers by Industry (Top 10 Organic)")
@@ -162,22 +224,19 @@ 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"
             )
+    
 
 if __name__ == "__main__":
-    # Check for essential environment variables
     if not os.environ.get(LINKEDIN_CLIENT_ID_ENV_VAR):
-        logging.warning(f"WARNING: '{LINKEDIN_CLIENT_ID_ENV_VAR}' environment variable not set. The app may not function correctly for LinkedIn API calls.")
+        logging.warning(f"WARNING: '{LINKEDIN_CLIENT_ID_ENV_VAR}' environment variable 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: One or more Bubble environment variables (BUBBLE_APP_NAME, BUBBLE_API_KEY_PRIVATE, BUBBLE_API_ENDPOINT) are not set. Bubble integration will fail.")
+        logging.warning("WARNING: Bubble environment variables not fully set.")
 
     try:
-        import matplotlib
         logging.info(f"Matplotlib version: {matplotlib.__version__} found. Backend: {matplotlib.get_backend()}")
-        # The backend is now set in ui_generators.py, which is good practice.
     except ImportError:
-        logging.error("Matplotlib is not installed. Plots will not be generated. Please install it: pip install matplotlib")
+        logging.error("Matplotlib is not installed. Plots will not be generated.")
 
-    # Launch the Gradio app
-    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)