Update linkedin_follower_stats.py

linkedin_follower_stats.py

@@ -1,291 +1,225 @@
-# -- coding: utf-8 --
 import json
 import requests
 import logging
 from datetime import datetime, timezone, timedelta
-from urllib.parse import quote, urlencode
-import requests_oauthlib # For version logging
+from urllib.parse import quote
 
 # Assuming you have a sessions.py with create_session
 # If sessions.py or create_session is not found, it will raise an ImportError,
 # which is appropriate for a module that depends on it.
-from sessions import create_session # Make sure this file exists and is correct
+from sessions import create_session
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 API_V2_BASE = 'https://api.linkedin.com/v2'
 API_REST_BASE = "https://api.linkedin.com/rest"
-LINKEDIN_API_VERSION = "202502"
+LINKEDIN_API_VERSION = "202502" # As per user's example for follower stats
 
 # --- ID to Name Mapping Helper Functions ---
 
 def _fetch_linkedin_names(session, url, params, result_key_path, name_key_path, id_key="id"):
     """
     Generic helper to fetch and map IDs to names from a LinkedIn API endpoint.
+    result_key_path: list of keys to navigate to the list of items (e.g., ["elements"])
+    name_key_path: list of keys to navigate to the name within an item (e.g., ["name", "localized", "en_US"])
     """
     mapping = {}
-    request_url_for_logging = url 
-    response_obj = None 
     try:
-        logging.debug(f"_fetch_linkedin_names (id: {id(session)}): About to prepare request. Session token: {session.token}, Session authorized: {session.authorized}, Expires at: {session.token.get('expires_at') if session.token else 'N/A'}")
-        logging.debug(f"_fetch_linkedin_names (id: {id(session)}): Session auth object: type={type(session.auth)}, value={session.auth}")
-
-        req = requests.Request('GET', url, params=params)
-        prepared_req = session.prepare_request(req) 
-        request_url_for_logging = prepared_req.url
-        
-        logging.debug(f"Fetching names from URL: {request_url_for_logging}")
-        logging.debug(f"Request headers for _fetch_linkedin_names: {json.dumps(dict(prepared_req.headers), indent=2)}")
-
-        response_obj = session.send(prepared_req, timeout=30)
-        response_obj.raise_for_status()
-        data = response_obj.json()
+        logging.debug(f"Fetching names from URL: {url} with params: {json.dumps(params)}") # Log params for clarity
+        response = session.get(url, params=params)
+        response.raise_for_status()
+        data = response.json()
 
         items = data
-        for key in result_key_path:
+        for key in result_key_path: 
             if isinstance(items, dict):
-                items = items.get(key) 
-                if items is None: 
-                    logging.warning(f"Key '{key}' not found in response from {request_url_for_logging} at path {result_key_path}. Response data: {json.dumps(data, indent=2)}")
-                    return mapping
-            else:
-                logging.warning(f"Expected dict to get key '{key}' but got {type(items)} at path {result_key_path} for URL {request_url_for_logging}. Check result_key_path.")
-                return mapping
-
-        if items is None: 
-            logging.warning(f"Items became None after navigating result_key_path for URL {request_url_for_logging}. Path: {result_key_path}")
-            return mapping
+                items = items.get(key, []) 
+            else: 
+                logging.warning(f"Expected dict to get key '{key}' but got {type(items)} at path {result_key_path} for URL {url}. Check result_key_path.")
+                return mapping 
 
         if isinstance(items, dict): 
             for item_id_str, item_data in items.items():
                 name = item_data
-                for key_nav in name_key_path:
+                for key_nav in name_key_path: 
                     if isinstance(name, dict):
                         name = name.get(key_nav)
                     else:
-                        name = None
+                        name = None 
                         break
                 if name:
-                    mapping[item_id_str] = name
+                    mapping[item_id_str] = name 
                 else:
-                    logging.warning(f"No name found for ID {item_id_str} at path {name_key_path} in item: {item_data} from URL {request_url_for_logging}")
+                    logging.warning(f"No name found for ID {item_id_str} at path {name_key_path} in item: {item_data} from URL {url}")
         elif isinstance(items, list): 
             for item in items:
                 item_id_val = item.get(id_key)
                 name = item
-                for key_nav in name_key_path:
+                for key_nav in name_key_path: 
                     if isinstance(name, dict):
                         name = name.get(key_nav)
                     else:
-                        name = None
+                        name = None 
                         break
                 if item_id_val is not None and name:
-                    mapping[str(item_id_val)] = name
+                    mapping[str(item_id_val)] = name 
                 else:
-                    if item_id_val is None:
-                        logging.warning(f"No ID ('{id_key}') found in item: {item} from URL {request_url_for_logging}")
-                    if name is None:
-                         logging.warning(f"No name found at path {name_key_path} for item with ID '{item_id_val}' in item: {item} from URL {request_url_for_logging}")
+                    logging.warning(f"No ID ('{id_key}') or name found at path {name_key_path} in item: {item} from URL {url}")
         else:
