Update app.py

app.py

@@ -402,56 +402,130 @@ def build_failed_bucket(title: str):
 
 
 # ============================================================
-# Community activity fetch
+# Generic bucketed section configs
 # ============================================================
-def empty_community_state(selected_year: int):
-    return {
-        "username": "",
-        "selected_year": int(selected_year),
-        "fetched": False,
-        "pr_opened": empty_activity_bucket("Pull Requests"),
-        "pr_activity": empty_activity_bucket("PR Activity"),
-        "thread_opened": empty_activity_bucket("Community Threads"),
-        "discussion_activity": empty_activity_bucket("Community Activity"),
-        "logs": "Community activity not fetched yet.",
-    }
+BUCKETED_SECTION_CONFIGS = {
+    "upvotes": {
+        "section_title": "Upvotes activity",
+        "chart_title": "Upvotes",
+        "palette_name": "purple",
+        "context_subject_label": "upvotes activity",
+        "radio_label": "Upvotes view",
+        "default_mode": "all",
+        "empty_logs_text": "Upvotes activity not fetched yet.",
+        "mode_labels": {
+            "all": "All",
+            "papers": "Papers",
+            "blog": "Blog",
+            "changelog": "Changelog",
+        },
+        "bucket_titles": {
+            "papers": "Paper Upvotes",
+            "blog": "Blog Upvotes",
+            "changelog": "Changelog Upvotes",
+        },
+        "bucket_log_labels": {
+            "papers": "paper upvote(s)",
+            "blog": "blog upvote(s)",
+            "changelog": "changelog upvote(s)",
+        },
+    },
+    "likes": {
+        "section_title": "Likes activity",
+        "chart_title": "Likes",
+        "palette_name": "blue",
+        "context_subject_label": "likes activity",
+        "radio_label": "Likes view",
+        "default_mode": "all",
+        "empty_logs_text": "Likes activity not fetched yet.",
+        "mode_labels": {
+            "all": "All",
+            "models": "Models",
+            "datasets": "Datasets",
+            "spaces": "Spaces",
+        },
+        "bucket_titles": {
+            "models": "Model Likes",
+            "datasets": "Dataset Likes",
+            "spaces": "Space Likes",
+        },
+        "bucket_log_labels": {
+            "models": "model like(s)",
+            "datasets": "dataset like(s)",
+            "spaces": "space like(s)",
+        },
+    },
+    "papers": {
+        "section_title": "Papers activity",
+        "chart_title": "Papers",
+        "palette_name": "teal",
+        "context_subject_label": "papers activity",
+        "radio_label": "Papers view",
+        "default_mode": "all",
+        "empty_logs_text": "Papers activity not fetched yet.",
+        "mode_labels": {
+            "all": "All",
+            "daily": "Daily Papers",
+            "authored": "Authored",
+        },
+        "bucket_titles": {
+            "daily": "Daily Papers",
+            "authored": "Authored Papers",
+        },
+        "bucket_log_labels": {
+            "daily": "daily paper submission(s)",
+            "authored": "authored paper(s)",
+        },
+    },
+}
 
 
-def fetch_user_discussion_activity(
+def get_bucketed_section_config(section_key: str):
+    return BUCKETED_SECTION_CONFIGS[section_key]
+
+
+def build_radio_choices(mode_labels: dict[str, str]):
+    return [(label, key) for key, label in mode_labels.items()]
+
+
+# ============================================================
+# Generic bucketed recent-activity fetch
+# ============================================================
+def fetch_bucketed_recent_activity(
     username: str,
     selected_year: int,
-    mode: str,
+    cache_scope: str,
+    activity_type: str,
+    bucket_titles: dict[str, str],
+    bucket_log_labels: dict[str, str],
+    empty_logs_text: str,
+    classifier,
 ):
     username = (username or "").strip()
     selected_year = int(selected_year)
 
-    title_map = {
-        "pr_opened": "Pull Requests",
-        "pr_activity": "PR Activity",
-        "thread_opened": "Community Threads",
-        "discussion_activity": "Community Activity",
-    }
-    title = title_map.get(mode, "Community")
+    cache_key = (username.lower(), selected_year, cache_scope)
+    cached = get_cache(cache_key)
+    if cached:
+        return cached
 
     if not username:
-        return {
-            "title": title,
-            "fetched": True,
-            "dates": [],
-            "count": 0,
-            "logs": "No username provided.",
-        }
+        state = empty_bucketed_activity_state(selected_year, empty_logs_text, bucket_titles)
+        state["fetched"] = True
+        state["logs"] = "No username provided."
+        set_cache(cache_key, state)
+        return state
 
-    dates = []
-    seen_ids = set()
+    bucket_dates = {key: [] for key in bucket_titles}
+    bucket_seen_ids = {key: set() for key in bucket_titles}
+
+    cursor = None
     skip = 0
     limit = 20
-    cursor = None
     pages_fetched = 0
 
     MAX_PAGES = 40
-    MAX_DURATION = 25
-    OPEN_EVENT_EPSILON_SECONDS = 90
+    MAX_DURATION = 20
     start = time.time()
 
     logs = []
@@ -465,94 +539,6 @@ def fetch_user_discussion_activity(
         }
     )
 
-    def normalize_payload(payload):
-        if isinstance(payload, list):
-            return payload, None
-
-        if isinstance(payload, dict):
-            events = payload.get("recentActivity")
-            if isinstance(events, list):
-                return events, payload.get("cursor")
-
-            for key in ["items", "events", "activity"]:
-                value = payload.get(key)
-                if isinstance(value, list):
-                    return value, payload.get("cursor")
-
-        return [], None
-
-    def extract_author_name(discussion: dict) -> str | None:
-        author = discussion.get("author")
-        if isinstance(author, str):
-            return author
-        if isinstance(author, dict):
-            for key in ["name", "username", "login"]:
-                value = author.get(key)
-                if isinstance(value, str):
-                    return value
-        return None
-
-    def parse_ts(raw_value):
-        if not raw_value:
-            return None
-        try:
-            return pd.to_datetime(raw_value, utc=True)
-        except Exception:
-            return None
-
-    def event_matches_mode(event: dict, discussion: dict) -> tuple[bool, str | None]:
-        is_pr = bool(discussion.get("isPullRequest", False))
-        author_name = extract_author_name(discussion)
-        repo_id = event.get("repoId", "unknown-repo")
-        discussion_num = discussion.get("num", "unknown-num")
-        event_id = event.get("eventId", "unknown-event")
-
-        if mode == "pr_opened":
-            if not is_pr:
-                return False, None
-            if not author_name or author_name.lower() != username.lower():
-                return False, None
-            return True, f"{repo_id}::pr::{discussion_num}"
-
-        if mode == "pr_activity":
-            if not is_pr:
-                return False, None
-            return True, f"event::{event_id}"
-
-        if mode == "thread_opened":
-            if is_pr:
-                return False, None
-            if not author_name or author_name.lower() != username.lower():
-                return False, None
-            return True, f"{repo_id}::thread::{discussion_num}"
-
-        if mode == "discussion_activity":
-            if is_pr:
-                return False, None
-            return True, f"event::{event_id}"
-
-        return False, None
-
-    def extract_date_for_mode(event: dict, discussion: dict):
-        event_ts = parse_ts(event.get("time"))
-        created_ts = parse_ts(discussion.get("createdAt"))
-
-        if mode in {"pr_opened", "thread_opened"}:
-            if created_ts is None:
-                return None
-            return created_ts.tz_localize(None).date()
-
-        if mode in {"pr_activity", "discussion_activity"}:
-            if event_ts is None:
-                return None
-            if created_ts is not None:
-                delta_seconds = abs((event_ts - created_ts).total_seconds())
-                if delta_seconds <= OPEN_EVENT_EPSILON_SECONDS:
-                    return None
-            return event_ts.tz_localize(None).date()
-
-        return None
-
     try:
         while True:
             if time.time() - start > MAX_DURATION:
