Code

@app.get("/api/panels")
def api_panels() -> JSONResponse:
    """Top panel-capable series clusters — real per-cluster measurements."""
    return JSONResponse(INVENTORY["panels"])


@app.get("/api/richest")
def api_richest() -> JSONResponse:
    """Series clusters with the most extracted tables — real counts."""
    return JSONResponse(INVENTORY["richest_by_tables"])


@app.get("/api/totals")
def api_totals() -> JSONResponse:
    return JSONResponse({
        "project": HEADLINES["project"],
        "inventory": INVENTORY["totals"],
        "provenance": INVENTORY["_provenance"],
    })

fetch('/api/panels').then(r => r.json()).then(rows => {
  const top = rows.slice(0, 18).reverse();
  // ArkPlotly = the kit's shared Plotly theme: transparent bg, --ark-* accent +
  // colorway, dark/light-aware, trimmed modebar (PNG + "Download data (CSV)").
  ArkPlotly.plot('panels-chart', [{
    type: 'bar', orientation: 'h',
    x: top.map(r => r.n_docs),
    y: top.map(r => r.display_name || r.label),   // English label (display_name)
    // r.original_label carries the Russian source title (shown in the hover/table)
    hovertext: top.map(r => `${r.display_name}<br>${r.n_docs} docs (${r.span})` +
                            (r.original_label ? `<br><i>${r.original_label}</i>` : '')),
    hovertemplate: '%{hovertext}<extra></extra>'
  }], {
    title: 'Panel-capable clusters by document count (top 18)',
    margin: {l: 300, r: 20, t: 40, b: 40},
    height: 600,
    xaxis: {title: 'documents in cluster'}
  }, {filename: 'vlad_panel_capable_clusters'});

  // Inline CSV download of the same table (real panels_csv artifact, text/csv).
  ArkDownloads.buttons({ csv: '/api/download/panels_csv' });
});

MEDIA = {
    "csv": "text/csv; charset=utf-8",
    "json": "application/json",
    "zip": "application/zip",
}

def _clusters_csv(key: str) -> bytes:
    """Serialize a real cluster list from inventory.json (panels / richest)."""
    inv = _load("inventory.json")
    buf = io.StringIO()
    w = csv.writer(buf)
    w.writerow(["series_cluster", "example_document", "n_docs", "n_years",
                "span", "extracted_tables", "body_chunks"])
    for r in inv[key]:
        w.writerow([r["series"], r["label"], r["n_docs"], r["n_years"],
                    r["span"], r["tables"], r["body"]])
    return buf.getvalue().encode("utf-8")

def render_artifact(art: dict) -> tuple[bytes, str, str]:
    raw = _bytes_for(art)
    return raw, MEDIA[art["fmt"]], _download_filename(art)

with open(INV, newline="", encoding="utf-8-sig") as fh:
    for r in csv.DictReader(fh):
        rows.append({
            "series": (r.get("series") or "").strip(),
            "label":  (r.get("sample") or "").strip() or (r.get("series") or ""),
            "n_docs": _int(r.get("n_docs")), "n_years": _int(r.get("years")),
            "span": (r.get("span") or "").strip(),
            "tables": _int(r.get("tables")), "body": _int(r.get("body")),
            "sample": (r.get("sample") or "").strip(),
        })
# panel-capable = a real cluster spanning >= 2 distinct years
panel = [x for x in rows if x["span"] and x["n_years"] >= 2]

# English-first display: translate the Russian source title, keep the original.
def _localize(row, tmap):
    s = row["sample"]
    if _is_cyrillic(s) and s in tmap:
        row["display_name"]   = tmap[s]   # English (primary)
        row["original_label"] = _clean(s) # Russian (secondary, shown in parens)
    else:
        row["display_name"]   = _clean(s) # already-English slug
        row["original_label"] = None