Update app.py

app.py

@@ -1,24 +1,54 @@
 # -*- coding: utf-8 -*-
 import gradio as gr
 import json
+# Assuming these custom modules exist in your project directory or Python path
 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
 
-
-# Shared state
+# Shared state for token received via POST
 token_received = {"status": False, "token": None, "client_id": None}
 
-# --- Handlers for token reception and status ---
+# --- Function to get user_token from URL on load ---
+def get_url_user_token(request: gr.Request):
+    """
+    This function is called when the Gradio app loads.
+    It attempts to retrieve 'user_token' from the URL query parameters.
+    """
+    user_token_from_url = "user_token not found in URL" # Default message
+    if request:
+        # request.query_params is a dictionary-like object.
+        # Example URL: https://your-gradio-app/?user_token=ABC123XYZ
+        # query_params would be {'user_token': 'ABC123XYZ'}
+        retrieved_token = request.query_params.get("session_id")
+        if retrieved_token:
+            user_token_from_url = retrieved_token
+            print(f"Retrieved user_token from URL: {user_token_from_url}")
+        else:
+            print("user_token key was not found in the URL query parameters.")
+    else:
+        # This case should ideally not happen if app.load is configured correctly
+        # and Gradio supplies the request object.
+        print("Request object not available to get_url_user_token function.")
+        user_token_from_url = "Could not access request object on load"
+    return user_token_from_url
+
+# --- Handlers for token reception (POST) and status ---
 def receive_token(accessToken: str, client_id: str):
     """
     Called by a hidden POST mechanism to supply the OAuth code/token and client ID.
     """
     try:
+        # The .replace("'", '"') is kept from your original code.
+        # Be cautious if accessToken format can vary.
         token_dict = json.loads(accessToken.replace("'", '"'))
     except json.JSONDecodeError as e:
+        print(f"Error decoding accessToken: {e}")
+        token_received["status"] = False # Ensure status reflects failure
+        token_received["token"] = None
+        token_received["client_id"] = client_id # Keep client_id if provided
         return {
-            "status": "❌ Invalid token format",
+            "status": "❌ Invalid token format (POST)",
             "token": "",
             "client_id": client_id
         }
@@ -26,25 +56,28 @@ def receive_token(accessToken: str, client_id: str):
     token_received["status"] = True
     token_received["token"] = token_dict
     token_received["client_id"] = client_id
+    print(f"Token (from POST) received successfully. Client ID: {client_id}")
     return {
-        "status": "✅ Token received",
-        "token": token_dict.get("access_token", ""),
+        "status": "✅ Token received (POST)",
+        "token": token_dict.get("access_token", "Access token key missing"), # Display part of the token
         "client_id": client_id
     }
 
 def check_status():
-    return "✅ Token received" if token_received["status"] else "❌ Waiting for token…"
+    return "✅ Token received (POST)" if token_received["status"] else "❌ Waiting for token (POST)…"
 
-def show_token():
-    return token_received["token"].get("access_token", "") if token_received["status"] else ""
+def show_token(): # Shows token from POST
+    if token_received["status"] and token_received["token"]:
+        return token_received["token"].get("access_token", "Access token key missing")
+    return ""
 
-def show_client():
-    return token_received["client_id"] or "" if token_received["status"] else ""
+def show_client(): # Shows client_id from POST
+    return token_received["client_id"] if token_received["status"] and token_received["client_id"] else ""
 
-# --- Guarded fetch functions ---
+# --- Guarded fetch functions (using token from POST) ---
 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.</p>"
+        return "<p style='color:red; text-align:center;'>❌ Access denied. No token (POST) available. Please send token first.</p>"
     # token_received["client_id"] and token_received["token"] required by fetch function
     html = fetch_and_render_dashboard(
         token_received["client_id"],
@@ -52,53 +85,72 @@ def guarded_fetch_dashboard():
     )
     return html
 
-
 def guarded_fetch_analytics():
     if not token_received["status"]:
         return (
-            "<p style='color:red; text-align:center;'>❌ Access denied. No token available.</p>",
-            None,
-            None
+            "<p style='color:red; text-align:center;'>❌ Access denied. No token (POST) available.</p>",
+            None, None, None, None, None, None, None # Match number of outputs
         )
+    # Assuming fetch_and_render_analytics returns 8 values
     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"]
     )
     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"]: # Added guard similar to other functions
