code/experiments/build_paper_artifacts.py

"""One-shot paper-artifact builder for the MacroLens NeurIPS 2026 D&B paper.

After every method has finished running and ``experiments/results/`` is
populated with ``RunRecord`` JSONs, this script bundles every downstream
artefact the paper consumes:

* **Aggregation** -- ``aggregate_results.aggregate(...)`` writes a long-form
  parquet to ``paper_artifacts/aggregate.parquet``.
* **Tables**      -- ``gen_tables.gen_tab_*`` writes 8 ``tab_<name>.tex``
  files into ``paper_artifacts/tables/``. Both the legacy nested-dict
  ``all_results[_quick].json`` (when present) and the new RunRecord glob are
  searched; whichever is available is used.
* **Figures**     -- ``gen_figures.render_all`` writes 5 ``fig_<name>.pdf``
  + ``fig_<name>.png`` pairs into ``paper_artifacts/figures/``.
* **Analysis**    -- ``analysis.run_all_analyses`` writes an
  ``analysis_results.json`` into the benchmark dir AND copies it to
  ``paper_artifacts/analysis/``.

CLI::

    python -m projects.agent_builder.scripts.whatif_bench.experiments.build_paper_artifacts \\
        --results-glob 'experiments/results/canon_*.json' \\
        --granularity   daily

Output tree (experiments/paper_artifacts/ -- experiment artifacts, NOT
under data_small_caps/, which is reserved for raw + derived data)::

    experiments/paper_artifacts/
        aggregate.parquet
        leaderboard.txt          (per-task primary-metric leaderboard)
        tables/   tab_*.tex
        figures/  fig_*.pdf, fig_*.png
        analysis/ analysis_results.json
"""

from __future__ import annotations

import argparse
import glob
import json
import logging
import shutil
from pathlib import Path
from typing import Any

from .. import config
from . import analysis as analysis_mod
from . import gen_figures
from . import gen_tables
from . import panel
from .aggregate_results import (
    _PRIMARY_METRIC_KEY,
    _PRIMARY_METRIC_LOWER_IS_BETTER,
    aggregate,
    print_summary,
)


logger = logging.getLogger(__name__)


def _legacy_results_dict(granularity: str) -> dict[str, Any]:
    """Return the legacy nested-dict ``all_results[_quick].json`` if present.

    These files used to live under ``data_small_caps/benchmark/<g>/`` but
    moved to ``experiments/results/legacy_per_family/`` once experiment
    outputs were separated from the benchmark tree. The granularity
    argument is kept for API compatibility with older callers; the
    legacy aggregates are not per-granularity (the file was overwritten
    by each granularity's runner).
    """
    del granularity  # legacy aggregates are not per-granularity on disk
    legacy_dir = Path(__file__).resolve().parent / "results" / "legacy_per_family"
    for cand in ("all_results.json", "all_results_quick.json"):
        p = legacy_dir / cand
        if p.exists():
            try:
                return json.loads(p.read_text())
            except (OSError, json.JSONDecodeError) as exc:
                logger.warning("could not read %s: %s", p, exc)
    return {}


def _write_leaderboard(per_task, output_path: Path) -> None:
    lines: list[str] = []
    lines.append("=== MacroLens leaderboard (per-task, primary-metric ranked) ===\n")
    for task in panel.ALL_TASKS:
        df = per_task.get(task)
        primary = _PRIMARY_METRIC_KEY.get(task, "?")
        if df is None or df.empty:
            lines.append(f"\n[{task}] (no records)\n")
            continue
        sub = df[df["metric_name"] == primary].dropna(subset=["value"]).copy()
        if sub.empty:
            lines.append(f"\n[{task}] primary metric '{primary}' missing.\n")
            continue
        agg = (sub.groupby(["method_id", "method_family"])["value"]
                  .mean().reset_index())
        ascending = _PRIMARY_METRIC_LOWER_IS_BETTER.get(task, True)
        agg = agg.sort_values("value", ascending=ascending).reset_index(drop=True)
        direction = "lower" if ascending else "higher"
        lines.append(f"\n[{task}] primary={primary} ({direction}=better):\n")
        for i, row in agg.iterrows():
            lines.append(f"  {i+1:2d}. {row['method_id']:30s} "
                         f"({row['method_family']:18s}) {row['value']:10.4f}\n")
    output_path.write_text("".join(lines))


def build(
    *,
    results_glob: str,
    granularity: str,
    output_dir: Path,
    quick: bool = False,
) -> dict[str, Any]:
    """Build every paper artefact under *output_dir*.

    Returns a manifest dict with the on-disk paths of the produced
    artefacts (handy for downstream LaTeX-build orchestration / CI).
    """
    output_dir = Path(output_dir)
    tables_dir = output_dir / "tables"
    figs_dir = output_dir / "figures"
    analysis_dir = output_dir / "analysis"
    for d in (output_dir, tables_dir, figs_dir, analysis_dir):
        d.mkdir(parents=True, exist_ok=True)

    manifest: dict[str, Any] = {
        "results_glob": results_glob,
        "granularity": granularity,
        "tables": {},
        "figures": {},
        "analysis": None,
        "leaderboard": None,
        "aggregate_parquet": None,
    }

    # 1. Aggregate RunRecord JSONs.
    parquet_path = output_dir / "aggregate.parquet"
    per_task = aggregate(input_glob=results_glob, output_path=parquet_path)
    manifest["aggregate_parquet"] = str(parquet_path) if parquet_path.exists() else None

    # 2. Per-task leaderboard.
    leaderboard_path = output_dir / "leaderboard.txt"
    _write_leaderboard(per_task, leaderboard_path)
    manifest["leaderboard"] = str(leaderboard_path)
    print_summary(per_task)

    # 3. LaTeX tables (use legacy nested-dict if available; tables degrade
    #    gracefully to "--" otherwise).
    legacy = _legacy_results_dict(granularity)
    table_calls: list[tuple[str, Any]] = [
        ("tsf",        gen_tables.gen_tab_tsf(legacy, granularity)),
        ("valuation",  gen_tables.gen_tab_valuation(legacy)),
        ("generation", gen_tables.gen_tab_generation(legacy)),
        ("scenario",   gen_tables.gen_tab_scenario(legacy)),
        ("re",         gen_tables.gen_tab_re(legacy)),
        ("zs_vs_ft",   gen_tables.gen_tab_zs_vs_ft(legacy, granularity)),
        ("ablation",   gen_tables.gen_tab_ablation(legacy)),
        ("panel",      gen_tables.gen_tab_panel_summary()),
    ]
    for name, body in table_calls:
        path = tables_dir / f"tab_{name}.tex"
        path.write_text(body)
        manifest["tables"][name] = str(path)

    # 4. Figures.
    long_df = None
    try:
        # Reuse the long-form DataFrame already produced by aggregate(); we
        # have to re-build it because aggregate() returns per-task split.
        from .aggregate_results import _load_records, _records_to_long_df
        paths = [Path(p) for p in sorted(glob.glob(results_glob))]
        recs, _, _ = _load_records(paths)
        long_df = _records_to_long_df(recs)
    except Exception as exc:  # pragma: no cover -- defensive
        logger.warning("could not build long-form DF for figures: %s", exc)
    if long_df is None:
        import pandas as pd
        long_df = pd.DataFrame()
    fig_outputs = gen_figures.render_all(
        long_df, figs_dir, granularity=granularity, quick=quick,
    )
    manifest["figures"] = {
        n: {"pdf": str(pdf), "png": str(png)} for n, (pdf, png) in fig_outputs.items()
    }

    # 5. Stratified analysis.
    try:
        analysis_results = analysis_mod.run_all_analyses(granularity)
        analysis_out = analysis_dir / "analysis_results.json"
        analysis_out.write_text(json.dumps(analysis_results, indent=2, default=str))
        manifest["analysis"] = str(analysis_out)
    except Exception as exc:
        logger.warning("analysis pipeline failed: %s", exc)
        manifest["analysis_error"] = str(exc)

    # 6. Manifest.
    manifest_path = output_dir / "manifest.json"
    manifest_path.write_text(json.dumps(manifest, indent=2, default=str))
    return manifest


def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--results-glob", type=str,
        # Results live under experiments/results/, NOT data_small_caps/.
        default=str(Path(__file__).parent / "results" / "canon_*.json"),
    )
    parser.add_argument(
        "--granularity", default="daily",
        choices=["daily", "weekly", "monthly"],
    )
    parser.add_argument(
        "--output-dir", type=Path,
        default=Path(__file__).parent / "paper_artifacts",
    )
    parser.add_argument("--quick", action="store_true",
                        help="Downsample inputs to keep CI runs fast.")
    args = parser.parse_args(argv)

    logging.basicConfig(level=logging.INFO, format="%(levelname)s  %(message)s")
    manifest = build(
        results_glob=args.results_glob,
        granularity=args.granularity,
        output_dir=args.output_dir,
        quick=args.quick,
    )
    logger.info("paper artefacts manifest: %s", manifest.get("aggregate_parquet"))
    return 0


if __name__ == "__main__":  # pragma: no cover
    import sys
    sys.exit(main())