Update app.py

app.py

@@ -363,57 +363,165 @@ def empty_activity_bucket(title: str):
     }
 
 
-# ============================================================
-# Community activity fetch
-# ============================================================
-def empty_community_state(selected_year: int):
-    return {
+def empty_bucketed_activity_state(
+    selected_year: int,
+    logs_text: str,
+    bucket_titles: dict[str, str],
+):
+    state = {
         "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.",
+        "logs": logs_text,
     }
 
+    for key, title in bucket_titles.items():
+        state[key] = empty_activity_bucket(title)
 
-def fetch_user_discussion_activity(
+    return state
+
+
+def build_fetched_bucket(title: str, dates: list, selected_year: int, label: str):
+    return {
+        "title": title,
+        "fetched": True,
+        "dates": dates,
+        "count": len(dates),
+        "logs": f"Found {len(dates)} {label} in {selected_year}.",
+    }
+
+
+def build_failed_bucket(title: str):
+    return {
+        "title": title,
+        "fetched": True,
+        "dates": [],
+        "count": 0,
+        "logs": "",
+    }
+
+
+# ============================================================
+# 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.",
+    },
+    "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.",
+    },
+    "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.",
+    },
+}
+
+
+def get_bucketed_cfg(section_key: str) -> dict:
+    return BUCKETED_SECTION_CONFIGS[section_key]
+
+
+# ============================================================
+# Generic bucketed recent-activity fetch helpers
+# ============================================================
+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 = []
@@ -427,94 +535,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:
@@ -529,7 +549,7 @@ def fetch_user_discussion_activity(
 
             params = {
                 "limit": limit,
-                "activityType": "discussion",
+                "activityType": activity_type,
                 "feedType": "user",
                 "entity": username,
             }
@@ -548,7 +568,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.")
@@ -560,28 +581,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.")
@@ -592,251 +620,11 @@ 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),
-        }
-
-    except Exception as e:
-        return {
-            "title": title,
-            "fetched": True,
-            "dates": [],
-            "count": 0,
-            "logs": f"{title} fetch failed: {str(e)}",
-        }
-
-
-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
-
-
-# ============================================================
-# Generic bucketed recent-activity fetch helpers
-# ============================================================
-def empty_bucketed_activity_state(
-    selected_year: int,
-    logs_text: str,
-    bucket_titles: dict[str, str],
-):
-    state = {
-        "username": "",
-        "selected_year": int(selected_year),
-        "fetched": False,
-        "logs": logs_text,
-    }
-
-    for key, title in bucket_titles.items():
-        state[key] = empty_activity_bucket(title)
-
-    return state
-
-
-def build_fetched_bucket(title: str, dates: list, selected_year: int, label: str):
-    return {
-        "title": title,
-        "fetched": True,
-        "dates": dates,
-        "count": len(dates),
-        "logs": f"Found {len(dates)} {label} in {selected_year}.",
-    }
-
-
-def build_failed_bucket(title: str):
-    return {
-        "title": title,
-        "fetched": True,
-        "dates": [],
-        "count": 0,
-        "logs": "",
-    }
-
-
-def fetch_bucketed_recent_activity(
-    username: str,
-    selected_year: int,
-    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)
-
-    cache_key = (username.lower(), selected_year, cache_scope)
-    cached = get_cache(cache_key)
-    if cached:
-        return cached
-
-    if not username:
-        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
-
-    bucket_dates = {key: [] for key in bucket_titles}
-    bucket_seen_ids = {key: set() for key in bucket_titles}
-
-    cursor = None
-    skip = 0
-    limit = 20
-    pages_fetched = 0
-
-    MAX_PAGES = 40
-    MAX_DURATION = 20
-    start = time.time()
-
-    logs = []
-
-    session = requests.Session()
-    session.headers.update(
-        {
-            "User-Agent": "hf-contributions-app/1.0",
-            "Accept": "application/json",
-            "Cache-Control": "no-cache",
-        }
-    )
-
-    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
-
-            recent_activity_rate_limiter.wait()
-
-            params = {
-                "limit": limit,
-                "activityType": activity_type,
-                "feedType": "user",
-                "entity": username,
-            }
-            if cursor:
-                params["cursor"] = cursor
-            else:
-                params["skip"] = skip
-
-            response = session.get(
-                "https://huggingface.co/api/recent-activity",
-                params=params,
-                timeout=20,
-            )
-            response.raise_for_status()
-
-            payload = response.json()
-            pages_fetched += 1
-
-            events = payload.get("recentActivity", [])
-            next_cursor = payload.get("cursor")
-
-            if not events:
-                logs.append("No more events.")
-                break
-
-            stop_early = False
-
-            for event in events:
-                if not isinstance(event, dict):
-                    continue
-
-                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
-
-                if event_ts.year != selected_year:
-                    continue
-
-                bucket_key, unique_id = classifier(event)
-
-                if not bucket_key or not unique_id:
-                    continue
-
-                if bucket_key not in bucket_dates:
-                    continue
-
-                if unique_id in bucket_seen_ids[bucket_key]:
-                    continue
-
-                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.")
-                break
-
-            if next_cursor:
-                cursor = next_cursor
-            else:
-                skip += limit
-
-        result = {
-            "username": username,
-            "selected_year": selected_year,
-            "fetched": True,
-            "logs": "",
+            "logs": "",
         }
 
         for key, title in bucket_titles.items():
@@ -936,173 +724,339 @@ def classify_paper_event(event: dict):
     return bucket_key, unique_id
 
 
-# ============================================================
-# Upvotes activity fetch
-# ============================================================
-def empty_upvotes_state(selected_year: int):
+BUCKETED_FETCH_HANDLERS = {
+    "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 empty_generic_section_state(section_key: str, selected_year: int):
+    cfg = get_bucketed_cfg(section_key)
     return empty_bucketed_activity_state(
         selected_year=selected_year,
-        logs_text="Upvotes activity not fetched yet.",
-        bucket_titles={
-            "papers": "Paper Upvotes",
-            "blog": "Blog Upvotes",
-            "changelog": "Changelog Upvotes",
-        },
+        logs_text=cfg["empty_logs_text"],
+        bucket_titles=cfg["bucket_titles"],
     )
 
 
-def fetch_all_upvotes_activity(username: str, selected_year: int):
+def fetch_generic_bucketed_section(section_key: str, username: str, selected_year: int):
+    cfg = get_bucketed_cfg(section_key)
+    handler = BUCKETED_FETCH_HANDLERS[section_key]
     return fetch_bucketed_recent_activity(
         username=username,
         selected_year=selected_year,
-        cache_scope="upvotes",
-        activity_type="upvote",
-        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.",
-        classifier=classify_upvote_event,
+        cache_scope=section_key,
+        activity_type=handler["activity_type"],
+        bucket_titles=cfg["bucket_titles"],
+        bucket_log_labels=cfg["bucket_log_labels"],
+        empty_logs_text=cfg["empty_logs_text"],
+        classifier=handler["classifier"],
     )
 
 
 # ============================================================
-# Likes activity fetch
+# Community activity fetch
 # ============================================================
-def empty_likes_state(selected_year: int):
-    return empty_bucketed_activity_state(
-        selected_year=selected_year,
-        logs_text="Likes activity not fetched yet.",
-        bucket_titles={
-            "models": "Model Likes",
-            "datasets": "Dataset Likes",
-            "spaces": "Space Likes",
-        },
-    )
+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 fetch_all_likes_activity(username: str, selected_year: int):
-    return fetch_bucketed_recent_activity(
-        username=username,
-        selected_year=selected_year,
-        cache_scope="likes",
-        activity_type="like",
-        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.",
-        classifier=classify_like_event,
-    )
+def fetch_user_discussion_activity(
+    username: str,
+    selected_year: int,
+    mode: str,
+):
+    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")
 
-# ============================================================
-# Papers activity fetch
-# ============================================================
-def empty_papers_state(selected_year: int):
-    return empty_bucketed_activity_state(
-        selected_year=selected_year,
-        logs_text="Papers activity not fetched yet.",
-        bucket_titles={
-            "daily": "Daily Papers",
-            "authored": "Authored Papers",
-        },
+    if not username:
+        return {
+            "title": title,
+            "fetched": True,
+            "dates": [],
+            "count": 0,
+            "logs": "No username provided.",
+        }
+
+    dates = []
+    seen_ids = set()
+    skip = 0
+    limit = 20
+    cursor = None
+    pages_fetched = 0
+
+    MAX_PAGES = 40
+    MAX_DURATION = 25
+    OPEN_EVENT_EPSILON_SECONDS = 90
+    start = time.time()
+
+    logs = []
+
+    session = requests.Session()
+    session.headers.update(
+        {
+            "User-Agent": "hf-contributions-app/1.0",
+            "Accept": "application/json",
+            "Cache-Control": "no-cache",
+        }
     )
 
+    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:
+                logs.append("Stopped due to timeout.")
+                break
+
+            if pages_fetched >= MAX_PAGES:
+                logs.append("Stopped due to max pages.")
+                break
+
+            recent_activity_rate_limiter.wait()
+
+            params = {
+                "limit": limit,
+                "activityType": "discussion",
+                "feedType": "user",
+                "entity": username,
+            }
+            if cursor:
+                params["cursor"] = cursor
+            else:
+                params["skip"] = skip
+
+            response = session.get(
+                "https://huggingface.co/api/recent-activity",
+                params=params,
+                timeout=20,
+            )
+            response.raise_for_status()
+
+            payload = response.json()
+            pages_fetched += 1
+
+            events, next_cursor = normalize_payload(payload)
+
+            if not events:
+                logs.append("No more events.")
+                break
+
+            stop_early = False
+
+            for event in events:
+                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:
+                    stop_early = True
+                    break
+
+                discussion = event.get("discussionData") or {}
+                if not isinstance(discussion, dict):
+                    continue
+
+                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
+
+                if unique_id in seen_ids:
+                    continue
+
+                seen_ids.add(unique_id)
+                dates.append(dt)
+
+            if stop_early:
+                logs.append("Stopped early after reaching feed events older than selected year.")
+                break
+
+            if next_cursor:
+                cursor = next_cursor
+            else:
+                skip += limit
 
-def fetch_all_papers_activity(username: str, selected_year: int):
-    return fetch_bucketed_recent_activity(
-        username=username,
-        selected_year=selected_year,
-        cache_scope="papers",
-        activity_type="update-paper",
-        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.",
-        classifier=classify_paper_event,
-    )
+        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),
+        }
 
-# ============================================================
-# 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()}
+    except Exception as e:
+        return {
+            "title": title,
+            "fetched": True,
+            "dates": [],
+            "count": 0,
+            "logs": f"{title} fetch failed: {str(e)}",
+        }
+
+
+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
 
-def get_calendar_bounds(year: int):
-    start = pd.Timestamp(f"{year}-01-01")
-    end = pd.Timestamp(f"{year}-12-31")
+    if not username:
+        state = empty_community_state(selected_year)
+        state["fetched"] = True
+        state["logs"] = "No username provided."
+        set_cache(cache_key, state)
+        return state
 
-    grid_start = start - pd.Timedelta(days=start.dayofweek)
-    grid_end = end + pd.Timedelta(days=(6 - end.dayofweek))
+    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")
 
-    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
+    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,
+    }
 
-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]
+    set_cache(cache_key, result)
+    return result
 
 
 # ============================================================
@@ -1365,189 +1319,13 @@ def render_community_loaded_banner(
     return render_status_badge(" · ".join(parts))
 
 
-def render_upvotes_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
-
-    parts = []
-    if viewer:
-        parts.append(f"Logged in as <b>{html.escape(viewer)}</b>")
-    else:
-        parts.append("Not logged in")
-
-    if not username:
-        parts.append("Enter a username to fetch upvotes activity")
-        return render_status_badge(" · ".join(parts))
-
-    if viewer and username.lower() == viewer.lower():
-        parts.append("Fetch your upvotes activity or enter another username")
-        parts.append(str(selected_year))
-    else:
-        parts.append(f"Ready to fetch upvotes activity for <b>{html.escape(username)}</b>")
-        parts.append(str(selected_year))
-
-    return render_status_badge(" · ".join(parts))
-
-
-def render_upvotes_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))
-
-
-def render_upvotes_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
-
-    if not username:
-        return render_upvotes_idle_banner("", 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("Fetching <b>your upvotes activity</b>")
-    else:
-        parts.append(f"Fetching upvotes activity for <b>{html.escape(username)}</b>")
-
-    parts.append(str(selected_year))
-    return render_status_badge(" · ".join(parts))
-
-
-def render_upvotes_loaded_banner(
-    upvotes_state: dict | None,
-    profile: gr.OAuthProfile | None,
-):
-    if not upvotes_state or not upvotes_state.get("username"):
-        year = upvotes_state.get("selected_year", datetime.now().year) if upvotes_state else datetime.now().year
-        return render_upvotes_idle_banner("", year, profile)
-
-    username = upvotes_state["username"]
-    selected_year = int(upvotes_state["selected_year"])
-    viewer = getattr(profile, "username", None) if profile else None
-
-    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("Viewing <b>your upvotes activity</b>")
-    else:
-        parts.append(f"Viewing upvotes activity for <b>{html.escape(username)}</b>")
-
-    parts.append(str(selected_year))
-    return render_status_badge(" · ".join(parts))
-
-
-def render_likes_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
-
-    parts = []
-    if viewer:
-        parts.append(f"Logged in as <b>{html.escape(viewer)}</b>")
-    else:
-        parts.append("Not logged in")
-
-    if not username:
-        parts.append("Enter a username to fetch likes activity")
-        return render_status_badge(" · ".join(parts))
-
-    if viewer and username.lower() == viewer.lower():
-        parts.append("Fetch your likes activity or enter another username")
-        parts.append(str(selected_year))
-    else:
-        parts.append(f"Ready to fetch likes activity for <b>{html.escape(username)}</b>")
-        parts.append(str(selected_year))
-
-    return render_status_badge(" · ".join(parts))
-
-
-def render_likes_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))
-
-
-def render_likes_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
-
-    if not username:
-        return render_likes_idle_banner("", 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("Fetching <b>your likes activity</b>")
-    else:
-        parts.append(f"Fetching likes activity for <b>{html.escape(username)}</b>")
-
-    parts.append(str(selected_year))
-    return render_status_badge(" · ".join(parts))
-
-
-def render_likes_loaded_banner(
-    likes_state: dict | None,
-    profile: gr.OAuthProfile | None,
-):
-    if not likes_state or not likes_state.get("username"):
-        year = likes_state.get("selected_year", datetime.now().year) if likes_state else datetime.now().year
-        return render_likes_idle_banner("", year, profile)
-
-    username = likes_state["username"]
-    selected_year = int(likes_state["selected_year"])
-    viewer = getattr(profile, "username", None) if profile else None
-
-    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("Viewing <b>your likes activity</b>")
-    else:
-        parts.append(f"Viewing likes activity for <b>{html.escape(username)}</b>")
-
-    parts.append(str(selected_year))
-    return render_status_badge(" · ".join(parts))
-
-
-def render_papers_idle_banner(
+def render_bucketed_idle_banner(
+    section_key: str,
     username,
     selected_year,
     profile: gr.OAuthProfile | None,
 ):
+    cfg = get_bucketed_cfg(section_key)
     username = (username or "").strip()
     selected_year = int(selected_year)
     viewer = getattr(profile, "username", None) if profile else None
@@ -1559,36 +1337,39 @@ def render_papers_idle_banner(
         parts.append("Not logged in")
 
     if not username:
-        parts.append("Enter a username to fetch papers activity")
+        parts.append(f"Enter a username to fetch {cfg['context_subject_label']}")
         return render_status_badge(" · ".join(parts))
 
     if viewer and username.lower() == viewer.lower():
-        parts.append("Fetch your papers activity or enter another username")
+        parts.append(f"Fetch your {cfg['context_subject_label']} or enter another username")
         parts.append(str(selected_year))
     else:
-        parts.append(f"Ready to fetch papers activity for <b>{html.escape(username)}</b>")
+        parts.append(f"Ready to fetch {cfg['context_subject_label']} for <b>{html.escape(username)}</b>")
         parts.append(str(selected_year))
 
     return render_status_badge(" · ".join(parts))
 
 
-def render_papers_invalid_banner(username: str, error_text: str | None = None):
+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))
 
 
-def render_papers_fetching_banner(
+def render_bucketed_fetching_banner(
+    section_key: str,
     username,
     selected_year,
     profile: gr.OAuthProfile | None,
 ):
+    cfg = get_bucketed_cfg(section_key)
     username = (username or "").strip()
     selected_year = int(selected_year)
     viewer = getattr(profile, "username", None) if profile else None
 
     if not username:
-        return render_papers_idle_banner("", selected_year, profile)
+        return render_bucketed_idle_banner(section_key, "", selected_year, profile)
 
     parts = []
     if viewer:
@@ -1597,24 +1378,26 @@ def render_papers_fetching_banner(
         parts.append("Not logged in")
 
     if viewer and username.lower() == viewer.lower():
-        parts.append("Fetching <b>your papers activity</b>")
+        parts.append(f"Fetching <b>your {cfg['context_subject_label']}</b>")
     else:
-        parts.append(f"Fetching papers activity for <b>{html.escape(username)}</b>")
+        parts.append(f"Fetching {cfg['context_subject_label']} for <b>{html.escape(username)}</b>")
 
     parts.append(str(selected_year))
     return render_status_badge(" · ".join(parts))
 
 
-def render_papers_loaded_banner(
-    papers_state: dict | None,
+def render_bucketed_loaded_banner(
+    section_key: str,
+    section_state: dict | None,
     profile: gr.OAuthProfile | None,
 ):
-    if not papers_state or not papers_state.get("username"):
-        year = papers_state.get("selected_year", datetime.now().year) if papers_state else datetime.now().year
-        return render_papers_idle_banner("", year, profile)
+    cfg = get_bucketed_cfg(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)
 
-    username = papers_state["username"]
-    selected_year = int(papers_state["selected_year"])
+    username = section_state["username"]
+    selected_year = int(section_state["selected_year"])
     viewer = getattr(profile, "username", None) if profile else None
 
     parts = []
@@ -1624,9 +1407,9 @@ def render_papers_loaded_banner(
         parts.append("Not logged in")
 
     if viewer and username.lower() == viewer.lower():
-        parts.append("Viewing <b>your papers activity</b>")
+        parts.append(f"Viewing <b>your {cfg['context_subject_label']}</b>")
     else:
-        parts.append(f"Viewing papers activity for <b>{html.escape(username)}</b>")
+        parts.append(f"Viewing {cfg['context_subject_label']} for <b>{html.escape(username)}</b>")
 
     parts.append(str(selected_year))
     return render_status_badge(" · ".join(parts))
@@ -1784,129 +1567,68 @@ def render_pr_combined_chart(community_state: dict | None, mode: str, username:
         "opened": f"{len(opened)} PRs opened by {username} in {year}",
         "activity": f"{len(activity)} PR follow-up events for {username} in {year}",
         "both": f"{len(opened) + len(activity)} total PR events for {username} in {year}",
-    }[mode]
-
-    return render_contrib_chart(
-        df,
-        year,
-        "Pull Requests",
-        palette_name="purple",
-        subtitle=subtitle,
-    )
-
-
-def render_discussion_combined_chart(community_state: dict | None, mode: str, username: str, year: int):
-    if not community_state or not community_state.get("fetched"):
-        return render_empty_chart("Community Discussions")
-
-    opened = community_state["thread_opened"]["dates"]
-    activity = community_state["discussion_activity"]["dates"]
-    merged = merge_dates(opened, activity, mode)
-    df = pd.DataFrame(merged, columns=["date"])
-
-    subtitle = {
-        "opened": f"{len(opened)} threads opened by {username} in {year}",
-        "activity": f"{len(activity)} discussion follow-up events for {username} in {year}",
-        "both": f"{len(opened) + len(activity)} total discussion events for {username} in {year}",
-    }[mode]
-
-    return render_contrib_chart(
-        df,
-        year,
-        "Community Discussions",
-        palette_name="teal",
-        subtitle=subtitle,
-    )
-
-
-def render_upvotes_chart(upvotes_state: dict | None, mode: str, username: str, year: int):
-    if not upvotes_state or not upvotes_state.get("fetched"):
-        return render_empty_chart("Upvotes")
-
-    papers = upvotes_state["papers"]["dates"]
-    blog = upvotes_state["blog"]["dates"]
-    changelog = upvotes_state["changelog"]["dates"]
-
-    if mode == "papers":
-        merged = list(papers)
-        subtitle = f"{len(papers)} paper upvote(s) by {username} in {year}"
-    elif mode == "blog":
-        merged = list(blog)
-        subtitle = f"{len(blog)} blog upvote(s) by {username} in {year}"
-    elif mode == "changelog":
-        merged = list(changelog)
-        subtitle = f"{len(changelog)} changelog upvote(s) by {username} in {year}"
-    else:
-        merged = list(papers) + list(blog) + list(changelog)
-        subtitle = f"{len(merged)} total upvote event(s) by {username} in {year}"
-
-    df = pd.DataFrame(merged, columns=["date"])
+    }[mode]
 
     return render_contrib_chart(
         df,
         year,
-        "Upvotes",
+        "Pull Requests",
         palette_name="purple",
         subtitle=subtitle,
     )
 
 
-def render_likes_chart(likes_state: dict | None, mode: str, username: str, year: int):
-    if not likes_state or not likes_state.get("fetched"):
-        return render_empty_chart("Likes")
-
-    models = likes_state["models"]["dates"]
-    datasets = likes_state["datasets"]["dates"]
-    spaces = likes_state["spaces"]["dates"]
-
-    if mode == "models":
-        merged = list(models)
-        subtitle = f"{len(models)} model like(s) by {username} in {year}"
-    elif mode == "datasets":
-        merged = list(datasets)
-        subtitle = f"{len(datasets)} dataset like(s) by {username} in {year}"
-    elif mode == "spaces":
-        merged = list(spaces)
-        subtitle = f"{len(spaces)} space like(s) by {username} in {year}"
-    else:
-        merged = list(models) + list(datasets) + list(spaces)
-        subtitle = f"{len(merged)} total like event(s) by {username} in {year}"
+def render_discussion_combined_chart(community_state: dict | None, mode: str, username: str, year: int):
+    if not community_state or not community_state.get("fetched"):
+        return render_empty_chart("Community Discussions")
 
+    opened = community_state["thread_opened"]["dates"]
+    activity = community_state["discussion_activity"]["dates"]
+    merged = merge_dates(opened, activity, mode)
     df = pd.DataFrame(merged, columns=["date"])
 
+    subtitle = {
+        "opened": f"{len(opened)} threads opened by {username} in {year}",
+        "activity": f"{len(activity)} discussion follow-up events for {username} in {year}",
+        "both": f"{len(opened) + len(activity)} total discussion events for {username} in {year}",
+    }[mode]
+
     return render_contrib_chart(
         df,
         year,
-        "Likes",
-        palette_name="blue",
+        "Community Discussions",
+        palette_name="teal",
         subtitle=subtitle,
     )
 
 
-def render_papers_chart(papers_state: dict | None, mode: str, username: str, year: int):
-    if not papers_state or not papers_state.get("fetched"):
-        return render_empty_chart("Papers")
+def render_bucketed_chart(section_key: str, section_state: dict | None, mode: str, username: str, year: int):
+    cfg = get_bucketed_cfg(section_key)
 
-    daily = papers_state["daily"]["dates"]
-    authored = papers_state["authored"]["dates"]
+    if not section_state or not section_state.get("fetched"):
+        return render_empty_chart(cfg["chart_title"])
 
-    if mode == "daily":
-        merged = list(daily)
-        subtitle = f"{len(daily)} Daily Papers submission(s) by {username} in {year}"
-    elif mode == "authored":
-        merged = list(authored)
-        subtitle = f"{len(authored)} authored paper(s) by {username} in {year}"
+    bucket_titles = cfg["bucket_titles"]
+    default_mode = cfg["default_mode"]
+    mode = mode or default_mode
+
+    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}"
     else:
-        merged = list(daily) + list(authored)
-        subtitle = f"{len(merged)} total papers event(s) by {username} in {year}"
+        merged = list(section_state.get(mode, {}).get("dates", []))
+        bucket_title = bucket_titles.get(mode, mode)
+        subtitle = f"{len(merged)} {bucket_title.lower()} by {username} in {year}"
 
     df = pd.DataFrame(merged, columns=["date"])
 
     return render_contrib_chart(
         df,
         year,
-        "Papers",
-        palette_name="teal",
+        cfg["chart_title"],
+        palette_name=cfg["palette_name"],
         subtitle=subtitle,
     )
 
@@ -2340,477 +2062,141 @@ def maybe_reset_community_section(
     )
 
 
-def maybe_reset_upvotes_section(
-    current_upvotes_state,
-    username,
-    selected_year,
-    upvotes_mode,
-    profile: gr.OAuthProfile | None,
-):
-    username = (username or "").strip()
-    selected_year = int(selected_year)
-    upvotes_mode = upvotes_mode or "all"
-
-    identity = validate_username(username, profile) if username else empty_identity("", "No username provided.")
-    if username and not identity.get("exists"):
-        state = empty_upvotes_state(selected_year)
-        state["username"] = username
-        state["selected_year"] = selected_year
-        state["logs"] = identity.get("error") or f"Username or org '{username}' was not found."
-        return (
-            state,
-            render_upvotes_invalid_banner(username, identity.get("error")),
-            gr.update(value="all", visible="hidden"),
-            render_empty_chart("Upvotes"),
-            state["logs"],
-        )
-
-    if not current_upvotes_state:
-        state = empty_upvotes_state(selected_year)
-        return (
-            state,
-            render_upvotes_idle_banner(username, selected_year, profile),
-            gr.update(value="all", visible="hidden"),
-            render_empty_chart("Upvotes"),
-            "Upvotes activity not fetched yet.",
-        )
-
-    previous_username = (current_upvotes_state.get("username") or "").strip()
-    previous_year = int(current_upvotes_state.get("selected_year") or selected_year)
-
-    same_username = previous_username.lower() == username.lower()
-    same_year = previous_year == selected_year
-
-    if same_username and same_year and current_upvotes_state.get("fetched"):
-        chart = render_upvotes_chart(
-            current_upvotes_state,
-            upvotes_mode,
-            username=username,
-            year=selected_year,
-        )
-        return (
-            current_upvotes_state,
-            render_upvotes_loaded_banner(current_upvotes_state, profile),
-            gr.update(value=upvotes_mode, visible=True),
-            chart,
-            current_upvotes_state.get("logs", "Upvotes activity already fetched."),
-        )
-
-    state = empty_upvotes_state(selected_year)
-    return (
-        state,
-        render_upvotes_idle_banner(username, selected_year, profile),
-        gr.update(value="all", visible="hidden"),
-        render_empty_chart("Upvotes"),
-        "Upvotes activity needs to be fetched for the current username/year.",
-    )
-
-
-def maybe_reset_likes_section(
-    current_likes_state,
-    username,
-    selected_year,
-    likes_mode,
-    profile: gr.OAuthProfile | None,
-):
+def prepare_bucketed_fetch_ui(section_key: str, username, selected_year, profile: gr.OAuthProfile | None):
     username = (username or "").strip()
-    selected_year = int(selected_year)
-    likes_mode = likes_mode or "all"
-
-    identity = validate_username(username, profile) if username else empty_identity("", "No username provided.")
-    if username and not identity.get("exists"):
-        state = empty_likes_state(selected_year)
-        state["username"] = username
-        state["selected_year"] = selected_year
-        state["logs"] = identity.get("error") or f"Username or org '{username}' was not found."
-        return (
-            state,
-            render_likes_invalid_banner(username, identity.get("error")),
-            gr.update(value="all", visible="hidden"),
-            render_empty_chart("Likes"),
-            state["logs"],
-        )
-
-    if not current_likes_state:
-        state = empty_likes_state(selected_year)
-        return (
-            state,
-            render_likes_idle_banner(username, selected_year, profile),
-            gr.update(value="all", visible="hidden"),
-            render_empty_chart("Likes"),
-            "Likes activity not fetched yet.",
-        )
-
-    previous_username = (current_likes_state.get("username") or "").strip()
-    previous_year = int(current_likes_state.get("selected_year") or selected_year)
-
-    same_username = previous_username.lower() == username.lower()
-    same_year = previous_year == selected_year
-
-    if same_username and same_year and current_likes_state.get("fetched"):
-        chart = render_likes_chart(
-            current_likes_state,
-            likes_mode,
-            username=username,
-            year=selected_year,
-        )
-        return (
-            current_likes_state,
-            render_likes_loaded_banner(current_likes_state, profile),
-            gr.update(value=likes_mode, visible=True),
-            chart,
-            current_likes_state.get("logs", "Likes activity already fetched."),
-        )
-
-    state = empty_likes_state(selected_year)
-    return (
-        state,
-        render_likes_idle_banner(username, selected_year, profile),
-        gr.update(value="all", visible="hidden"),
-        render_empty_chart("Likes"),
-        "Likes activity needs to be fetched for the current username/year.",
-    )
+    if username:
+        identity = validate_username(username, profile)
+        if not identity.get("exists"):
+            return render_bucketed_invalid_banner(section_key, username, identity.get("error"))
+    return render_bucketed_fetching_banner(section_key, username, selected_year, profile)
 
 
-def maybe_reset_papers_section(
-    current_papers_state,
+def maybe_reset_bucketed_section(
+    section_key: str,
+    current_state,
     username,
     selected_year,
-    papers_mode,
+    mode,
     profile: gr.OAuthProfile | None,
 ):
+    cfg = get_bucketed_cfg(section_key)
     username = (username or "").strip()
     selected_year = int(selected_year)
-    papers_mode = papers_mode or "all"
+    mode = mode or cfg["default_mode"]
 
     identity = validate_username(username, profile) if username else empty_identity("", "No username provided.")
     if username and not identity.get("exists"):
-        state = empty_papers_state(selected_year)
+        state = empty_generic_section_state(section_key, selected_year)
         state["username"] = username
         state["selected_year"] = selected_year
         state["logs"] = identity.get("error") or f"Username or org '{username}' was not found."
         return (
             state,
-            render_papers_invalid_banner(username, identity.get("error")),
-            gr.update(value="all", visible="hidden"),
-            render_empty_chart("Papers"),
+            render_bucketed_invalid_banner(section_key, username, identity.get("error")),
+            gr.update(value=cfg["default_mode"], visible="hidden"),
+            render_empty_chart(cfg["chart_title"]),
             state["logs"],
         )
 
-    if not current_papers_state:
-        state = empty_papers_state(selected_year)
+    if not current_state:
+        state = empty_generic_section_state(section_key, selected_year)
         return (
             state,
-            render_papers_idle_banner(username, selected_year, profile),
-            gr.update(value="all", visible="hidden"),
-            render_empty_chart("Papers"),
-            "Papers activity not fetched yet.",
+            render_bucketed_idle_banner(section_key, username, selected_year, profile),
+            gr.update(value=cfg["default_mode"], visible="hidden"),
+            render_empty_chart(cfg["chart_title"]),
+            cfg["empty_logs_text"],
         )
 
-    previous_username = (current_papers_state.get("username") or "").strip()
-    previous_year = int(current_papers_state.get("selected_year") or selected_year)
+    previous_username = (current_state.get("username") or "").strip()
+    previous_year = int(current_state.get("selected_year") or selected_year)
 
     same_username = previous_username.lower() == username.lower()
     same_year = previous_year == selected_year
 
-    if same_username and same_year and current_papers_state.get("fetched"):
-        chart = render_papers_chart(
-            current_papers_state,
-            papers_mode,
+    if same_username and same_year and current_state.get("fetched"):
+        chart = render_bucketed_chart(
+            section_key,
+            current_state,
+            mode,
             username=username,
             year=selected_year,
         )
         return (
-            current_papers_state,
-            render_papers_loaded_banner(current_papers_state, profile),
-            gr.update(value=papers_mode, visible=True),
+            current_state,
+            render_bucketed_loaded_banner(section_key, current_state, profile),
+            gr.update(value=mode, visible=True),
             chart,
-            current_papers_state.get("logs", "Papers activity already fetched."),
-        )
-
-    state = empty_papers_state(selected_year)
-    return (
-        state,
-        render_papers_idle_banner(username, selected_year, profile),
-        gr.update(value="all", visible="hidden"),
-        render_empty_chart("Papers"),
-        "Papers activity needs to be fetched for the current username/year.",
-    )
-
-
-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_upvotes_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_upvotes_invalid_banner(username, identity.get("error"))
-    return render_upvotes_fetching_banner(username, selected_year, profile)
-
-
-def prepare_likes_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_likes_invalid_banner(username, identity.get("error"))
-    return render_likes_fetching_banner(username, selected_year, profile)
-
-
-def prepare_papers_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_papers_invalid_banner(username, identity.get("error"))
-    return render_papers_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 fetch_and_render_upvotes(
-    current_state,
-    username,
-    selected_year,
-    upvotes_mode,
-    profile: gr.OAuthProfile | None,
-):
-    username = (username or "").strip()
-    selected_year = int(selected_year)
-    upvotes_mode = upvotes_mode or "all"
-
-    identity = validate_username(username, profile)
-    if username and not identity.get("exists"):
-        empty_state = empty_upvotes_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_upvotes_invalid_banner(username, identity.get("error")),
-            render_empty_chart("Upvotes"),
-            empty_state["logs"],
-            gr.update(value="all", visible="hidden"),
-        )
-
-    state = fetch_all_upvotes_activity(username, selected_year)
-
-    chart = render_upvotes_chart(
-        state,
-        upvotes_mode,
-        username=username,
-        year=selected_year,
-    )
-
-    return (
-        state,
-        render_upvotes_loaded_banner(state, profile),
-        chart,
-        state["logs"],
-        gr.update(value=upvotes_mode, visible=True),
-    )
-
-
-def fetch_and_render_likes(
-    current_state,
-    username,
-    selected_year,
-    likes_mode,
-    profile: gr.OAuthProfile | None,
-):
-    username = (username or "").strip()
-    selected_year = int(selected_year)
-    likes_mode = likes_mode or "all"
-
-    identity = validate_username(username, profile)
-    if username and not identity.get("exists"):
-        empty_state = empty_likes_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_likes_invalid_banner(username, identity.get("error")),
-            render_empty_chart("Likes"),
-            empty_state["logs"],
-            gr.update(value="all", visible="hidden"),
+            current_state.get("logs", f"{cfg['chart_title']} activity already fetched."),
         )
 
-    state = fetch_all_likes_activity(username, selected_year)
-
-    chart = render_likes_chart(
-        state,
-        likes_mode,
-        username=username,
-        year=selected_year,
-    )
-
+    state = empty_generic_section_state(section_key, selected_year)
     return (
         state,
-        render_likes_loaded_banner(state, profile),
-        chart,
-        state["logs"],
-        gr.update(value=likes_mode, visible=True),
+        render_bucketed_idle_banner(section_key, username, selected_year, profile),
+        gr.update(value=cfg["default_mode"], visible="hidden"),
+        render_empty_chart(cfg["chart_title"]),
+        f"{cfg['chart_title']} activity needs to be fetched for the current username/year.",
     )
 
 
-def fetch_and_render_papers(
+def fetch_and_render_bucketed_section(
+    section_key: str,
     current_state,
     username,
     selected_year,
-    papers_mode,
+    mode,
     profile: gr.OAuthProfile | None,
 ):
+    _ = current_state
+    cfg = get_bucketed_cfg(section_key)
     username = (username or "").strip()
     selected_year = int(selected_year)
-    papers_mode = papers_mode or "all"
+    mode = mode or cfg["default_mode"]
 
     identity = validate_username(username, profile)
     if username and not identity.get("exists"):
-        empty_state = empty_papers_state(selected_year)
+        empty_state = empty_generic_section_state(section_key, 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_papers_invalid_banner(username, identity.get("error")),
-            render_empty_chart("Papers"),
+            render_bucketed_invalid_banner(section_key, username, identity.get("error")),
+            render_empty_chart(cfg["chart_title"]),
             empty_state["logs"],
-            gr.update(value="all", visible="hidden"),
+            gr.update(value=cfg["default_mode"], visible="hidden"),
         )
 
-    state = fetch_all_papers_activity(username, selected_year)
+    state = fetch_generic_bucketed_section(section_key, username, selected_year)
 
-    chart = render_papers_chart(
+    chart = render_bucketed_chart(
+        section_key,
         state,
-        papers_mode,
+        mode,
         username=username,
         year=selected_year,
     )
 
     return (
         state,
-        render_papers_loaded_banner(state, profile),
+        render_bucketed_loaded_banner(section_key, state, profile),
         chart,
         state["logs"],
-        gr.update(value=papers_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),
-    )
-
-
-def rerender_upvotes_from_state(upvotes_state, upvotes_mode):
-    if not upvotes_state:
-        return render_empty_chart("Upvotes")
-    return render_upvotes_chart(
-        upvotes_state,
-        upvotes_mode or "all",
-        username=(upvotes_state.get("username") or ""),
-        year=int(upvotes_state.get("selected_year") or datetime.now().year),
-    )
-
-
-def rerender_likes_from_state(likes_state, likes_mode):
-    if not likes_state:
-        return render_empty_chart("Likes")
-    return render_likes_chart(
-        likes_state,
-        likes_mode or "all",
-        username=(likes_state.get("username") or ""),
-        year=int(likes_state.get("selected_year") or datetime.now().year),
+        gr.update(value=mode, visible=True),
     )
 
 
-def rerender_papers_from_state(papers_state, papers_mode):
-    if not papers_state:
-        return render_empty_chart("Papers")
-    return render_papers_chart(
-        papers_state,
-        papers_mode or "all",
-        username=(papers_state.get("username") or ""),
-        year=int(papers_state.get("selected_year") or datetime.now().year),
+def rerender_bucketed_from_state(section_key: str, section_state, mode):
+    cfg = get_bucketed_cfg(section_key)
+    if not section_state:
+        return render_empty_chart(cfg["chart_title"])
+    return render_bucketed_chart(
+        section_key,
+        section_state,
+        mode or cfg["default_mode"],
+        username=(section_state.get("username") or ""),
+        year=int(section_state.get("selected_year") or datetime.now().year),
     )
 
 
@@ -2832,9 +2218,9 @@ def hydrate_header_on_load(
 
     repo_context_html = render_idle_context_banner(effective_username, profile)
     community_context_html = render_community_idle_banner(effective_username, selected_year, profile)
-    upvotes_context_html = render_upvotes_idle_banner(effective_username, selected_year, profile)
-    likes_context_html = render_likes_idle_banner(effective_username, selected_year, profile)
-    papers_context_html = render_papers_idle_banner(effective_username, selected_year, profile)
+    upvotes_context_html = render_bucketed_idle_banner("upvotes", effective_username, selected_year, profile)
+    likes_context_html = render_bucketed_idle_banner("likes", effective_username, selected_year, profile)
+    papers_context_html = render_bucketed_idle_banner("papers", effective_username, selected_year, profile)
 
     return (
         username_update,
@@ -3499,26 +2885,21 @@ with gr.Blocks(title="HF Contributions") as demo:
 
     with gr.Column(elem_classes="toggles-container"):
         upvotes_view_mode = gr.Radio(
-            choices=[
-                ("All", "all"),
-                ("Papers", "papers"),
-                ("Blog", "blog"),
-                ("Changelog", "changelog"),
-            ],
-            value="all",
-            label="Upvotes view",
+            choices=[(label, key) for key, label in BUCKETED_SECTION_CONFIGS["upvotes"]["mode_labels"].items()],
+            value=BUCKETED_SECTION_CONFIGS["upvotes"]["default_mode"],
+            label=BUCKETED_SECTION_CONFIGS["upvotes"]["radio_label"],
             visible="hidden",
             elem_classes=["gh-toggle-radio"],
             elem_id="upvotes-view-toggle",
         )
 
-    upvotes_chart = gr.HTML(render_empty_chart("Upvotes"))
+    upvotes_chart = gr.HTML(render_empty_chart(BUCKETED_SECTION_CONFIGS["upvotes"]["chart_title"]))
 
     upvotes_logs_box = gr.Textbox(
         label="Upvotes Fetch Logs",
         interactive=False,
         lines=10,
-        value="Upvotes activity not fetched yet.",
+        value=BUCKETED_SECTION_CONFIGS["upvotes"]["empty_logs_text"],
     )
 
     gr.Markdown("## Likes activity")
@@ -3530,26 +2911,21 @@ with gr.Blocks(title="HF Contributions") as demo:
 
     with gr.Column(elem_classes="toggles-container"):
         likes_view_mode = gr.Radio(
-            choices=[
-                ("All", "all"),
-                ("Models", "models"),
-                ("Datasets", "datasets"),
-                ("Spaces", "spaces"),
-            ],
-            value="all",
-            label="Likes view",
+            choices=[(label, key) for key, label in BUCKETED_SECTION_CONFIGS["likes"]["mode_labels"].items()],
+            value=BUCKETED_SECTION_CONFIGS["likes"]["default_mode"],
+            label=BUCKETED_SECTION_CONFIGS["likes"]["radio_label"],
             visible="hidden",
             elem_classes=["gh-toggle-radio"],
             elem_id="likes-view-toggle",
         )
 
-    likes_chart = gr.HTML(render_empty_chart("Likes"))
+    likes_chart = gr.HTML(render_empty_chart(BUCKETED_SECTION_CONFIGS["likes"]["chart_title"]))
 
     likes_logs_box = gr.Textbox(
         label="Likes Fetch Logs",
         interactive=False,
         lines=10,
-        value="Likes activity not fetched yet.",
+        value=BUCKETED_SECTION_CONFIGS["likes"]["empty_logs_text"],
     )
 
     gr.Markdown("## Papers activity")
@@ -3561,25 +2937,21 @@ with gr.Blocks(title="HF Contributions") as demo:
 
     with gr.Column(elem_classes="toggles-container"):
         papers_view_mode = gr.Radio(
-            choices=[
-                ("All", "all"),
-                ("Daily Papers", "daily"),
-                ("Authored", "authored"),
-            ],
-            value="all",
-            label="Papers view",
+            choices=[(label, key) for key, label in BUCKETED_SECTION_CONFIGS["papers"]["mode_labels"].items()],
+            value=BUCKETED_SECTION_CONFIGS["papers"]["default_mode"],
+            label=BUCKETED_SECTION_CONFIGS["papers"]["radio_label"],
             visible="hidden",
             elem_classes=["gh-toggle-radio"],
             elem_id="papers-view-toggle",
         )
 
-    papers_chart = gr.HTML(render_empty_chart("Papers"))
+    papers_chart = gr.HTML(render_empty_chart(BUCKETED_SECTION_CONFIGS["papers"]["chart_title"]))
 
     papers_logs_box = gr.Textbox(
         label="Papers Fetch Logs",
         interactive=False,
         lines=10,
-        value="Papers activity not fetched yet.",
+        value=BUCKETED_SECTION_CONFIGS["papers"]["empty_logs_text"],
     )
 
     repo_fetch_outputs = [
@@ -3677,7 +3049,14 @@ with gr.Blocks(title="HF Contributions") as demo:
     demo.load(
         fn=hydrate_header_on_load,
         inputs=[username, selected_year],
-        outputs=[username, context_box, community_context_box, upvotes_context_box, likes_context_box, papers_context_box],
+        outputs=[
+            username,
+            context_box,
+            community_context_box,
+            upvotes_context_box,
+            likes_context_box,
+            papers_context_box,
+        ],
         show_progress="hidden",
     )
 
@@ -3705,17 +3084,17 @@ with gr.Blocks(title="HF Contributions") as demo:
         outputs=community_reset_outputs,
         show_progress="hidden",
     ).then(
-        fn=maybe_reset_upvotes_section,
+        fn=lambda state, uname, year, mode, profile: maybe_reset_bucketed_section("upvotes", state, uname, year, mode, profile),
         inputs=[upvotes_state, username, selected_year, upvotes_view_mode],
         outputs=upvotes_reset_outputs,
         show_progress="hidden",
     ).then(
-        fn=maybe_reset_likes_section,
+        fn=lambda state, uname, year, mode, profile: maybe_reset_bucketed_section("likes", state, uname, year, mode, profile),
         inputs=[likes_state, username, selected_year, likes_view_mode],
         outputs=likes_reset_outputs,
         show_progress="hidden",
     ).then(
-        fn=maybe_reset_papers_section,
+        fn=lambda state, uname, year, mode, profile: maybe_reset_bucketed_section("papers", state, uname, year, mode, profile),
         inputs=[papers_state, username, selected_year, papers_view_mode],
         outputs=papers_reset_outputs,
         show_progress="hidden",
@@ -3760,12 +3139,12 @@ with gr.Blocks(title="HF Contributions") as demo:
     )
 
     fetch_upvotes_button.click(
-        fn=prepare_upvotes_fetch_ui,
+        fn=lambda uname, year, profile: prepare_bucketed_fetch_ui("upvotes", uname, year, profile),
         inputs=[username, selected_year],
         outputs=upvotes_context_box,
         show_progress="hidden",
     ).then(
-        fn=fetch_and_render_upvotes,
+        fn=lambda state, uname, year, mode, profile: fetch_and_render_bucketed_section("upvotes", state, uname, year, mode, profile),
         inputs=[upvotes_state, username, selected_year, upvotes_view_mode],
         outputs=upvotes_fetch_outputs,
         show_progress="full",
@@ -3776,19 +3155,19 @@ with gr.Blocks(title="HF Contributions") as demo:
     )
 
     upvotes_view_mode.change(
-        fn=rerender_upvotes_from_state,
+        fn=lambda state, mode: rerender_bucketed_from_state("upvotes", state, mode),
         inputs=[upvotes_state, upvotes_view_mode],
         outputs=upvotes_chart,
         show_progress="hidden",
     )
 
     fetch_likes_button.click(
-        fn=prepare_likes_fetch_ui,
+        fn=lambda uname, year, profile: prepare_bucketed_fetch_ui("likes", uname, year, profile),
         inputs=[username, selected_year],
         outputs=likes_context_box,
         show_progress="hidden",
     ).then(
-        fn=fetch_and_render_likes,
+        fn=lambda state, uname, year, mode, profile: fetch_and_render_bucketed_section("likes", state, uname, year, mode, profile),
         inputs=[likes_state, username, selected_year, likes_view_mode],
         outputs=likes_fetch_outputs,
         show_progress="full",
@@ -3799,19 +3178,19 @@ with gr.Blocks(title="HF Contributions") as demo:
     )
 
     likes_view_mode.change(
-        fn=rerender_likes_from_state,
+        fn=lambda state, mode: rerender_bucketed_from_state("likes", state, mode),
         inputs=[likes_state, likes_view_mode],
         outputs=likes_chart,
         show_progress="hidden",
     )
 
     fetch_papers_button.click(
-        fn=prepare_papers_fetch_ui,
+        fn=lambda uname, year, profile: prepare_bucketed_fetch_ui("papers", uname, year, profile),
         inputs=[username, selected_year],
         outputs=papers_context_box,
         show_progress="hidden",
     ).then(
-        fn=fetch_and_render_papers,
+        fn=lambda state, uname, year, mode, profile: fetch_and_render_bucketed_section("papers", state, uname, year, mode, profile),
         inputs=[papers_state, username, selected_year, papers_view_mode],
         outputs=papers_fetch_outputs,
         show_progress="full",
@@ -3822,7 +3201,7 @@ with gr.Blocks(title="HF Contributions") as demo:
     )
 
     papers_view_mode.change(
-        fn=rerender_papers_from_state,
+        fn=lambda state, mode: rerender_bucketed_from_state("papers", state, mode),
         inputs=[papers_state, papers_view_mode],
         outputs=papers_chart,
         show_progress="hidden",