+        return ("<p style='color:red; text-align:center;'>❌ Access denied. No token (POST) available.</p>", None)
     html, fig = generate_mentions_dashboard(
         token_received["client_id"],
         token_received["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("Send your OAuth token via API call, then explore dashboard and analytics.")
+    gr.Markdown("Send your OAuth token via API call (POST), then explore dashboard and analytics. URL parameters can also be displayed.")
 
-    # Hidden elements: simulate POST endpoint
+    # Hidden elements: simulate POST endpoint for OAuth token
     hidden_token = gr.Textbox(visible=False, elem_id="hidden_token")
     hidden_client = gr.Textbox(visible=False, elem_id="hidden_client_id")
     hidden_btn = gr.Button(visible=False, elem_id="hidden_btn")
 
-    status_box = gr.Textbox(value=check_status(), label="Status", interactive=False)
-    token_display = gr.Textbox(value=show_token(), label="Access Token", interactive=False)
-    client_display = gr.Textbox(value=show_client(), label="Client ID", interactive=False)
+    # --- Display elements ---
+    # Textbox for the user_token from URL
+    url_user_token_display = gr.Textbox(label="User Token (from URL)", interactive=False, placeholder="Attempting to load from URL...")
+    
+    status_box = gr.Textbox(label="POST Token Status", interactive=False) # Clarified label
+    token_display = gr.Textbox(label="Access Token (from POST)", interactive=False)
+    client_display = gr.Textbox(label="Client ID (from POST)", interactive=False)
+
+    # --- Load URL parameter on app start ---
+    # The `get_url_user_token` function will be called when the app loads.
+    # `gr.Request` is automatically passed to `get_url_user_token`.
+    app.load(
+        fn=get_url_user_token,
+        inputs=None, # No explicit Gradio inputs needed, only gr.Request
+        outputs=[url_user_token_display]
+    )
 
-    # Wire hidden POST handler
+    # Wire hidden POST handler for OAuth token
     hidden_btn.click(
         fn=receive_token,
         inputs=[hidden_token, hidden_client],
         outputs=[status_box, token_display, client_display]
     )
 
-    # Polling timer to update status and displays
-    timer = gr.Timer(1.0)
+    # Polling timer to update status and displays for the POSTed token
+    # Initial values are set by app.load for status_box, token_display, client_display
+    # then updated by timer ticks or hidden_btn click.
+    # We call check_status, show_token, show_client once at load time and then via timer.
+    app.load(fn=check_status, outputs=status_box)
+    app.load(fn=show_token, outputs=token_display)
+    app.load(fn=show_client, outputs=client_display)
+    
+    timer = gr.Timer(1.0) # Poll every 1 second
     timer.tick(fn=check_status, outputs=status_box)
     timer.tick(fn=show_token, outputs=token_display)
     timer.tick(fn=show_client, outputs=client_display)
@@ -108,7 +160,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         with gr.TabItem("1️⃣ Dashboard"):
             gr.Markdown("View your organization's recent posts and their engagement statistics.")
             fetch_dashboard_btn = gr.Button("📊 Fetch Posts & Stats", variant="primary")
-            dashboard_html = gr.HTML(value="<p style='text-align: center; color: #555;'>Waiting for token...</p>")
+            dashboard_html = gr.HTML(value="<p style='text-align: center; color: #555;'>Waiting for POST token...</p>")
             fetch_dashboard_btn.click(
                 fn=guarded_fetch_dashboard,
                 inputs=[],
@@ -119,45 +171,47 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             gr.Markdown("View follower count and monthly gains for your organization.")
             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 POST token...</p>")
             
-            with gr.Row():  # Use Row to align the two plots side-by-side
-                follower_plot = gr.Plot(visible=False)
-                growth_rate_plot = gr.Plot(visible=False)
+            with gr.Row():
+                follower_plot = gr.Plot(visible=True) # Made visible, will be empty until data
+                growth_rate_plot = gr.Plot(visible=True) # Made visible
 
             with gr.Row():
-                post_eng_rate_plot = gr.Plot(visible=False)
+                post_eng_rate_plot = gr.Plot(visible=True) # Made visible
 
             with gr.Row():
-                interaction_data = gr.Plot(visible=False)
+                interaction_data = gr.Plot(visible=True) # Made visible
 
             with gr.Row():
-                eb_data = gr.Plot(visible=False)
+                eb_data = gr.Plot(visible=True) # Made visible
 
             with gr.Row():
-                mentions_vol_data = gr.Plot(visible=False)
-                mentions_sentiment_data = gr.Plot(visible=False)
-        
+                mentions_vol_data = gr.Plot(visible=True) # Made visible
+                mentions_sentiment_data = gr.Plot(visible=True) # Made visible
+            
             fetch_analytics_btn.click(
                 fn=guarded_fetch_analytics,
                 inputs=[],
-                outputs=[follower_count, follower_plot, growth_rate_plot, post_eng_rate_plot, interaction_data, eb_data, mentions_vol_data, mentions_sentiment_data]
+                outputs=[follower_count, follower_plot, growth_rate_plot, post_eng_rate_plot, interaction_data, eb_data, mentions_vol_data, mentions_sentiment_data],
+                # Show plots after click; they might need to be initially invisible if fetch_and_render_analytics can return None for plots on error
+                # For simplicity, keeping them visible. Handle None returns in your fetch function if necessary.
             )
 
-
         with gr.TabItem("3️⃣ Mentions"):
             gr.Markdown("Analyze sentiment of recent posts that mention your organization.")
             fetch_mentions_btn = gr.Button("🧠 Fetch Mentions & Sentiment", variant="primary")
-            mentions_html = gr.HTML()
-            mentions_plot = gr.Plot(visible=False)
+            mentions_html = gr.HTML(value="<p style='text-align: center; color: #555;'>Waiting for POST token...</p>") # Added placeholder
+            mentions_plot = gr.Plot(visible=True) # Made visible
             fetch_mentions_btn.click(
                 fn=run_mentions_and_load,
                 inputs=[],
                 outputs=[mentions_html, mentions_plot]
             )
 
-
- 
 # Launch the app
 if __name__ == "__main__":
+    # The share=True option creates a public link. Be mindful of security.
+    # For embedding, you'll use the server_name and server_port you configure for your hosting.
     app.launch(server_name="0.0.0.0", server_port=7860, share=True)
+