Upload folder using huggingface_hub

src/generate_report.py

@@ -36,7 +36,36 @@ DEFAULT_DB = "../data/scp_dataset.duckdb"
 DEFAULT_IMAGES = "../images"
 DEFAULT_REPORT = "../STATISTICS.md"
 
-CAPTION = "SCP Wiki content pages · 2008–2026 · n = 19,439 · via Crom"
+CAPTION = "SCP Wiki content pages · 2008–2026 · n = 19,438 · via Crom"
+
+# Placeholder/institutional credit names to drop from author stats.
+_PLACEHOLDERS = "('Anonymous', 'Unknown Author', 'Staff', 'Site News Team')"
+
+# Shared TEMP views (registered in main()): `credits` is one row per attribution credit;
+# `page_authors` applies the all-authors rule — AUTHOR credits where present, else the
+# page's submitter/poster — so co-authors count and every page is attributed.
+_VIEWS_SQL = f"""
+CREATE TEMP VIEW credits AS
+SELECT p.url, p.rating, p.title, p.created_at,
+       p.created_by_display_name AS poster,
+       a.type AS role, a.user_display_name AS name
+FROM pages p,
+     unnest(from_json(p.attributions,
+       '[{{"type":"VARCHAR","user_display_name":"VARCHAR","date":"VARCHAR","order":"INTEGER"}}]'
+     )) AS t(a);
+
+CREATE TEMP VIEW page_authors AS
+WITH ac AS (
+    SELECT DISTINCT url, name AS author FROM credits
+    WHERE role = 'AUTHOR' AND name NOT IN {_PLACEHOLDERS}
+)
+SELECT url, author FROM ac
+UNION
+SELECT p.url, p.created_by_display_name FROM pages p
+WHERE p.created_by_display_name IS NOT NULL
+  AND p.created_by_display_name NOT IN {_PLACEHOLDERS}
+  AND p.url NOT IN (SELECT url FROM ac);
+"""
 
 # Palette.
 INK, SUBINK, MUTED, GRID = "#222222", "#555555", "#9a9a9a", "#ececec"
@@ -381,8 +410,7 @@ def chart_author_pareto(con: duckdb.DuckDBPyConnection, images: Path) -> str:
         sorted(
             r[0]
             for r in con.execute(
-                "SELECT count(*) FROM pages WHERE created_by_wikidot_id IS NOT NULL "
-                "GROUP BY created_by_wikidot_id"
+                "SELECT count(*) FROM page_authors GROUP BY author"
             ).fetchall()
         )
     )