-            logging.warning(f"Expected list or dict of items at {result_key_path} from URL {request_url_for_logging}, got {type(items)}. Full items: {items}")
-
-    except requests.exceptions.HTTPError as http_err:
-        status_code = "N/A"; error_text = str(http_err); response_headers = {}
-        if http_err.response is not None:
-            status_code = http_err.response.status_code
-            error_text = http_err.response.text
-            response_headers = dict(http_err.response.headers)
-        logging.error(f"HTTP error in _fetch_linkedin_names from {request_url_for_logging} (Status: {status_code}): {error_text}")
-        logging.error(f"Response Headers: {json.dumps(response_headers, indent=2)}")
-    except requests.exceptions.RequestException as req_err:
-        logging.error(f"Request error in _fetch_linkedin_names from {request_url_for_logging}: {str(req_err)}")
-        if req_err.response is not None:
-            logging.error(f"Associated Response Status: {req_err.response.status_code}, Text: {req_err.response.text}, Headers: {json.dumps(dict(req_err.response.headers), indent=2)}")
-    except json.JSONDecodeError as json_err:
-        response_text = "Not available"
-        if response_obj is not None and hasattr(response_obj, 'text'): response_text = response_obj.text
-        logging.error(f"Error decoding JSON for names from {request_url_for_logging}: {json_err}. Response text: {response_text}")
+            logging.warning(f"Expected list or dict of items at {result_key_path} from URL {url}, got {type(items)}")
+            
+    except requests.exceptions.RequestException as e:
+        status_code = getattr(e.response, 'status_code', 'N/A')
+        error_text = getattr(e.response, 'text', str(e)) # Log the raw error text
+        logging.error(f"Error fetching names from {url} (Status: {status_code}): {error_text}")
+    except json.JSONDecodeError as e:
+        logging.error(f"Error decoding JSON for names from {url}: {e}. Response: {response.text if 'response' in locals() else 'N/A'}")
     except Exception as e:
-        logging.error(f"Unexpected error in _fetch_linkedin_names from {request_url_for_logging}: {e}", exc_info=True)
-        if response_obj is not None:
-            logging.error(f"Associated Response (if any) Status: {getattr(response_obj, 'status_code', 'N/A')}, Text: {getattr(response_obj, 'text', 'N/A')}")
+        logging.error(f"Unexpected error fetching names from {url}: {e}", exc_info=True)
     return mapping
 
 def get_functions_map(session):
+    """Fetches all LinkedIn functions and returns a map of {id: name}."""
     url = f"{API_V2_BASE}/functions"
-    params = {'count': 200} 
+    params = {} # Relies on Accept-Language header from session
     logging.info("Fetching all LinkedIn functions.")
     return _fetch_linkedin_names(session, url, params, ["elements"], ["name", "localized", "en_US"], "id")
 
 def get_seniorities_map(session):
+    """Fetches all LinkedIn seniorities and returns a map of {id: name}."""
     url = f"{API_V2_BASE}/seniorities"
-    params = {'count': 200} 
+    params = {} # Relies on Accept-Language header from session
     logging.info("Fetching all LinkedIn seniorities.")
     return _fetch_linkedin_names(session, url, params, ["elements"], ["name", "localized", "en_US"], "id")
 
 def get_industries_map(session, industry_urns, version="DEFAULT"):
+    """Fetches names for a list of industry URNs by pulling ALL industries and filtering locally."""
+    # parse and dedupe IDs
     industry_ids = [_parse_urn_to_id(urn) for urn in industry_urns or []]
     unique_ids = set(filter(None, industry_ids))
     if not unique_ids:
         return {}
 
+    # we'll page through the full list; LinkedIn defaults to 10, so bump count
     url = f"{API_V2_BASE}/industryTaxonomyVersions/{version}/industries"
-    params = { 'start': 0, 'count': 500 }
-    request_url_for_logging = url 
-    response_obj = None
-    logging.info(f"Fetching all industries (to filter {len(unique_ids)} IDs)")
+    params = {
+        'start': 0,
+        'count': 500  # should exceed total # of industries
+    }
+
+    logging.info(f"Fetching all industries (to filter {len(unique_ids)} IDs) from {url}")
     try:
-        logging.debug(f"get_industries_map (id: {id(session)}): About to prepare request. Session token: {session.token}, Session authorized: {session.authorized}, Expires at: {session.token.get('expires_at') if session.token else 'N/A'}")
-        logging.debug(f"get_industries_map (id: {id(session)}): Session auth object: type={type(session.auth)}, value={session.auth}")
-        req = requests.Request('GET', url, params=params)
-        prepared_req = session.prepare_request(req)
-        request_url_for_logging = prepared_req.url
-        logging.debug(f"Requesting all industries from URL: {request_url_for_logging}")
-        logging.debug(f"Request headers for get_industries_map: {json.dumps(dict(prepared_req.headers), indent=2)}")
-
-        response_obj = session.send(prepared_req, timeout=30)
-        response_obj.raise_for_status()
-        data = response_obj.json()
+        response = session.get(url, params=params)
+        response.raise_for_status()
+        data = response.json()
         elements = data.get('elements', [])
 
         mapping = {}
         for el in elements:
             el_id = el.get('id')
             if el_id and str(el_id) in unique_ids:
