Update app.py

app.py

@@ -4,7 +4,8 @@ import json
 import os
 import logging
 import html
-import pandas as pd # Ensure pandas is imported if you're dealing with DataFrames
+import pandas as pd # Ensure pandas is imported
+from datetime import datetime # Used for pd.Timestamp
 
 # Import functions from your custom modules
 from Data_Fetching_and_Rendering import fetch_and_render_dashboard
@@ -15,7 +16,7 @@ from gradio_utils import get_url_user_token
 from Bubble_API_Calls import (
     fetch_linkedin_token_from_bubble,
     bulk_upload_to_bubble,
-    fetch_linkedin_posts_data_from_bubble  # Added new function
+    fetch_linkedin_posts_data_from_bubble
 )
 from Linkedin_Data_API_Calls import (
     fetch_linkedin_posts_core,
@@ -34,21 +35,20 @@ def check_token_status(token_state):
 
 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.
+    Processes user token, fetches LinkedIn token, fetches Bubble posts,
+    and determines if an initial fetch or update is needed for LinkedIn posts.
+    Updates token state and UI for the sync button.
     """
     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}
-    # 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")}) 
+    new_state = token_state.copy() if token_state else {
+        "token": None, "client_id": None, "org_urn": None, 
+        "bubble_posts_df": None, "fetch_count_for_api": 0 
+    }
+    new_state.update({"org_urn": org_urn, "bubble_posts_df": new_state.get("bubble_posts_df"), "fetch_count_for_api": new_state.get("fetch_count_for_api", 0)})
 
-    # Determine button properties - default to hidden and non-interactive
-    button_visible = True
-    button_interactive = True
+    # Default button update: hidden and non-interactive
+    button_update = gr.update(visible=False, interactive=False, value="🔄 Sync LinkedIn Posts")
 
     client_id = os.environ.get("Linkedin_client_id")
     if not client_id:
@@ -57,87 +57,131 @@ def process_and_store_bubble_token(url_user_token, org_urn, token_state):
     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}")
         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
+                new_state["token"] = parsed_linkedin_token
                 logging.info("✅ LinkedIn Token successfully fetched from Bubble.")
             else:
-                new_state["token"] = None # Explicitly set to None if fetch fails
+                new_state["token"] = None
                 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
+            new_state["token"] = None
             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
+        new_state["token"] = None
         logging.info("No valid URL user token provided for LinkedIn token fetch, or an error was indicated.")
 
-    # Fetch posts from Bubble using org_urn
+    # Fetch posts from Bubble
     current_org_urn = new_state.get("org_urn")
+    bubble_posts_df = None 
     if current_org_urn:
         logging.info(f"Attempting to fetch posts from Bubble for org_urn: {current_org_urn}")
         try:
-            # Assuming fetch_linkedin_posts_data_from_bubble returns a Pandas DataFrame or None
-            bubble_posts_df, error_message  = fetch_linkedin_posts_data_from_bubble(current_org_urn, "LI_posts")
-            new_state["bubble_posts_df"] = bubble_posts_df # Store DataFrame in state
-            logging.info(f"df  {len(bubble_posts_df)}")
-
-            if bubble_posts_df is not None and not new_state["bubble_posts_df"].empty:
-                logging.info(f"✅ Successfully fetched {len(bubble_posts_df)} posts from Bubble. Sync button will be disabled.")
-                button_visible = False
-                button_interactive = False
+            fetched_df, error_message = fetch_linkedin_posts_data_from_bubble(current_org_urn, "LI_posts")
+            if error_message:
+                logging.warning(f"Error reported by fetch_linkedin_posts_data_from_bubble: {error_message}. Treating as no data.")
             else:
-                logging.info("ℹ️ No posts found in Bubble for this organization or DataFrame is empty. Sync button will get visible.")
-                # button_visible and button_interactive remain False
+                bubble_posts_df = fetched_df
+            new_state["bubble_posts_df"] = bubble_posts_df
         except Exception as e:
-            logging.error(f"❌ Error fetching posts from Bubble: {e}")
-            # button_visible and button_interactive remain False
+            logging.error(f"❌ Error fetching posts from Bubble: {e}. Treating as no data.")
+            new_state["bubble_posts_df"] = None # Ensure it's None on error
     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) # 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
+
+    # Logic for determining fetch/update based on bubble_posts_df
+    # DATE_COLUMN_NAME is now 'published_at' and contains ISO datetime strings.
+    DATE_COLUMN_NAME = 'published_at' 
+    DEFAULT_INITIAL_FETCH_COUNT = 100 # Standard number of posts for initial fetch
+
+    if new_state["bubble_posts_df"] is None or new_state["bubble_posts_df"].empty:
+        logging.info(f"ℹ️ No posts found in Bubble or DataFrame is empty. Button to fetch initial {DEFAULT_INITIAL_FETCH_COUNT} posts will be visible.")
+        new_state['fetch_count_for_api'] = DEFAULT_INITIAL_FETCH_COUNT
+        button_update = gr.update(value=f"🔄 Fetch Initial {DEFAULT_INITIAL_FETCH_COUNT} LinkedIn Posts", visible=True, interactive=True)
+    else:
+        try:
+            df_for_date_check = new_state["bubble_posts_df"].copy() # Use a copy to avoid SettingWithCopyWarning
+            if DATE_COLUMN_NAME not in df_for_date_check.columns:
+                logging.warning(f"Date column '{DATE_COLUMN_NAME}' not found in Bubble posts DataFrame. Assuming initial fetch of {DEFAULT_INITIAL_FETCH_COUNT} posts.")
+                new_state['fetch_count_for_api'] = DEFAULT_INITIAL_FETCH_COUNT
+                button_update = gr.update(value=f"🔄 Fetch Initial {DEFAULT_INITIAL_FETCH_COUNT} (Date Column Missing)", visible=True, interactive=True)
+            elif df_for_date_check[DATE_COLUMN_NAME].isnull().all():
+                logging.warning(f"Date column '{DATE_COLUMN_NAME}' contains all null values. Assuming initial fetch of {DEFAULT_INITIAL_FETCH_COUNT} posts.")
+                new_state['fetch_count_for_api'] = DEFAULT_INITIAL_FETCH_COUNT
+                button_update = gr.update(value=f"🔄 Fetch Initial {DEFAULT_INITIAL_FETCH_COUNT} (Date Column Empty)", visible=True, interactive=True)
+            else:
+                # Convert ISO datetime strings to datetime objects
+                df_for_date_check[DATE_COLUMN_NAME] = pd.to_datetime(df_for_date_check[DATE_COLUMN_NAME], errors='coerce', utc=True)
+                last_post_date_utc = df_for_date_check[DATE_COLUMN_NAME].dropna().max()
+
+                if pd.isna(last_post_date_utc):
+                    logging.warning(f"No valid dates found in '{DATE_COLUMN_NAME}' after conversion. Assuming initial fetch of {DEFAULT_INITIAL_FETCH_COUNT} posts.")
+                    new_state['fetch_count_for_api'] = DEFAULT_INITIAL_FETCH_COUNT
+                    button_update = gr.update(value=f"🔄 Fetch Initial {DEFAULT_INITIAL_FETCH_COUNT} (No Valid Dates)", visible=True, interactive=True)
+                else:
+                    today_utc = pd.Timestamp('now', tz='UTC').normalize() 
+                    last_post_date_utc_normalized = last_post_date_utc.normalize()
+
+                    time_difference_days = (today_utc - last_post_date_utc_normalized).days
+                    logging.info(f"Last post date (UTC, normalized): {last_post_date_utc_normalized}, Today (UTC, normalized): {today_utc}, Difference: {time_difference_days} days.")
+
+                    if time_difference_days >= 7:
+                        num_weeks = max(1, time_difference_days // 7) 
+                        fetch_count = num_weeks * 10
+                        new_state['fetch_count_for_api'] = fetch_count
+                        button_label = f"🔄 Update Last {num_weeks} Week(s) (~{fetch_count} Posts)"
+                        logging.info(f"Data is {time_difference_days} days old. Update needed for {num_weeks} weeks, ~{fetch_count} posts.")
+                        button_update = gr.update(value=button_label, visible=True, interactive=True)
+                    else:
+                        logging.info(f"Data is fresh ({time_difference_days} days old). No update needed now.")
+                        new_state['fetch_count_for_api'] = 0 
+                        button_update = gr.update(visible=False, interactive=False)
+        except Exception as e:
+            logging.error(f"Error processing dates from Bubble posts: {e}. Defaulting to initial fetch of {DEFAULT_INITIAL_FETCH_COUNT} posts.")
+            new_state['fetch_count_for_api'] = DEFAULT_INITIAL_FETCH_COUNT
+            button_update = gr.update(value=f"🔄 Fetch Initial {DEFAULT_INITIAL_FETCH_COUNT} (Date Error)", visible=True, interactive=True)
+            
+    token_status_message = check_token_status(new_state)
+    logging.info(f"Token processing complete. LinkedIn Token Status: {token_status_message}. Button update: {button_update}. Fetch count for API: {new_state['fetch_count_for_api']}")
+    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.
+    Fetches LinkedIn posts based on 'fetch_count_for_api' in token_state, 
+    analyzes them, and uploads to Bubble.
     """
     logging.info("Starting guarded_fetch_posts process.")
-    if not token_state or not token_state.get("token"): # Checks for LinkedIn token
+    if not token_state or not token_state.get("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. Please ensure token is fetched via URL parameter.</p>"
+        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") # This is the LinkedIn token dict
+    token_dict = token_state.get("token")
     org_urn = token_state.get('org_urn')
+    fetch_count_value = token_state.get('fetch_count_for_api') 
 
     if not org_urn:
         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 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 (check .env file or environment variables).</p>"
+        return "<p style='color:red; text-align:center;'>❌ Configuration error: LinkedIn Client ID missing.</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.
+    if fetch_count_value == 0: 
+        logging.info("guarded_fetch_posts called, but fetch_count_for_api is 0. Data is fresh.")
+        return "<p style='color:green; text-align:center;'>✅ Data is already up-to-date. No new posts fetched.</p>"
+    
+    if fetch_count_value is None: # Should ideally not happen with new logic, but as a safeguard
+        logging.warning("fetch_count_for_api is None in guarded_fetch_posts. This might indicate an issue. Defaulting to fetching a standard amount if your API supports it or all.")
+        # Depending on your API, None might mean fetch all or a default.
+        # If your API requires a specific count for "all", you might need to adjust here or in fetch_linkedin_posts_core.
 
     try:
-        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)
+        logging.info(f"Step 1: Fetching core posts for org_urn: {org_urn}. Fetch count parameter for API: {fetch_count_value}")
+        processed_raw_posts, stats_map, _ = fetch_linkedin_posts_core(client_id, token_dict, org_urn, count=fetch_count_value)
 
         if not processed_raw_posts:
             logging.info("No posts found to process via LinkedIn API after step 1.")
@@ -163,32 +207,33 @@ 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 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>"
+        action_performed = f"Initial data fetch (~{fetch_count_value} posts)" if fetch_count_value == DEFAULT_INITIAL_FETCH_COUNT else f"Data update (target: ~{fetch_count_value} posts)"
+        logging.info(f"Successfully completed: {action_performed}. Uploaded posts and comments to Bubble.")
+        return f"<p style='color:green; text-align:center;'>✅ {action_performed} complete. 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.") # Logs full traceback
-        return "<p style='color:red; text-align:center;'>❌ An unexpected error occurred while processing LinkedIn data. Please check logs.</p>"
+        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 "❌ Access denied. No token available for dashboard."
-    return "<p style='text-align: center; color: #555;'>Dashboard content would load here if implemented.</p>"
+    if token_state.get("bubble_posts_df") is not None and not token_state["bubble_posts_df"].empty:
+        return f"<p style='text-align: center;'>Dashboard would show {len(token_state['bubble_posts_df'])} posts from Bubble.</p>"
+    else:
+        return "<p style='text-align: center; color: #555;'>No posts loaded from Bubble yet for the dashboard.</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 ("❌ 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 ("❌ Access denied. No token available for mentions.", None)
     return generate_mentions_dashboard(token_state.get("client_id"), token_state.get("token"))