@@ -390,6 +418,7 @@ def chart_author_pareto(con: duckdb.DuckDBPyConnection, images: Path) -> str:
     frac_authors = np.arange(1, len(counts) + 1) / len(counts)
     desc = counts[::-1]
     top2 = desc[: max(1, len(desc) // 50)].sum() / counts.sum()
+    solo = int((counts == 1).sum())
 
     fig, ax = plt.subplots(figsize=(7.5, 6.5))
 
@@ -412,9 +441,9 @@ def chart_author_pareto(con: duckdb.DuckDBPyConnection, images: Path) -> str:
     _style_axes(ax, "Authorship is a power law")
 
     takeaway = (
-        f"Contribution is steeply unequal: the most prolific 2% of authors wrote "
-        f"{top2:.0%} of all pages, while 1,335 authors (nearly half) wrote exactly one. "
-        "A small core sustains the wiki."
+        "Counting every credited author (not just whoever posted the page), contribution is "
+        f"steeply unequal: the most prolific 2% hold {top2:.0%} of all author credits, while "
+        f"{solo:,} authors have a single credit. A small core sustains the wiki."
     )
 
     return _img(
@@ -565,9 +594,10 @@ def chart_rating_by_class(con: duckdb.DuckDBPyConnection, images: Path) -> str:
 def chart_prolific_vs_acclaimed(con: duckdb.DuckDBPyConnection, images: Path) -> str:
     """Bubble scatter of authors: output vs acclaim, sized by total rating."""
     rows = con.execute("""
-        SELECT created_by_display_name, count(*) n, avg(rating) ar, sum(rating) total
-        FROM pages WHERE created_by_display_name IS NOT NULL AND rating IS NOT NULL
-        GROUP BY 1 HAVING count(*) >= 10
+        SELECT pa.author, count(*) n, avg(p.rating) ar, sum(p.rating) total
+        FROM page_authors pa JOIN pages p ON p.url = pa.url
+        WHERE p.rating IS NOT NULL
+        GROUP BY pa.author HAVING count(*) >= 10
     """).fetchall()
     n = np.array([r[1] for r in rows])
     ar = np.array([r[2] for r in rows])
@@ -605,9 +635,10 @@ def chart_prolific_vs_acclaimed(con: duckdb.DuckDBPyConnection, images: Path) ->
     _style_axes(ax, "Prolific vs. acclaimed authors")
 
     takeaway = (
-        "Output and acclaim are different games. The most prolific authors cluster at modest "
-        "average ratings, while the highest-rated authors are comparatively selective — bubble "
-        "size (total score) shows a few writers manage both volume and quality."
+        "Counting every credited author (co-authors included), output and acclaim remain "
+        "different games: the most prolific cluster at modest average ratings, while the "
+        "highest-rated are comparatively selective — bubble size (total score) shows a few "
+        "writers manage both volume and quality."
     )
 
     return _img(
@@ -617,6 +648,169 @@ def chart_prolific_vs_acclaimed(con: duckdb.DuckDBPyConnection, images: Path) ->
     )
 
 
+def chart_coauthorship_over_time(con: duckdb.DuckDBPyConnection, images: Path) -> str:
+    """Line: share of pages with two or more credited authors, by year."""
+    rows = con.execute(f"""
+        WITH ac AS (
+            SELECT url, count(DISTINCT name) AS k FROM credits
+            WHERE role = 'AUTHOR' AND name NOT IN {_PLACEHOLDERS}
+            GROUP BY url
+        )
+        SELECT year(p.created_at) AS yr, count(*) AS total,
+               count(*) FILTER (WHERE coalesce(ac.k, 0) >= 2) AS co
+        FROM pages p LEFT JOIN ac ON ac.url = p.url
+        GROUP BY yr ORDER BY yr
+    """).fetchall()
+    years = [r[0] for r in rows]
+    pct = [100.0 * r[2] / r[1] for r in rows]
+
+    fig, ax = plt.subplots(figsize=(10, 5.2))
+    ax.plot(years, pct, color=ACCENT, linewidth=2.4, marker="o", markersize=4)
+    ax.fill_between(years, pct, color=ACCENT, alpha=0.08)
+    ax.set_ylabel("% of pages with ≥2 credited authors")
+    ax.set_ylim(0, max(pct) * 1.15)
+    ax.set_xticks(range(min(years), max(years) + 1, 2))
+    _style_axes(ax, "Co-authorship over time")
+
+    peak = max(pct)
+    takeaway = (
+        f"Co-authorship has climbed from near zero to about {peak:.0f}% of pages in recent years "
+        "— modern SCP is increasingly a team effort (2026 is a partial year). Early collaboration "
+        "is undercounted: the attribution metadata recording co-authors is a later convention."
+    )
+    return _img(
+        "Co-authorship over time",
+        _save(fig, images, "coauthorship_over_time"),
+        takeaway,
+    )
+
+
+def chart_rating_by_team(con: duckdb.DuckDBPyConnection, images: Path) -> str:
+    """Bar: median rating by number of credited authors."""
+    rows = con.execute("""
+        WITH per_page AS (
+            SELECT pa.url, any_value(p.rating) AS rating, count(*) AS n
+            FROM page_authors pa JOIN pages p ON p.url = pa.url
+            WHERE p.rating IS NOT NULL GROUP BY pa.url
+        ),
+        bucketed AS (SELECT rating, least(n, 4) AS team FROM per_page)
+        SELECT team, count(*) AS pages, median(rating) AS med
+        FROM bucketed GROUP BY team ORDER BY team
+    """).fetchall()
+    names = {1: "1 (solo)", 2: "2", 3: "3", 4: "4+"}
+    labels = [names[r[0]] for r in rows]
+    med = [r[2] for r in rows]
+    counts = [r[1] for r in rows]
+
+    fig, ax = plt.subplots(figsize=(9, 5))
+    bars = ax.bar(labels, med, color=ACCENT, width=0.62)
+    ax.bar_label(bars, fmt="{:.0f}", padding=3, color=SUBINK, fontsize=10)
+    for i, c in enumerate(counts):
+        ax.text(i, max(med) * 0.04, f"n={c:,}", ha="center", color="white", fontsize=8)
+    ax.set_ylabel("median rating")
+    ax.set_xlabel("number of credited authors")
+    _style_axes(ax, "Bigger teams, higher ratings")
+
+    takeaway = (
+        f"Median rating rises with team size — from {med[0]:.0f} for solo pages to {med[-1]:.0f} "
+        "for the largest teams. Collaboration correlates with a warmer reception, though the "
+        "most ambitious projects also tend to attract co-authors."
+    )
+    return _img(
+        "Bigger teams, higher ratings",
+        _save(fig, images, "rating_by_team"),
+        takeaway,
+    )
+
+
+def chart_collaboration_network(con: duckdb.DuckDBPyConnection, images: Path) -> str:
+    """Circular network of co-authorship among the most-connected authors."""
+    edges = con.execute("""
+        WITH a AS (SELECT url, author FROM page_authors)
+        SELECT x.author, y.author, count(*) AS w
+        FROM a x JOIN a y ON x.url = y.url AND x.author < y.author
+        GROUP BY x.author, y.author
+    """).fetchall()
+    pages = dict(
+        con.execute(
+            "SELECT author, count(*) FROM page_authors GROUP BY author"
+        ).fetchall()
+    )
+    # Rank authors by *recurring* collaboration (≥2 shared pages) so the named hub matches the
+    # drawn edges; one-off links from mass-collaboration pages would otherwise dominate.
+    recurring = [(a, b, w) for a, b, w in edges if w >= 2]
+    degree: dict[str, int] = {}
+    for a1, a2, w in recurring:
+        degree[a1] = degree.get(a1, 0) + w
+        degree[a2] = degree.get(a2, 0) + w
+    top = [
+        a for a, _ in sorted(degree.items(), key=lambda kv: kv[1], reverse=True)[:26]
+    ]
+    rank = set(top)
+    sub = [(a, b, w) for a, b, w in recurring if a in rank and b in rank]
+
+    angles = np.linspace(0, 2 * np.pi, len(top), endpoint=False)
+    xy = {
+        a: (float(np.cos(t)), float(np.sin(t)))
+        for a, t in zip(top, angles, strict=True)
+    }
+    maxw = max(e[2] for e in sub)
+
+    fig, ax = plt.subplots(figsize=(9.5, 9.5))
+    for a, b, w in sub:
+        (x1, y1), (x2, y2) = xy[a], xy[b]
+        ax.plot(
+            [x1, x2],
+            [y1, y2],
+            color=ACCENT,
+            solid_capstyle="round",
+            zorder=1,
+            alpha=min(0.75, 0.10 + 0.65 * w / maxw),
+            linewidth=0.4 + 3.0 * w / maxw,
+        )
+    sizes = [float(np.clip(pages.get(a, 1) * 2.0, 30, 600)) for a in top]
+    ax.scatter(
+        [xy[a][0] for a in top],
+        [xy[a][1] for a in top],
+        s=sizes,
+        color=INK,
+        edgecolors="white",
+        linewidth=0.6,
+        zorder=2,
+    )
+    for a, t in zip(top, angles, strict=True):
+        deg = float(np.degrees(t))
+        flip = 90 < deg < 270
+        ax.text(
+            1.06 * np.cos(t),
+            1.06 * np.sin(t),
+            a,
+            fontsize=7.5,
+            color=INK,
+            ha="right" if flip else "left",
+            va="center",
+            rotation=deg + 180 if flip else deg,
+            rotation_mode="anchor",
+        )
+    ax.set_xlim(-1.5, 1.5)
+    ax.set_ylim(-1.5, 1.5)
+    ax.set_aspect("equal")
+    ax.axis("off")
+    ax.set_title("How authors collaborate", loc="left", pad=12)
+    ax.figure.text(0.005, 0.005, CAPTION, fontsize=7.5, color=MUTED, ha="left")
+
+    takeaway = (
+        f"Co-authorship forms tight clusters around a few hubs — {top[0]} is the most connected. "
+        "Node size is total pages, edge weight is shared pages; the modern wiki is a densely "
+        "woven collaborative network, not a crowd of soloists."
+    )
+    return _img(
+        "How authors collaborate",
+        _save(fig, images, "collaboration_network"),
+        takeaway,
+    )
+
+
 def chart_tag_cooccurrence(con: duckdb.DuckDBPyConnection, images: Path) -> str:
     """Heatmap of Jaccard association between the top theme tags."""
     tags = [t for t, _ in _theme_tags(con, 14)]
@@ -739,18 +933,40 @@ def table_top_pages(con: duckdb.DuckDBPyConnection) -> str:
 
 
 def table_top_authors(con: duckdb.DuckDBPyConnection) -> str:
-    """Markdown table of the 15 most prolific authors."""
+    """Markdown table of the 15 most-credited authors (all-authors rule)."""
     rows = con.execute("""
-        SELECT created_by_display_name, count(*) n, round(avg(rating)) ar,
-               round(sum(rating)) tot, arg_max(title, rating) best
-        FROM pages WHERE created_by_display_name IS NOT NULL AND rating IS NOT NULL
-        GROUP BY 1 ORDER BY n DESC LIMIT 15
+        WITH team AS (SELECT url, count(*) AS n FROM page_authors GROUP BY url)
+        SELECT pa.author, count(*) AS pages, round(avg(p.rating)) AS ar,
+               round(sum(p.rating)) AS tot,
+               round(100.0 * count(*) FILTER (WHERE team.n >= 2) / count(*)) AS collab,
+               arg_max(p.title, p.rating) AS best
+        FROM page_authors pa
+        JOIN pages p ON p.url = pa.url
+        JOIN team ON team.url = pa.url
+        WHERE p.rating IS NOT NULL
+        GROUP BY pa.author ORDER BY pages DESC LIMIT 15
     """).fetchall()
 
     table = _md_table(
-        ["#", "Author", "Pages", "Avg rating", "Total rating", "Best-rated work"],
         [
-            [str(i), r[0], f"{r[1]:,}", f"{r[2]:.0f}", f"{r[3]:,.0f}", r[4]]
+            "#",
+            "Author",
+            "Pages",
+            "Avg rating",
+            "Total rating",
+            "Co-authored",
+            "Best-rated work",
+        ],
+        [
+            [
+                str(i),
+                r[0],
+                f"{r[1]:,}",
+                f"{r[2]:.0f}",
+                f"{r[3]:,.0f}",
+                f"{r[4]:.0f}%",
+                r[5],
+            ]
             for i, r in enumerate(rows, 1)
         ],
     )
@@ -758,10 +974,74 @@ def table_top_authors(con: duckdb.DuckDBPyConnection) -> str:
     takeaway = (
         "The most prolific authors are not the highest-scoring on average — volume and acclaim "
         "rarely coincide — but their cumulative totals show how much of the wiki rests on a few "
-        "dozen people."
+        "dozen people. The co-authored share shows how collaboratively each writer works."
     )
 
-    return _section("Top 15 most prolific authors", table, takeaway)
+    return _section("Top 15 authors (all credited authors)", table, takeaway)
+
+
+def table_coauthor_duos(con: duckdb.DuckDBPyConnection) -> str:
+    """Markdown table of the most frequent co-author pairs."""
+    rows = con.execute("""
+        WITH a AS (SELECT url, author FROM page_authors)
+        SELECT x.author, y.author, count(*) AS n, round(avg(p.rating)) AS ar
+        FROM a x JOIN a y ON x.url = y.url AND x.author < y.author
+        JOIN pages p ON p.url = x.url
+        WHERE p.rating IS NOT NULL
+        GROUP BY x.author, y.author ORDER BY n DESC LIMIT 12
+    """).fetchall()
+
+    table = _md_table(
+        ["#", "Author A", "Author B", "Shared pages", "Avg rating"],
+        [
+            [str(i), r[0], r[1], f"{r[2]:,}", f"{r[3]:.0f}"]
+            for i, r in enumerate(rows, 1)
+        ],
+    )
+    takeaway = (
+        "The wiki's tightest writing partnerships — recurring duos that have co-authored many "
+        "pages together, several rating well above the site median."
+    )
+    return _section("Top co-author duos", table, takeaway)
+
+
+def table_most_collaborative(con: duckdb.DuckDBPyConnection) -> str:
+    """Markdown table of authors with the most distinct co-authors."""
+    rows = con.execute("""
+        WITH a AS (SELECT url, author FROM page_authors)
+        SELECT x.author, count(DISTINCT y.author) AS partners, count(DISTINCT x.url) AS pages
+        FROM a x JOIN a y ON x.url = y.url AND x.author <> y.author
+        GROUP BY x.author ORDER BY partners DESC LIMIT 15
+    """).fetchall()
+
+    table = _md_table(
+        ["#", "Author", "Distinct co-authors", "Co-authored pages"],
+        [[str(i), r[0], f"{r[1]:,}", f"{r[2]:,}"] for i, r in enumerate(rows, 1)],
+    )
+    takeaway = (
+        "The community's connectors — authors who have written with the widest circle of "
+        "collaborators, knitting otherwise separate clusters together."
+    )
+    return _section("Most collaborative authors", table, takeaway)
+
+
+def table_top_rewriters(con: duckdb.DuckDBPyConnection) -> str:
+    """Markdown table of authors credited with the most rewrites."""
+    rows = con.execute(f"""
+        SELECT name, count(*) AS n, round(avg(rating)) AS ar
+        FROM credits WHERE role = 'REWRITE' AND name NOT IN {_PLACEHOLDERS}
+        GROUP BY name ORDER BY n DESC LIMIT 12
+    """).fetchall()
+
+    table = _md_table(
+        ["#", "Rewriter", "Pages rewritten", "Avg rating"],
+        [[str(i), r[0], f"{r[1]:,}", f"{r[2]:.0f}"] for i, r in enumerate(rows, 1)],
+    )
+    takeaway = (
+        "The canon's caretakers: a small group does most of the rewriting that keeps the early, "
+        "heavily-trafficked articles current."
+    )
+    return _section("Top rewriters", table, takeaway)
 
 
 # --- Orchestration --------------------------------------------------------------------
@@ -777,9 +1057,19 @@ _CHARTS = (
     chart_rating_by_year,
     chart_rating_by_class,
     chart_prolific_vs_acclaimed,
+    chart_coauthorship_over_time,
+    chart_rating_by_team,
     chart_tag_cooccurrence,
+    chart_collaboration_network,
+)
+_TABLES = (
+    table_per_year,
+    table_top_pages,
+    table_top_authors,
+    table_coauthor_duos,
+    table_most_collaborative,
+    table_top_rewriters,
 )
-_TABLES = (table_per_year, table_top_pages, table_top_authors)
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -807,6 +1097,7 @@ def main(argv: list[str] | None = None) -> int:
     setup_style()
 
     con = duckdb.connect(args.db, read_only=True)
+    con.execute(_VIEWS_SQL)  # register the `credits` and `page_authors` views
     sections: list[str] = []
     try:
         for fn in _CHARTS:

src/scp_dataset.py

@@ -8,12 +8,13 @@ GOI formats, essays, art) created in a given year on the English SCP wiki
 Captured per page: url, wikidot id, title, rating, vote count, category, created_at
 (UTC), revision count, comment count, thumbnail url, parent url, created_by
 (crom id / display name / unix name / wikidot id), source (raw Wikidot text), summary,
-tags, and alternate titles. Rendered text content and attributions are skipped; hidden
-pages and user/author pages are filtered out server-side.
+tags, alternate titles, and attributions (a JSON array of {type, user_display_name,
+date, order}). Only the rendered text content is skipped; hidden pages and user/author
+pages are filtered out server-side.
 
 The DuckDB file is the checkpoint: re-running a year resumes from the last saved page
 (a `created_at` watermark) and re-fetched rows upsert in place, so interruptions and
-Ctrl+C are safe. The schema is fully normalized (no JSON columns): a `pages` table plus
+Ctrl+C are safe. A `pages` table (with an `attributions` JSON column) plus normalized
 `page_tags` and `page_alternate_titles` child tables.
 
 Usage (run from the src/ directory):
@@ -30,6 +31,7 @@ from __future__ import annotations
 import argparse
 import asyncio
 import contextlib
+import json
 import logging
 import signal
 import sys
@@ -164,6 +166,7 @@ CREATE TABLE IF NOT EXISTS pages (
     created_by_wikidot_id   VARCHAR,
     source                  VARCHAR,                -- raw Wikidot source text
     summary                 VARCHAR,                -- author summary, often null
+    attributions            JSON,                   -- [{type, user_display_name, ...}]
     fetched_at              TIMESTAMP NOT NULL      -- UTC (naive); when saved
 );
 
@@ -202,6 +205,7 @@ _PAGE_COLUMNS = (
     "created_by_wikidot_id",
     "source",
     "summary",
+    "attributions",
     "fetched_at",
 )
 
@@ -213,12 +217,30 @@ _INSERT_PAGE = (
 
 
 def connect(db_path: str) -> duckdb.DuckDBPyConnection:
-    """Open the DuckDB database and ensure the schema exists."""
+    """Open the DuckDB database and ensure the schema (with migrations) exists."""
     con = duckdb.connect(db_path)
     con.execute(_SCHEMA)
+    # Migration: add `attributions` to databases created before the column existed.
+    con.execute("ALTER TABLE pages ADD COLUMN IF NOT EXISTS attributions JSON")
     return con
 
 
+def _attributions_json(page: Page) -> str:
+    """Serialize a page's attributions to a JSON array string for the JSON column."""
+    return json.dumps(
+        [
+            {
+                "type": a.type.value,
+                "user_display_name": a.user_display_name,
+                "date": a.date.isoformat() if a.date is not None else None,
+                "order": a.order,
+            }
+            for a in page.attributions or ()
+        ],
+        ensure_ascii=False,
+    )
+
+
 def _page_row(page: Page, fetched_at: datetime) -> tuple[object, ...]:
     """Flatten a page into a row tuple matching `_PAGE_COLUMNS`."""
     author = page.created_by
@@ -240,6 +262,7 @@ def _page_row(page: Page, fetched_at: datetime) -> tuple[object, ...]:
         author.wikidot_id if author else None,
         page.source,
         page.summary,
+        _attributions_json(page),
         fetched_at,
     )
 
@@ -362,6 +385,7 @@ def _log_plan(
         source=True,
         summary=True,
         alternate_titles=True,
+        attributions=True,
     )
     remaining = max(0, expected - already)
     est = remaining * per_page
@@ -422,6 +446,7 @@ async def crawl_year(args: argparse.Namespace) -> int:  # noqa: C901, PLR0915
         source=True,
         summary=True,
         alternate_titles=True,
+        attributions=True,
     )
 
     try:
@@ -471,6 +496,7 @@ async def crawl_year(args: argparse.Namespace) -> int:  # noqa: C901, PLR0915
                     source=True,
                     summary=True,
                     alternate_titles=True,
+                    attributions=True,
                 )
             )
             if batch.pages: