Update app.py

app.py

@@ -1,10 +1,7 @@
-# app.py
-# -- coding: utf-8 --
 import gradio as gr
 import pandas as pd
 import os
 import logging
-import time # Added for simulating delay
 
 # --- Module Imports ---
 # Functions from your existing/provided custom modules
@@ -27,36 +24,21 @@ from ui_generators import (
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# --- Helper function to load HTML animation ---
-def get_sync_animation_html():
-    """Loads the HTML content for the sync animation."""
-    try:
-        # Ensure this path is correct relative to where app.py is run
-        # Make sure 'sync_animation.html' is in the same directory as app.py
-        with open("sync_animation.html", "r", encoding="utf-8") as f:
-            return f.read()
-    except FileNotFoundError:
-        logging.error("sync_animation.html not found. Please ensure it's in the same directory as app.py.")
-        return "<p style='text-align:center; color: red;'>Animation file not found. Syncing...</p>"
-    except Exception as e:
-        logging.error(f"Error loading sync_animation.html: {e}")
-        return f"<p style='text-align:center; color: red;'>Error loading animation: {e}. Syncing...</p>"
-
 # --- 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)
 
-    # Ensure dataframes are at least empty DataFrames if not found in state
+    # 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())
 
     logging.info("Calling fetch_and_render_analytics with current token_state data.")
     try:
-        # Call the actual or placeholder function
         return fetch_and_render_analytics(
             token_state.get("client_id"),
             token_state.get("token"),
@@ -69,108 +51,70 @@ def guarded_fetch_analytics(token_state):
         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)
 
-# --- Animation Test Function (Generator) ---
-def show_animation_then_simulate_processing():
-    """
-    Yields the animation HTML, then simulates a delay,
-    and finally yields a completion message.
-    """
-    logging.info("TEST BUTTON: Yielding animation HTML.")
-    yield get_sync_animation_html() # First update: Display the animation
-
-    logging.info("TEST BUTTON: Simulating processing (server-side delay of 8 seconds).")
-    time.sleep(8) # Server-side delay
-
-    logging.info("TEST BUTTON: Simulation complete. Yielding completion message.")
-    yield "<p style='text-align:center; color: green; font-size: 1.2em;'>✅ Animation Test Complete!</p>" # Second update
-
 
 # --- 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(),
-        "bubble_operations_log_df": pd.DataFrame(), 
-        "mentions_should_sync_now": False, 
-        "fs_should_sync_now": False, 
-        "url_user_token_temp_storage": None # Not used in current logic, but kept from original
+        "url_user_token_temp_storage": None
     })
 
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
-    # These textboxes are used to capture URL parameters via app.load()
+    # 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)
 
-    # This function runs when the Gradio app loads in the browser.
-    # It calls `get_url_user_token` which should be JavaScript or a Gradio request handler.
-    # For it to work with JavaScript `fn=None, inputs=None, ..., js="() => { ... return [token, urn]; }"
-    # For Python function, it needs a gr.Request input.
+    # 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)
 
-    def initial_load_sequence(url_token, org_urn_val, current_state, request: gr.Request): # Added request for get_url_user_token if it needs it
-        """Handles the initial processing after URL parameters are potentially loaded."""
-        # If get_url_user_token is pure Python and needs request, it's passed here.
-        # If get_url_user_token was JS, url_token and org_urn_val would be populated from its output.
-        
-        # If url_token and org_urn_val are NOT populated by app.load (e.g. if get_url_user_token is a JS snippet that didn't run or returned null)
-        # you might need to call get_url_user_token here again if it's a Python function that needs the request object.
-        # However, app.load is designed to populate its outputs.
-        # For this example, we assume url_token and org_urn_val are correctly passed from org_urn_display.change
-        # which is triggered after app.load populates org_urn_display.
-
-        logging.info(f"Initial load sequence triggered. Org URN via change: {org_urn_val}, URL Token via change: {'Present' if url_token else 'Absent'}")
-        
-        # Call state_manager.process_and_store_bubble_token
+    # 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)
-        
-        # Call ui_generators.display_main_dashboard
-        dashboard_content_html = display_main_dashboard(new_state) 
-        
-        return status_msg, new_state, btn_update, dashboard_content_html
+        # 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"):
             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.")
-            
-            with gr.Row():
-                sync_data_btn = gr.Button("🔄 Sync LinkedIn Data", variant="primary", visible=False, interactive=False)
-                test_animation_btn = gr.Button("🧪 Test Animation Display", variant="secondary")
-
-            # HTML component to display sync status or animation
-            sync_status_html_output = gr.HTML("<p style='text-align:center;'>Sync status will appear here.</p>") 
-            
-            # HTML component to display the main dashboard content
+            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>")
 
-            # When org_urn_display changes (after app.load), trigger initial_load_sequence
+            # 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"
             )
-
-            # Original Sync Button Logic (multi-step process)
+            # 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(
-                fn=lambda: get_sync_animation_html(), # Show animation first
-                inputs=None,
-                outputs=[sync_status_html_output],
-                show_progress=False 
-            ).then(
-                fn=sync_all_linkedin_data_orchestrator, # Perform actual sync
+                fn=sync_all_linkedin_data_orchestrator,
                 inputs=[token_state],
-                outputs=[sync_status_html_output, token_state], 
-                show_progress=False # Animation is the progress
+                outputs=[sync_status_html_output, token_state], # token_state is updated here
+                show_progress="full"
             ).then(
-                fn=process_and_store_bubble_token, # Re-process token/state after sync
-                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, # 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
             ).then(
                 fn=display_main_dashboard, # Refresh dashboard display
                 inputs=[token_state],
@@ -178,29 +122,14 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 show_progress=False
             )
 
-            # New Test Animation Button Logic (uses the generator function)
-            test_animation_btn.click(
-                fn=show_animation_then_simulate_processing,
-                inputs=None,
-                outputs=[sync_status_html_output],
-                show_progress=False # Animation itself is the progress indicator
-            )
-
         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...") # For HTML content like follower count
-            with gr.Row():
-                follower_plot = gr.Plot(label="Follower Demographics")
-                growth_plot = 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 = gr.Plot(label="Mentions Volume")
-                mentions_sentiment_plot = gr.Plot(label="Mentions Sentiment")
+            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],
@@ -213,7 +142,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             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")
-            
             refresh_mentions_display_btn.click(
                 fn=run_mentions_tab_display, inputs=[token_state],
                 outputs=[mentions_html, mentions_sentiment_dist_plot],
@@ -236,7 +164,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
 if __name__ == "__main__":
-    # Check for environment variables
+    # 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.")
     if not os.environ.get(BUBBLE_APP_NAME_ENV_VAR) or \
@@ -244,12 +172,12 @@ if __name__ == "__main__":
        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.")
 
-    # Check for Matplotlib (optional, but good for plots)
     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")
 
     # Launch the Gradio app
-    app.launch(server_name="0.0.0.0", server_port=7860, debug=True, share=False)
+    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)