Update app.py

app.py

@@ -1,9 +1,8 @@
 # -*- coding: utf-8 -*-
 import gradio as gr
 import json
-import requests # Added for API calls
-import os # Added for environment variables
-import urllib.parse # Added for URL encoding (though requests handles params well)
+# requests, os, urllib.parse are used by Bubble_API_Calls.py, not directly here anymore
+# but good to keep if you add other direct calls later.
 
 # Assuming these custom modules exist in your project directory or Python path
 from Data_Fetching_and_Rendering import fetch_and_render_dashboard
@@ -11,94 +10,113 @@ from analytics_fetch_and_rendering import fetch_and_render_analytics
 from mentions_dashboard import generate_mentions_dashboard
 
 # Import the function from your utils file
-from gradio_utils import get_url_user_token # Assuming gradio_utils.py is in the same directory
+from gradio_utils import get_url_user_token 
+# Import the Bubble API call function (ensure filename matches: Bubble_API_Calls.py)
 from Bubble_API_Calls import fetch_linkedin_token_from_bubble
 
-# Shared state for token received via POST or Bubble
-token_received = {"status": False, "token": None, "client_id": None}
+# --- Session State dependent functions ---
+def check_token_status(current_token_state):
+    """Checks if a valid token exists in the session state."""
+    if current_token_state and current_token_state.get("token") and current_token_state.get("status"):
+        return "✅ Token available"
+    return "❌ Waiting for token…"
+
+def get_active_client_id(current_token_state):
+    """Gets the client_id from the session state if a token is available."""
+    if current_token_state and current_token_state.get("token") and current_token_state.get("status"):
+        return current_token_state.get("client_id", "Client ID not set")
+    return ""
 
-# --- Handlers for token reception (POST) and status ---
-def receive_token(accessToken: str, client_id: str):
+# --- Function to process and store token from Bubble ---
+def process_and_store_bubble_token(url_user_token_str, current_token_state):
     """
-    Called by a hidden POST mechanism to supply the OAuth code/token and client ID.
+    Fetches token from Bubble, updates session state, and returns UI update values.
+    Args:
+        url_user_token_str: The token string extracted from the URL.
+        current_token_state: The current session state for the token.
+    Returns:
+        Tuple: (bubble_api_status_msg, overall_status, client_id_display, updated_token_state)
     """
-    try:
-        token_dict = json.loads(accessToken.replace("'", '"'))
-    except json.JSONDecodeError as e:
-        print(f"Error decoding accessToken (POST): {e}")
-        token_received["status"] = False
-        token_received["token"] = None
-        token_received["client_id"] = client_id
-        return "❌ Invalid token format (POST)", "", client_id
-    
-    token_received["status"] = True
-    token_received["token"] = token_dict # This should be the dict like {"access_token": "value"}
-    token_received["client_id"] = client_id
-    print(f"Token (from POST) received successfully. Client ID: {client_id}")
-    # Update status box, token display, client display directly
-    return check_status(), show_token(), show_client()
-
-
-def check_status():
-    return "✅ Token available" if token_received["status"] else "❌ Waiting for token…"
-
-def show_token(): # Shows access_token if available
-    if token_received["status"] and token_received["token"] and isinstance(token_received["token"], dict):
-        return token_received["token"].get("access_token", "Access token key missing in dict")
-    elif token_received["status"] and token_received["token"]: # If token is a raw string (should not happen with new logic)
-        return str(token_received["token"]) # Fallback, but ideally token_received["token"] is always a dict if status is True
-    return ""
-
-def show_client():
-    return token_received["client_id"] if token_received["status"] and token_received["client_id"] else ""
-
-
-
-# --- Guarded fetch functions (using token from POST or Bubble) ---
-# These functions expect token_received["token"] to be a dictionary 
-# like {"access_token": "actual_token_value", ...}
-def guarded_fetch_dashboard():
-    if not token_received["status"]:
-        return "<p style='color:red; text-align:center;'>❌ Access denied. No token available. Please send token first or ensure URL token is valid.</p>"
+    bubble_api_status_msg = "Waiting for URL token..."
+    new_token_state = current_token_state.copy() if current_token_state else {"status": False, "token": None, "client_id": None}
+
+    if not url_user_token_str or "not found" in url_user_token_str or "Could not access" in url_user_token_str:
+        bubble_api_status_msg = f"ℹ️ No valid user token from URL to query Bubble. ({url_user_token_str})"
+        # Even if no valid URL token, return current status based on existing state
+        return bubble_api_status_msg, check_token_status(new_token_state), get_active_client_id(new_token_state), new_token_state
+
+    print(f"Attempting to fetch token from Bubble with state: {url_user_token_str}")
+    parsed_token_dict = fetch_linkedin_token_from_bubble(url_user_token_str)
+
+    if parsed_token_dict and isinstance(parsed_token_dict, dict) and "access_token" in parsed_token_dict:
+        new_token_state["status"] = True
+        new_token_state["token"] = parsed_token_dict
+        new_token_state["client_id"] = f"Bubble (state: {url_user_token_str})"
+        bubble_api_status_msg = f"✅ Token successfully fetched from Bubble for state: {url_user_token_str}"
+        print(bubble_api_status_msg)
+    else:
+        # Fetch failed or no valid token returned, keep previous state or mark as no token
+        # If you want a Bubble failure to explicitly clear any old token:
+        # new_token_state["status"] = False
+        # new_token_state["token"] = None
+        # new_token_state["client_id"] = None 
+        # For now, it just means the Bubble fetch didn't provide a new one.
+        bubble_api_status_msg = f"❌ Failed to fetch a valid token from Bubble for state: {url_user_token_str}. Check console logs from Bubble_API_Calls.py."
+        print(bubble_api_status_msg)
+        # If the goal is that ONLY a successful bubble fetch provides a token, then reset status:
+        new_token_state["status"] = False
+        new_token_state["token"] = None
+        # client_id might be kept or cleared based on preference
+        # new_token_state["client_id"] = f"Bubble fetch failed (state: {url_user_token_str})"
+
+
+    return bubble_api_status_msg, check_token_status(new_token_state), get_active_client_id(new_token_state), new_token_state
+
+# --- Guarded fetch functions (now use token_state) ---
+def guarded_fetch_dashboard(current_token_state):
+    if not (current_token_state and current_token_state.get("status") and current_token_state.get("token")):
+        return "<p style='color:red; text-align:center;'>❌ Access denied. No token available.</p>"
     html = fetch_and_render_dashboard(
-        token_received["client_id"],
-        token_received["token"] 
+        current_token_state["client_id"],
+        current_token_state["token"] 
     )
     return html
 