-                name = el.get('name', {}).get('localized', {}).get('en_US')
+                # drill into name.localized.en_US
+                name = el.get('name', {}) \
+                         .get('localized', {}) \
+                         .get('en_US')
                 if name:
                     mapping[str(el_id)] = name
                 else:
-                    logging.warning(f"Industry {el_id} has no en_US name field in element: {el} from URL {request_url_for_logging}")
+                    logging.warning(f"Industry {el_id} has no en_US name field")
         return mapping
-    except requests.exceptions.HTTPError as http_err:
-        status_code = "N/A"; error_text = str(http_err); response_headers = {}
-        if http_err.response is not None:
-            status_code = http_err.response.status_code
-            error_text = http_err.response.text
-            response_headers = dict(http_err.response.headers)
-        logging.error(f"HTTP error fetching all industries from {request_url_for_logging} (Status: {status_code}): {error_text}")
-        logging.error(f"Response Headers: {json.dumps(response_headers, indent=2)}")
-        return {}
-    except requests.exceptions.RequestException as req_err:
-        logging.error(f"Request error fetching all industries from {request_url_for_logging}: {str(req_err)}")
-        if req_err.response is not None:
-            logging.error(f"Associated Response Status: {req_err.response.status_code}, Text: {req_err.response.text}, Headers: {json.dumps(dict(req_err.response.headers), indent=2)}")
-        return {}
-    except json.JSONDecodeError as json_err:
-        response_text = "Not available"
-        if response_obj is not None and hasattr(response_obj, 'text'): response_text = response_obj.text
-        logging.error(f"Error decoding JSON for industries from {request_url_for_logging}: {json_err}. Response text: {response_text}")
-        return {}
-    except Exception as e:
-        logging.error(f"Unexpected error fetching all industries from {request_url_for_logging}: {e}", exc_info=True)
-        if response_obj is not None:
-            logging.error(f"Associated Response (if any) Status: {getattr(response_obj, 'status_code', 'N/A')}, Text: {getattr(response_obj, 'text', 'N/A')}")
+
+    except requests.exceptions.RequestException as e:
+        status_code = getattr(e.response, 'status_code', 'N/A')
+        logging.error(f"Error fetching all industries: {status_code} – {getattr(e.response, 'text', str(e))}")
         return {}
 
+
+
 def get_geo_map(session, geo_urns):
+    """Fetches names for a list of geo URNs. Returns a map {id: name}."""
     if not geo_urns: return {}
     geo_ids = [_parse_urn_to_id(urn) for urn in geo_urns if urn]
     unique_ids = list(set(filter(None, geo_ids)))
     if not unique_ids: return {}
 
-    MAX_GEO_IDS_PER_CALL = 100 
-    all_geo_mappings = {}
-
-    for i in range(0, len(unique_ids), MAX_GEO_IDS_PER_CALL):
-        chunk_ids = unique_ids[i:i + MAX_GEO_IDS_PER_CALL]
-        if not chunk_ids: continue
+    # As per LinkedIn docs for BATCH_GET: ids=List(12345,23456)&locale=(language:en,country:US)
+    ids_param_string = "List(" + ",".join(map(str, unique_ids)) + ")"
+    locale_param_string = "(language:en,country:US)" # Must be exactly this string format
 
-        ids_param_value = "List(" + ",".join(map(str, chunk_ids)) + ")"
-        locale_param_value = "(language:en,country:US)" 
+    # Parameters must be passed in the URL string directly for this specific API format
+    # The `params` dict for session.get() will be empty.
+    url = f"{API_V2_BASE}/geo?ids={ids_param_string}&locale={locale_param_string}"
+    #url = f"{API_V2_BASE}/geo?ids=List({','.join(map(str, unique_ids))})&locale=(language:en,country:US)"
 
-        url = f"{API_V2_BASE}/geo"
-        geo_params = { 'ids': ids_param_value, 'locale': locale_param_value }
-        
-        logging.info(f"Fetching names for {len(chunk_ids)} geo IDs (chunk {i//MAX_GEO_IDS_PER_CALL + 1})")
-        chunk_mapping = _fetch_linkedin_names(session, url, geo_params, ["results"], ["defaultLocalizedName", "value"])
-        all_geo_mappings.update(chunk_mapping)
-        
-    return all_geo_mappings
+    
+    logging.info(f"Fetching names for {len(unique_ids)} unique geo IDs using URL: {url}")
+    return _fetch_linkedin_names(session, url, {}, ["results"], ["defaultLocalizedName", "value"])
 
 
 def _parse_urn_to_id(urn_string):
+    """Helper to get the last part (ID) from a URN string."""
     if not isinstance(urn_string, str):
         logging.debug(f"Invalid URN type: {type(urn_string)}, value: {urn_string}. Cannot parse ID.")
         return None
     try:
         return urn_string.split(':')[-1]
-    except IndexError:
+    except IndexError: 
         logging.warning(f"Could not parse ID from URN: {urn_string}")
         return None
-    except Exception as e: 
+    except Exception as e:
         logging.error(f"Unexpected error parsing URN {urn_string}: {e}")
         return None
 
 # --- Follower Data Fetching Functions ---
 
-def fetch_monthly_follower_gains(comm_client_id, token_dict, org_urn, api_rest_base_url):
+def fetch_monthly_follower_gains(session, org_urn, api_rest_base):
     """
-    Fetches monthly follower gains using a dedicated OAuth2Session for REST API calls.
+    Fetches monthly follower gains for the last 12 full months.
+    The start date is set to the first day of the month, 12 months prior to the current month, at midnight UTC.
     """
-    now_utc = datetime.now(timezone.utc)
-    # Calculate start of the month, approximately 12 months ago
-    start_of_reporting_period = (now_utc - timedelta(days=365)).replace(day=1, hour=0, minute=0, second=0, microsecond=0)
-    start_ms = int(start_of_reporting_period.timestamp() * 1000)
-
-    base_url = f"{api_rest_base_url}/organizationalEntityFollowerStatistics"
-    # Using the same timeIntervals format as in the original failing log, as it's standard for REST
-    time_intervals_value = f"(timeRange:(start:{start_ms}),timeGranularityType:MONTH)"
-
-    api_params = {
-        "q": "organizationalEntity",
-        "organizationalEntity": org_urn,
-        "timeIntervals": time_intervals_value
-    }
-    
-    logging.info(f"Preparing to fetch monthly follower gains for {org_urn} using a dedicated session.")
-    logging.debug(f"API Parameters for monthly gains: {json.dumps(api_params)}")
-    logging.debug(f"Received client_id for dedicated session: {comm_client_id}")
-    logging.debug(f"Received token_dict for dedicated session (access_token type): {type(token_dict.get('access_token')) if token_dict else 'N/A'}")
+    # now = datetime.now()
 
+    # twelve_months_ago = now - timedelta(days=365)
+    # twelve_months_ago = twelve_months_ago.replace(day=1)
+    
+    # start_date = int(twelve_months_ago.timestamp() * 1000)
+
+    # # Build URL with explicit query string
+    # url = (
+    #     f"{api_rest_base}/organizationalEntityFollowerStatistics"
+    #     f"?q=organizationalEntity"
+    #     f"&organizationalEntity={org_urn}"
+    #     f"&timeIntervals.timeGranularityType=MONTH"
+    #     f"&timeIntervals.timeRange.start={start_date}"
+    #     # LinkedIn defaults the end of the timeRange to the current time if not specified.
+    # )
+    # logging.info(f"Fetching monthly follower gains from URL: {url}")
+
+    now = datetime.now(timezone.utc)
+    twelve_months_ago = now - timedelta(days=365)
+    twelve_months_ago = twelve_months_ago.replace(day=1)
+
+    start_date = int(twelve_months_ago.timestamp() * 1000)
+    end_date = int(now.timestamp() * 1000)  # You could omit this if letting LinkedIn default
+
+    time_intervals = f"(timeRange:(start:{start_date},end:{end_date}),timeGranularityType:MONTH)"
+
+    url = (
+        f"{api_rest_base}/organizationalEntityFollowerStatistics"
+        f"?q=organizationalEntity"
+        f"&organizationalEntity={org_urn}"
+        f"&timeIntervals={time_intervals}"
+    )
 
     results = []
-    request_url_for_logging = "Not constructed" 
-    response_obj = None 
-
     try:
-        # Create a new session specifically for this REST API call
-        # This session will not have X-Restli-Protocol-Version header by default from OAuth2Session
-        # It will also not inherit any potentially problematic headers from a shared session.
-        rest_session = create_session(comm_client_id, token=token_dict) 
-        rest_session.headers.update({
-            "LinkedIn-Version": LINKEDIN_API_VERSION
-        })
-        logging.info(f"Dedicated REST session created for monthly gains (id: {id(rest_session)}).")
-        logging.debug(f"Dedicated REST session token (type): {type(rest_session.token)}, Authorized: {rest_session.authorized}")
-        if rest_session.token and 'access_token' in rest_session.token:
-             logging.debug(f"Dedicated REST session access token (partial): {str(rest_session.token['access_token'])[:20]}...")
-        else:
-            logging.warning("Dedicated REST session: token is None or 'access_token' key is missing.")
-
-
-        req = requests.Request('GET', base_url, params=api_params)
-        prepared_req = rest_session.prepare_request(req) # Use the dedicated session
-        request_url_for_logging = prepared_req.url
-        
-        logging.info(f"Requesting monthly follower gains from URL: {request_url_for_logging}")
-        # Log only essential headers, avoid logging full token if present in headers directly
-        headers_to_log = {k: v for k, v in prepared_req.headers.items() if k.lower() != 'authorization'}
-        logging.debug(f"Request Headers for monthly gains (excluding Authorization): {json.dumps(headers_to_log, indent=2)}")
-
-
-        response_obj = rest_session.send(prepared_req, timeout=30) # Use the dedicated session
-        response_obj.raise_for_status() 
-        data = response_obj.json()
+        response = session.get(url)
+        response.raise_for_status()  # Raises an HTTPError for bad responses (4XX or 5XX)
+        data = response.json()
         
         elements = data.get('elements', [])
         if not elements:
-            logging.info(f"No 'elements' found in monthly follower gains API response for {org_urn} (start_ms {start_ms}). Response data: {json.dumps(data, indent=2)}")
+            logging.info(f"No 'elements' found in API response for {org_urn} for start_ms {start_ms}.")
 
         for item in elements:
             time_range = item.get('timeRange', {})
@@ -294,128 +228,104 @@ def fetch_monthly_follower_gains(comm_client_id, token_dict, org_urn, api_rest_b
                 logging.warning(f"Skipping item due to missing 'start' timestamp: {item}")
                 continue
             
+            # Convert timestamp (milliseconds) to YYYY-MM-DD date string in UTC
             date_obj = datetime.fromtimestamp(ts / 1000, tz=timezone.utc)
             date_str = date_obj.strftime('%Y-%m-%d')
             
             gains = item.get('followerGains', {})
-            if gains is None: gains = {} 
+            # It's possible 'followerGains' itself is missing or None
+            if gains is None: 
+                gains = {} # Ensure gains is a dict to prevent error on .get()
 
             results.append({
-                'category_name': date_str,
+                'category_name': date_str, # This is the start date of the month's data
                 'follower_count_organic': gains.get('organicFollowerGain', 0),
                 'follower_count_paid': gains.get('paidFollowerGain', 0),
                 'follower_count_type': 'follower_gains_monthly',
                 'organization_urn': org_urn
             })
-        logging.info(f"Fetched {len(results)} monthly follower entries for {org_urn} starting from {start_of_reporting_period.strftime('%Y-%m-%d')}.")
+        logging.info(f"Fetched {len(results)} monthly follower entries for {org_urn} starting from {start_of_period.strftime('%Y-%m-%d')}.")
     
     except requests.exceptions.HTTPError as http_err:
-        code = "N/A"; text = str(http_err); resp_headers = {}
-        if http_err.response is not None:
-            code = http_err.response.status_code
-            text = http_err.response.text
-            resp_headers = dict(http_err.response.headers)
+        # More specific error for HTTP errors
+        code = getattr(http_err.response, 'status_code', 'N/A')
+        text = getattr(http_err.response, 'text', str(http_err))
         logging.error(f"HTTP error fetching monthly gains for {org_urn}: {code} - {text}")
-        logging.error(f"Request URL was: {request_url_for_logging}")
-        logging.error(f"Response Headers: {json.dumps(resp_headers, indent=2)}")
-    except requests.exceptions.RequestException as req_err: 
-        logging.error(f"RequestException fetching monthly gains for {org_urn}: {str(req_err)}")
-        logging.error(f"Request URL was: {request_url_for_logging}")
-        if req_err.response is not None: 
-            logging.error(f"Associated Response Status: {req_err.response.status_code}")
-            logging.error(f"Associated Response Text: {req_err.response.text}")
-            logging.error(f"Associated Response Headers: {json.dumps(dict(req_err.response.headers), indent=2)}")
-    except json.JSONDecodeError as json_err:
-        response_text = "Not available"
-        if response_obj is not None and hasattr(response_obj, 'text'):
-            response_text = response_obj.text
-        logging.error(f"Error decoding JSON for monthly follower gains for {org_urn}: {json_err}")
-        logging.error(f"Request URL was: {request_url_for_logging}")
-        logging.error(f"Raw Response Text: {response_text}")
+        logging.error(f"Request URL: {url}")
+    except requests.exceptions.RequestException as e:
+        # Catch other request-related errors (e.g., connection issues)
+        code = getattr(e.response, 'status_code', 'N/A') if e.response is not None else 'N/A'
+        text = getattr(e.response, 'text', str(e)) if e.response is not None else str(e)
+        logging.error(f"Error fetching monthly gains for {org_urn}: {code} - {text}")
+        logging.error(f"Request URL: {url}")
     except Exception as ex:
-        logging.error(f"An unexpected error occurred while fetching monthly gains for {org_urn}: {str(ex)}", exc_info=True)
-        logging.error(f"Request URL was: {request_url_for_logging}")
-        if response_obj is not None: 
-            logging.error(f"Response Status (if available): {getattr(response_obj, 'status_code', 'N/A')}")
-            logging.error(f"Response Text (if available): {getattr(response_obj, 'text', 'N/A')}")
-            logging.error(f"Response Headers (if available): {json.dumps(dict(getattr(response_obj, 'headers', {})), indent=2)}")
-            
+        # Catch any other unexpected errors (e.g., JSON parsing if response is not JSON)
+        logging.error(f"An unexpected error occurred while fetching monthly gains for {org_urn}: {str(ex)}")
+        logging.error(f"Request URL: {url}")
+        
     return results
 
 
 def fetch_follower_demographics(session, org_urn, functions_map, seniorities_map):
+    """
+    Fetches current follower demographics, applying Top-N for specified categories.
+    """
     final_demographics_results = []
-    base_url = f"{API_REST_BASE}/organizationalEntityFollowerStatistics"
-    params = { 'q': 'organizationalEntity', 'organizationalEntity': org_urn }
+    # Parameters for the main demographics call
+    params = {
+        'q': 'organizationalEntity',
+        'organizationalEntity': org_urn
+    }
+    url = f"{API_REST_BASE}/organizationalEntityFollowerStatistics"
     
-    logging.info(f"Preparing to fetch follower demographics for org URN {org_urn}.")
-    logging.debug(f"API Parameters for demographics: {json.dumps(params)}")
-    request_url_for_logging = "Not constructed"
-    response_obj = None
+    logging.info(f"Fetching follower demographics from: {url} for org URN {org_urn} with params: {json.dumps(params)}")
 
     try:
-        logging.debug(f"fetch_follower_demographics (id: {id(session)}): About to prepare request. Session token: {session.token}, Session authorized: {session.authorized}, Expires at: {session.token.get('expires_at') if session.token else 'N/A'}")
-        logging.debug(f"fetch_follower_demographics (id: {id(session)}): Session auth object: type={type(session.auth)}, value={session.auth}")
-        logging.debug(f"fetch_follower_demographics (id: {id(session)}): Auto-refresh URL: {session.auto_refresh_url}, Auto-refresh kwargs: {session.auto_refresh_kwargs}")
-        if session.token and 'access_token' in session.token:
-            logging.debug(f"fetch_follower_demographics: Access token (partial): {str(session.token['access_token'])[:20]}...")
-        else:
-            logging.warning("fetch_follower_demographics: session.token is None or 'access_token' key is missing before prepare_request.")
-
-        req = requests.Request('GET', base_url, params=params)
-        prepared_req = session.prepare_request(req)
-        request_url_for_logging = prepared_req.url
-
-        logging.info(f"Requesting follower demographics from URL: {request_url_for_logging}")
-        logging.debug(f"Request Headers for demographics: {json.dumps(dict(prepared_req.headers), indent=2)}")
-
-        response_obj = session.send(prepared_req, timeout=30) 
-        response_obj.raise_for_status()
-        data = response_obj.json()
+        response = session.get(url, params=params)
+        response.raise_for_status()
+        data = response.json()
         
         elements = data.get("elements", [])
         if not elements:
-            logging.warning(f"No elements found in follower demographics response for {org_urn}. Response data: {json.dumps(data, indent=2)}")
+            logging.warning(f"No elements found in follower demographics response for {org_urn}.")
             return []
         
-        stat_element = elements[0] if len(elements) > 0 else None
-        if not stat_element:
-            logging.warning(f"Elements list is empty or stat_element is None in demographics response for {org_urn}. Response data: {json.dumps(data, indent=2)}")
-            return []
+        stat_element = elements[0] 
 
         def _get_entries_for_type(raw_items_list, type_name, id_map, id_field_name_in_item, org_urn_val):
             current_type_entries = []
             if not raw_items_list:
                 logging.debug(f"No raw items for demographic type '{type_name}' for org {org_urn_val}.")
                 return current_type_entries
+
             for item in raw_items_list:
                 category_name_val = "Unknown"
-                if type_name == "follower_association": 
+                if type_name == "follower_association":
                     category_name_val = item.get(id_field_name_in_item, f"Unknown {id_field_name_in_item}")
                 else: 
                     urn_val = item.get(id_field_name_in_item)
                     entity_id = _parse_urn_to_id(urn_val)
-                    if entity_id and id_map: 
-                        category_name_val = id_map.get(str(entity_id), f"Unknown {type_name.split('_')[-1].capitalize()} (ID: {entity_id})")
-                    elif urn_val: 
-                         category_name_val = f"Unmapped {type_name.split('_')[-1].capitalize()} (URN: {urn_val})"
-                    else: 
-                        category_name_val = f"Missing URN for {type_name.split('_')[-1].capitalize()}"
+                    category_name_val = id_map.get(str(entity_id), f"Unknown {type_name.split('_')[-1].capitalize()} (ID: {entity_id if entity_id else urn_val})")
+                
                 counts = item.get("followerCounts", {})
                 organic_count = counts.get("organicFollowerCount", 0)
-                paid_count = counts.get("paidFollowerCount", 0) 
+                paid_count = counts.get("paidFollowerCount", 0)
+
                 current_type_entries.append({
                     "category_name": category_name_val,
-                    "follower_count_organic": organic_count, 
-                    "follower_count_paid": paid_count,       
+                    "follower_count_organic": organic_count,
+                    "follower_count_paid": paid_count,
                     "follower_count_type": type_name,
                     "organization_urn": org_urn_val
                 })
             return current_type_entries
+
         industry_urns_to_map = [item.get("industry") for item in stat_element.get("followerCountsByIndustry", []) if item.get("industry")]
         geo_urns_to_map = [item.get("geo") for item in stat_element.get("followerCountsByGeoCountry", []) if item.get("geo")]
-        live_industries_map = get_industries_map(session, list(set(industry_urns_to_map))) 
-        live_geo_map = get_geo_map(session, list(set(geo_urns_to_map))) 
+        
+        live_industries_map = get_industries_map(session, industry_urns_to_map)
+        live_geo_map = get_geo_map(session, geo_urns_to_map)
+
         demographic_configs = [
             {"items_key": "followerCountsBySeniority", "type_name": "follower_seniority", "id_map": seniorities_map, "id_field": "seniority", "top_n": 10},
             {"items_key": "followerCountsByFunction", "type_name": "follower_function", "id_map": functions_map, "id_field": "function", "top_n": 10},
@@ -423,123 +333,74 @@ def fetch_follower_demographics(session, org_urn, functions_map, seniorities_map
             {"items_key": "followerCountsByGeoCountry", "type_name": "follower_geo", "id_map": live_geo_map, "id_field": "geo", "top_n": 10},
             {"items_key": "followerCountsByAssociationType", "type_name": "follower_association", "id_map": {}, "id_field": "associationType", "top_n": None} 
         ]
+
         for config in demographic_configs:
             raw_items = stat_element.get(config["items_key"], [])
             processed_entries = _get_entries_for_type(raw_items, config["type_name"], config["id_map"], config["id_field"], org_urn)
+            
             if config["top_n"] is not None and processed_entries:
-                for entry in processed_entries:
+                for entry in processed_entries: 
                     if not isinstance(entry.get("follower_count_organic"), (int, float)):
-                        logging.warning(f"Invalid organic follower count for sorting in {config['type_name']}: {entry['follower_count_organic']}. Setting to 0.")
                         entry["follower_count_organic"] = 0
                 sorted_entries = sorted(processed_entries, key=lambda x: x.get("follower_count_organic", 0), reverse=True)
                 final_demographics_results.extend(sorted_entries[:config["top_n"]])
                 logging.debug(f"Added top {config['top_n']} for {config['type_name']}. Count: {len(sorted_entries[:config['top_n']])}")
-            else: 
-                final_demographics_results.extend(processed_entries)
+            else:
+                final_demographics_results.extend(processed_entries) 
                 logging.debug(f"Added all for {config['type_name']}. Count: {len(processed_entries)}")
+        
         logging.info(f"Processed follower demographics for {org_urn}. Total entries from all types: {len(final_demographics_results)}")
-    except requests.exceptions.HTTPError as http_err:
-        code = "N/A"; text = str(http_err); resp_headers = {}
-        if http_err.response is not None:
-            code = http_err.response.status_code
-            text = http_err.response.text
-            resp_headers = dict(http_err.response.headers)
-        logging.error(f"HTTP error fetching follower demographics for {org_urn} (Status: {code}): {text}")
-        logging.error(f"Request URL was: {request_url_for_logging}")
-        logging.error(f"Response Headers: {json.dumps(resp_headers, indent=2)}")
-    except requests.exceptions.RequestException as req_err:
-        logging.error(f"RequestException fetching follower demographics for {org_urn}: {str(req_err)}")
-        logging.error(f"Request URL was: {request_url_for_logging}")
-        if req_err.response is not None:
-            logging.error(f"Associated Response Status: {req_err.response.status_code}")
-            logging.error(f"Associated Response Text: {req_err.response.text}")
-            logging.error(f"Associated Response Headers: {json.dumps(dict(req_err.response.headers), indent=2)}")
-    except json.JSONDecodeError as json_err:
-        response_text = "Not available"
-        if response_obj is not None and hasattr(response_obj, 'text'):
-            response_text = response_obj.text
-        logging.error(f"Error decoding JSON for follower demographics for {org_urn}: {json_err}")
-        logging.error(f"Request URL was: {request_url_for_logging}")
-        logging.error(f"Raw Response Text: {response_text}")
+
+    except requests.exceptions.RequestException as e:
+        status_code = getattr(e.response, 'status_code', 'N/A')
+        error_text = getattr(e.response, 'text', str(e))
+        logging.error(f"Error fetching follower demographics for {org_urn} (Status: {status_code}): {error_text}")
+    except json.JSONDecodeError as e:
+        logging.error(f"Error decoding JSON for follower demographics for {org_urn}: {e}. Response: {response.text if 'response' in locals() else 'N/A'}")
     except Exception as e:
         logging.error(f"Unexpected error fetching follower demographics for {org_urn}: {e}", exc_info=True)
-        logging.error(f"Request URL was: {request_url_for_logging}")
-        if response_obj is not None:
-            logging.error(f"Response Status (if available): {getattr(response_obj, 'status_code', 'N/A')}")
-            logging.error(f"Response Text (if available): {getattr(response_obj, 'text', 'N/A')}")
-            logging.error(f"Response Headers (if available): {json.dumps(dict(getattr(response_obj, 'headers', {})), indent=2)}")
     return final_demographics_results
 
 # --- Main Orchestration Function ---
 
 def get_linkedin_follower_stats(comm_client_id, community_token, org_urn):
-    logging.info(f"--- Initiating get_linkedin_follower_stats for org: {org_urn} ---")
-    logging.info(f"requests-oauthlib version: {requests_oauthlib.__version__}") # Log version
-    logging.debug(f"Received comm_client_id: {comm_client_id}")
-    logging.debug(f"Received community_token - Type: {type(community_token)}, IsSet: {bool(community_token)}")
-    if isinstance(community_token, str) and len(community_token) > 10:
-        logging.debug(f"Received community_token (partial): {community_token[:10]}...")
-    elif isinstance(community_token, dict):
-         logging.debug(f"Received community_token (dict): { {k: (v[:10] + '...' if k == 'access_token' and isinstance(v, str) and len(v)>10 else v) for k,v in community_token.items()} }")
-
+    """
+    Main function to fetch all follower statistics (monthly gains and demographics)
+    and format them for Bubble.
+    """
     if not all([comm_client_id, community_token, org_urn]):
-        logging.error("Client ID, community_token, or Organization URN is missing or empty.")
-        if not comm_client_id: logging.error("comm_client_id is missing.")
-        if not community_token: logging.error("community_token is missing or empty.") 
-        if not org_urn: logging.error("org_urn is missing.")
+        logging.error("Client ID, token, or Organization URN is missing for get_linkedin_follower_stats.")
         return []
 
-    token_dict = community_token if isinstance(community_token, dict) else {'access_token': str(community_token), 'token_type': 'Bearer'}
+    token_dict = community_token if isinstance(community_token, dict) else {'access_token': community_token, 'token_type': 'Bearer'}
     
-    if not token_dict.get('access_token'):
-        logging.error("Failed to construct a valid token_dict: 'access_token' is empty.")
-        logging.debug(f"Problematic token_dict: {token_dict}")
-        return []
-    
-    logging.debug(f"Constructed token_dict for session: { {k: (v[:10] + '...' if k == 'access_token' and isinstance(v, str) and len(v)>10 else v) for k,v in token_dict.items()} }")
-    
-    session = None
+    session = None 
     try:
-        session = create_session(comm_client_id, token=token_dict) 
+        session = create_session(comm_client_id, token=token_dict)
         session.headers.update({
             "X-Restli-Protocol-Version": "2.0.0", 
-            "LinkedIn-Version": LINKEDIN_API_VERSION, 
-            "Accept-Language": "en_US" 
+            "LinkedIn-Version": LINKEDIN_API_VERSION,
+            "Accept-Language": "en_US" # Explicitly set for v2 name lookups if not default in session
         })
-        logging.info(f"Session (id: {id(session)}) created and headers updated for org {org_urn}.")
-        logging.debug(f"get_linkedin_follower_stats (id: {id(session)}): Session token after creation: {session.token}, Session authorized: {session.authorized}, Expires at: {session.token.get('expires_at') if session.token else 'N/A'}")
-        logging.debug(f"get_linkedin_follower_stats (id: {id(session)}): Session auth object: type={type(session.auth)}, value={session.auth}")
-        logging.debug(f"get_linkedin_follower_stats (id: {id(session)}): Auto-refresh URL: {session.auto_refresh_url}, Auto-refresh kwargs: {session.auto_refresh_kwargs}")
-
-        if session.token and 'access_token' in session.token:
-             logging.debug(f"get_linkedin_follower_stats: Access token in session (partial): {str(session.token['access_token'])[:20]}...")
-        else:
-            logging.warning("get_linkedin_follower_stats: session.token is None or 'access_token' key is missing after session creation.")
-
-
     except Exception as e:
         logging.error(f"Failed to create session or update headers for org {org_urn}: {e}", exc_info=True)
-        return []
+        return [] 
 
-    logging.info(f"Starting follower stats retrieval for org: {org_urn} using session (id: {id(session)})")
+    logging.info(f"Starting follower stats retrieval for org: {org_urn}")
 
-    functions_map = get_functions_map(session) # Pass session
-    seniorities_map = get_seniorities_map(session) # Pass session
+    functions_map = get_functions_map(session)
+    seniorities_map = get_seniorities_map(session)
     
-    if not functions_map: logging.warning(f"Functions map is empty for org {org_urn}.")
-    if not seniorities_map: logging.warning(f"Seniorities map is empty for org {org_urn}.")
+    if not functions_map: logging.warning(f"Functions map is empty for org {org_urn}. Function names might not be resolved.")
+    if not seniorities_map: logging.warning(f"Seniorities map is empty for org {org_urn}. Seniority names might not be resolved.")
 
     all_follower_data = []
 
-    monthly_gains = fetch_monthly_follower_gains(comm_client_id, token_dict, org_urn, API_REST_BASE)
+    monthly_gains = fetch_monthly_follower_gains(session, org_urn, API_REST_BASE)
     all_follower_data.extend(monthly_gains)
 
-    demographics = fetch_follower_demographics(session, org_urn, functions_map, seniorities_map) # Pass session
+    demographics = fetch_follower_demographics(session, org_urn, functions_map, seniorities_map)
     all_follower_data.extend(demographics)
 
-    if not all_follower_data:
-        logging.warning(f"No follower data (gains or demographics) could be compiled for {org_urn}.")
-    else:
-        logging.info(f"Successfully compiled {len(all_follower_data)} total follower stat entries for {org_urn}.")
-    
-    return all_follower_data
+    logging.info(f"Successfully compiled {len(all_follower_data)} total follower stat entries for {org_urn}.")
+    return all_follower_data