Update app.py

app.py

@@ -1,9 +1,10 @@
+# -- coding: utf-8 --
 import gradio as gr
 import json
 import os
 import logging
 import html
-import pandas as pd
+import pandas as pd # Ensure pandas is imported if you're dealing with DataFrames
 
 # Import functions from your custom modules
 from Data_Fetching_and_Rendering import fetch_and_render_dashboard
@@ -35,69 +36,77 @@ def process_and_store_bubble_token(url_user_token, org_urn, token_state):
     """
     Processes the user token from the URL, fetches LinkedIn token from Bubble,
     fetches initial posts from Bubble, and updates the token state and UI accordingly.
+    Returns updates for status_box, token_state, and sync_posts_to_bubble_btn.
     """
     logging.info(f"Processing token with URL user token: '{url_user_token}', Org URN: '{org_urn}'")
+    
     # Initialize or copy existing state, adding bubble_posts_df
     new_state = token_state.copy() if token_state else {"token": None, "client_id": None, "org_urn": None, "bubble_posts_df": None}
-    new_state.update({"token": None, "org_urn": org_urn, "bubble_posts_df": None}) # Ensure bubble_posts_df is reset/initialized
+    # Ensure org_urn is updated from input, and bubble_posts_df is reset/initialized for this run.
+    # Token will be set later if fetched.
+    new_state.update({"org_urn": org_urn, "bubble_posts_df": None, "token": new_state.get("token")}) 
 
-    # Default button state: invisible and non-interactive
-    button_update = gr.Button(
-        value="🔄 Fetch, Analyze & Store Posts to Bubble",
-        variant="primary",
-        visible=False,
-        interactive=False
-    )
+    # Determine button properties - default to hidden and non-interactive
+    button_visible = False
+    button_interactive = False
 
     client_id = os.environ.get("Linkedin_client_id")
     if not client_id:
         logging.error("CRITICAL ERROR: 'Linkedin_client_id' environment variable not set.")
         new_state["client_id"] = "ENV VAR MISSING"
-        # Even if client_id is missing, we might still be able to fetch from Bubble if org_urn is present
-        # and then decide button visibility.
     else:
         new_state["client_id"] = client_id
 
     # Attempt to fetch LinkedIn token from Bubble (related to LinkedIn API access)
     if url_user_token and "not found" not in url_user_token and "Could not access" not in url_user_token:
         logging.info(f"Attempting to fetch LinkedIn token from Bubble with user token: {url_user_token}")
-        parsed_linkedin_token = fetch_linkedin_token_from_bubble(url_user_token)
-        if isinstance(parsed_linkedin_token, dict) and "access_token" in parsed_linkedin_token:
-            new_state["token"] = parsed_linkedin_token
-            logging.info("✅ LinkedIn Token successfully fetched from Bubble.")
-        else:
-            logging.warning("❌ Failed to fetch a valid LinkedIn token from Bubble.")
+        try:
+            parsed_linkedin_token = fetch_linkedin_token_from_bubble(url_user_token)
+            if isinstance(parsed_linkedin_token, dict) and "access_token" in parsed_linkedin_token:
+                new_state["token"] = parsed_linkedin_token # Update token in new_state
+                logging.info("✅ LinkedIn Token successfully fetched from Bubble.")
+            else:
+                new_state["token"] = None # Explicitly set to None if fetch fails
+                logging.warning(f"❌ Failed to fetch a valid LinkedIn token from Bubble. Response: {parsed_linkedin_token}")
+        except Exception as e:
+            new_state["token"] = None # Explicitly set to None on error
+            logging.error(f"❌ Exception while fetching LinkedIn token from Bubble: {e}")
     else:
+        new_state["token"] = None # Ensure token is None if no valid url_user_token
         logging.info("No valid URL user token provided for LinkedIn token fetch, or an error was indicated.")
 
-    # Fetch posts from Bubble using org_urn, regardless of LinkedIn token status for this specific fetch
+    # Fetch posts from Bubble using org_urn
     current_org_urn = new_state.get("org_urn")
     if current_org_urn:
         logging.info(f"Attempting to fetch posts from Bubble for org_urn: {current_org_urn}")
         try:
             # Assuming fetch_posts_from_bubble returns a Pandas DataFrame or None
             df_bubble_posts = fetch_posts_from_bubble(current_org_urn)
-            new_state["bubble_posts_df"] = df_bubble_posts
+            new_state["bubble_posts_df"] = df_bubble_posts # Store DataFrame in state
 
             if df_bubble_posts is not None and not df_bubble_posts.empty:
                 logging.info(f"✅ Successfully fetched {len(df_bubble_posts)} posts from Bubble. Sync button will be enabled.")
-                button_update = gr.Button(
-                    value="🔄 Fetch, Analyze & Store Posts to Bubble",
-                    variant="primary",
-                    visible=True,
-                    interactive=True
-                )
+                button_visible = True
+                button_interactive = True
             else:
                 logging.info("ℹ️ No posts found in Bubble for this organization or DataFrame is empty. Sync button will remain hidden.")
+                # button_visible and button_interactive remain False
         except Exception as e:
             logging.error(f"❌ Error fetching posts from Bubble: {e}")
-            # Keep button hidden on error
+            # button_visible and button_interactive remain False
     else:
         logging.warning("Org URN not available in state. Cannot fetch posts from Bubble.")
+        # button_visible and button_interactive remain False
         
-    token_status_message = check_token_status(new_state)
-    logging.info(f"Token processing complete. Status: {token_status_message}. Button visible: {button_update.visible}")
-    return token_status_message, new_state, button_update
+    token_status_message = check_token_status(new_state) # Check based on potentially updated new_state["token"]
+    
+    # Log the determined visibility before creating the update object
+    logging.info(f"Token processing complete. LinkedIn Token Status: {token_status_message}. Button visible: {button_visible}, Button interactive: {button_interactive}")
+    
+    # Create a gr.update object for the button
+    button_component_update = gr.update(visible=button_visible, interactive=button_interactive)
+    
+    return token_status_message, new_state, button_component_update
 
 def guarded_fetch_posts(token_state):
     """
@@ -105,12 +114,12 @@ def guarded_fetch_posts(token_state):
     This function is guarded by token availability.
     """
     logging.info("Starting guarded_fetch_posts process.")
-    if not token_state or not token_state.get("token"):
+    if not token_state or not token_state.get("token"): # Checks for LinkedIn token
         logging.error("Access denied for guarded_fetch_posts. No LinkedIn token available.")
-        return "<p style='color:red; text-align:center;'>❌ Access denied. LinkedIn token not available.</p>"
+        return "<p style='color:red; text-align:center;'>❌ Access denied. LinkedIn token not available. Please ensure token is fetched via URL parameter.</p>"
 
     client_id = token_state.get("client_id")
-    token_dict = token_state.get("token")
+    token_dict = token_state.get("token") # This is the LinkedIn token dict
     org_urn = token_state.get('org_urn')
 
     if not org_urn:
@@ -118,20 +127,25 @@ def guarded_fetch_posts(token_state):
         return "<p style='color:red; text-align:center;'>❌ Configuration error: Organization URN missing.</p>"
     if not client_id or client_id == "ENV VAR MISSING":
         logging.error("Client ID not found or missing in token_state for guarded_fetch_posts.")
-        return "<p style='color:red; text-align:center;'>❌ Configuration error: LinkedIn Client ID missing.</p>"
+        return "<p style='color:red; text-align:center;'>❌ Configuration error: LinkedIn Client ID missing (check .env file or environment variables).</p>"
+
+    # Additional check: Ensure the button was meant to be clickable (i.e., Bubble posts were found)
+    # This is an indirect check, as the button's clickability should prevent this if UI works as intended.
+    # However, adding a check on bubble_posts_df might be redundant if the button is correctly managed.
+    # For now, relying on the LinkedIn token check as the primary guard for this function.
 
     try:
-        logging.info(f"Step 1: Fetching core posts for org_urn: {org_urn}")
+        logging.info(f"Step 1: Fetching core posts for org_urn: {org_urn} using LinkedIn API.")
         processed_raw_posts, stats_map, _ = fetch_linkedin_posts_core(client_id, token_dict, org_urn)
 
         if not processed_raw_posts:
-            logging.info("No posts found to process after step 1.")
-            return "<p style='color:orange; text-align:center;'>ℹ️ No new LinkedIn posts found to process.</p>"
+            logging.info("No posts found to process via LinkedIn API after step 1.")
+            return "<p style='color:orange; text-align:center;'>ℹ️ No new LinkedIn posts found to process at this time.</p>"
 
         post_urns = [post["id"] for post in processed_raw_posts if post.get("id")]
         logging.info(f"Extracted {len(post_urns)} post URNs for further processing.")
 