-def guarded_fetch_analytics():
-    if not token_received["status"]:
+def guarded_fetch_analytics(current_token_state):
+    if not (current_token_state and current_token_state.get("status") and current_token_state.get("token")):
         return (
             "<p style='color:red; text-align:center;'>❌ Access denied. No token available.</p>",
             None, None, None, None, None, None, None 
         )
+    client_id = current_token_state["client_id"]
+    token_data = current_token_state["token"]
     count_md, plot, growth_plot, avg_post_eng_rate, interaction_metrics, eb_metrics, mentions_vol_metrics, mentions_sentiment_metrics = fetch_and_render_analytics(
-        token_received["client_id"],
-        token_received["token"] 
+        client_id,
+        token_data
     )
     return count_md, plot, growth_plot, avg_post_eng_rate, interaction_metrics, eb_metrics, mentions_vol_metrics, mentions_sentiment_metrics
 
-def run_mentions_and_load():
-    if not token_received["status"]:
+def run_mentions_and_load(current_token_state):
+    if not (current_token_state and current_token_state.get("status") and current_token_state.get("token")):
         return ("<p style='color:red; text-align:center;'>❌ Access denied. No token available.</p>", None)
     html, fig = generate_mentions_dashboard(
-        token_received["client_id"],
-        token_received["token"] 
+        current_token_state["client_id"],
+        current_token_state["token"] 
     )
     return html, fig
 
 # --- Build the Gradio UI ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                title="LinkedIn Post Viewer & Analytics") as app:
-    gr.Markdown("# 🚀 LinkedIn Organization Post Viewer & Analytics")
-    gr.Markdown("Token can be supplied via URL parameter (for Bubble.io lookup) or hidden POST. Then explore dashboard and analytics.")
+    
+    # Session state to store the token info
+    # Initial value is a dictionary representing an unauthenticated state.
+    token_state = gr.State(value={"status": False, "token": None, "client_id": None})
 
-    # Hidden elements: simulate POST endpoint for OAuth token
-    hidden_token_input = gr.Textbox(visible=False, elem_id="hidden_token") 
-    hidden_client_input = gr.Textbox(visible=False, elem_id="hidden_client_id") 
-    hidden_btn = gr.Button(visible=False, elem_id="hidden_btn")
+    gr.Markdown("# 🚀 LinkedIn Organization Post Viewer & Analytics")
+    gr.Markdown("Token is supplied via URL parameter for Bubble.io lookup. Then explore dashboard and analytics.")
 
-    # --- Display elements ---
+    # Hidden textbox to capture token from URL
     url_user_token_display = gr.Textbox(
         label="User Token (from URL - Hidden)", 
         interactive=False, 
@@ -106,39 +124,38 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         visible=False 
     )
     