@@ -567,7 +553,7 @@ def fetch_user_discussion_activity(
 
             params = {
                 "limit": limit,
-                "activityType": "discussion",
+                "activityType": activity_type,
                 "feedType": "user",
                 "entity": username,
             }
@@ -586,7 +572,8 @@ def fetch_user_discussion_activity(
             payload = response.json()
             pages_fetched += 1
 
-            events, next_cursor = normalize_payload(payload)
+            events = payload.get("recentActivity", [])
+            next_cursor = payload.get("cursor")
 
             if not events:
                 logs.append("No more events.")
@@ -598,28 +585,35 @@ def fetch_user_discussion_activity(
                 if not isinstance(event, dict):
                     continue
 
-                event_ts = parse_ts(event.get("time"))
-                if event_ts is not None and event_ts.year < selected_year:
+                raw_time = event.get("time")
+                if not raw_time:
+                    continue
+
+                try:
+                    event_ts = pd.to_datetime(raw_time, utc=True)
+                except Exception:
+                    continue
+
+                if event_ts.year < selected_year:
                     stop_early = True
                     break
 
-                discussion = event.get("discussionData") or {}
-                if not isinstance(discussion, dict):
+                if event_ts.year != selected_year:
                     continue
 
-                keep, unique_id = event_matches_mode(event, discussion)
-                if not keep or not unique_id:
+                bucket_key, unique_id = classifier(event)
+
+                if not bucket_key or not unique_id:
                     continue
 
-                dt = extract_date_for_mode(event, discussion)
-                if dt is None or dt.year != selected_year:
+                if bucket_key not in bucket_dates:
                     continue
 
-                if unique_id in seen_ids:
+                if unique_id in bucket_seen_ids[bucket_key]:
                     continue
 
-                seen_ids.add(unique_id)
-                dates.append(dt)
+                bucket_seen_ids[bucket_key].add(unique_id)
+                bucket_dates[bucket_key].append(event_ts.tz_localize(None).date())
 
             if stop_early:
                 logs.append("Stopped early after reaching feed events older than selected year.")
@@ -630,156 +624,46 @@ def fetch_user_discussion_activity(
             else:
                 skip += limit
 
-        logs.append(f"Fetched {pages_fetched} page(s) from recent-activity.")
-        logs.append(f"Found {len(dates)} unique {mode} event(s) in {selected_year}.")
-
-        return {
-            "title": title,
+        result = {
+            "username": username,
+            "selected_year": selected_year,
             "fetched": True,
-            "dates": dates,
-            "count": len(dates),
-            "logs": "\n".join(logs),
+            "logs": "",
         }
 
-    except Exception as e:
-        return {
-            "title": title,
-            "fetched": True,
-            "dates": [],
-            "count": 0,
-            "logs": f"{title} fetch failed: {str(e)}",
-        }
+        for key, title in bucket_titles.items():
+            result[key] = build_fetched_bucket(
+                title=title,
+                dates=bucket_dates[key],
+                selected_year=selected_year,
+                label=bucket_log_labels[key],
+            )
 
+        logs.append(f"Fetched {pages_fetched} page(s) from recent-activity.")
+        logs.append(
+            " | ".join(
+                f"{bucket_titles[key]}: {len(bucket_dates[key])}"
+                for key in bucket_titles
+            )
+        )
 
-def fetch_all_community_activity(username: str, selected_year: int):
-    username = (username or "").strip()
-    selected_year = int(selected_year)
-
-    cache_key = (username.lower(), selected_year, "community")
-    cached = get_cache(cache_key)
-    if cached:
-        return cached
-
-    if not username:
-        state = empty_community_state(selected_year)
-        state["fetched"] = True
-        state["logs"] = "No username provided."
-        set_cache(cache_key, state)
-        return state
-
-    pr_opened = fetch_user_discussion_activity(username, selected_year, "pr_opened")
-    pr_activity = fetch_user_discussion_activity(username, selected_year, "pr_activity")
-    thread_opened = fetch_user_discussion_activity(username, selected_year, "thread_opened")
-    discussion_activity = fetch_user_discussion_activity(username, selected_year, "discussion_activity")
-
-    combined_logs = "\n\n".join(
-        [
-            "[Pull Requests]\n" + pr_opened["logs"],
-            "[PR Activity]\n" + pr_activity["logs"],
-            "[Community Threads]\n" + thread_opened["logs"],
-            "[Community Activity]\n" + discussion_activity["logs"],
-        ]
-    )
-
-    result = {
-        "username": username,
-        "selected_year": selected_year,
-        "fetched": True,
-        "pr_opened": pr_opened,
-        "pr_activity": pr_activity,
-        "thread_opened": thread_opened,
-        "discussion_activity": discussion_activity,
-        "logs": combined_logs,
-    }
-
-    set_cache(cache_key, result)
-    return result
+        result["logs"] = "\n".join(logs)
 
+        set_cache(cache_key, result)
+        return result
 
-# ============================================================
-# Generic bucketed sections config
-# ============================================================
-BUCKETED_SECTION_CONFIGS = {
-    "upvotes": {
-        "section_title": "Upvotes activity",
-        "chart_title": "Upvotes",
-        "palette_name": "purple",
-        "context_subject_label": "upvotes activity",
-        "radio_label": "Upvotes view",
-        "default_mode": "all",
-        "mode_labels": {
-            "all": "All",
-            "papers": "Papers",
-            "blog": "Blog",
-            "changelog": "Changelog",
-        },
-        "bucket_titles": {
-            "papers": "Paper Upvotes",
-            "blog": "Blog Upvotes",
-            "changelog": "Changelog Upvotes",
-        },
-        "bucket_log_labels": {
-            "papers": "paper upvote(s)",
-            "blog": "blog upvote(s)",
-            "changelog": "changelog upvote(s)",
-        },
-        "empty_logs_text": "Upvotes activity not fetched yet.",
-        "activity_type": "upvote",
-    },
-    "likes": {
-        "section_title": "Likes activity",
-        "chart_title": "Likes",
-        "palette_name": "blue",
-        "context_subject_label": "likes activity",
-        "radio_label": "Likes view",
-        "default_mode": "all",
-        "mode_labels": {
-            "all": "All",
-            "models": "Models",
-            "datasets": "Datasets",
-            "spaces": "Spaces",
-        },
-        "bucket_titles": {
-            "models": "Model Likes",
-            "datasets": "Dataset Likes",
-            "spaces": "Space Likes",
-        },
-        "bucket_log_labels": {
-            "models": "model like(s)",
-            "datasets": "dataset like(s)",
-            "spaces": "space like(s)",
-        },
-        "empty_logs_text": "Likes activity not fetched yet.",
-        "activity_type": "like",
-    },
-    "papers": {
-        "section_title": "Papers activity",
-        "chart_title": "Papers",
-        "palette_name": "teal",
-        "context_subject_label": "papers activity",
-        "radio_label": "Papers view",
-        "default_mode": "all",
-        "mode_labels": {
-            "all": "All",
-            "daily": "Daily Papers",
-            "authored": "Authored",
-        },
-        "bucket_titles": {
-            "daily": "Daily Papers",
-            "authored": "Authored Papers",
-        },
-        "bucket_log_labels": {
-            "daily": "daily paper submission(s)",
-            "authored": "authored paper(s)",
-        },
-        "empty_logs_text": "Papers activity not fetched yet.",
-        "activity_type": "update-paper",
-    },
-}
+    except Exception as e:
+        failed = {
+            "username": username,
+            "selected_year": selected_year,
+            "fetched": True,
+            "logs": f"{cache_scope.capitalize()} fetch failed: {str(e)}",
+        }
 
+        for key, title in bucket_titles.items():
+            failed[key] = build_failed_bucket(title)
 
-def get_bucketed_section_config(section_key: str):
-    return BUCKETED_SECTION_CONFIGS[section_key]
+        return failed
 
 
 # ============================================================
@@ -847,24 +731,35 @@ def classify_paper_event(event: dict):
     return bucket_key, unique_id
 
 
-BUCKETED_CLASSIFIERS = {
-    "upvotes": classify_upvote_event,
-    "likes": classify_like_event,
-    "papers": classify_paper_event,
+BUCKETED_SECTION_RUNTIME = {
+    "upvotes": {
+        "activity_type": "upvote",
+        "classifier": classify_upvote_event,
+    },
+    "likes": {
+        "activity_type": "like",
+        "classifier": classify_like_event,
+    },
+    "papers": {
+        "activity_type": "update-paper",
+        "classifier": classify_paper_event,
+    },
 }
 
 
 def fetch_generic_bucketed_section(section_key: str, username: str, selected_year: int):
     cfg = get_bucketed_section_config(section_key)
+    runtime = BUCKETED_SECTION_RUNTIME[section_key]
+
     return fetch_bucketed_recent_activity(
         username=username,
         selected_year=selected_year,
         cache_scope=section_key,
-        activity_type=cfg["activity_type"],
+        activity_type=runtime["activity_type"],
         bucket_titles=cfg["bucket_titles"],
         bucket_log_labels=cfg["bucket_log_labels"],
         empty_logs_text=cfg["empty_logs_text"],
-        classifier=BUCKETED_CLASSIFIERS[section_key],
+        classifier=runtime["classifier"],
     )
 
 
@@ -878,432 +773,303 @@ def empty_generic_section_state(section_key: str, selected_year: int):
 
 
 # ============================================================
-# Contribution grid helpers
-# ============================================================
-PALETTES = {
-    "green": ["#0e4429", "#006d32", "#26a641", "#39d353"],
-    "blue": ["#0a3069", "#0969da", "#54aeff", "#79c0ff"],
-    "pink": ["#6e1f4d", "#bf3989", "#db61a2", "#f778ba"],
-    "orange": ["#5f370e", "#a14d00", "#d97706", "#f59e0b"],
-    "purple": ["#4c1d95", "#6d28d9", "#8b5cf6", "#c4b5fd"],
-    "teal": ["#0f766e", "#0d9488", "#14b8a6", "#5eead4"],
-}
-
-TOOLTIP_SAFE_COLUMNS = 2
-
-
-def level_from_count(count: int) -> int:
-    if count <= 0:
-        return 0
-    if count == 1:
-        return 1
-    if count <= 3:
-        return 2
-    if count <= 7:
-        return 3
-    return 4
-
-
-def level_color(palette_name: str, level: int) -> str:
-    if level <= 0:
-        return "var(--gh-empty-cell)"
-    palette = PALETTES[palette_name]
-    return palette[min(level - 1, len(palette) - 1)]
-
-
-def build_daily_count_map(df: pd.DataFrame):
-    if df.empty:
-        return {}
-
-    counts = (
-        df.copy()
-        .assign(date=pd.to_datetime(df["date"]).dt.date, count=1)
-        .groupby("date", as_index=False)["count"]
-        .sum()
-    )
-    return {row["date"]: int(row["count"]) for _, row in counts.iterrows()}
-
-
-def get_calendar_bounds(year: int):
-    start = pd.Timestamp(f"{year}-01-01")
-    end = pd.Timestamp(f"{year}-12-31")
-
-    grid_start = start - pd.Timedelta(days=start.dayofweek)
-    grid_end = end + pd.Timedelta(days=(6 - end.dayofweek))
-
-    all_days = pd.date_range(grid_start, grid_end, freq="D")
-    num_weeks = len(all_days) // 7
-    return start, end, grid_start, grid_end, all_days, num_weeks
-
-
-def month_positions_for_year(year: int, grid_start: pd.Timestamp):
-    month_starts = pd.date_range(f"{year}-01-01", f"{year}-12-31", freq="MS")
-    return [(d.strftime("%b"), int((d - grid_start).days // 7)) for d in month_starts]
-
-
-# ============================================================
-# Name helpers
-# ============================================================
-def resolve_display_name(
-    username: str,
-    profile: gr.OAuthProfile | None,
-    identity: dict | None = None,
-):
-    username = (username or "").strip()
-    if not username:
-        return ""
-
-    profile_username = getattr(profile, "username", None) if profile is not None else None
-    profile_name = getattr(profile, "name", None) if profile is not None else None
-
-    if profile_username and profile_username.lower() == username.lower():
-        if isinstance(profile_name, str) and profile_name.strip():
-            return f"{profile_name.strip()} (@{profile_username})"
-        return f"@{profile_username}"
-
-    if identity:
-        display_name = identity.get("display_name")
-        if isinstance(display_name, str) and display_name.strip():
-            return display_name
-
-        fullname = identity.get("fullname")
-        identity_username = identity.get("username") or username
-        if isinstance(fullname, str) and fullname.strip():
-            return f"{fullname.strip()} (@{identity_username})"
-
-        if isinstance(identity_username, str) and identity_username.strip():
-            return f"@{identity_username.strip()}"
-
-    return f"@{username}"
-
-
-# ============================================================
-# Banner helpers
+# Community activity fetch
 # ============================================================
-def render_status_badge(text: str):
-    return f'<div class="gh-status">{text}</div>'
+def empty_community_state(selected_year: int):
+    return {
+        "username": "",
+        "selected_year": int(selected_year),
+        "fetched": False,
+        "pr_opened": empty_activity_bucket("Pull Requests"),
+        "pr_activity": empty_activity_bucket("PR Activity"),
+        "thread_opened": empty_activity_bucket("Community Threads"),
+        "discussion_activity": empty_activity_bucket("Community Activity"),
+        "logs": "Community activity not fetched yet.",
+    }
 
 
-def render_idle_context_banner(
+def fetch_user_discussion_activity(
     username: str,
-    profile: gr.OAuthProfile | None,
+    selected_year: int,
+    mode: str,
 ):
     username = (username or "").strip()
-    viewer = getattr(profile, "username", None) if profile else None
-
-    if viewer:
-        if not username or username.lower() == viewer.lower():
-            return render_status_badge(
-                f"Logged in as <b>{html.escape(viewer)}</b> · Fetch your activity or enter another username"
-            )
-        return render_status_badge(
-            f"Logged in as <b>{html.escape(viewer)}</b> · Ready to fetch <b>{html.escape(username)}</b> · Public repos only"
-        )
-
-    if username:
-        return render_status_badge(
-            f"Not logged in · Ready to fetch <b>{html.escape(username)}</b> · Public repos only"
-        )
-
-    return render_status_badge("Not logged in · Enter a username to get started")
-
-
-def render_invalid_username_banner(username: str, error_text: str | None = None):
-    username = (username or "").strip()
-    message = error_text or f"Username or org '{username}' was not found."
-    return render_status_badge(html.escape(message))
-
+    selected_year = int(selected_year)
 
-def render_context_banner(app_state: dict | None, profile: gr.OAuthProfile | None):
-    if not app_state or not app_state.get("username"):
-        return render_idle_context_banner("", profile)
+    title_map = {
+        "pr_opened": "Pull Requests",
+        "pr_activity": "PR Activity",
+        "thread_opened": "Community Threads",
+        "discussion_activity": "Community Activity",
+    }
+    title = title_map.get(mode, "Community")
 
-    username = app_state["username"]
-    selected_year = int(app_state["selected_year"])
-    is_own = bool(app_state.get("is_own_profile", False))
-    can_toggle = bool(app_state.get("can_toggle_visibility", False))
-    viewer = getattr(profile, "username", None) if profile else None
+    if not username:
+        return {
+            "title": title,
+            "fetched": True,
+            "dates": [],
+            "count": 0,
+            "logs": "No username provided.",
+        }
 
-    parts = []
+    dates = []
+    seen_ids = set()
+    skip = 0
+    limit = 20
+    cursor = None
+    pages_fetched = 0
 
-    if viewer:
-        parts.append(f"Logged in as <b>{html.escape(viewer)}</b>")
-    else:
-        parts.append("Not logged in")
+    MAX_PAGES = 40
+    MAX_DURATION = 25
+    OPEN_EVENT_EPSILON_SECONDS = 90
+    start = time.time()
 
-    if viewer and username.lower() == viewer.lower():
-        parts.append("Viewing <b>your activity</b>")
-    else:
-        parts.append(f"Viewing <b>{html.escape(username)}</b>")
+    logs = []
 
-    parts.append(str(selected_year))
+    session = requests.Session()
+    session.headers.update(
+        {
+            "User-Agent": "hf-contributions-app/1.0",
+            "Accept": "application/json",
+            "Cache-Control": "no-cache",
+        }
+    )
 
-    if is_own and can_toggle:
-        parts.append("Private repos available")
-    else:
-        parts.append("Public repos only")
+    def normalize_payload(payload):
+        if isinstance(payload, list):
+            return payload, None
 
-    return render_status_badge(" · ".join(parts))
+        if isinstance(payload, dict):
+            events = payload.get("recentActivity")
+            if isinstance(events, list):
+                return events, payload.get("cursor")
 
+            for key in ["items", "events", "activity"]:
+                value = payload.get(key)
+                if isinstance(value, list):
+                    return value, payload.get("cursor")
 
-def render_fetching_context_banner(
-    username,
-    selected_year,
-    profile: gr.OAuthProfile | None,
-):
-    username = (username or "").strip()
-    selected_year = int(selected_year)
-    viewer = getattr(profile, "username", None) if profile else None
+        return [], None
 
-    if not username:
-        return render_idle_context_banner("", profile)
+    def extract_author_name(discussion: dict) -> str | None:
+        author = discussion.get("author")
+        if isinstance(author, str):
+            return author
+        if isinstance(author, dict):
+            for key in ["name", "username", "login"]:
+                value = author.get(key)
+                if isinstance(value, str):
+                    return value
+        return None
 
-    parts = []
+    def parse_ts(raw_value):
+        if not raw_value:
+            return None
+        try:
+            return pd.to_datetime(raw_value, utc=True)
+        except Exception:
+            return None
 
-    if viewer:
-        parts.append(f"Logged in as <b>{html.escape(viewer)}</b>")
-    else:
-        parts.append("Not logged in")
+    def event_matches_mode(event: dict, discussion: dict) -> tuple[bool, str | None]:
+        is_pr = bool(discussion.get("isPullRequest", False))
+        author_name = extract_author_name(discussion)
+        repo_id = event.get("repoId", "unknown-repo")
+        discussion_num = discussion.get("num", "unknown-num")
+        event_id = event.get("eventId", "unknown-event")
 
-    if viewer and username.lower() == viewer.lower():
-        parts.append("Fetching <b>your activity</b>")
-        parts.append(str(selected_year))
-        parts.append("Checking public and private repos")
-    else:
-        parts.append(f"Fetching <b>{html.escape(username)}</b>")
-        parts.append(str(selected_year))
-        parts.append("Checking public repos")
+        if mode == "pr_opened":
+            if not is_pr:
+                return False, None
+            if not author_name or author_name.lower() != username.lower():
+                return False, None
+            return True, f"{repo_id}::pr::{discussion_num}"
 
-    return render_status_badge(" · ".join(parts))
+        if mode == "pr_activity":
+            if not is_pr:
+                return False, None
+            return True, f"event::{event_id}"
 
+        if mode == "thread_opened":
+            if is_pr:
+                return False, None
+            if not author_name or author_name.lower() != username.lower():
+                return False, None
+            return True, f"{repo_id}::thread::{discussion_num}"
 
-def render_community_idle_banner(
-    username,
-    selected_year,
-    profile: gr.OAuthProfile | None,
-):
-    username = (username or "").strip()
-    selected_year = int(selected_year)
-    viewer = getattr(profile, "username", None) if profile else None
+        if mode == "discussion_activity":
+            if is_pr:
+                return False, None
+            return True, f"event::{event_id}"
 
-    parts = []
-    if viewer:
-        parts.append(f"Logged in as <b>{html.escape(viewer)}</b>")
-    else:
-        parts.append("Not logged in")
+        return False, None
 
-    if not username:
-        parts.append("Enter a username to fetch community activity")
-        return render_status_badge(" · ".join(parts))
+    def extract_date_for_mode(event: dict, discussion: dict):
+        event_ts = parse_ts(event.get("time"))
+        created_ts = parse_ts(discussion.get("createdAt"))
 
-    if viewer and username.lower() == viewer.lower():
-        parts.append("Fetch your community activity or enter another username")
-        parts.append(str(selected_year))
-    else:
-        parts.append(f"Ready to fetch community activity for <b>{html.escape(username)}</b>")
-        parts.append(str(selected_year))
+        if mode in {"pr_opened", "thread_opened"}:
+            if created_ts is None:
+                return None
+            return created_ts.tz_localize(None).date()
 
-    return render_status_badge(" · ".join(parts))
+        if mode in {"pr_activity", "discussion_activity"}:
+            if event_ts is None:
+                return None
+            if created_ts is not None:
+                delta_seconds = abs((event_ts - created_ts).total_seconds())
+                if delta_seconds <= OPEN_EVENT_EPSILON_SECONDS:
+                    return None
+            return event_ts.tz_localize(None).date()
 
+        return None
 
-def render_community_invalid_banner(username: str, error_text: str | None = None):
-    username = (username or "").strip()
-    message = error_text or f"Username or org '{username}' was not found."
-    return render_status_badge(html.escape(message))
+    try:
+        while True:
+            if time.time() - start > MAX_DURATION:
+                logs.append("Stopped due to timeout.")
+                break
 
+            if pages_fetched >= MAX_PAGES:
+                logs.append("Stopped due to max pages.")
+                break
 
-def render_community_fetching_banner(
-    username,
-    selected_year,
-    profile: gr.OAuthProfile | None,
-):
-    username = (username or "").strip()
-    selected_year = int(selected_year)
-    viewer = getattr(profile, "username", None) if profile else None
+            recent_activity_rate_limiter.wait()
 
-    if not username:
-        return render_community_idle_banner("", selected_year, profile)
+            params = {
+                "limit": limit,
+                "activityType": "discussion",
+                "feedType": "user",
+                "entity": username,
+            }
+            if cursor:
+                params["cursor"] = cursor
+            else:
+                params["skip"] = skip
 
-    parts = []
-    if viewer:
-        parts.append(f"Logged in as <b>{html.escape(viewer)}</b>")
-    else:
-        parts.append("Not logged in")
+            response = session.get(
+                "https://huggingface.co/api/recent-activity",
+                params=params,
+                timeout=20,
+            )
+            response.raise_for_status()
 
-    if viewer and username.lower() == viewer.lower():
-        parts.append("Fetching <b>your community activity</b>")
-    else:
-        parts.append(f"Fetching community activity for <b>{html.escape(username)}</b>")
+            payload = response.json()
+            pages_fetched += 1
 
-    parts.append(str(selected_year))
-    return render_status_badge(" · ".join(parts))
+            events, next_cursor = normalize_payload(payload)
 
+            if not events:
+                logs.append("No more events.")
+                break
 
-def render_community_loaded_banner(
-    community_state: dict | None,
-    profile: gr.OAuthProfile | None,
-):
-    if not community_state or not community_state.get("username"):
-        year = community_state.get("selected_year", datetime.now().year) if community_state else datetime.now().year
-        return render_community_idle_banner("", year, profile)
+            stop_early = False
 
-    username = community_state["username"]
-    selected_year = int(community_state["selected_year"])
-    viewer = getattr(profile, "username", None) if profile else None
+            for event in events:
+                if not isinstance(event, dict):
+                    continue
 
-    parts = []
-    if viewer:
-        parts.append(f"Logged in as <b>{html.escape(viewer)}</b>")
-    else:
-        parts.append("Not logged in")
+                event_ts = parse_ts(event.get("time"))
+                if event_ts is not None and event_ts.year < selected_year:
+                    stop_early = True
+                    break
 
-    if viewer and username.lower() == viewer.lower():
-        parts.append("Viewing <b>your community activity</b>")
-    else:
-        parts.append(f"Viewing community activity for <b>{html.escape(username)}</b>")
+                discussion = event.get("discussionData") or {}
+                if not isinstance(discussion, dict):
+                    continue
 
-    parts.append(str(selected_year))
-    return render_status_badge(" · ".join(parts))
+                keep, unique_id = event_matches_mode(event, discussion)
+                if not keep or not unique_id:
+                    continue
 
+                dt = extract_date_for_mode(event, discussion)
+                if dt is None or dt.year != selected_year:
+                    continue
 
-def render_bucketed_idle_banner(
-    section_key: str,
-    username,
-    selected_year,
-    profile: gr.OAuthProfile | None,
-):
-    cfg = get_bucketed_section_config(section_key)
-    username = (username or "").strip()
-    selected_year = int(selected_year)
-    viewer = getattr(profile, "username", None) if profile else None
-    subject = cfg["context_subject_label"]
+                if unique_id in seen_ids:
+                    continue
 
-    parts = []
-    if viewer:
-        parts.append(f"Logged in as <b>{html.escape(viewer)}</b>")
-    else:
-        parts.append("Not logged in")
+                seen_ids.add(unique_id)
+                dates.append(dt)
 
-    if not username:
-        parts.append(f"Enter a username to fetch {subject}")
-        return render_status_badge(" · ".join(parts))
+            if stop_early:
+                logs.append("Stopped early after reaching feed events older than selected year.")
+                break
 
-    if viewer and username.lower() == viewer.lower():
-        parts.append(f"Fetch your {subject} or enter another username")
-        parts.append(str(selected_year))
-    else:
-        parts.append(f"Ready to fetch {subject} for <b>{html.escape(username)}</b>")
-        parts.append(str(selected_year))
+            if next_cursor:
+                cursor = next_cursor
+            else:
+                skip += limit
 
-    return render_status_badge(" · ".join(parts))
+        logs.append(f"Fetched {pages_fetched} page(s) from recent-activity.")
+        logs.append(f"Found {len(dates)} unique {mode} event(s) in {selected_year}.")
 
+        return {
+            "title": title,
+            "fetched": True,
+            "dates": dates,
+            "count": len(dates),
+            "logs": "\n".join(logs),
+        }
 
-def render_bucketed_invalid_banner(section_key: str, username: str, error_text: str | None = None):
-    _ = section_key
-    username = (username or "").strip()
-    message = error_text or f"Username or org '{username}' was not found."
-    return render_status_badge(html.escape(message))
+    except Exception as e:
+        return {
+            "title": title,
+            "fetched": True,
+            "dates": [],
+            "count": 0,
+            "logs": f"{title} fetch failed: {str(e)}",
+        }
 
 
-def render_bucketed_fetching_banner(
-    section_key: str,
-    username,
-    selected_year,
-    profile: gr.OAuthProfile | None,
-):
-    cfg = get_bucketed_section_config(section_key)
+def fetch_all_community_activity(username: str, selected_year: int):
     username = (username or "").strip()
     selected_year = int(selected_year)
-    viewer = getattr(profile, "username", None) if profile else None
-    subject = cfg["context_subject_label"]
-
-    if not username:
-        return render_bucketed_idle_banner(section_key, "", selected_year, profile)
-
-    parts = []
-    if viewer:
-        parts.append(f"Logged in as <b>{html.escape(viewer)}</b>")
-    else:
-        parts.append("Not logged in")
-
-    if viewer and username.lower() == viewer.lower():
-        parts.append(f"Fetching <b>your {subject}</b>")
-    else:
-        parts.append(f"Fetching {subject} for <b>{html.escape(username)}</b>")
-
-    parts.append(str(selected_year))
-    return render_status_badge(" · ".join(parts))
 
+    cache_key = (username.lower(), selected_year, "community")
+    cached = get_cache(cache_key)
+    if cached:
+        return cached
 
-def render_bucketed_loaded_banner(
-    section_key: str,
-    section_state: dict | None,
-    profile: gr.OAuthProfile | None,
-):
-    cfg = get_bucketed_section_config(section_key)
-
-    if not section_state or not section_state.get("username"):
-        year = section_state.get("selected_year", datetime.now().year) if section_state else datetime.now().year
-        return render_bucketed_idle_banner(section_key, "", year, profile)
+    if not username:
+        state = empty_community_state(selected_year)
+        state["fetched"] = True
+        state["logs"] = "No username provided."
+        set_cache(cache_key, state)
+        return state
 
-    username = section_state["username"]
-    selected_year = int(section_state["selected_year"])
-    viewer = getattr(profile, "username", None) if profile else None
-    subject = cfg["context_subject_label"]
+    pr_opened = fetch_user_discussion_activity(username, selected_year, "pr_opened")
+    pr_activity = fetch_user_discussion_activity(username, selected_year, "pr_activity")
+    thread_opened = fetch_user_discussion_activity(username, selected_year, "thread_opened")
+    discussion_activity = fetch_user_discussion_activity(username, selected_year, "discussion_activity")
 
-    parts = []
-    if viewer:
-        parts.append(f"Logged in as <b>{html.escape(viewer)}</b>")
-    else:
-        parts.append("Not logged in")
+    combined_logs = "\n\n".join(
+        [
+            "[Pull Requests]\n" + pr_opened["logs"],
+            "[PR Activity]\n" + pr_activity["logs"],
+            "[Community Threads]\n" + thread_opened["logs"],
+            "[Community Activity]\n" + discussion_activity["logs"],
+        ]
+    )
 
-    if viewer and username.lower() == viewer.lower():
-        parts.append(f"Viewing <b>your {subject}</b>")
-    else:
-        parts.append(f"Viewing {subject} for <b>{html.escape(username)}</b>")
+    result = {
+        "username": username,
+        "selected_year": selected_year,
+        "fetched": True,
+        "pr_opened": pr_opened,
+        "pr_activity": pr_activity,
+        "thread_opened": thread_opened,
+        "discussion_activity": discussion_activity,
+        "logs": combined_logs,
+    }
 
-    parts.append(str(selected_year))
-    return render_status_badge(" · ".join(parts))
+    set_cache(cache_key, result)
+    return result
 
 
 # ============================================================
 # Render helpers
 # ============================================================
-def render_metric_cards(
-    total_activity: int,
-    created_by_type: dict,
-    repo_commit_counts_by_type: dict,
-    selected_year: int,
-):
-    return f"""
-    <div class="stats-grid">
-      <div class="gh-card">
-        <div class="gh-card-label">Total activity</div>
-        <div class="gh-card-value">{total_activity}</div>
-        <div class="gh-card-sub">Creations + repo contributions in {selected_year}</div>
-      </div>
-
-      <div class="gh-card">
-        <div class="gh-card-label">🧠 Models created</div>
-        <div class="gh-card-value">{created_by_type["model"]}</div>
-        <div class="gh-card-sub">{repo_commit_counts_by_type["model"]} contributions on model repos</div>
-      </div>
-
-      <div class="gh-card">
-        <div class="gh-card-label">📦 Datasets created</div>
-        <div class="gh-card-value">{created_by_type["dataset"]}</div>
-        <div class="gh-card-sub">{repo_commit_counts_by_type["dataset"]} contributions on dataset repos</div>
-      </div>
-
-      <div class="gh-card">
-        <div class="gh-card-label">🚀 Spaces created</div>
-        <div class="gh-card-value">{created_by_type["space"]}</div>
-        <div class="gh-card-sub">{repo_commit_counts_by_type["space"]} contributions on space repos</div>
-      </div>
-    </div>
-    """
-
-
 def render_empty_chart(title: str):
     safe_title = html.escape(title)
     return f"""
@@ -1493,22 +1259,23 @@ def render_discussion_combined_chart(community_state: dict | None, mode: str, us
 
 def render_bucketed_chart(section_key: str, section_state: dict | None, mode: str, username: str, year: int):
     cfg = get_bucketed_section_config(section_key)
+    chart_title = cfg["chart_title"]
+    default_mode = cfg["default_mode"]
 
     if not section_state or not section_state.get("fetched"):
-        return render_empty_chart(cfg["chart_title"])
+        return render_empty_chart(chart_title)
 
-    bucket_titles = cfg["bucket_titles"]
-    default_mode = cfg["default_mode"]
     mode = mode or default_mode
+    bucket_keys = list(cfg["bucket_titles"].keys())
 
     if mode == "all":
         merged = []
-        for bucket_key in bucket_titles:
-            merged.extend(section_state[bucket_key]["dates"])
-        subtitle = f"{len(merged)} total {cfg['chart_title'].lower()} event(s) by {username} in {year}"
+        for key in bucket_keys:
+            merged.extend(section_state[key]["dates"])
+        subtitle = f"{len(merged)} total {chart_title.lower()} event(s) by {username} in {year}"
     else:
         merged = list(section_state.get(mode, {}).get("dates", []))
-        bucket_title = bucket_titles.get(mode, mode)
+        bucket_title = cfg["bucket_titles"].get(mode, mode)
         subtitle = f"{len(merged)} {bucket_title.lower()} by {username} in {year}"
 
     df = pd.DataFrame(merged, columns=["date"])
@@ -1516,7 +1283,7 @@ def render_bucketed_chart(section_key: str, section_state: dict | None, mode: st
     return render_contrib_chart(
         df,
         year,
-        cfg["chart_title"],
+        chart_title,
         palette_name=cfg["palette_name"],
         subtitle=subtitle,
     )
@@ -1769,7 +1536,7 @@ def render_app_state(
 
 
 # ============================================================
-# Repo handlers
+# Stable return-based fetch / reset logic
 # ============================================================
 def prepare_repo_fetch_ui(
     username,
@@ -1869,9 +1636,6 @@ def rerender_from_state(app_state, visibility_mode, profile: gr.OAuthProfile | N
     return render_app_state(app_state, visibility_mode, profile)
 
 
-# ============================================================
-# Community handlers
-# ============================================================
 def maybe_reset_community_section(
     current_community_state,
     username,
@@ -1954,96 +1718,6 @@ def maybe_reset_community_section(
     )
 
 
-def prepare_community_fetch_ui(username, selected_year, profile: gr.OAuthProfile | None):
-    username = (username or "").strip()
-    if username:
-        identity = validate_username(username, profile)
-        if not identity.get("exists"):
-            return render_community_invalid_banner(username, identity.get("error"))
-    return render_community_fetching_banner(username, selected_year, profile)
-
-
-def fetch_and_render_community(
-    current_state,
-    username,
-    selected_year,
-    pr_mode,
-    discussion_mode,
-    profile: gr.OAuthProfile | None,
-):
-    username = (username or "").strip()
-    selected_year = int(selected_year)
-    pr_mode = pr_mode or "both"
-    discussion_mode = discussion_mode or "both"
-
-    identity = validate_username(username, profile)
-    if username and not identity.get("exists"):
-        empty_state = empty_community_state(selected_year)
-        empty_state["username"] = username
-        empty_state["selected_year"] = selected_year
-        empty_state["logs"] = identity.get("error") or f"Username or org '{username}' was not found."
-        return (
-            empty_state,
-            render_community_invalid_banner(username, identity.get("error")),
-            render_empty_chart("Pull Requests"),
-            render_empty_chart("Community Discussions"),
-            empty_state["logs"],
-            gr.update(value="both", visible="hidden"),
-            gr.update(value="both", visible="hidden"),
-        )
-
-    state = fetch_all_community_activity(username, selected_year)
-
-    pr_chart = render_pr_combined_chart(
-        state,
-        pr_mode,
-        username=username,
-        year=selected_year,
-    )
-
-    discussion_chart = render_discussion_combined_chart(
-        state,
-        discussion_mode,
-        username=username,
-        year=selected_year,
-    )
-
-    return (
-        state,
-        render_community_loaded_banner(state, profile),
-        pr_chart,
-        discussion_chart,
-        state["logs"],
-        gr.update(value=pr_mode, visible=True),
-        gr.update(value=discussion_mode, visible=True),
-    )
-
-
-def rerender_pr_from_state(community_state, pr_mode):
-    if not community_state:
-        return render_empty_chart("Pull Requests")
-    return render_pr_combined_chart(
-        community_state,
-        pr_mode or "both",
-        username=(community_state.get("username") or ""),
-        year=int(community_state.get("selected_year") or datetime.now().year),
-    )
-
-
-def rerender_discussions_from_state(community_state, discussion_mode):
-    if not community_state:
-        return render_empty_chart("Community Discussions")
-    return render_discussion_combined_chart(
-        community_state,
-        discussion_mode or "both",
-        username=(community_state.get("username") or ""),
-        year=int(community_state.get("selected_year") or datetime.now().year),
-    )
-
-
-# ============================================================
-# Generic bucketed handlers
-# ============================================================
 def maybe_reset_bucketed_section(
     section_key: str,
     current_state,
@@ -2113,6 +1787,15 @@ def maybe_reset_bucketed_section(
     )
 
 
+def prepare_community_fetch_ui(username, selected_year, profile: gr.OAuthProfile | None):
+    username = (username or "").strip()
+    if username:
+        identity = validate_username(username, profile)
+        if not identity.get("exists"):
+            return render_community_invalid_banner(username, identity.get("error"))
+    return render_community_fetching_banner(username, selected_year, profile)
+
+
 def prepare_bucketed_fetch_ui(section_key: str, username, selected_year, profile: gr.OAuthProfile | None):
     username = (username or "").strip()
     if username:
@@ -2122,6 +1805,62 @@ def prepare_bucketed_fetch_ui(section_key: str, username, selected_year, profile
     return render_bucketed_fetching_banner(section_key, username, selected_year, profile)
 
 
+def fetch_and_render_community(
+    current_state,
+    username,
+    selected_year,
+    pr_mode,
+    discussion_mode,
+    profile: gr.OAuthProfile | None,
+):
+    username = (username or "").strip()
+    selected_year = int(selected_year)
+    pr_mode = pr_mode or "both"
+    discussion_mode = discussion_mode or "both"
+
+    identity = validate_username(username, profile)
+    if username and not identity.get("exists"):
+        empty_state = empty_community_state(selected_year)
+        empty_state["username"] = username
+        empty_state["selected_year"] = selected_year
+        empty_state["logs"] = identity.get("error") or f"Username or org '{username}' was not found."
+        return (
+            empty_state,
+            render_community_invalid_banner(username, identity.get("error")),
+            render_empty_chart("Pull Requests"),
+            render_empty_chart("Community Discussions"),
+            empty_state["logs"],
+            gr.update(value="both", visible="hidden"),
+            gr.update(value="both", visible="hidden"),
+        )
+
+    state = fetch_all_community_activity(username, selected_year)
+
+    pr_chart = render_pr_combined_chart(
+        state,
+        pr_mode,
+        username=username,
+        year=selected_year,
+    )
+
+    discussion_chart = render_discussion_combined_chart(
+        state,
+        discussion_mode,
+        username=username,
+        year=selected_year,
+    )
+
+    return (
+        state,
+        render_community_loaded_banner(state, profile),
+        pr_chart,
+        discussion_chart,
+        state["logs"],
+        gr.update(value=pr_mode, visible=True),
+        gr.update(value=discussion_mode, visible=True),
+    )
+
+
 def fetch_and_render_bucketed_section(
     section_key: str,
     current_state,
@@ -2169,6 +1908,28 @@ def fetch_and_render_bucketed_section(
     )
 
 
+def rerender_pr_from_state(community_state, pr_mode):
+    if not community_state:
+        return render_empty_chart("Pull Requests")
+    return render_pr_combined_chart(
+        community_state,
+        pr_mode or "both",
+        username=(community_state.get("username") or ""),
+        year=int(community_state.get("selected_year") or datetime.now().year),
+    )
+
+
+def rerender_discussions_from_state(community_state, discussion_mode):
+    if not community_state:
+        return render_empty_chart("Community Discussions")
+    return render_discussion_combined_chart(
+        community_state,
+        discussion_mode or "both",
+        username=(community_state.get("username") or ""),
+        year=int(community_state.get("selected_year") or datetime.now().year),
+    )
+
+
 def rerender_bucketed_from_state(section_key: str, section_state, mode):
     cfg = get_bucketed_section_config(section_key)
     if not section_state:
@@ -2183,7 +1944,7 @@ def rerender_bucketed_from_state(section_key: str, section_state, mode):
 
 
 # ============================================================
-# Factory helpers
+# Factory helpers for Gradio-compatible handlers
 # ============================================================
 def make_prepare_bucketed_fetch_ui(section_key: str):
     def _fn(username, selected_year, profile: gr.OAuthProfile | None):
@@ -2824,6 +2585,10 @@ button.gh-cell {
 
 year_options = list(range(datetime.now().year, 2017, -1))
 
+upvotes_cfg = get_bucketed_section_config("upvotes")
+likes_cfg = get_bucketed_section_config("likes")
+papers_cfg = get_bucketed_section_config("papers")
+
 with gr.Blocks(title="HF Contributions") as demo:
     app_state = gr.State(value=None)
     community_state = gr.State(value=None)
@@ -2936,21 +2701,21 @@ with gr.Blocks(title="HF Contributions") as demo:
 
     with gr.Column(elem_classes="toggles-container"):
         upvotes_view_mode = gr.Radio(
-            choices=[(label, key) for key, label in get_bucketed_section_config("upvotes")["mode_labels"].items()],
-            value=get_bucketed_section_config("upvotes")["default_mode"],
-            label=get_bucketed_section_config("upvotes")["radio_label"],
+            choices=build_radio_choices(upvotes_cfg["mode_labels"]),
+            value=upvotes_cfg["default_mode"],
+            label=upvotes_cfg["radio_label"],
             visible="hidden",
             elem_classes=["gh-toggle-radio"],
             elem_id="upvotes-view-toggle",
         )
 
-    upvotes_chart = gr.HTML(render_empty_chart(get_bucketed_section_config("upvotes")["chart_title"]))
+    upvotes_chart = gr.HTML(render_empty_chart(upvotes_cfg["chart_title"]))
 
     upvotes_logs_box = gr.Textbox(
         label="Upvotes Fetch Logs",
         interactive=False,
         lines=10,
-        value=get_bucketed_section_config("upvotes")["empty_logs_text"],
+        value=upvotes_cfg["empty_logs_text"],
     )
 
     gr.Markdown("## Likes activity")
@@ -2962,21 +2727,21 @@ with gr.Blocks(title="HF Contributions") as demo:
 
     with gr.Column(elem_classes="toggles-container"):
         likes_view_mode = gr.Radio(
-            choices=[(label, key) for key, label in get_bucketed_section_config("likes")["mode_labels"].items()],
-            value=get_bucketed_section_config("likes")["default_mode"],
-            label=get_bucketed_section_config("likes")["radio_label"],
+            choices=build_radio_choices(likes_cfg["mode_labels"]),
+            value=likes_cfg["default_mode"],
+            label=likes_cfg["radio_label"],
             visible="hidden",
             elem_classes=["gh-toggle-radio"],
             elem_id="likes-view-toggle",
         )
 
-    likes_chart = gr.HTML(render_empty_chart(get_bucketed_section_config("likes")["chart_title"]))
+    likes_chart = gr.HTML(render_empty_chart(likes_cfg["chart_title"]))
 
     likes_logs_box = gr.Textbox(
         label="Likes Fetch Logs",
         interactive=False,
         lines=10,
-        value=get_bucketed_section_config("likes")["empty_logs_text"],
+        value=likes_cfg["empty_logs_text"],
     )
 
     gr.Markdown("## Papers activity")
@@ -2988,21 +2753,21 @@ with gr.Blocks(title="HF Contributions") as demo:
 
     with gr.Column(elem_classes="toggles-container"):
         papers_view_mode = gr.Radio(
-            choices=[(label, key) for key, label in get_bucketed_section_config("papers")["mode_labels"].items()],
-            value=get_bucketed_section_config("papers")["default_mode"],
-            label=get_bucketed_section_config("papers")["radio_label"],
+            choices=build_radio_choices(papers_cfg["mode_labels"]),
+            value=papers_cfg["default_mode"],
+            label=papers_cfg["radio_label"],
             visible="hidden",
             elem_classes=["gh-toggle-radio"],
             elem_id="papers-view-toggle",
         )
 
-    papers_chart = gr.HTML(render_empty_chart(get_bucketed_section_config("papers")["chart_title"]))
+    papers_chart = gr.HTML(render_empty_chart(papers_cfg["chart_title"]))
 
     papers_logs_box = gr.Textbox(
         label="Papers Fetch Logs",
         interactive=False,
         lines=10,
-        value=get_bucketed_section_config("papers")["empty_logs_text"],
+        value=papers_cfg["empty_logs_text"],
     )
 
     repo_fetch_outputs = [