-        logging.info("Step 2: Fetching comments.")
+        logging.info("Step 2: Fetching comments via LinkedIn API.")
         all_comments_data = fetch_comments(client_id, token_dict, post_urns, stats_map)
 
         logging.info("Step 3: Analyzing sentiment.")
@@ -148,26 +162,20 @@ def guarded_fetch_posts(token_state):
         bulk_upload_to_bubble(li_post_stats, "LI_post_stats")
         bulk_upload_to_bubble(li_post_comments, "LI_post_comments")
 
-        logging.info("Successfully fetched and uploaded posts and comments to Bubble.")
-        return "<p style='color:green; text-align:center;'>✅ Posts and comments uploaded to Bubble.</p>"
+        logging.info("Successfully fetched from LinkedIn and uploaded posts and comments to Bubble.")
+        return "<p style='color:green; text-align:center;'>✅ Posts and comments from LinkedIn uploaded to Bubble.</p>"
 
     except ValueError as ve:
         logging.error(f"ValueError during LinkedIn data processing: {ve}")
         return f"<p style='color:red; text-align:center;'>❌ Error: {html.escape(str(ve))}</p>"
     except Exception as e:
-        logging.exception("An unexpected error occurred in guarded_fetch_posts.")
-        return "<p style='color:red; text-align:center;'>❌ An unexpected error occurred. Please check logs.</p>"
+        logging.exception("An unexpected error occurred in guarded_fetch_posts.") # Logs full traceback
+        return "<p style='color:red; text-align:center;'>❌ An unexpected error occurred while processing LinkedIn data. Please check logs.</p>"
 
 def guarded_fetch_dashboard(token_state):
     """Fetches and renders the dashboard if token is available."""
     if not token_state or not token_state.get("token"):
         return "❌ Access denied. No token available for dashboard."
-    # This function is not used in the current UI structure for the first tab's main content
-    # but kept for potential future use or if it's called elsewhere.
-    # The first tab's content is now primarily the button and its output.
-    # If you intend to display a dashboard here *after* fetching, this would need integration.
-    # For now, returning a placeholder or status.
-    # return fetch_and_render_dashboard(token_state.get("client_id"), token_state.get("token"))
     return "<p style='text-align: center; color: #555;'>Dashboard content would load here if implemented.</p>"
 
 
@@ -195,50 +203,43 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
     gr.Markdown("Token is supplied via URL parameter for Bubble.io lookup. Then explore dashboard and analytics.")
 
     url_user_token_display = gr.Textbox(label="User Token (from URL - Hidden)", interactive=False, visible=False)
-    status_box = gr.Textbox(label="Overall Token Status", interactive=False, value="Initializing...") # Initial status
-    org_urn_display = gr.Textbox(label="Organization URN (from URL - Hidden)", interactive=False, visible=False) # Renamed for clarity
+    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 user token and org URN from URL parameters
     app.load(fn=get_url_user_token, inputs=None, outputs=[url_user_token_display, org_urn_display])
 
     with gr.Tabs():
         with gr.TabItem("1️⃣ Dashboard & Sync"):
-            gr.Markdown("View your organization's recent posts and their engagement statistics. "
-                        "Fetch new posts from LinkedIn, analyze, and store them in Bubble.")
+            gr.Markdown("Fetch initial data from Bubble. If posts are found, you can choose to sync newer posts from LinkedIn.")
             
-            # Button is initially not visible and not interactive.
-            # Its state will be updated by process_and_store_bubble_token
             sync_posts_to_bubble_btn = gr.Button(
-                "🔄 Fetch, Analyze & Store Posts to Bubble",
+                "🔄 Fetch from LinkedIn, Analyze & Store to Bubble", # Updated label for clarity
                 variant="primary",
                 visible=False, 
                 interactive=False
             )
             
             dashboard_html_output = gr.HTML(
-                "<p style='text-align: center; color: #555;'>System initializing... Status and actions will appear shortly. "
-                "If data is found in Bubble, the 'Fetch, Analyze & Store' button will become active.</p>"
+                "<p style='text-align: center; color: #555;'>System initializing... "
+                "Checking for existing data in Bubble. The 'Fetch from LinkedIn...' button will activate if initial data is found.</p>"
             )
             