-    parsed_token_dict = gr.Textbox(label="Bubble API Call Status", interactive=False, placeholder="Waiting for URL token...")
+    # Display for Bubble API call status
+    bubble_api_status_display = gr.Textbox(label="Bubble API Call Status", interactive=False, placeholder="Waiting for URL token...")
 
+    # Overall status displays
     status_box = gr.Textbox(label="Overall Token Status", interactive=False) 
-    token_display = gr.Textbox(label="Access Token (Active)", interactive=False)
     client_display = gr.Textbox(label="Client ID (Active)", interactive=False)
+    # Note: The textbox for displaying the actual token is removed.
 
     # --- Load URL parameter on app start & Link to Bubble Fetch ---
     app.load(
         fn=get_url_user_token, 
-        inputs=None, 
+        inputs=None, # get_url_user_token takes gr.Request implicitly
         outputs=[url_user_token_display] 
     )
 
+    # When the hidden url_user_token_display changes (due to app.load),
+    # trigger the Bubble API call and update session state.
     url_user_token_display.change(
-        fn=fetch_linkedin_token_from_bubble,
-        inputs=[url_user_token_display],
-        outputs=[parsed_token_dict]
-    )
-
-    hidden_btn.click(
-        fn=receive_token,
-        inputs=[hidden_token_input, hidden_client_input],
-        outputs=[status_box, token_display, client_display] 
+        fn=process_and_store_bubble_token,
+        inputs=[url_user_token_display, token_state], # Pass current state
+        outputs=[bubble_api_status_display, status_box, client_display, token_state] # Update UI and state
     )
     
-    app.load(fn=check_status, outputs=status_box)
-    app.load(fn=show_token, outputs=token_display)
-    app.load(fn=show_client, outputs=client_display)
+    # Initial UI state based on initial token_state
+    app.load(fn=check_token_status, inputs=[token_state], outputs=status_box)
+    app.load(fn=get_active_client_id, inputs=[token_state], outputs=client_display)
     
-    timer = gr.Timer(2.0) 
-    timer.tick(fn=check_status, outputs=status_box)
-    timer.tick(fn=show_token, outputs=token_display)
-    timer.tick(fn=show_client, outputs=client_display)
+    # Timer to periodically update status (e.g., if token could expire or be managed externally)
+    # This might be less critical if token acquisition is only at the start via URL.
+    timer = gr.Timer(5.0) # Poll every 5 seconds, adjust as needed
+    timer.tick(fn=check_token_status, inputs=[token_state], outputs=status_box)
+    timer.tick(fn=get_active_client_id, inputs=[token_state], outputs=client_display)
 
     # Tabs for functionality
     with gr.Tabs():
@@ -148,7 +165,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             dashboard_html = gr.HTML(value="<p style='text-align: center; color: #555;'>Waiting for token...</p>")
             fetch_dashboard_btn.click(
                 fn=guarded_fetch_dashboard,
-                inputs=[],
+                inputs=[token_state], # Pass session state
                 outputs=[dashboard_html]
             )
 
@@ -161,23 +178,19 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             with gr.Row():
                 follower_plot = gr.Plot(visible=True) 
                 growth_rate_plot = gr.Plot(visible=True)
-
             with gr.Row():
                 post_eng_rate_plot = gr.Plot(visible=True)
-
             with gr.Row():
                 interaction_data = gr.Plot(visible=True)
-
             with gr.Row():
                 eb_data = gr.Plot(visible=True)
-
             with gr.Row():
                 mentions_vol_data = gr.Plot(visible=True)
                 mentions_sentiment_data = gr.Plot(visible=True)
             
             fetch_analytics_btn.click(
                 fn=guarded_fetch_analytics,
-                inputs=[],
+                inputs=[token_state], # Pass session state
                 outputs=[follower_count, follower_plot, growth_rate_plot, post_eng_rate_plot, interaction_data, eb_data, mentions_vol_data, mentions_sentiment_data]
             )
 
@@ -188,14 +201,11 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             mentions_plot = gr.Plot(visible=True)
             fetch_mentions_btn.click(
                 fn=run_mentions_and_load,
-                inputs=[],
+                inputs=[token_state], # Pass session state
                 outputs=[mentions_html, mentions_plot]
             )
 
 # Launch the app
 if __name__ == "__main__":
     # Ensure the 'Bubble_API' environment variable is set where this app is run.
-    # For local testing, you can set it in your terminal before running:
-    # export Bubble_API="YOUR_ACTUAL_BUBBLE_API_KEY"
-    # python app.py
     app.launch(server_name="0.0.0.0", server_port=7860, share=True)