build.py

"""End-to-end build: normalize → incremental vectors → BM25 → graph → package.

Default mode is ``auto``: skip when the endomorphosis source revision is
unchanged, otherwise delta-refresh embeddings by ``entry_cid`` and rebuild
BM25/graph from the current corpus. Publication to ``justicedao/*`` is opt-in
via ``upload=True``.
"""

from __future__ import annotations

import os

import json

import pandas as pd
import traceback
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

from .sparse import export_sparse_graphrag
from .mem import MemAbort, checkpoint, log_mem
from .spill import spill_dir_for, spill_pickle
from .package import package_from_spill, package_release
from .catalog import get_country, indexable_countries, is_local_law_pack, target_repo

from .incremental import (
    fetch_hub_prior,
    load_embedding_cache,
    load_prior_release,
    load_release_vectors_by_cid,
    merge_embedding_maps,
    plan_rebuild,
    save_embedding_cache,
)
from .normalize import build_corpus, load_source
from .auth import configure_hf
from .vectors import (
    DIMENSION,
    MODEL_NAME,
    assemble_embeddings,
    embeddings_by_cid,
    layout_stub_vectors,
    layout_vectors,
    select_device,
)

ROOT = Path(os.environ.get("COUNTRY_LAWS_IR_ROOT", str(Path.home() / ".ipfs_datasets" / "country-laws-ir")))
CACHE = ROOT / "cache"
RELEASES = ROOT / "releases"
REPORTS = ROOT / "reports"
PROGRESS = ROOT / "progress.jsonl"


def _log(msg: str) -> None:
    ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
    print(f"[{ts}] {msg}", flush=True)


def record_progress(event: dict[str, Any]) -> None:
    event = dict(event)
    event.setdefault("ts", datetime.now(timezone.utc).isoformat())
    PROGRESS.parent.mkdir(parents=True, exist_ok=True)
    lock_path = PROGRESS.with_suffix(".lock")
    with lock_path.open("a", encoding="utf-8") as lock_fh:
        try:
            import fcntl

            fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX)
        except Exception:
            pass
        with PROGRESS.open("a", encoding="utf-8") as f:
            f.write(json.dumps(event, ensure_ascii=False) + "\n")


def _prior_dir_for(
    slug: str,
    out: Path,
    prior_dir: Path | None,
    *,
    fetch_hub: bool = True,
) -> Path | None:
    if prior_dir is not None:
        return Path(prior_dir)
    if out.is_dir() and (out / "manifest.json").is_file():
        return out
    default = RELEASES / f"ipfs_{slug}_laws_ir"
    if default.is_dir() and (default / "manifest.json").is_file() and default.resolve() != out.resolve():
        return default
    if not fetch_hub:
        return None
    hub = fetch_hub_prior(slug, cache_root=CACHE / "hub-ir")
    if hub is not None:
        _log(f"using justicedao prior {hub}")
    return hub


