code/verify_factor_intervention_cache.py

from __future__ import annotations

import argparse
from collections import Counter
import hashlib
import json
from pathlib import Path
import time

import torch
from safetensors.torch import load_file


EXPECTED_ROWS = 108_096
EXPECTED_TRAIN = 104_000
EXPECTED_VALIDATION = 4_096
EXPECTED_ANCHORS = 72_000
EXPECTED_VERSION = "lens-safe-v4"
COMPARE_FIELDS = (
    "source_record_id",
    "style_id",
    "source",
    "split",
    "shard",
    "factor",
    "factor_index",
    "family",
    "level",
    "sign",
    "signed_intensity",
    "operation_seed",
    "transform_version",
    "anchor_kind",
    "repeat_of",
    "panel",
    "anima_pilot",
)


def read_json(path: Path) -> dict:
    return json.loads(path.read_text(encoding="utf-8"))


def read_jsonl(path: Path) -> list[dict]:
    with path.open(encoding="utf-8") as handle:
        return [json.loads(line) for line in handle if line.strip()]


def distribution(rows: list[dict]) -> dict[str, dict[str, int]]:
    output = {}
    for field in ("split", "source", "factor", "family", "level", "anchor_kind"):
        output[field] = dict(sorted(Counter(str(row[field]) for row in rows).items()))
    return output


def read_packed_sources(root: Path, needed: set[str], errors: list[str]) -> dict[str, dict]:
    sources: dict[str, dict] = {}
    paths = sorted(root.glob("train-rank*/features-*.json")) + sorted(
        root.glob("validation-*/features-*.json")
    )
    if not paths:
        add_error(errors, f"packed metadata is missing under {root}")
        return sources
    for path in paths:
        try:
            rows = read_json(path).get("records", [])
        except (OSError, json.JSONDecodeError) as error:
            add_error(errors, f"invalid packed metadata {path}: {error}")
            continue
        for row in rows:
            record_id = str(row.get("record_id"))
            if record_id not in needed:
                continue
            if record_id in sources:
                add_error(errors, f"duplicate source record in packed metadata: {record_id}")
            sources[record_id] = row
    return sources


def add_error(errors: list[str], message: str) -> None:
    if len(errors) < 100:
        errors.append(message)


def main() -> int:
    parser = argparse.ArgumentParser(description="Verify the factor-intervention feature cache.")
    parser.add_argument("--run-root", type=Path, required=True)
    parser.add_argument("--packed-root", type=Path, required=True)
    parser.add_argument("--output", type=Path)
    args = parser.parse_args()

    started = time.perf_counter()
    manifest_path = args.run_root / "manifest.jsonl"
    cache = args.run_root / "full_external"
    output = args.output or args.run_root / "verification.json"
    errors: list[str] = []

    manifest_rows = read_jsonl(manifest_path)
    manifest_sha256 = hashlib.sha256(manifest_path.read_bytes()).hexdigest()
    manifest_by_id = {str(row["record_id"]): row for row in manifest_rows}
    if len(manifest_by_id) != len(manifest_rows):
        add_error(errors, "manifest contains duplicate record IDs")
    if len(manifest_rows) != EXPECTED_ROWS:
        add_error(errors, f"manifest row count {len(manifest_rows)} != {EXPECTED_ROWS}")
    if sum(row["split"] == "train" for row in manifest_rows) != EXPECTED_TRAIN:
        add_error(errors, "manifest train count mismatch")
    if sum(row["split"] == "validation" for row in manifest_rows) != EXPECTED_VALIDATION:
        add_error(errors, "manifest validation count mismatch")
    train_anchors = {row["source_record_id"] for row in manifest_rows if row["split"] == "train"}
    if len(train_anchors) != EXPECTED_ANCHORS:
        add_error(errors, f"unique train anchors {len(train_anchors)} != {EXPECTED_ANCHORS}")
    if {row.get("transform_version") for row in manifest_rows} != {EXPECTED_VERSION}:
        add_error(errors, "manifest transform version mismatch")

    train_rows = [row for row in manifest_rows if row["split"] == "train"]
    validation_rows = [row for row in manifest_rows if row["split"] == "validation"]
    train_source_ids = {row["source_record_id"] for row in train_rows}
    validation_source_ids = {row["source_record_id"] for row in validation_rows}
    if train_source_ids & validation_source_ids:
        add_error(errors, "train and validation source records overlap")
    train_style_ids = {row["style_id"] for row in train_rows}
    validation_style_ids = {row["style_id"] for row in validation_rows}
    if train_style_ids & validation_style_ids:
        add_error(errors, "train and validation style identities overlap")

    for row in train_rows:
        repeat_of = row.get("repeat_of")
        if repeat_of is None:
            continue
        base = manifest_by_id.get(str(repeat_of))
        if base is None:
            add_error(errors, f"repeat base is missing: {repeat_of}")
            continue
        for field in ("source_record_id", "style_id", "source", "factor", "family", "sign"):
            if row.get(field) != base.get(field):
                add_error(errors, f"repeat pair differs in {field}: {row['record_id']}")
                break
        if row.get("level") == base.get("level"):
            add_error(errors, f"repeat pair has identical intensity: {row['record_id']}")

    source_ids = {row["source_record_id"] for row in manifest_rows}
    packed_sources = read_packed_sources(args.packed_root, source_ids, errors)
    missing_sources = source_ids - set(packed_sources)
    if missing_sources:
        add_error(errors, f"source IDs absent from packed metadata: {len(missing_sources)}")
    for row in manifest_rows:
        source = packed_sources.get(row["source_record_id"])
        if source is None:
            continue
        for field in ("style_id", "source", "split", "shard"):
            if row.get(field) != source.get(field):
                add_error(errors, f"{row['record_id']}: source {field} alignment mismatch")
                break

    summaries = []
    for worker in range(4):
        path = cache / f"intervention-worker-{worker}.json"
        try:
            summary = read_json(path)
        except (FileNotFoundError, OSError, json.JSONDecodeError) as error:
            add_error(errors, f"invalid worker summary {worker}: {error}")
            continue
        summaries.append(summary)
        if summary.get("status") != "complete" or summary.get("mode") != "full":
            add_error(errors, f"worker {worker} is not complete/full")
        if summary.get("manifest_sha256") != manifest_sha256:
            add_error(errors, f"worker {worker} manifest hash mismatch")
    if sum(int(row.get("records", 0)) for row in summaries) != EXPECTED_ROWS:
        add_error(errors, "worker summary row total mismatch")

    json_parts = sorted(cache.glob("intervention-w*-p*.json"))
    tensor_parts = sorted(cache.glob("intervention-w*-p*.safetensors"))
    json_stems = {path.stem for path in json_parts}
    tensor_stems = {path.name.removesuffix(".safetensors") for path in tensor_parts}
    if json_stems != tensor_stems:
        add_error(errors, "JSON/safetensors part pairing mismatch")
    temporary_files = sorted(cache.glob(".*.tmp"))
    if temporary_files:
        add_error(errors, f"temporary part files remain: {temporary_files[0].name}")

    cached_ids: set[str] = set()
    cached_rows: list[dict] = []
    part_indices: dict[int, list[int]] = {worker: [] for worker in range(4)}
    finite_tensors = 0
    tensor_bytes = 0
    for metadata_path in json_parts:
        try:
            metadata = read_json(metadata_path)
        except (OSError, json.JSONDecodeError) as error:
            add_error(errors, f"invalid part metadata {metadata_path.name}: {error}")
            continue
        worker = int(metadata.get("worker_index", -1))
        part_index = int(metadata.get("part_index", -1))
        if worker not in part_indices:
            add_error(errors, f"invalid worker index in {metadata_path.name}")
            continue
        part_indices[worker].append(part_index)
        if metadata.get("manifest_sha256") != manifest_sha256:
            add_error(errors, f"manifest hash mismatch in {metadata_path.name}")
        if metadata.get("kind") != "factor_intervention_full_face":
            add_error(errors, f"feature kind mismatch in {metadata_path.name}")
        if metadata.get("backbone") != "siglip2_so400m" or metadata.get("layer_indices") != [6, 14, 26]:
            add_error(errors, f"backbone metadata mismatch in {metadata_path.name}")
        records = metadata.get("records", [])
        tensor_path = metadata_path.with_suffix(".safetensors")
        try:
            tensors = load_file(tensor_path, device="cpu")
        except Exception as error:
            add_error(errors, f"cannot load {tensor_path.name}: {error}")
            continue
        tensor_bytes += tensor_path.stat().st_size
        expected = {
            "full": ((len(records), 30, 1152), torch.bfloat16),
            "face": ((len(records), 30, 1152), torch.bfloat16),
            "face_mask": ((len(records),), torch.bool),
        }
        if set(tensors) != set(expected):
            add_error(errors, f"tensor keys mismatch in {tensor_path.name}")
        valid_contract = True
        for name, (shape, dtype) in expected.items():
            tensor = tensors.get(name)
            if tensor is None or tuple(tensor.shape) != shape or tensor.dtype != dtype:
                add_error(errors, f"{name} contract mismatch in {tensor_path.name}")
                valid_contract = False
                continue
            if not torch.isfinite(tensor).all().item():
                add_error(errors, f"non-finite {name} tensor in {tensor_path.name}")
                valid_contract = False
        if valid_contract:
            finite_tensors += len(expected)
        if "face_mask" in tensors and len(records) == tensors["face_mask"].shape[0]:
            declared = torch.tensor([bool(row.get("face_present")) for row in records])
            if not torch.equal(declared, tensors["face_mask"]):
                add_error(errors, f"face mask/metadata mismatch in {tensor_path.name}")
        for row in records:
            record_id = str(row.get("record_id"))
            if record_id in cached_ids:
                add_error(errors, f"duplicate cached record ID: {record_id}")
            cached_ids.add(record_id)
            cached_rows.append(row)
            manifest_row = manifest_by_id.get(record_id)
            if manifest_row is None:
                add_error(errors, f"cached ID absent from manifest: {record_id}")
                continue
            for field in COMPARE_FIELDS:
                if row.get(field) != manifest_row.get(field):
                    add_error(errors, f"{record_id}: {field} differs from manifest")
                    break
            if row.get("source_shard") != row.get("shard"):
                add_error(errors, f"{record_id}: source shard alignment mismatch")

    for worker, indices in part_indices.items():
        if sorted(indices) != list(range(len(indices))):
            add_error(errors, f"worker {worker} part indices are not contiguous")
    missing_ids = set(manifest_by_id) - cached_ids
    extra_ids = cached_ids - set(manifest_by_id)
    if missing_ids:
        add_error(errors, f"missing cached IDs: {len(missing_ids)}")
    if extra_ids:
        add_error(errors, f"extra cached IDs: {len(extra_ids)}")
    if len(cached_rows) != EXPECTED_ROWS:
        add_error(errors, f"cached row count {len(cached_rows)} != {EXPECTED_ROWS}")

    manifest_distribution = distribution(manifest_rows)
    cache_distribution = distribution(cached_rows)
    if cache_distribution != manifest_distribution:
        add_error(errors, "cached distribution differs from manifest")

    expected_pilot_ids = {
        row["record_id"] for row in manifest_rows if bool(row.get("anima_pilot"))
    }
    pilot_dir = args.run_root / "anima_pilot_images"
    actual_pilot_ids = {path.stem for path in pilot_dir.glob("*.webp")}
    if actual_pilot_ids != expected_pilot_ids:
        add_error(
            errors,
            f"Anima pilot image IDs differ: missing={len(expected_pilot_ids - actual_pilot_ids)}, extra={len(actual_pilot_ids - expected_pilot_ids)}",
        )

    report = {
        "status": "pass" if not errors else "fail",
        "transform_version": EXPECTED_VERSION,
        "manifest_sha256": manifest_sha256,
        "manifest_rows": len(manifest_rows),
        "cached_rows": len(cached_rows),
        "unique_cached_ids": len(cached_ids),
        "parts": len(json_parts),
        "finite_tensor_contracts": finite_tensors,
        "tensor_bytes": tensor_bytes,
        "worker_summaries": summaries,
        "unique_train_anchors": len(train_anchors),
        "packed_sources_found": len(packed_sources),
        "train_style_identities": len(train_style_ids),
        "validation_style_identities": len(validation_style_ids),
        "anima_pilot_images": len(actual_pilot_ids),
        "distribution": cache_distribution,
        "elapsed_seconds": time.perf_counter() - started,
        "errors": errors,
    }
    output.parent.mkdir(parents=True, exist_ok=True)
    temporary = output.with_suffix(output.suffix + ".tmp")
    temporary.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    temporary.replace(output)
    print(json.dumps(report, indent=2))
    return 0 if not errors else 1


if __name__ == "__main__":
    raise SystemExit(main())