-            # Event: When URL token or org URN is loaded/changed, process it.
-            # This will update token_state and the sync_posts_to_bubble_btn.
-            # Using org_urn_display.change as the primary trigger after app.load completes.
-            # If get_url_user_token is very fast, app.load might be better, but .change is robust.
+            # Combined trigger: process tokens and Bubble data once both URL params are potentially loaded.
+            # Using .then() to chain after initial load.
+            # The `process_and_store_bubble_token` will run when `org_urn_display` (which is an output of app.load)
+            # receives its value.
             org_urn_display.change(
                 fn=process_and_store_bubble_token,
                 inputs=[url_user_token_display, org_urn_display, token_state],
-                outputs=[status_box, token_state, sync_posts_to_bubble_btn] # Added button to outputs
+                outputs=[status_box, token_state, sync_posts_to_bubble_btn] 
             )
-            # Also trigger if url_user_token_display changes, in case org_urn loads first
-            # but token processing depends on url_user_token_display.
-            # This creates a dependency: if one changes, the function runs with current values of both.
+            # Fallback if url_user_token_display changes after org_urn_display (less likely but for robustness)
             url_user_token_display.change(
                 fn=process_and_store_bubble_token,
                 inputs=[url_user_token_display, org_urn_display, token_state],
                 outputs=[status_box, token_state, sync_posts_to_bubble_btn]
             )
 
-            # Click handler for the sync button
             sync_posts_to_bubble_btn.click(
                 fn=guarded_fetch_posts, 
                 inputs=[token_state], 
@@ -246,9 +247,9 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
         with gr.TabItem("2️⃣ Analytics"):
-            gr.Markdown("View follower count and monthly gains for your organization.")
+            gr.Markdown("View follower count and monthly gains for your organization (requires LinkedIn token).")
             fetch_analytics_btn = gr.Button("📈 Fetch Follower Analytics", variant="primary")
-            follower_count = gr.Markdown("<p style='text-align: center; color: #555;'>Waiting for token...</p>")
+            follower_count = gr.Markdown("<p style='text-align: center; color: #555;'>Waiting for LinkedIn token...</p>")
 
             with gr.Row():
                 follower_plot, growth_plot = gr.Plot(), gr.Plot()
@@ -269,9 +270,9 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
         with gr.TabItem("3️⃣ Mentions"):
-            gr.Markdown("Analyze sentiment of recent posts that mention your organization.")
+            gr.Markdown("Analyze sentiment of recent posts that mention your organization (requires LinkedIn token).")
             fetch_mentions_btn = gr.Button("🧠 Fetch Mentions & Sentiment", variant="primary")
-            mentions_html = gr.HTML("<p style='text-align: center; color: #555;'>Waiting for token...</p>")
+            mentions_html = gr.HTML("<p style='text-align: center; color: #555;'>Waiting for LinkedIn token...</p>")
             mentions_plot = gr.Plot()
             fetch_mentions_btn.click(
                 fn=run_mentions_and_load,
@@ -279,18 +280,14 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 outputs=[mentions_html, mentions_plot]
             )
             
-    # Initial check of token status on app load (primarily for the status_box)
-    # The button visibility is handled by process_and_store_bubble_token
+    # This app.load updates the status_box based on the initial token_state.
+    # The process_and_store_bubble_token function will provide a more definitive update soon after.
     app.load(fn=lambda ts: check_token_status(ts), inputs=[token_state], outputs=status_box)
-    # Timer to periodically update the token status display (optional, but good for UX)
+    # Timer to periodically update the LinkedIn token status display
     gr.Timer(15.0).tick(fn=lambda ts: check_token_status(ts), inputs=[token_state], outputs=status_box)
 
 
 if __name__ == "__main__":
     if not os.environ.get("Linkedin_client_id"):
         logging.warning("WARNING: The 'Linkedin_client_id' environment variable is not set. The application may not function correctly for LinkedIn API calls.")
-    # Ensure the app launches.
-    # For testing, you might want share=False or specific server_name/port.
-    # share=True is useful for public sharing via Gradio link.
     app.launch(server_name="0.0.0.0", server_port=7860, share=True)
-    # app.launch(share=True) # Simpler launch for testing if specific port/host not needed