def _encode_vectors(
    *,
    corpus: pd.DataFrame,
    country_slug: str,
    prior,
    plan,
    skip_vectors: bool,
    device: str,
) -> tuple[dict[str, Any], str | None, dict[str, Any]]:
    import gc

    vector_report: dict[str, Any] = {"status": "stub"}
    vector_blocker = None
    if skip_vectors:
        vectors = layout_stub_vectors(corpus, reason="skip_vectors flag")
        return vectors, "skip_vectors", {"status": "stub", "reason": "skip_vectors"}

    cid_cache_path = CACHE / "embeddings" / f"{country_slug}_by_cid.parquet"
    prior_by_cid = {}
    if plan.reuse_embeddings:
        prior_by_cid = merge_embedding_maps(
            load_embedding_cache(cid_cache_path),
            None if prior is None else load_release_vectors_by_cid(prior.directory),
        )
        _log(f"embedding cache reused_cids={len(prior_by_cid)}")
    try:
        positional = CACHE / "embeddings" / f"{country_slug}.npy"
        resolved, fallback = select_device(device)
        if fallback:
            _log(f"embedding device fallback requested={device} using={resolved}")
        embeddings, vector_report = assemble_embeddings(
            corpus,
            prior_by_cid,
            encode_missing=True,
            device=resolved,
            checkpoint_path=str(positional),
        )
        if (
            vector_report.get("status") in {"stub_missing_encoder", "incomplete"}
            and not int(vector_report.get("n_reused") or 0)
        ):
            vector_blocker = vector_report.get("reason") or vector_report.get("status")
            vectors = layout_stub_vectors(corpus, reason=str(vector_blocker))
            return vectors, vector_blocker, vector_report
        vectors = layout_vectors(corpus, embeddings)
        if int(vector_report.get("n_reused") or 0) and vector_report.get("status") != "reused":
            vectors["stats"]["status"] = "partial"
            vectors["stats"]["n_reused"] = int(vector_report.get("n_reused") or 0)
            vectors["stats"]["n_missing"] = int(vector_report.get("n_missing") or 0)
            vector_blocker = vector_report.get("reason") or vector_report.get("status")
        save_embedding_cache(
            cid_cache_path,
            merge_embedding_maps(prior_by_cid, embeddings_by_cid(corpus, embeddings)),
            model_name=MODEL_NAME,
            dimension=DIMENSION,
        )
        del embeddings
        gc.collect()
        _log(
            f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']} "
            f"reused={vector_report.get('n_reused')} encoded={vector_report.get('n_encoded')}"
        )
        return vectors, None, vector_report
    except Exception as exc:
        vector_blocker = f"embedding_failed: {exc}"
        _log(f"vector embedding failed; writing stub ({exc})")
        vectors = layout_stub_vectors(corpus, reason=vector_blocker)
        return vectors, vector_blocker, {"status": "failed", "reason": str(exc)}


