Update analytics_fetch_and_rendering.py

analytics_fetch_and_rendering.py

@@ -1,349 +1,148 @@
 import json
 import requests
-from sessions import create_session
-from datetime import datetime, timezone, timedelta # Added timezone, timedelta
-import matplotlib.pyplot as plt # Added for plotting
-from error_handling import display_error
+from datetime import datetime, timezone, timedelta
+import matplotlib.pyplot as plt
 import gradio as gr
 import traceback
 import html
 
+from sessions import create_session
+from error_handling import display_error
 
 API_V2_BASE = 'https://api.linkedin.com/v2'
-API_REST_BASE = "https://api.linkedin.com/rest"
+API_REST_BASE = 'https://api.linkedin.com/rest'
 
 def extract_follower_gains(data):
-    """Extracts monthly follower gains from API response."""
-    results = []
-    print(f"Raw gains data received for extraction: {json.dumps(data, indent=2)}") # Debug print
     elements = data.get("elements", [])
     if not elements:
-        print("Warning: No 'elements' found in follower statistics response.")
         return []
 
+    results = []
     for item in elements:
-        time_range = item.get("timeRange", {})
-        start_timestamp = time_range.get("start")
-        if start_timestamp is None:
-            print("Warning: Skipping item due to missing start timestamp.")
+        start_timestamp = item.get("timeRange", {}).get("start")
+        if not start_timestamp:
             continue
 
-        # Convert timestamp to YYYY-MM format for clearer labeling
-        # Use UTC timezone explicitly
         try:
-            date_obj = datetime.fromtimestamp(start_timestamp / 1000, tz=timezone.utc)
-            # Format as Year-Month (e.g., 2024-03)
-            date_str = date_obj.strftime('%Y-%m')
-        except Exception as time_e:
-            print(f"Warning: Could not parse timestamp {start_timestamp}. Error: {time_e}. Skipping item.")
+            date_str = datetime.fromtimestamp(start_timestamp / 1000, tz=timezone.utc).strftime('%Y-%m')
+        except Exception:
             continue
 
-        follower_gains = item.get("followerGains", {})
-        # Handle potential None values from API by defaulting to 0
-        organic_gain = follower_gains.get("organicFollowerGain", 0) or 0
-        paid_gain = follower_gains.get("paidFollowerGain", 0) or 0
-
+        gains = item.get("followerGains", {})
         results.append({
-            "date": date_str, # Store simplified date string
-            "organic": organic_gain,
-            "paid": paid_gain
+            "date": date_str,
+            "organic": gains.get("organicFollowerGain", 0) or 0,
+            "paid": gains.get("paidFollowerGain", 0) or 0
         })
 
-    print(f"Extracted follower gains (unsorted): {results}") # Debug print
-    # Sort results by date string to ensure chronological order for plotting
-    try:
-        results.sort(key=lambda x: x['date'])
-    except Exception as sort_e:
-        print(f"Warning: Could not sort follower gains by date. Error: {sort_e}")
-
-    print(f"Extracted follower gains (sorted): {results}")
-    return results
+    return sorted(results, key=lambda x: x['date'])
 
-def fetch_analytics_data(comm_client_id, comm_token):
-    """Fetches org URN, follower count, and follower gains using the Marketing token."""
-    print("--- Fetching Analytics Data ---")
-    if not comm_token:
+def fetch_analytics_data(client_id, token):
+    if not token:
         raise ValueError("comm_token is missing.")
 
-    token_dict = comm_token if isinstance(comm_token, dict) else {'access_token': comm_token, 'token_type': 'Bearer'}
-    ln_mkt = create_session(comm_client_id, token=token_dict)
+    token_dict = token if isinstance(token, dict) else {'access_token': token, 'token_type': 'Bearer'}
+    session = create_session(client_id, token=token_dict)
 
     try:
-        # 1. Fetch Org URN and Name
-        print("Fetching Org URN for analytics...")
-        # This function already handles errors and raises ValueError
-        #org_urn, org_name = fetch_org_urn(token_dict)
         org_urn, org_name = "urn:li:organization:19010008", "GRLS"
-        print(f"Analytics using Org: {org_name} ({org_urn})")
 
-        # 2. Fetch Follower Count (v2 API)
-        # Endpoint requires r_organization_social permission
-        print("Fetching follower count...")
         count_url = f"{API_V2_BASE}/networkSizes/{org_urn}?edgeType=CompanyFollowedByMember"
-        print(f"Requesting follower count from: {count_url}")
-        resp_count = ln_mkt.get(count_url)
-        print(f"→ COUNT Response Status: {resp_count.status_code}")
-        print(f"→ COUNT Response Body: {resp_count.text}")
-        resp_count.raise_for_status() # Check for HTTP errors
-        count_data = resp_count.json()
-        # The follower count is in 'firstDegreeSize'
-        follower_count = count_data.get("firstDegreeSize", 0)
-        print(f"Follower count: {follower_count}")
+        follower_count = session.get(count_url).json().get("firstDegreeSize", 0)
 
-
-        # 3. Fetch Follower Gains (REST API)
-        # Endpoint requires r_organization_social permission
-        print("Fetching follower gains...")
-        # Calculate start date: 12 months ago, beginning of that month, UTC
-        now = datetime.now(timezone.utc)
-        # Go back roughly 365 days
-        twelve_months_ago = now - timedelta(days=365)
-        # Set to the first day of that month
-        start_of_period = twelve_months_ago.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
-        start_ms = int(start_of_period.timestamp() * 1000)
-        print(f"Requesting gains starting from: {start_of_period.strftime('%Y-%m-%d %H:%M:%S %Z')} ({start_ms} ms)")
+        start = datetime.now(timezone.utc) - timedelta(days=365)
+        start = start.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+        start_ms = int(start.timestamp() * 1000)
 
         gains_url = (
             f"{API_REST_BASE}/organizationalEntityFollowerStatistics"
-            f"?q=organizationalEntity"
-            f"&organizationalEntity={org_urn}"
+            f"?q=organizationalEntity&organizationalEntity={org_urn}"
             f"&timeIntervals.timeGranularityType=MONTH"
             f"&timeIntervals.timeRange.start={start_ms}"
-            # No end date needed to get data up to the latest available month
         )
-        print(f"Requesting gains from: {gains_url}")
-        resp_gains = ln_mkt.get(gains_url)
-        print(f"→ GAINS Request Headers: {resp_gains.request.headers}")
-        print(f"→ GAINS Response Status: {resp_gains.status_code}")
-        print(f"→ GAINS Response Body (first 500 chars): {resp_gains.text[:500]}")
-        resp_gains.raise_for_status() # Check for HTTP errors
-        gains_data = resp_gains.json()
-
-        # 4. Process Gains Data using the extraction function
-        follower_gains_list = extract_follower_gains(gains_data)
+        gains_data = session.get(gains_url).json()
+        gains = extract_follower_gains(gains_data)
 
-        # Return all fetched data
-        return org_name, follower_count, follower_gains_list
+        return org_name, follower_count, gains
 
     except requests.exceptions.RequestException as e:
-        status = e.response.status_code if e.response is not None else "N/A"
-        details = ""
-        if e.response is not None:
-            try:
-                details = f" Details: {e.response.json()}"
-            except json.JSONDecodeError:
-                details = f" Response: {e.response.text[:200]}..."
-        print(f"ERROR fetching analytics data (Status: {status}).{details}")
-        # Re-raise a user-friendly error, including the original exception context
-        raise ValueError(f"Failed to fetch analytics data from LinkedIn API (Status: {status}). Check permissions (r_organization_social) and API status.") from e
-    except ValueError as ve:
-         # Catch ValueErrors raised by fetch_org_urn
-         print(f"ERROR during analytics data fetch (likely Org URN): {ve}")
-         raise ve # Re-raise the specific error message
+        status = getattr(e.response, 'status_code', 'N/A')
+        msg = f"Failed to fetch LinkedIn analytics (Status: {status})."
+        raise ValueError(msg) from e
     except Exception as e:
-        print(f"UNEXPECTED ERROR processing analytics data: {e}")
-        tb = traceback.format_exc()
-        print(tb)
-        raise ValueError(f"An unexpected error occurred while fetching or processing analytics data.") from e
+        raise ValueError("Unexpected error during LinkedIn analytics fetch.") from e
 
+def plot_follower_gains(data):
+    plt.style.use('seaborn-v0_8-whitegrid')
 
-def plot_follower_gains(follower_data):
-    """Generates a matplotlib plot for follower gains. Returns the figure object."""
-    print(f"Plotting follower gains data: {follower_data}")
-    plt.style.use('seaborn-v0_8-whitegrid') # Use a nice style
-
-    if not follower_data:
-        print("No follower data to plot.")
-        # Create an empty plot with a message
+    if not data:
         fig, ax = plt.subplots(figsize=(10, 5))
-        ax.text(0.5, 0.5, 'No follower gains data available for the last 12 months.',
-                horizontalalignment='center', verticalalignment='center',
-                transform=ax.transAxes, fontsize=12, color='grey')
-        ax.set_title('Monthly Follower Gains (Last 12 Months)')
-        ax.set_xlabel('Month')
-        ax.set_ylabel('Follower Gains')
-        # Remove ticks if there's no data
-        ax.set_xticks([])
-        ax.set_yticks([])
-        plt.tight_layout()
-        return fig # Return the figure object
-
-    try:
-        # Ensure data is sorted by date (should be done in extract_follower_gains, but double-check)
-        follower_data.sort(key=lambda x: x['date'])
-
-        dates = [entry['date'] for entry in follower_data] # Should be 'YYYY-MM' strings
-        organic_gains = [entry['organic'] for entry in follower_data]
-        paid_gains = [entry['paid'] for entry in follower_data]
-
-        # Create the plot
-        fig, ax = plt.subplots(figsize=(12, 6)) # Use fig, ax pattern
-
-        ax.plot(dates, organic_gains, label='Organic Follower Gain', marker='o', linestyle='-', color='#0073b1') # LinkedIn blue
-        ax.plot(dates, paid_gains, label='Paid Follower Gain', marker='x', linestyle='--', color='#d9534f') # Reddish color
-
-        # Customize the plot
-        ax.set_xlabel('Month (YYYY-MM)')
-        ax.set_ylabel('Number of New Followers')
-        ax.set_title('Monthly Follower Gains (Last 12 Months)')
-
-        # Improve x-axis label readability
-        # Show fewer labels if there are many months
-        tick_frequency = max(1, len(dates) // 10) # Show label roughly every N months
-        ax.set_xticks(dates[::tick_frequency])
-        ax.tick_params(axis='x', rotation=45, labelsize=9) # Rotate and adjust size
-
-        ax.legend(title="Gain Type")
-        ax.grid(True, linestyle='--', alpha=0.6) # Lighter grid
-
-        # Add value labels on top of bars/points (optional, can get crowded)
-        # for i, (org, paid) in enumerate(zip(organic_gains, paid_gains)):
-        #     if org > 0: ax.text(i, org, f'{org}', ha='center', va='bottom', fontsize=8)
-        #     if paid > 0: ax.text(i, paid, f'{paid}', ha='center', va='bottom', fontsize=8, color='red')
-
-
-        plt.tight_layout() # Adjust layout to prevent labels from overlapping
-
-        print("Successfully generated follower gains plot.")
-        # Return the figure object for Gradio
-        return fig
-    except Exception as plot_e:
-        print(f"ERROR generating follower gains plot: {plot_e}")
-        tb = traceback.format_exc()
-        print(tb)
-        # Return an empty plot with an error message if plotting fails
-        fig, ax = plt.subplots(figsize=(10, 5))
-        ax.text(0.5, 0.5, f'Error generating plot: {plot_e}',
-                horizontalalignment='center', verticalalignment='center',
-                transform=ax.transAxes, fontsize=12, color='red', wrap=True)
-        ax.set_title('Follower Gains Plot Error')
-        plt.tight_layout()
+        ax.text(0.5, 0.5, 'No follower gains data.', ha='center', va='center', transform=ax.transAxes)
+        ax.set_title('Monthly Follower Gains')
+        ax.set_xticks([]); ax.set_yticks([])
         return fig
 
-# Add this function below `plot_follower_gains` in your code
-
-def plot_growth_rate(follower_data, total_follower_count):
-    """
-    Generates a line chart for Follower Growth Rate (%) on a monthly basis.
-    """
-    print(f"Plotting follower growth rate from data: {follower_data} and total followers: {total_follower_count}")
-    if not follower_data:
+    dates = [d['date'] for d in data]
+    organic = [d['organic'] for d in data]
+    paid = [d['paid'] for d in data]
+
+    fig, ax = plt.subplots(figsize=(12, 6))
+    ax.plot(dates, organic, label='Organic', marker='o', color='#0073b1')
+    ax.plot(dates, paid, label='Paid', marker='x', linestyle='--', color='#d9534f')
+    ax.set(title='Monthly Follower Gains', xlabel='Month', ylabel='New Followers')
+    ax.tick_params(axis='x', rotation=45)
+    ax.legend()
+    plt.tight_layout()
+    return fig
+
+def plot_growth_rate(data, total):
+    if not data:
         fig, ax = plt.subplots(figsize=(10, 5))
-        ax.text(0.5, 0.5, 'No data available to calculate growth rate.',
-                horizontalalignment='center', verticalalignment='center',
-                transform=ax.transAxes, fontsize=12, color='grey')
-        ax.set_title('Monthly Follower Growth Rate (%)')
-        ax.set_xticks([])
-        ax.set_yticks([])
-        plt.tight_layout()
+        ax.text(0.5, 0.5, 'No data for growth rate.', ha='center', va='center', transform=ax.transAxes)
+        ax.set_title('Growth Rate (%)')
+        ax.set_xticks([]); ax.set_yticks([])
         return fig
 
-    try:
-        follower_data.sort(key=lambda x: x['date'])
-        dates = [entry['date'] for entry in follower_data]
-        total_gains = [entry['organic'] + entry['paid'] for entry in follower_data]
-
-        # Reconstruct monthly total followers backwards from the current total
-        followers_at_end_of_month = []
-        current_total = total_follower_count
-        for gain in reversed(total_gains):
-            followers_at_end_of_month.insert(0, current_total)
-            current_total -= gain
-
-        # followers_at_end_of_month now contains follower totals at end of each month
-        growth_rates = []
-        for i in range(1, len(followers_at_end_of_month)):
-            start = followers_at_end_of_month[i - 1]
-            end = followers_at_end_of_month[i]
-            rate = ((end - start) / start * 100) if start > 0 else 0
-            growth_rates.append(rate)
-
-        # Trim the first date (because we start calculating growth from second month)
-        rate_dates = dates[1:]
+    dates = [d['date'] for d in data]
+    gains = [d['organic'] + d['paid'] for d in data]
 
-        fig, ax = plt.subplots(figsize=(12, 6))
-        ax.plot(rate_dates, growth_rates, label='Growth Rate (%)', marker='o', linestyle='-', color='green')
-        ax.set_title('Monthly Follower Growth Rate (%)')
-        ax.set_xlabel('Month (YYYY-MM)')
-        ax.set_ylabel('Growth Rate (%)')
-        ax.grid(True, linestyle='--', alpha=0.6)
-        tick_frequency = max(1, len(rate_dates) // 10)
-        ax.set_xticks(rate_dates[::tick_frequency])
-        ax.tick_params(axis='x', rotation=45, labelsize=9)
-        ax.legend()
+    history = []
+    current = total
+    for g in reversed(gains):
+        history.insert(0, current)
+        current -= g
 
-        plt.tight_layout()
-        print("Successfully generated growth rate plot.")
-        return fig
-
-    except Exception as e:
-        print(f"ERROR generating growth rate plot: {e}")
-        tb = traceback.format_exc()
-        print(tb)
-        fig, ax = plt.subplots(figsize=(10, 5))
-        ax.text(0.5, 0.5, f'Error generating growth rate plot: {e}',
-                horizontalalignment='center', verticalalignment='center',
-                transform=ax.transAxes, fontsize=12, color='red', wrap=True)
-        ax.set_title('Follower Growth Rate Plot Error')
-        plt.tight_layout()
-        return fig
+    rates = [((history[i] - history[i-1]) / history[i-1] * 100 if history[i-1] else 0) for i in range(1, len(history))]
 
+    fig, ax = plt.subplots(figsize=(12, 6))
+    ax.plot(dates[1:], rates, label='Growth Rate (%)', marker='o', color='green')
+    ax.set(title='Monthly Growth Rate (%)', xlabel='Month', ylabel='Growth %')
+    ax.tick_params(axis='x', rotation=45)
+    ax.legend()
+    plt.tight_layout()
+    return fig
 
+def fetch_and_render_analytics(client_id, token):
+    loading = gr.update(value="<p>Loading follower count...</p>", visible=True)
+    hidden = gr.update(value=None, visible=False)
 
-def fetch_and_render_analytics(comm_client_id, comm_token):
-    """Fetches analytics data and prepares updates for Gradio UI."""
-    print("--- Rendering Analytics Tab ---")
-    # Initial state for outputs
-    count_output = gr.update(value="<p>Loading follower count...</p>", visible=True)
-    plot_output = gr.update(value=None, visible=False) # Hide plot initially
-
-    if not comm_token:
-        print("ERROR: Marketing token missing for analytics.")
-        error_msg = "<p style='color: red; text-align: center; font-weight: bold;'>❌ Error: Missing LinkedIn Marketing token. Please complete the login process first.</p>"
-        return gr.update(value=error_msg, visible=True), gr.update(value=None, visible=False)
+    if not token:
+        error = "<p style='color:red;'>❌ Missing token. Please log in.</p>"
+        return gr.update(value=error, visible=True), hidden, hidden
 
     try:
-        # Fetch all data together
-        org_name, follower_count, follower_gains_list = fetch_analytics_data(comm_client_id, comm_token)
-
-        # Format follower count display - Nicer HTML
-        count_display_html = f"""
-        <div style='text-align: center; padding: 20px; background-color: #e7f3ff; border: 1px solid #bce8f1; border-radius: 8px; margin-bottom: 20px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>
-            <p style='font-size: 1.1em; color: #31708f; margin-bottom: 5px;'>Total Followers for</p>
-            <p style='font-size: 1.4em; font-weight: bold; color: #005a9e; margin-bottom: 10px;'>{html.escape(org_name)}</p>
-            <p style='font-size: 2.8em; font-weight: bold; color: #0073b1; margin: 0;'>{follower_count:,}</p>
-            <p style='font-size: 0.9em; color: #777; margin-top: 5px;'>(As of latest data available)</p>
+        name, count, gains = fetch_analytics_data(client_id, token)
+
+        count_html = f"""
+        <div style='text-align:center; padding:20px; background:#e7f3ff; border:1px solid #bce8f1; border-radius:8px;'>
+            <p style='font-size:1.1em; color:#31708f;'>Total Followers for</p>
+            <p style='font-size:1.4em; font-weight:bold; color:#005a9e;'>{html.escape(name)}</p>
+            <p style='font-size:2.8em; font-weight:bold; color:#0073b1;'>{count:,}</p>
+            <p style='font-size:0.9em; color:#777;'>(As of latest data)</p>
         </div>
         """
-        count_output = gr.update(value=count_display_html, visible=True)
-
-        # Generate plot
-        print("Generating follower gains plot...")
-        plot_fig = plot_follower_gains(follower_gains_list)
-        # If plot generation failed, plot_fig might contain an error message plot
-        plot_output = gr.update(value=plot_fig, visible=True)
-
-        # Generate follower growth rate plot
-        growth_rate_fig = plot_growth_rate(follower_gains_list, follower_count)
-        growth_output = gr.update(value=growth_rate_fig, visible=True)
-
-        return count_output, plot_output, growth_output
+        return gr.update(value=count_html, visible=True), gr.update(value=plot_follower_gains(gains), visible=True), gr.update(value=plot_growth_rate(gains, count), visible=True)
 
-    except (ValueError, requests.exceptions.RequestException) as api_ve:
-        # Catch specific API or configuration errors from fetch_analytics_data
-        print(f"API or VALUE ERROR during analytics fetch: {api_ve}")
-        error_update = display_error(f"Failed to load analytics: {api_ve}", api_ve)
-        # Show error in the count area, hide plot
-        return gr.update(value=error_update.get('value', "<p style='color: red;'>Error loading follower count.</p>"), visible=True), gr.update(value=None, visible=False)
     except Exception as e:
-        # Catch any other unexpected errors during fetch or plotting
-        print(f"UNEXPECTED ERROR during analytics rendering: {e}")
-        tb = traceback.format_exc()
-        print(tb)
-        error_update = display_error("An unexpected error occurred while loading analytics.", e)
-        error_html = error_update.get('value', "<p style='color: red;'>An unexpected error occurred.</p>")
-        # Ensure the error message is HTML-safe
-        if isinstance(error_html, str) and not error_html.strip().startswith("<"):
-             error_html = f"<pre style='color: red; white-space: pre-wrap;'>{html.escape(error_html)}</pre>"
-        # Show error in the count area, hide plot
-        return gr.update(value=error_html, visible=True), gr.update(value=None, visible=False)
+        error = display_error("Analytics load failed.", e).get('value', "<p style='color:red;'>Error loading data.</p>")
+        return gr.update(value=error, visible=True), hidden, hidden