Update linkedin_follower_stats.py

linkedin_follower_stats.py

@@ -95,21 +95,48 @@ def get_seniorities_map(session):
     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. Returns a map {id: name}."""
-    if not industry_urns: return {}
-    industry_ids = [_parse_urn_to_id(urn) for urn in industry_urns if urn]
-    unique_ids = list(set(filter(None, industry_ids))) 
-    if not unique_ids: return {}
-        
+    """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"
-    # As per LinkedIn docs for BATCH_GET: ids={id1}&ids={id2}&locale.language=en&locale.country=US
     params = {
-        'ids': unique_ids, # requests library will format this as ids=id1&ids=id2...
-        'locale.language': 'en',
-        'locale.country': 'US'
+        # use the single 'locale' param like the GET_ALL example
+        'locale': '(language:en,country:US)',
+        'start': 0,
+        'count': 500  # should exceed total # of industries
     }
-    logging.info(f"Fetching names for {len(unique_ids)} unique industry IDs using BATCH_GET.")
-    return _fetch_linkedin_names(session, url, params, ["results"], ["name", "localized", "en_US"])
+
+    logging.info(f"Fetching all industries (to filter {len(unique_ids)} IDs) from {url}")
+    try:
+        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:
+                # 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")
+        return mapping
+
+    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):
@@ -149,63 +176,47 @@ def _parse_urn_to_id(urn_string):
 
 def fetch_monthly_follower_gains(session, org_urn):
     """
-    Fetches monthly follower gains for the last 12-13 months to ensure full coverage.
-    Uses parameter names as confirmed by user's working script.
+    Fetches monthly follower gains using URL-concatenated timeInterval param,
+    matching the old working approach.
     """
-    results = []
     now = datetime.now(timezone.utc)
-    # Go back 13 months to ensure we capture at least 12 full previous months
-    # and have a buffer, as LinkedIn might report based on full previous months.
-    thirteen_months_ago = now - relativedelta(months=13) 
-    start_of_period = thirteen_months_ago.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+    thirteen_months_ago = now - relativedelta(months=13)
+    start_of_period = thirteen_months_ago.replace(day=1, tzinfo=timezone.utc)
     start_ms = int(start_of_period.timestamp() * 1000)
-    
-    # Parameters as per user's working script and common LinkedIn patterns for time-bound stats
-    params = {
-        'q': 'organizationalEntity',
-        'organizationalEntity': org_urn,
-        'timeIntervals.timeGranularityType': 'MONTH',
-        'timeIntervals.timeRange.start': start_ms
-    }
-    url = f"{API_REST_BASE}/organizationalEntityFollowerStatistics"
-    
-    logging.info(f"Fetching monthly follower gains from: {url} with params: {json.dumps(params)}")
 
+    # 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_ms}"
+    )
+    logging.info(f"Fetching monthly follower gains from URL: {url}")
+
+    results = []
     try:
-        response = session.get(url, params=params)
+        response = session.get(url)
         response.raise_for_status()
         data = response.json()
-
-        for item in data.get("elements", []):
-            time_range = item.get("timeRange", {})
-            start_timestamp_ms = time_range.get("start")
-            if start_timestamp_ms is None:
-                logging.warning("Skipping item due to missing start timestamp in monthly gains.")
+        for item in data.get('elements', []):
+            ts = item.get('timeRange', {}).get('start')
+            if ts is None:
                 continue
-
-            date_obj = datetime.fromtimestamp(start_timestamp_ms / 1000, tz=timezone.utc)
-            date_str = date_obj.strftime('%Y-%m-%d') # First day of the month
-            
-            follower_gains = item.get("followerGains", {})
-            organic_gain = follower_gains.get("organicFollowerGain", 0)
-            paid_gain = follower_gains.get("paidFollowerGain", 0)
-
+            date_str = datetime.fromtimestamp(ts/1000, tz=timezone.utc).strftime('%Y-%m-%d')
+            gains = item.get('followerGains', {})
             results.append({
-                "category_name": date_str,
-                "follower_count_organic": organic_gain,
-                "follower_count_paid": paid_gain,
-                "follower_count_type": "follower_gains_monthly",
-                "organization_urn": org_urn 
+                'category_name': date_str,
+                '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 gain entries for org URN {org_urn}.")
+        logging.info(f"Fetched {len(results)} monthly follower entries for {org_urn}")
     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 monthly follower gains for {org_urn} (Status: {status_code}): {error_text}")
-    except json.JSONDecodeError as e:
-        logging.error(f"Error decoding JSON for monthly follower gains for {org_urn}: {e}. Response: {response.text if 'response' in locals() else 'N/A'}")
-    except Exception as e:
-        logging.error(f"Unexpected error fetching monthly follower gains for {org_urn}: {e}", exc_info=True)
+        code = getattr(e.response, 'status_code', 'N/A')
+        text = getattr(e.response, 'text', str(e))
+        logging.error(f"Error fetching monthly gains: {code} - {text}")
     return results