diff --git "a/src/app.py" "b/src/app.py"
--- "a/src/app.py"
+++ "b/src/app.py"
@@ -1,1195 +1,1200 @@
-from __future__ import annotations
-
-import base64
-import os
-from pathlib import Path
-from typing import List
-
-import pandas as pd
-import networkx as nx
-import streamlit as st
-import plotly.express as px
-import plotly.graph_objects as go
-from pyvis.network import Network
-import streamlit.components.v1 as components
-
-HF_REPO_ID = os.environ.get("HF_REPO_ID", "")
-
-def csv_download_link(data: bytes, filename: str, label: str) -> None:
-
- b64 = base64.b64encode(data).decode()
- st.markdown(
- f''
- f'{label}',
- unsafe_allow_html=True,
- )
-HF_TOKEN = os.environ.get("HF_TOKEN", "")
-
-st.set_page_config(page_title="CitationHub", page_icon="📚", layout="wide")
-
-ALLOWED_INTENTS = [
- "background","uses","similarities","motivation",
- "differences","future_work","extends",
-]
-INTENT_COLORS = {
- "background":"#94a3b8","uses":"#22c55e","similarities":"#3b82f6",
- "motivation":"#f59e0b","differences":"#ef4444",
- "future_work":"#8b5cf6","extends":"#06b6d4",
-}
-NODE_COLORS = {
- "seed_paper":"#111827","citing_paper":"#dbeafe","citation_event":"#fde68a",
- "journal":"#ede9fe","author":"#fee2e2","affiliation":"#fae8ff",
- "city":"#cffafe","country":"#ffedd5","field":"#e0e7ff","intent":"#dcfce7",
-}
-NODE_TYPE_COLORS = {
- "seed_paper":"#111827","citing_paper":"#3b82f6","citation_event":"#f59e0b",
- "journal":"#8b5cf6","author":"#ef4444","affiliation":"#ec4899",
- "city":"#06b6d4","country":"#f97316","field":"#6366f1","intent":"#22c55e",
-}
-
-DEFAULT_DATA_DIR = Path(os.environ.get(
- "CITATIONHUB_DATA_DIR",
- "/tmp/citationhub_data",
-))
-
-def fmt_num(x):
- try: return f"{int(x):,}"
- except: return "-"
-
-def _hf_download(filename: str) -> str:
- from huggingface_hub import hf_hub_download
- return hf_hub_download(
- repo_id=HF_REPO_ID, repo_type="dataset",
- filename=f"data/{filename}", token=HF_TOKEN or None,
- )
-
-def _read(filename: str, data_dir: Path | None = None, columns: list | None = None) -> pd.DataFrame:
- path = _hf_download(filename) if HF_REPO_ID else str(data_dir / filename)
- return pd.read_parquet(path, columns=columns, engine="pyarrow")
-
-def plotly_network_fig(
- nodes_df: pd.DataFrame,
- edges_df: pd.DataFrame,
- title: str = "",
- height: int = 750,
- seed_node_ids: list | None = None,
-) -> go.Figure:
-
- G = nx.Graph()
- node_meta: dict = {}
- for _, row in nodes_df.iterrows():
- nid = str(row["node_id"])
- G.add_node(nid)
- node_meta[nid] = row
-
- for _, row in edges_df.iterrows():
- s, t = str(row["source"]), str(row["target"])
- if s in node_meta and t in node_meta:
- G.add_edge(s, t, edge_type=row.get("edge_type", ""))
-
- if len(G.nodes) == 0:
- return go.Figure()
-
- k = max(1.5, 3.0 / (len(G.nodes) ** 0.4))
- pos = nx.spring_layout(G, seed=42, k=k, iterations=60)
-
- ex, ey = [], []
- for src, tgt in G.edges():
- x0, y0 = pos.get(src, (0, 0))
- x1, y1 = pos.get(tgt, (0, 0))
- ex += [x0, x1, None]
- ey += [y0, y1, None]
-
- traces: list[go.BaseTraceType] = [
- go.Scatter(
- x=ex, y=ey, mode="lines",
- line=dict(width=0.8, color="#cbd5e1"),
- hoverinfo="none", showlegend=False,
- )
- ]
-
- for ntype, color in NODE_TYPE_COLORS.items():
- subset = nodes_df[nodes_df["node_type"] == ntype]
- if subset.empty:
- continue
- xs, ys, hovers, texts = [], [], [], []
- for _, row in subset.iterrows():
- nid = str(row["node_id"])
- if nid not in pos:
- continue
- x, y = pos[nid]
- xs.append(x); ys.append(y)
- label = str(row.get("label", ""))[:50]
- texts.append(label if ntype == "seed_paper" else "")
- hovers.append(
- f"{label}
"
- f"Type: {ntype}
"
- f"DOI: {row.get('doi','') or '-'}
"
- f"Pub: {row.get('publication_name','') or '-'}
"
- f"Group: {row.get('group','') or '-'}"
- )
-
- is_seed = ntype == "seed_paper"
- traces.append(go.Scatter(
- x=xs, y=ys,
- mode="markers+text" if is_seed else "markers",
- text=texts, textposition="top center",
- hovertext=hovers, hoverinfo="text",
- name=ntype,
- marker=dict(
- size=20 if is_seed else 10,
- color=color,
- line=dict(width=1.5 if is_seed else 0.5, color="white"),
- symbol="circle",
- ),
- ))
-
- fig = go.Figure(data=traces)
- fig.update_layout(
- title=dict(text=title, font=dict(size=14)),
- showlegend=True,
- legend=dict(title="Node type", itemsizing="constant"),
- hovermode="closest",
- height=height,
- margin=dict(l=0, r=0, t=40 if title else 10, b=0),
- paper_bgcolor="white",
- plot_bgcolor="#f8fafc",
- xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
- yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
- )
- return fig
-
-def plotly_ontology_fig(height: int = 820) -> go.Figure:
-
-
- NODE_PROPS = {
- "seed_paper": "doi · title · journal\nauthor · affiliation\ncountry · field · citedby_count",
- "citation_event": "event_id · citing_year\nprimary_intent · context\nis_influential",
- "citing_paper": "doi · title\nyear · venue · oa_pdf",
- "intent": "background · uses\nsimilarities · motivation\ndifferences · future_work · extends",
- "journal": "journal_name",
- "author": "author_name · author_id",
- "affiliation": "affiliation_name",
- "city": "city_name",
- "country": "country_name",
- "field": "field_name",
- }
-
- node_defs = [
- ("seed", "Top5PctCitedPaper", "seed_paper"),
- ("event", "CitationEvent", "citation_event"),
- ("citing", "CitingPaper", "citing_paper"),
- ("intent", "Intent", "intent"),
- ("journal", "Journal", "journal"),
- ("author", "Author", "author"),
- ("affiliation", "Affiliation", "affiliation"),
- ("city", "City", "city"),
- ("country", "Country", "country"),
- ("field", "Field", "field"),
- ]
- edge_defs = [
- ("event","citing","hasCitingPaper"), ("event","seed","hasCitedPaper"),
- ("event","intent","hasPrimaryIntent"), ("seed","journal","publishedInJournal"),
- ("seed","author","hasAuthor"), ("seed","affiliation","hasAffiliation"),
- ("seed","city","locatedInCity"), ("seed","country","locatedInCountry"),
- ("seed","field","belongsToField"),
- ]
- G = nx.DiGraph()
- for nid, _, _ in node_defs:
- G.add_node(nid)
- for s, t, _ in edge_defs:
- G.add_edge(s, t)
-
- pos = nx.spring_layout(G, seed=7, k=2.5, iterations=80)
-
- ex, ey = [], []
- ann = []
- for s, t, lbl in edge_defs:
- x0, y0 = pos[s]; x1, y1 = pos[t]
- ex += [x0, x1, None]; ey += [y0, y1, None]
- mx, my = (x0+x1)/2, (y0+y1)/2
- ann.append(dict(
- x=mx, y=my, text=f"{lbl}",
- showarrow=False, font=dict(size=9, color="#64748b"),
- bgcolor="rgba(255,255,255,0.75)",
- ))
-
- traces: list[go.BaseTraceType] = [
- go.Scatter(x=ex, y=ey, mode="lines",
- line=dict(width=1.2, color="#94a3b8"),
- hoverinfo="none", showlegend=False)
- ]
-
- for nid, label, ntype in node_defs:
- x, y = pos[nid]
- color = NODE_TYPE_COLORS.get(ntype, "#94a3b8")
- props = NODE_PROPS.get(ntype, "")
-
- traces.append(go.Scatter(
- x=[x], y=[y], mode="markers+text",
- text=[f"{label}"], textposition="top center",
- hoverinfo="text",
- hovertext=(f"{label}
Type: {ntype}
"
- + props.replace("\n", "
")),
- name=label, showlegend=False,
- marker=dict(size=24, color=color,
- line=dict(width=1.5, color="white")),
- textfont=dict(size=11, color="#1e293b"),
- ))
-
- if props:
- prop_html = props.replace("\n", "
")
- ann.append(dict(
- x=x, y=y,
- text=f"{prop_html}",
- showarrow=False,
- xanchor="center",
- yanchor="top",
- yshift=-22,
- font=dict(size=8, color="#64748b"),
- bgcolor="rgba(248,250,252,0.85)",
- borderpad=2,
- ))
-
- fig = go.Figure(data=traces)
- fig.update_layout(
- showlegend=False, hovermode="closest", height=height,
- annotations=ann,
- margin=dict(l=10, r=10, t=20, b=10),
- paper_bgcolor="white", plot_bgcolor="#f8fafc",
- xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
- yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
- )
- return fig
-
-def inject_fullscreen(html: str) -> str:
- extra = """
-
-
- 🖱 Scroll: zoom | Drag: pan | Click node: info
-
- """
- return html.replace(" ", extra + "")
-
-_SEED_COLS = [
- "seed_paper_id","doi","title","publication_name","creator","affilname",
- "affiliation_city","affiliation_country","group","cover_date","citedby_count",
- "author_id","affiliation_id","country_id","field_id","journal_id",
-]
-_INTENTS_SQL = "'" + "','".join(["background","uses","similarities","motivation",
- "differences","future_work","extends"]) + "'"
-
-@st.cache_data(show_spinner=False)
-def load_data(data_dir_str: str):
- import duckdb, pyarrow.parquet as pq
- d = None if HF_REPO_ID else Path(data_dir_str)
-
- seed_path = _hf_download("seed_cited_papers_normalized.parquet") if HF_REPO_ID else str(d / "seed_cited_papers_normalized.parquet")
- events_path = _hf_download("citation_events_normalized.parquet") if HF_REPO_ID else str(d / "citation_events_normalized.parquet")
-
- avail = pq.read_schema(seed_path).names
- cols = [c for c in _SEED_COLS if c in avail]
- seed_df = pd.read_parquet(seed_path, columns=cols, engine="pyarrow")
-
- seed = pd.DataFrame({
- "seed_paper_id": seed_df["seed_paper_id"],
- "doi": seed_df.get("doi", pd.Series(dtype=str)).fillna(""),
- "title": seed_df.get("title", pd.Series(dtype=str)).fillna(""),
- "journal": seed_df.get("publication_name", pd.Series(dtype=str)).fillna(""),
- "author": seed_df.get("creator", pd.Series(dtype=str)).fillna(""),
- "affiliation": seed_df.get("affilname", pd.Series(dtype=str)).fillna(""),
- "city": seed_df.get("affiliation_city", pd.Series(dtype=str)).fillna(""),
- "country": seed_df.get("affiliation_country", pd.Series(dtype=str)).fillna(""),
- "field": seed_df.get("group", pd.Series(dtype=str)).fillna(""),
- "cover_date": seed_df.get("cover_date", pd.Series(dtype=str)).fillna(""),
- "citedby_count": pd.to_numeric(seed_df.get("citedby_count"), errors="coerce").fillna(0).astype(int),
- "author_id": seed_df.get("author_id", pd.Series(dtype=object)),
- "affiliation_id": seed_df.get("affiliation_id", pd.Series(dtype=object)),
- "country_id": seed_df.get("country_id", pd.Series(dtype=object)),
- "field_id": seed_df.get("field_id", pd.Series(dtype=object)),
- "journal_id": seed_df.get("journal_id", pd.Series(dtype=object)),
- })
- for col in ["title","doi","journal","field","country"]:
- seed[f"{col}_lc"] = seed[col].astype(str).str.lower()
- seed = seed.sort_values(["citedby_count","title"], ascending=[False,True]).reset_index(drop=True)
-
- ep = events_path.replace("\\", "/")
- stats = duckdb.execute(f"""
- SELECT MIN(citing_year) AS yr_min, MAX(citing_year) AS yr_max,
- COUNT(*) AS total, COUNT(DISTINCT citing_paper_id) AS n_citing
- FROM read_parquet('{ep}')
- WHERE primary_intent IN ({_INTENTS_SQL})
- """).df().iloc[0]
-
- filters = {
- "fields": sorted([x for x in seed["field"].dropna().astype(str).unique() if x]),
- "countries": sorted([x for x in seed["country"].dropna().astype(str).unique() if x]),
- "journals": sorted([x for x in seed["journal"].dropna().astype(str).unique() if x]),
- "intents": ALLOWED_INTENTS,
- "year_min": int(stats["yr_min"]) if pd.notna(stats["yr_min"]) else 2000,
- "year_max": int(stats["yr_max"]) if pd.notna(stats["yr_max"]) else 2025,
- }
- overview = {
- "seed_papers": int(len(seed)),
- "citation_events": int(stats["total"]),
- "citing_papers": int(stats["n_citing"]),
- "authors": int(seed["author"].replace("", pd.NA).dropna().nunique()),
- "journals": int(seed["journal"].replace("", pd.NA).dropna().nunique()),
- "countries": int(seed["country"].replace("", pd.NA).dropna().nunique()),
- "fields": int(seed["field"].replace("", pd.NA).dropna().nunique()),
- "intents": len(ALLOWED_INTENTS),
- }
- return seed, events_path, filters, overview
-
-@st.cache_data(show_spinner=False)
-def load_events_for_paper(events_path: str, seed_paper_id: str, year_min: int, year_max: int) -> pd.DataFrame:
- import duckdb
- ep = events_path.replace("\\", "/")
- sid = seed_paper_id.replace("'", "''")
- return duckdb.execute(f"""
- SELECT citation_event_id,
- cited_seed_paper_id AS seed_paper_id,
- citing_paper_id, citing_title, citing_doi,
- TRY_CAST(citing_year AS INTEGER) AS citing_year,
- citing_venue, primary_intent, contexts,
- TRY_CAST(context_count AS INTEGER) AS context_count,
- TRY_CAST(intent_count AS INTEGER) AS intent_count,
- is_influential
- FROM read_parquet('{ep}')
- WHERE cited_seed_paper_id = '{sid}'
- AND primary_intent IN ({_INTENTS_SQL})
- AND TRY_CAST(citing_year AS INTEGER) BETWEEN {year_min} AND {year_max}
- ORDER BY context_count DESC NULLS LAST
- """).df()
-
-@st.cache_data(show_spinner=False)
-def load_global_intent_stats(events_path: str) -> pd.DataFrame:
- import duckdb
- ep = events_path.replace("\\", "/")
- return duckdb.execute(f"""
- SELECT primary_intent AS intent, COUNT(*) AS count
- FROM read_parquet('{ep}')
- WHERE primary_intent IN ({_INTENTS_SQL})
- GROUP BY primary_intent
- """).df()
-
-@st.cache_data(show_spinner=False)
-def load_cocited_papers(events_path: str, selected_seed_id: str, top_n: int = 15) -> pd.DataFrame:
- import duckdb
- ep = events_path.replace("\\", "/")
- sid = selected_seed_id.replace("'", "''")
- return duckdb.execute(f"""
- WITH citing_ids AS (
- SELECT DISTINCT citing_paper_id
- FROM read_parquet('{ep}')
- WHERE cited_seed_paper_id = '{sid}'
- )
- SELECT cited_seed_paper_id AS seed_paper_id, COUNT(*) AS co_citation_count
- FROM read_parquet('{ep}')
- WHERE citing_paper_id IN (SELECT citing_paper_id FROM citing_ids)
- AND cited_seed_paper_id != '{sid}'
- GROUP BY cited_seed_paper_id
- ORDER BY co_citation_count DESC
- LIMIT {top_n}
- """).df()
-
-@st.cache_data(show_spinner=False)
-def load_analytics_data(events_path: str) -> dict:
- import duckdb
- ep = events_path.replace("\\", "/")
-
- intent_trend = duckdb.execute(f"""
- SELECT TRY_CAST(citing_year AS INTEGER) AS year,
- primary_intent, COUNT(*) AS count
- FROM read_parquet('{ep}')
- WHERE primary_intent IN ({_INTENTS_SQL})
- AND TRY_CAST(citing_year AS INTEGER) >= 2000
- GROUP BY year, primary_intent
- ORDER BY year
- """).df()
-
- venues = duckdb.execute(f"""
- SELECT citing_venue, COUNT(*) AS count
- FROM read_parquet('{ep}')
- WHERE primary_intent IN ({_INTENTS_SQL})
- AND citing_venue IS NOT NULL AND citing_venue != ''
- GROUP BY citing_venue
- ORDER BY count DESC
- LIMIT 20
- """).df()
-
- influential = duckdb.execute(f"""
- SELECT is_influential, COUNT(*) AS count
- FROM read_parquet('{ep}')
- WHERE primary_intent IN ({_INTENTS_SQL})
- GROUP BY is_influential
- """).df()
-
- return {"intent_trend": intent_trend, "venues": venues, "influential": influential}
-
-@st.cache_data(show_spinner=False)
-def load_authors_data(data_dir_str: str) -> pd.DataFrame:
- return _read("authors.parquet", None if HF_REPO_ID else Path(data_dir_str),
- columns=["author_id","author_name"])
-
-@st.cache_data(show_spinner=False)
-def load_geo_data(data_dir_str: str) -> pd.DataFrame:
- return _read("affiliation_geo.parquet", None if HF_REPO_ID else Path(data_dir_str),
- columns=["affiliation_name","city_name","country_name"])
-
-_KG_NODE_COLS = ["node_id","node_type","label","doi","publication_name","citedby_count"]
-
-@st.cache_data(show_spinner=False)
-def load_kg_nodes(data_dir_str: str) -> pd.DataFrame:
- path = _hf_download("kg_nodes.parquet") if HF_REPO_ID else str(Path(data_dir_str) / "kg_nodes.parquet")
- return pd.read_parquet(path, columns=_safe_cols(path, _KG_NODE_COLS), engine="pyarrow")
-
-@st.cache_data(show_spinner=False)
-def get_parquet_path(filename: str, data_dir_str: str) -> str:
-
- if HF_REPO_ID:
- return _hf_download(filename)
-
- return str(Path(data_dir_str) / filename).replace("\\", "/")
-
-@st.cache_data(show_spinner=False)
-def query_kg_edges_for_node(node_id: str, kg_edges_path: str, max_edges: int = 80) -> pd.DataFrame:
-
- import duckdb
- safe_path = kg_edges_path.replace("\\", "/")
- safe_node = node_id.replace("'", "''")
- q = f"""
- SELECT source, target, edge_type
- FROM read_parquet('{safe_path}')
- WHERE source = '{safe_node}' OR target = '{safe_node}'
- LIMIT {int(max_edges)}
- """
- return duckdb.execute(q).df()
-
-@st.cache_data(show_spinner=False)
-def query_enriched_stats(enriched_path: str):
-
- import duckdb
- safe_path = enriched_path.replace("\\", "/")
-
- sem_df = duckdb.execute(f"""
- SELECT has_semantic_evidence, COUNT(*) AS count
- FROM read_parquet('{safe_path}')
- GROUP BY has_semantic_evidence
- """).df()
-
- field_df = duckdb.execute(f"""
- SELECT field_folder AS field,
- AVG(CAST(has_semantic_evidence AS INTEGER)) AS sem_ratio,
- COUNT(*) AS event_count
- FROM read_parquet('{safe_path}')
- GROUP BY field_folder
- ORDER BY sem_ratio DESC
- LIMIT 20
- """).df()
-
- return sem_df, field_df
-
-@st.cache_data(show_spinner=False)
-def query_explorer_edges(node_id: str, kg_edges_path: str, max_edges: int = 60) -> pd.DataFrame:
-
- import duckdb
- safe_path = kg_edges_path.replace("\\", "/")
- safe_node = node_id.replace("'", "''")
- q = f"""
- SELECT source, target, edge_type
- FROM read_parquet('{safe_path}')
- WHERE source = '{safe_node}' OR target = '{safe_node}'
- LIMIT {int(max_edges)}
- """
- return duckdb.execute(q).df()
-
-def filter_seed_papers(seed, q, fields, countries, journals):
- df = seed.copy()
- q = (q or "").strip().lower()
- if q:
- df = df[df["title_lc"].str.contains(q, na=False) | df["doi_lc"].str.contains(q, na=False)]
- if fields: df = df[df["field"].str.lower().isin({x.lower() for x in fields})]
- if countries: df = df[df["country"].str.lower().isin({x.lower() for x in countries})]
- if journals: df = df[df["journal"].str.lower().isin({x.lower() for x in journals})]
- return df.reset_index(drop=True)
-
-def event_subset(events, seed_paper_id, year_min, year_max):
- df = events[events["seed_paper_id"] == seed_paper_id].copy()
- df = df[df["citing_year"].fillna(-99999) >= year_min]
- df = df[df["citing_year"].fillna(99999) <= year_max]
- return df.reset_index(drop=True)
-
-def build_intent_summary(df):
- counts = df.groupby("primary_intent").size().to_dict()
- return pd.DataFrame({"intent": ALLOWED_INTENTS,
- "count": [int(counts.get(i,0)) for i in ALLOWED_INTENTS]})
-
-def build_context_rows(df, limit=20):
- rows = []
- df = df.sort_values(["context_count","intent_count","citing_year"],
- ascending=[False,False,False], na_position="last")
- for _, row in df.iterrows():
- ctx = row["contexts"]
- if isinstance(ctx, list) and ctx:
- for c in ctx[:2]:
- rows.append({"primary_intent": row["primary_intent"],
- "citing_title": row["citing_title"],
- "citing_doi": row["citing_doi"],
- "citing_year": None if pd.isna(row["citing_year"]) else int(row["citing_year"]),
- "context": c})
- if len(rows) >= limit: break
- return pd.DataFrame(rows[:limit])
-
-def build_citing_table(df, limit=30):
- if df.empty:
- return pd.DataFrame(columns=["citing_title","citing_year","primary_intent","context_count"])
- return (df.sort_values(["context_count","intent_count","citing_year"],
- ascending=[False,False,False], na_position="last")
- [["citing_paper_id","citing_title","citing_doi","citing_year","primary_intent","context_count"]]
- .drop_duplicates(subset=["citing_paper_id"]).head(limit))
-
-def get_cocited_papers(selected_seed_id, events, seed, top_n=15):
-
- citing_ids = events[events["seed_paper_id"] == selected_seed_id]["citing_paper_id"].unique()
- cocited = (events[events["citing_paper_id"].isin(citing_ids) &
- (events["seed_paper_id"] != selected_seed_id)]
- .groupby("seed_paper_id").size()
- .reset_index(name="co_citation_count")
- .sort_values("co_citation_count", ascending=False)
- .head(top_n))
- return cocited.merge(seed[["seed_paper_id","title","field","journal","citedby_count"]],
- on="seed_paper_id", how="left")
-
-def get_kg_subgraph(seed_doi: str, kg_nodes, kg_edges, max_edges=80):
-
- node_id = f"seed:{seed_doi}"
- edges = kg_edges[(kg_edges["source"] == node_id) |
- (kg_edges["target"] == node_id)].head(max_edges)
- if edges.empty:
- return None, None
- all_node_ids = set(edges["source"].tolist()) | set(edges["target"].tolist())
- nodes = kg_nodes[kg_nodes["node_id"].isin(all_node_ids)]
- return nodes, edges
-
-def get_explorer_subgraph(search_node_id: str, kg_nodes, kg_edges, max_edges=60):
-
- edges = kg_edges[(kg_edges["source"] == search_node_id) |
- (kg_edges["target"] == search_node_id)].head(max_edges)
- if edges.empty:
- return None, None
- all_ids = set(edges["source"].tolist()) | set(edges["target"].tolist())
- nodes = kg_nodes[kg_nodes["node_id"].isin(all_ids)]
- return nodes, edges
-
-def pyvis_citation_graph(seed_row, events_df):
- net = Network(height="780px", width="100%", bgcolor="#ffffff", font_color="#111827", directed=True)
- sid = seed_row["seed_paper_id"]
- net.add_node(sid, label=seed_row["title"][:60], color="#111827", size=34, shape="dot",
- font={"color":"white"})
- for _, row in events_df.sort_values(["context_count","intent_count"],
- ascending=False).head(40).iterrows():
- cid = row["citing_paper_id"]
- net.add_node(cid, label=(row["citing_title"] or row["citing_doi"] or cid)[:60],
- color=NODE_COLORS["citing_paper"], size=18, shape="dot")
- ctx = (row["contexts"] or [])[0] if isinstance(row["contexts"], list) and row["contexts"] else ""
- yr = "" if pd.isna(row["citing_year"]) else int(row["citing_year"])
- net.add_edge(cid, sid, label=row["primary_intent"],
- color=INTENT_COLORS.get(row["primary_intent"],"#94a3b8"),
- title=f"Intent: {row['primary_intent']}