@@ -197,44 +242,50 @@ def run_mentions_and_load(token_state):
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                title="LinkedIn Post Viewer & Analytics") as app:
 
-    # 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})
+    # Define DEFAULT_INITIAL_FETCH_COUNT here if needed by guarded_fetch_posts for its messages,
+    # or ensure it's passed/accessible if logic depends on it there.
+    # For now, it's only used within process_and_store_bubble_token.
+    DEFAULT_INITIAL_FETCH_COUNT = 100 
+
+
+    token_state = gr.State(value={
+        "token": None, 
+        "client_id": None, 
+        "org_urn": None, 
+        "bubble_posts_df": None,
+        "fetch_count_for_api": 0 
+    })
 
     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 LinkedIn Token Status", interactive=False, value="Initializing...") 
+    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)
 
     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("Fetch initial data from Bubble. If posts are found, you can choose to sync newer posts from LinkedIn.")
+            gr.Markdown("System checks for existing data in Bubble. The button below will activate if new posts need to be fetched or updated from LinkedIn.")
             
             sync_posts_to_bubble_btn = gr.Button(
-                "🔄 Fetch from LinkedIn, Analyze & Store to Bubble", # Updated label for clarity
+                value="🔄 Sync LinkedIn Posts", 
                 variant="primary",
-                visible=False, 
+                visible=False,    
                 interactive=False
             )
             
             dashboard_html_output = gr.HTML(
                 "<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>"
+                "Checking for existing data in Bubble and LinkedIn token.</p>"
             )
             
-            # 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] 
+                outputs=[status_box, token_state, sync_posts_to_bubble_btn]    
             )
-            # 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],
@@ -242,11 +293,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             )
 
             sync_posts_to_bubble_btn.click(
-                fn=guarded_fetch_posts, 
-                inputs=[token_state], 
+                fn=guarded_fetch_posts,    
+                inputs=[token_state],    
                 outputs=[dashboard_html_output]
+            ).then( 
+                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]
             )
-
+            
         with gr.TabItem("2️⃣ Analytics"):
             gr.Markdown("View follower count and monthly gains for your organization (requires LinkedIn token).")
             fetch_analytics_btn = gr.Button("📈 Fetch Follower Analytics", variant="primary")
@@ -281,10 +336,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 outputs=[mentions_html, mentions_plot]
             )
             
-    # 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 LinkedIn token status display
     gr.Timer(15.0).tick(fn=lambda ts: check_token_status(ts), inputs=[token_state], outputs=status_box)