Update app.py

app.py

@@ -1,16 +1,21 @@
-# -*- coding: utf-8 -*-
 import gradio as gr
 import json
 import os
 import logging
 import html
+import pandas as pd
 
+# Import functions from your custom modules
 from Data_Fetching_and_Rendering import fetch_and_render_dashboard
 from analytics_fetch_and_rendering import fetch_and_render_analytics
 from mentions_dashboard import generate_mentions_dashboard
 from gradio_utils import get_url_user_token
-from Bubble_API_Calls import fetch_linkedin_token_from_bubble, bulk_upload_to_bubble
-
+# Updated import to include fetch_posts_from_bubble
+from Bubble_API_Calls import (
+    fetch_linkedin_token_from_bubble,
+    bulk_upload_to_bubble,
+    fetch_posts_from_bubble  # Added new function
+)
 from Linkedin_Data_API_Calls import (
     fetch_linkedin_posts_core,
     fetch_comments,
@@ -19,83 +24,125 @@ from Linkedin_Data_API_Calls import (
     prepare_data_for_bubble
 )
 
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
 def check_token_status(token_state):
+    """Checks the status of the LinkedIn token."""
     return "✅ Token available" if token_state and token_state.get("token") else "❌ Token not available"
 
-
 def process_and_store_bubble_token(url_user_token, org_urn, token_state):
-    new_state = token_state.copy() if token_state else {"token": None, "client_id": None, "org_urn": None}
-    new_state.update({"token": None, "org_urn": org_urn})
+    """
+    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.
+    """
+    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
+
+    # Default button state: invisible and non-interactive
+    button_update = gr.Button(
+        value="🔄 Fetch, Analyze & Store Posts to Bubble",
+        variant="primary",
+        visible=False,
+        interactive=False
+    )
 
     client_id = os.environ.get("Linkedin_client_id")
     if not client_id:
-        print("❌ CRITICAL ERROR: 'Linkedin_client_id' environment variable not set.")
+        logging.error("CRITICAL ERROR: 'Linkedin_client_id' environment variable not set.")
         new_state["client_id"] = "ENV VAR MISSING"
-        return check_token_status(new_state), new_state
-
-    new_state["client_id"] = client_id
-    if not url_user_token or "not found" in url_user_token or "Could not access" in url_user_token:
-        return check_token_status(new_state), new_state
-
-    print(f"Attempting to fetch token from Bubble with user token: {url_user_token}")
-    parsed = fetch_linkedin_token_from_bubble(url_user_token)
-
-    if isinstance(parsed, dict) and "access_token" in parsed:
-        new_state["token"] = parsed
-        print("✅ Token successfully fetched from Bubble.")
+        # 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:
-        print("❌ Failed to fetch a valid token from Bubble.")
-
-    return check_token_status(new_state), new_state
+        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.")
+    else:
+        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
+    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
+
+            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
+                )
+            else:
+                logging.info("ℹ️ No posts found in Bubble for this organization or DataFrame is empty. Sync button will remain hidden.")
+        except Exception as e:
+            logging.error(f"❌ Error fetching posts from Bubble: {e}")
+            # Keep button hidden on error
+    else:
+        logging.warning("Org URN not available in state. Cannot fetch posts from Bubble.")
+        
+    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
 
 def guarded_fetch_posts(token_state):
+    """
+    Fetches LinkedIn posts, analyzes them, and uploads to Bubble.
+    This function is guarded by token availability.
+    """
     logging.info("Starting guarded_fetch_posts process.")
     if not token_state or not token_state.get("token"):
-        logging.error("Access denied. No token available.")
-        return "<p style='color:red; text-align:center;'>❌ Access denied. No token available.</p>"
+        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>"
 
     client_id = token_state.get("client_id")
     token_dict = token_state.get("token")
-    org_urn = token_state.get('org_urn') # Ensure 'org_urn' is correctly fetched from token_state
+    org_urn = token_state.get('org_urn')
 
     if not org_urn:
-        logging.error("Organization URN (org_urn) not found in token_state.")
+        logging.error("Organization URN (org_urn) not found in token_state for guarded_fetch_posts.")
         return "<p style='color:red; text-align:center;'>❌ Configuration error: Organization URN missing.</p>"
-    if not client_id:
-        logging.error("Client ID not found in token_state.")
-        return "<p style='color:red; text-align:center;'>❌ Configuration error: Client ID 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>"
 
     try:
-        # Step 1: Fetch core post data (text, summary, category) and their basic stats
         logging.info(f"Step 1: Fetching core posts for org_urn: {org_urn}")
         processed_raw_posts, stats_map, _ = fetch_linkedin_posts_core(client_id, token_dict, org_urn)
-        # org_name is returned as the third item, captured as _ if not used directly here
 
         if not processed_raw_posts:
             logging.info("No posts found to process after step 1.")
-            return "<p style='color:orange; text-align:center;'>ℹ️ No posts found to process.</p>"
+            return "<p style='color:orange; text-align:center;'>ℹ️ No new LinkedIn posts found to process.</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.")
 
-        # Step 2: Fetch comments for these posts
         logging.info("Step 2: Fetching comments.")
         all_comments_data = fetch_comments(client_id, token_dict, post_urns, stats_map)
 
-        # Step 3: Analyze sentiment of the comments
         logging.info("Step 3: Analyzing sentiment.")
         sentiments_per_post = analyze_sentiment(all_comments_data)
 
-        # Step 4: Compile detailed post objects
         logging.info("Step 4: Compiling detailed posts.")
         detailed_posts = compile_detailed_posts(processed_raw_posts, stats_map, sentiments_per_post)
 
-        # Step 5: Prepare data for Bubble
         logging.info("Step 5: Preparing data for Bubble.")
         li_posts, li_post_stats, li_post_comments = prepare_data_for_bubble(detailed_posts, all_comments_data)
 
-        # Step 6: Bulk upload to Bubble
         logging.info("Step 6: Uploading data to Bubble.")
         bulk_upload_to_bubble(li_posts, "LI_posts")
         bulk_upload_to_bubble(li_post_stats, "LI_post_stats")
@@ -104,68 +151,94 @@ def guarded_fetch_posts(token_state):
         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>"
 
-    except ValueError as ve: # Catch specific errors like "Failed to fetch posts"
+    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.") # Logs full traceback
+        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>"
 
-
-
 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 "<p style='color:red; text-align:center;'>❌ Access denied. No token available.</p>"
-    return fetch_and_render_dashboard(token_state.get("client_id"), 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>"
 
 
 def guarded_fetch_analytics(token_state):
+    """Fetches and renders analytics if token is available."""
     if not token_state or not token_state.get("token"):
-        return ("<p style='color:red; text-align:center;'>❌ Access denied. No token available.</p>",
+        return ("❌ Access denied. No token available for analytics.",
                 None, None, None, None, None, None, None)
-
     return fetch_and_render_analytics(token_state.get("client_id"), token_state.get("token"))
 
-
 def run_mentions_and_load(token_state):
+    """Generates mentions dashboard if token is available."""
     if not token_state or not token_state.get("token"):
-        return ("<p style='color:red; text-align:center;'>❌ Access denied. No token available.</p>", None)
+        return ("❌ Access denied. No token available for mentions.", None)
     return generate_mentions_dashboard(token_state.get("client_id"), token_state.get("token"))
 
-
+# --- Gradio UI Blocks ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                title="LinkedIn Post Viewer & Analytics") as app:
 
-    token_state = gr.State(value={"token": None, "client_id": None, "org_urn": None})
+    # Initialize state with the new field for Bubble DataFrame
+    token_state = gr.State(value={"token": None, "client_id": None, "org_urn": None, "bubble_posts_df": None})
 
     gr.Markdown("# 🚀 LinkedIn Organization Post Viewer & Analytics")
     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)
-    org_urn = gr.Textbox(visible=False)  # Needed for input, was missing from initial script
-
-    app.load(fn=get_url_user_token, inputs=None, outputs=[url_user_token_display, org_urn])
-
-    url_user_token_display.change(
-        fn=process_and_store_bubble_token,
-        inputs=[url_user_token_display, org_urn, token_state],
-        outputs=[status_box, token_state]
-    )
+    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
 
-
-    app.load(fn=check_token_status, inputs=[token_state], outputs=status_box)
-    gr.Timer(5.0).tick(fn=check_token_status, inputs=[token_state], outputs=status_box)
+    # 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"):
-            gr.Markdown("View your organization's recent posts and their engagement statistics.")
+        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.")
             
-            sync_posts_to_bubble_btn = gr.Button("🔄 Fetch, Analyze & Store Posts to Bubble", variant="primary")
-            dashboard_html_output = gr.HTML("<p style='text-align: center; color: #555;'>Click the button to fetch posts and store them in Bubble. Status will appear here.</p>")
+            # 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",
+                variant="primary",
+                visible=False, 
+                interactive=False
+            )
             
-            # Corrected: The click handler now calls guarded_fetch_posts
-            # and dashboard_html_output is correctly defined in this scope.
+            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>"
+            )
+            
+            # 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.
+            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
+            )
+            # 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.
+            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], 
@@ -205,8 +278,19 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 inputs=[token_state],
                 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
+    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)
+    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"):
-        print("WARNING: The 'Linkedin_client_id' environment variable is not set. The application may not function correctly.")
+        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