def build_country(
    source: str,
    out: Path | None = None,
    upload: bool = False,
    device: str = "cuda",
    neighbor_k: int = 8,
    skip_vectors: bool = False,
    mode: str = "auto",
    force: bool = False,
    prior_dir: Path | None = None,
    fetch_hub_prior_ir: bool = True,
    renormalize: bool = False,
) -> dict[str, Any]:
    from .normalize import preflight_local_shard_source

    preflight_local_shard_source(source)
    country = get_country(source)
    if not country.get("indexable", True):
        raise RuntimeError(f"{country['repo']} is excluded: {country.get('skip_reason')}")
    repo = country["repo"]
    out = Path(out) if out else RELEASES / f"ipfs_{country['slug']}_laws_ir"
    local_dir = country.get("local_source_dir") or (
        str(Path(source).resolve()) if is_local_law_pack(Path(source)) else None
    )
    _log(
        f"build start {repo} -> {out} "
        f"(upload={upload} mode={mode} force={force} renormalize={renormalize}) local={local_dir}"
    )
    configure_hf()
    CACHE.mkdir(parents=True, exist_ok=True)
    REPORTS.mkdir(parents=True, exist_ok=True)
    laws, articles, source_meta = load_source(local_dir or repo, CACHE)
    _log(
        f"source loaded laws={source_meta['n_laws_source']} "
        f"articles={source_meta['n_articles_source']} rev={source_meta['source_revision']}"
    )
    prior = load_prior_release(
        _prior_dir_for(
            country["slug"],
            out,
            prior_dir,
            fetch_hub=fetch_hub_prior_ir,
        )
    )
    plan = plan_rebuild(
        mode=mode,
        source_meta=source_meta,
        prior=prior,
        force=force,
        rebuild_stub_vectors=not skip_vectors,
    )
    if plan.skip_build and not renormalize:
        _log(f"skip unchanged {country['slug']} rev={plan.source_revision}")
        result = {
            "country": country["slug"],
            "source": repo,
            "source_revision": source_meta["source_revision"],
            "out": str(out),
            "target_hub_id": target_repo(country["slug"]),
            "skipped": True,
            "incremental": plan.to_dict(),
            "normalization": {"n_out": plan.delta.current_count if plan.delta else 0},
            "vector_blocker": None,
            "neighbor_via": None,
            "schema_version": "country-laws-ir-graphrag/v1",
        }
        record_progress({"event": "skipped_unchanged", **{k: v for k, v in result.items() if k != "normalization"}})
        return result

    corpus, norm_report = build_corpus(laws, articles, source_meta)
    report_path = REPORTS / f"{country['slug']}_normalization.json"
    report_path.write_text(json.dumps(norm_report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
    (REPORTS / "normalization.json").write_text(
        json.dumps(norm_report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
    )
    _log(
        f"normalized docs={len(corpus)} unit={norm_report['unit']} "
        f"dropped={norm_report['n_dropped_total']} report={report_path}"
    )
    if corpus.empty:
        raise RuntimeError("Normalized corpus is empty; refusing to package")
    verdict = (norm_report or {}).get("verification") or {}
    if verdict.get("blocks_graphrag") and not force:
        from .verify import NormalizationAdmissionError

        raise NormalizationAdmissionError(
            f"{country['slug']} failed normalization verifiers: {verdict.get('failed_ids')}"
        )

    import gc

    plan = plan_rebuild(
        mode=mode,
        source_meta=source_meta,
        prior=prior,
        current_corpus=corpus,
        force=force,
        rebuild_stub_vectors=not skip_vectors,
        compare_normalized=renormalize and not force,
    )
    _log(
        f"rebuild kind={plan.kind.value} reuse_embeddings={plan.reuse_embeddings} "
        f"added={0 if plan.delta is None else plan.delta.n_added} "
        f"removed={0 if plan.delta is None else plan.delta.n_removed}"
    )
    if plan.skip_build:
        _log(f"skip unchanged after normalize {country['slug']}")
        result = {
            "country": country["slug"],
            "source": repo,
            "source_revision": source_meta["source_revision"],
            "out": str(out),
            "target_hub_id": target_repo(country["slug"]),
            "skipped": True,
            "incremental": plan.to_dict(),
            "normalization": {
                "n_out": norm_report.get("n_out"),
                "unit": norm_report.get("unit"),
                "n_law_rows": norm_report.get("n_law_rows"),
                "n_child_rows": norm_report.get("n_child_rows"),
            },
            "vector_blocker": None,
            "neighbor_via": None,
            "schema_version": "country-laws-ir-graphrag/v1",
        }
        record_progress({"event": "skipped_unchanged", **{k: v for k, v in result.items() if k != "normalization"}})
        return result

    n_docs = len(corpus)
    spill = spill_dir_for(country["slug"], CACHE)
    spill.mkdir(parents=True, exist_ok=True)
    corpus_ckpt = CACHE / f"{country['slug']}_corpus.parquet"
    corpus.to_parquet(corpus_ckpt, index=False)
    checkpoint("after_normalize", log=_log)

    vectors, vector_blocker, vector_report = _encode_vectors(
        corpus=corpus,
        country_slug=country["slug"],
        prior=prior,
        plan=plan,
        skip_vectors=skip_vectors,
        device=device,
    )
    spill_pickle(spill / "vectors.pkl", vectors)
    del vectors
    gc.collect()
    checkpoint("vectors_spilled", log=_log)
    extra_manifest = {"incremental": {**plan.to_dict(), "vectors": vector_report}}

    neighbor_via = "hf_graphrag"
    if out.exists():
        import shutil as _shutil

        _shutil.rmtree(out)
    out.mkdir(parents=True, exist_ok=True)
    _log(f"sparse GraphRAG via hf_graphrag.bm25/graph parquet builders n={n_docs}")
    sparse_report = export_sparse_graphrag(corpus, out)
    extra_manifest["sparse"] = sparse_report
    with open(spill / "vectors.pkl", "rb") as _vf:
        import pickle as _pickle

        vectors = _pickle.load(_vf)
    dummy_bm25 = {
        "documents": pd.DataFrame(),
        "postings": pd.DataFrame(),
        "stats": (sparse_report.get("bm25") or {}).get("bm25")
        or (sparse_report.get("bm25") or {}),
    }
    dummy_graph = {
        "nodes": pd.DataFrame(),
        "edges": pd.DataFrame(),
        "incoming": pd.DataFrame(),
        "outgoing": pd.DataFrame(),
        "stats": sparse_report.get("graph") or {},
    }
    code_root = Path(__file__).resolve().parent.parent
    manifest = package_release(
        out,
        corpus,
        dummy_bm25,
        dummy_graph,
        vectors,
        source_meta,
        country,
        code_root,
        normalization_report=norm_report,
        extra_manifest=extra_manifest,
        wipe=False,
        skip_bm25_graph=True,
    )
    del corpus, vectors
    gc.collect()
    _log(f"packaged {out}")
    result = {
        "country": country["slug"],
        "source": repo,
        "source_revision": source_meta["source_revision"],
        "out": str(out),
        "target_hub_id": target_repo(country["slug"]),
        "counts": manifest["counts"],
        "normalization": norm_report,
        "vector_blocker": vector_blocker,
        "neighbor_via": neighbor_via,
        "schema_version": manifest["schema_version"],
        "skipped": False,
        "incremental": extra_manifest["incremental"],
    }
    if upload:
        from .upload import upload_release

        hub = upload_release(out, target_repo(country["slug"]))
        result["hub"] = hub
        _log(f"uploaded {hub['url']} rev={hub['revision']}")
        record_progress({"event": "uploaded", **result})
    else:
        record_progress({"event": "built_local", **{k: v for k, v in result.items() if k != "normalization"}})
    return result


def batch(
    slugs: list[str] | None = None,
    upload: bool = False,
    skip_done: bool = True,
    mode: str = "auto",
    force: bool = False,
    skip_vectors: bool = False,
) -> list[dict[str, Any]]:
    """Build every indexable country. Unchanged Hub revisions are skipped in auto mode.

    ``skip_done`` is kept for compatibility: it no longer skips a country whose
    source revision changed. Pass ``force=True`` (or ``--no-skip-done``) to
    rebuild regardless of CID overlap.
    """
    targets = slugs or [c["slug"] for c in indexable_countries()]
    if "malta" in targets:
        targets = ["malta"] + [s for s in targets if s != "malta"]
    results = []
    rebuild_force = force or not skip_done
    for slug in targets:
        try:
            results.append(
                build_country(
                    slug,
                    upload=upload,
                    mode=mode,
                    force=rebuild_force,
                    skip_vectors=skip_vectors,
                )
            )
        except Exception as exc:
            _log(f"FAILED {slug}: {exc}")
            record_progress(
                {
                    "event": "failed",
                    "country": slug,
                    "error": str(exc),
                    "traceback": traceback.format_exc(),
                }
            )
            continue
    return results


def reindex_from_gaps(
    *,
    upload: bool = False,
    slugs: list[str] | None = None,
    limit: int | None = None,
    max_corpus_rows: int | None = 20_000,
    skip_vectors: bool = False,
    workers: int = 4,
    mode: str = "auto",
    force: bool = False,
    all_indexable: bool = False,
    device: str = "cuda",
    renormalize: bool = False,
    corpus_rows: dict[str, int] | None = None,
) -> list[dict[str, Any]]:
    """Rebuild country IR. Default is Hub gaps; ``all_indexable`` processes every catalog country.

    ``workers`` is a ceiling. Live memory, disk, and free GPU memory shrink it,
    and a full host backs off instead of starting another country. Default cap
    skips huge corpora (Finland, Dominican Republic). Pass
    ``max_corpus_rows=None`` to include them.
    """
    from .catalog import indexable_countries
    from .coverage import gap_report

    if slugs is None:
        if all_indexable:
            rows = [{"slug": c["slug"], "corpus_rows": 0} for c in indexable_countries()]
            _log(f"reindex all indexable n={len(rows)}")
        else:
            report = gap_report(workers=workers)
            rows = [c for c in report["countries"] if c.get("rebuild")]
            _log(
                f"reindex targets n={len(rows)} "
                f"(from scan rebuild={len(report.get('rebuild') or [])})"
            )
        rows.sort(key=lambda r: int(r.get("corpus_rows") or 0))
        if max_corpus_rows is not None:
            rows = [
                r
                for r in rows
                if int(r.get("corpus_rows") or 0) <= int(max_corpus_rows)
            ]
        if limit is not None:
            rows = rows[: int(limit)]
        queued = [(str(r["slug"]), int(r.get("corpus_rows") or 0)) for r in rows]
    else:
        known = corpus_rows or {}
        queued = [(str(slug), int(known.get(str(slug)) or 0)) for slug in slugs]
    kwargs = {
        "upload": upload,
        "mode": mode,
        "force": force,
        "skip_vectors": skip_vectors,
        "fetch_hub_prior_ir": True,
        "device": device,
        "renormalize": renormalize,
    }
    ceiling = max(1, int(workers or 1))
    _log(f"reindex adaptive ceiling={ceiling} countries={len(queued)} device={device}")
    return _run_adaptive(queued, kwargs, ceiling)


def _run_adaptive(
    queued: list[tuple[str, int]],
    kwargs: dict[str, Any],
    ceiling: int,
) -> list[dict[str, Any]]:
    """Start countries only while memory, disk, and a GPU have room."""

    import multiprocessing as mp
    import time
    from concurrent.futures import FIRST_COMPLETED, ProcessPoolExecutor, wait

    from .resources import (
        admit_parallelism,
        assign_device,
        backoff_seconds,
        can_admit,
        job_slots,
        probe_host,
    )

    try:
        mp.set_start_method("spawn", force=False)
    except RuntimeError:
        pass

    pending = list(enumerate(queued))
    inflight: dict[Any, tuple[int, str, str, int]] = {}
    results: list[dict[str, Any] | None] = [None] * len(queued)
    pressure = 0
    last_sig: tuple[Any, ...] | None = None
    requested = str(kwargs.get("device") or "cuda")
    with ProcessPoolExecutor(max_workers=ceiling, max_tasks_per_child=1) as pool:
        while pending or inflight:
            snap = probe_host()
            admission = admit_parallelism(snap, ceiling=ceiling)
            devices = admission.devices
            if requested == "cpu":
                devices = ("cpu",) if admission.workers else ()
            elif requested.startswith("cuda:") and requested not in devices:
                devices = ()
            limit = admission.workers if devices else 0
            signature = (limit, devices, admission.reason)
            if signature != last_sig:
                _log(
                    f"admit workers={limit} devices={list(devices)} reason={admission.reason} "
                    f"mem={snap.mem_available_gib:.1f}G disk={snap.disk_free_gib:.0f}G "
                    f"inflight={len(inflight)} pending={len(pending)}"
                )
                last_sig = signature
            used = sum(item[3] for item in inflight.values())
            started = False
            while pending and devices:
                _idx, (_source, rows) = pending[0]
                cost = job_slots(rows)
                if not can_admit(used, limit, cost):
                    break
                device = assign_device(devices, tuple(item[2] for item in inflight.values()))
                idx, (source, _rows) = pending.pop(0)
                held = limit if cost >= 1_000_000 else cost
                task_kwargs = dict(kwargs)
                task_kwargs["device"] = device
                future = pool.submit(_reindex_one_country, (source, task_kwargs))
                inflight[future] = (idx, source, device, held)
                used += held
                started = True
                _log(f"admit start {source} device={device} slots={cost}")
            if started:
                pressure = 0
            if inflight:
                done, _pending_futs = wait(
                    set(inflight), timeout=5.0, return_when=FIRST_COMPLETED
                )
                for future in done:
                    idx, source, _device, _held = inflight.pop(future)
                    try:
                        results[idx] = future.result()
                    except Exception as exc:
                        _log(f"FAILED {source}: {exc}")
                        results[idx] = {"country": source, "skipped": False, "error": str(exc)}
                continue
            if not pending:
                break
            delay = backoff_seconds(admission.backoff_s or 15.0, pressure)
            pressure += 1
            _log(f"backoff {delay:.0f}s reason={admission.reason} pressure={pressure}")
            time.sleep(delay)
    return [row for row in results if row is not None]


def _reindex_one_country(item: tuple[str, dict[str, Any]]) -> dict[str, Any]:
    slug, kwargs = item
    _log(f"reindex start {slug}")
    try:
        return build_country(slug, **kwargs)
    except Exception as exc:
        _log(f"FAILED {slug}: {exc}")
        record_progress(
            {
                "event": "failed",
                "country": slug,
                "error": str(exc),
                "traceback": traceback.format_exc(),
            }
        )
        return {"country": slug, "skipped": False, "error": str(exc)}