Citation Network Guide

import requests
import networkx as nx

def get_citations(doi, max_results=100):
    """Fetch papers that cite a given DOI using OpenAlex."""
    work_url = f"https://api.openalex.org/works/doi:{doi}"
    resp = requests.get(work_url)
    work = resp.json()
    openalex_id = work['id']

    # Get citing works
    citing_url = (
        f"https://api.openalex.org/works"
        f"?filter=cites:{openalex_id}"
        f"&per_page={max_results}"
        f"&sort=cited_by_count:desc"
    )
    citing_resp = requests.get(citing_url)
    citing_works = citing_resp.json()['results']

    return [{
        'id': w['id'],
        'title': w['title'],
        'year': w['publication_year'],
        'cited_by_count': w['cited_by_count'],
        'authors': [a['author']['display_name']
                    for a in w.get('authorships', [])]
    } for w in citing_works]

import networkx as nx

def build_citation_network(seed_doi, depth=2):
    """Build a citation network to specified depth from a seed paper."""
    G = nx.DiGraph()
    visited = set()
    queue = [(seed_doi, 0)]

    while queue:
        doi, level = queue.pop(0)
        if doi in visited or level > depth:
            continue
        visited.add(doi)

        citations = get_citations(doi, max_results=20)
        for paper in citations:
            G.add_node(paper['id'],
                       title=paper['title'],
                       year=paper['year'],
                       citations=paper['cited_by_count'])
            G.add_edge(paper['id'], doi)  # citing -> cited

            if level + 1 <= depth:
                queue.append((paper['id'], level + 1))

    return G

# Build and analyze
G = build_citation_network("10.1234/example", depth=2)
print(f"Nodes: {G.number_of_nodes()}, Edges: {G.number_of_edges()}")

# PageRank (most important papers in the network)
pagerank = nx.pagerank(G, alpha=0.85)
top_papers = sorted(pagerank.items(), key=lambda x: x[1], reverse=True)[:10]

for paper_id, score in top_papers:
    title = G.nodes[paper_id].get('title', 'Unknown')
    print(f"  PR={score:.4f}: {title[:80]}")

# Betweenness centrality (bridge papers)
betweenness = nx.betweenness_centrality(G)
bridges = sorted(betweenness.items(), key=lambda x: x[1], reverse=True)[:10]

# Community detection (research clusters)
from networkx.algorithms.community import greedy_modularity_communities
communities = list(greedy_modularity_communities(G.to_undirected()))
print(f"Detected {len(communities)} research clusters")

def build_cocitation_network(papers_with_refs):
    """Build co-citation network from papers with their reference lists."""
    from itertools import combinations
    G = nx.Graph()

    for paper in papers_with_refs:
        refs = paper['references']
        for a, b in combinations(refs, 2):
            if G.has_edge(a, b):
                G[a][b]['weight'] += 1
            else:
                G.add_edge(a, b, weight=1)

    return G

from pyvis.network import Network

def visualize_citation_network(G, output='citation_network.html'):
    net = Network(height='800px', width='100%', directed=True)

    for node in G.nodes():
        title = G.nodes[node].get('title', str(node))[:60]
        size = min(5 + G.nodes[node].get('citations', 0) * 0.1, 40)
        net.add_node(str(node), label=title, size=size,
                     title=G.nodes[node].get('title', ''))

    for u, v in G.edges():
        net.add_edge(str(u), str(v))

    net.set_options("""
    var options = {
      "physics": {"barnesHut": {"gravitationalConstant": -3000}},
      "nodes": {"font": {"size": 10}}
    }
    """)
    net.save_graph(output)
    print(f"Saved to {output}")