scripts/validate_human_style_examples.py

"""Validate human-style OracleMem natural-example JSONL files.

Each input row is expected to be a self-contained example with sessions,
messages, evidence units, query-required evidence IDs, and candidate memories
with per-unit coverage scores. This script performs structural validation only;
it does not judge annotation quality.
"""

from __future__ import annotations

import argparse
import json
import math
import sys
from collections import Counter
from pathlib import Path
from typing import Any


TOP_LEVEL_FIELDS: dict[str, tuple[str, ...]] = {
    "id": ("id", "example_id", "instance_id"),
    "domain": ("domain",),
    "sessions": ("sessions",),
    "future_query": ("future_query", "query", "question"),
    "required_unit_ids_for_query": ("required_unit_ids_for_query",),
    "evidence_units": ("evidence_units",),
    "candidate_memories": ("candidate_memories",),
}

FUTURE_QUERY_FIELDS: dict[str, tuple[str, ...]] = {
    "text": ("text", "query", "question"),
    "answer": ("answer", "gold_answer"),
    "should_abstain": ("should_abstain",),
}

SESSION_FIELDS: dict[str, tuple[str, ...]] = {
    "session_id": ("session_id", "id"),
    "messages": ("messages",),
}

MESSAGE_FIELDS: dict[str, tuple[str, ...]] = {
    "role": ("role", "speaker"),
    "content": ("content", "text"),
}

EVIDENCE_UNIT_FIELDS: dict[str, tuple[str, ...]] = {
    "unit_id": ("unit_id", "id", "evidence_unit_id"),
    "text": ("canonical_text", "text"),
}

CANDIDATE_FIELDS: dict[str, tuple[str, ...]] = {
    "candidate_id": ("candidate_id", "memory_id", "id"),
    "text": ("text", "serialized", "content"),
    "coverage": ("coverage", "coverage_by_unit", "unit_coverage", "coverage_scores"),
}


class Validator:
    def __init__(self, max_errors: int) -> None:
        self.max_errors = max_errors
        self.errors: list[str] = []
        self.omitted_errors = 0
        self.seen_example_ids: dict[str, str] = {}
        self.domain_counts: Counter[str] = Counter()
        self.domain_sessions: Counter[str] = Counter()
        self.domain_messages: Counter[str] = Counter()
        self.domain_units: Counter[str] = Counter()
        self.domain_candidates: Counter[str] = Counter()
        self.rows_seen = 0

    def add_error(self, location: str, message: str) -> None:
        if len(self.errors) < self.max_errors:
            self.errors.append(f"{location}: {message}")
        else:
            self.omitted_errors += 1

    @property
    def truncated_errors(self) -> bool:
        return self.omitted_errors > 0


def first_present(record: dict[str, Any], aliases: tuple[str, ...]) -> tuple[str | None, Any]:
    for key in aliases:
        if key in record:
            return key, record[key]
    return None, None


def require_fields(
    validator: Validator,
    location: str,
    record: Any,
    fields: dict[str, tuple[str, ...]],
) -> bool:
    if not isinstance(record, dict):
        validator.add_error(location, "expected object")
        return False

    ok = True
    for canonical_name, aliases in fields.items():
        key, _ = first_present(record, aliases)
        if key is None:
            alias_text = "/".join(aliases)
            validator.add_error(location, f"missing required field {canonical_name} ({alias_text})")
            ok = False
    return ok


def as_id(value: Any) -> str | None:
    if isinstance(value, str) and value:
        return value
    if isinstance(value, int) and not isinstance(value, bool):
        return str(value)
    return None


def validate_stringish(validator: Validator, location: str, field_name: str, value: Any) -> None:
    if not isinstance(value, str) or not value.strip():
        validator.add_error(location, f"{field_name} must be a non-empty string")


def validate_id_list(
    validator: Validator,
    location: str,
    field_name: str,
    value: Any,
) -> list[str]:
    if not isinstance(value, list):
        validator.add_error(location, f"{field_name} must be a list")
        return []

    ids: list[str] = []
    seen: set[str] = set()
    for index, item in enumerate(value):
        item_id = as_id(item)
        item_location = f"{location}.{field_name}[{index}]"
        if item_id is None:
            validator.add_error(item_location, "must be a non-empty string or integer ID")
            continue
        if item_id in seen:
            validator.add_error(item_location, f"duplicate ID {item_id!r}")
        seen.add(item_id)
        ids.append(item_id)
    return ids


def validate_sessions(validator: Validator, location: str, value: Any) -> tuple[int, int]:
    if not isinstance(value, list):
        validator.add_error(location, "sessions must be a list")
        return 0, 0

    session_ids: set[str] = set()
    message_count = 0
    for session_index, session in enumerate(value):
        session_location = f"{location}.sessions[{session_index}]"
        if not require_fields(validator, session_location, session, SESSION_FIELDS):
            continue

        _, raw_session_id = first_present(session, SESSION_FIELDS["session_id"])
        session_id = as_id(raw_session_id)
        if session_id is None:
            validator.add_error(session_location, "session_id must be a non-empty string or integer ID")
        elif session_id in session_ids:
            validator.add_error(session_location, f"duplicate session_id {session_id!r}")
        else:
            session_ids.add(session_id)

        _, messages = first_present(session, SESSION_FIELDS["messages"])
        if not isinstance(messages, list):
            validator.add_error(f"{session_location}.messages", "messages must be a list")
            continue

        message_count += len(messages)
        for message_index, message in enumerate(messages):
            message_location = f"{session_location}.messages[{message_index}]"
            if not require_fields(validator, message_location, message, MESSAGE_FIELDS):
                continue
            _, role = first_present(message, MESSAGE_FIELDS["role"])
            _, content = first_present(message, MESSAGE_FIELDS["content"])
            validate_stringish(validator, message_location, "role", role)
            validate_stringish(validator, message_location, "content", content)

    return len(value), message_count


def validate_evidence_units(validator: Validator, location: str, value: Any) -> tuple[set[str], int]:
    if not isinstance(value, list):
        validator.add_error(location, "evidence_units must be a list")
        return set(), 0

    unit_ids: set[str] = set()
    for unit_index, unit in enumerate(value):
        unit_location = f"{location}.evidence_units[{unit_index}]"
        if not require_fields(validator, unit_location, unit, EVIDENCE_UNIT_FIELDS):
            continue

        _, raw_unit_id = first_present(unit, EVIDENCE_UNIT_FIELDS["unit_id"])
        unit_id = as_id(raw_unit_id)
        if unit_id is None:
            validator.add_error(unit_location, "unit_id must be a non-empty string or integer ID")
        elif unit_id in unit_ids:
            validator.add_error(unit_location, f"duplicate unit_id {unit_id!r}")
        else:
            unit_ids.add(unit_id)

        _, text = first_present(unit, EVIDENCE_UNIT_FIELDS["text"])
        validate_stringish(validator, unit_location, "text", text)

    return unit_ids, len(value)


def validate_candidate_memories(
    validator: Validator,
    location: str,
    value: Any,
    evidence_unit_ids: set[str],
) -> int:
    if not isinstance(value, list):
        validator.add_error(location, "candidate_memories must be a list")
        return 0

    candidate_ids: set[str] = set()
    for candidate_index, candidate in enumerate(value):
        candidate_location = f"{location}.candidate_memories[{candidate_index}]"
        if not require_fields(validator, candidate_location, candidate, CANDIDATE_FIELDS):
            continue

        _, raw_candidate_id = first_present(candidate, CANDIDATE_FIELDS["candidate_id"])
        candidate_id = as_id(raw_candidate_id)
        if candidate_id is None:
            validator.add_error(candidate_location, "candidate_id must be a non-empty string or integer ID")
        elif candidate_id in candidate_ids:
            validator.add_error(candidate_location, f"duplicate candidate_id {candidate_id!r}")
        else:
            candidate_ids.add(candidate_id)

        _, text = first_present(candidate, CANDIDATE_FIELDS["text"])
        validate_stringish(validator, candidate_location, "text", text)

        coverage_key, coverage = first_present(candidate, CANDIDATE_FIELDS["coverage"])
        if not isinstance(coverage, dict):
            validator.add_error(candidate_location, "coverage must be an object mapping unit IDs to scores")
            continue

        for unit_id, score in coverage.items():
            coverage_location = f"{candidate_location}.{coverage_key}[{unit_id!r}]"
            if unit_id not in evidence_unit_ids:
                validator.add_error(coverage_location, "references unknown evidence unit")
            if isinstance(score, bool) or not isinstance(score, (int, float)):
                validator.add_error(coverage_location, "coverage score must be numeric")
                continue
            if not math.isfinite(float(score)) or not 0.0 <= float(score) <= 1.0:
                validator.add_error(coverage_location, "coverage score must be in [0, 1]")

    return len(value)


def validate_example(validator: Validator, path: Path, line_number: int, row: Any) -> None:
    validator.rows_seen += 1
    location = f"{path}:{line_number}"

    if not require_fields(validator, location, row, TOP_LEVEL_FIELDS):
        if not isinstance(row, dict):
            return

    assert isinstance(row, dict)

    _, raw_example_id = first_present(row, TOP_LEVEL_FIELDS["id"])
    example_id = as_id(raw_example_id)
    if example_id is None:
        validator.add_error(location, "id must be a non-empty string or integer ID")
        example_key = f"<missing-id:{path}:{line_number}>"
    else:
        example_key = example_id
        if example_id in validator.seen_example_ids:
            first_location = validator.seen_example_ids[example_id]
            validator.add_error(location, f"duplicate example id {example_id!r}; first seen at {first_location}")
        else:
            validator.seen_example_ids[example_id] = location

    _, domain_value = first_present(row, TOP_LEVEL_FIELDS["domain"])
    domain = domain_value if isinstance(domain_value, str) and domain_value else "<missing>"
    if domain == "<missing>":
        validator.add_error(location, "domain must be a non-empty string")

    _, sessions = first_present(row, TOP_LEVEL_FIELDS["sessions"])
    _, evidence_units = first_present(row, TOP_LEVEL_FIELDS["evidence_units"])
    _, required_units = first_present(row, TOP_LEVEL_FIELDS["required_unit_ids_for_query"])
    _, candidate_memories = first_present(row, TOP_LEVEL_FIELDS["candidate_memories"])

    session_count, message_count = validate_sessions(validator, location, sessions)
    evidence_unit_ids, unit_count = validate_evidence_units(validator, location, evidence_units)
    required_unit_ids = validate_id_list(
        validator,
        location,
        "required_unit_ids_for_query",
        required_units,
    )

    for unit_id in required_unit_ids:
        if unit_id not in evidence_unit_ids:
            validator.add_error(
                f"{location}.required_unit_ids_for_query",
                f"required unit {unit_id!r} is not present in evidence_units",
            )

    candidate_count = validate_candidate_memories(validator, location, candidate_memories, evidence_unit_ids)

    validator.domain_counts[domain] += 1
    validator.domain_sessions[domain] += session_count
    validator.domain_messages[domain] += message_count
    validator.domain_units[domain] += unit_count
    validator.domain_candidates[domain] += candidate_count

    _, future_query = first_present(row, TOP_LEVEL_FIELDS["future_query"])
    if isinstance(future_query, str):
        validate_stringish(validator, location, "future_query", future_query)
    elif isinstance(future_query, dict):
        if require_fields(validator, f"{location}.future_query", future_query, FUTURE_QUERY_FIELDS):
            _, query_text = first_present(future_query, FUTURE_QUERY_FIELDS["text"])
            _, answer = first_present(future_query, FUTURE_QUERY_FIELDS["answer"])
            _, should_abstain = first_present(
                future_query, FUTURE_QUERY_FIELDS["should_abstain"]
            )
            validate_stringish(validator, f"{location}.future_query", "text", query_text)
            validate_stringish(validator, f"{location}.future_query", "answer", answer)
            if not isinstance(should_abstain, bool):
                validator.add_error(
                    f"{location}.future_query",
                    "should_abstain must be a boolean",
                )
    else:
        validator.add_error(location, "future_query must be a non-empty string or object")

    # Keep linters honest and make debugging partial records easier.
    _ = example_key


def validate_path(validator: Validator, path: Path) -> None:
    if not path.exists():
        validator.add_error(str(path), "file does not exist")
        return
    if not path.is_file():
        validator.add_error(str(path), "path is not a file")
        return

    with path.open("r", encoding="utf-8") as handle:
        for line_number, line in enumerate(handle, start=1):
            stripped = line.strip()
            if not stripped:
                validator.add_error(f"{path}:{line_number}", "blank lines are not valid JSONL records")
                continue
            try:
                row = json.loads(stripped)
            except json.JSONDecodeError as exc:
                validator.add_error(f"{path}:{line_number}", f"invalid JSON: {exc.msg}")
                continue
            validate_example(validator, path, line_number, row)


def print_summary(validator: Validator, paths: list[Path]) -> None:
    print(f"Validated {validator.rows_seen} records from {len(paths)} file(s).")
    print("Domain summary:")
    if not validator.domain_counts:
        print("  <none>")
    else:
        for domain in sorted(validator.domain_counts):
            print(
                "  "
                f"{domain}: "
                f"records={validator.domain_counts[domain]}, "
                f"sessions={validator.domain_sessions[domain]}, "
                f"messages={validator.domain_messages[domain]}, "
                f"evidence_units={validator.domain_units[domain]}, "
                f"candidate_memories={validator.domain_candidates[domain]}"
            )

    if validator.errors:
        print(f"Errors ({len(validator.errors)} shown):")
        for error in validator.errors:
            print(f"  - {error}")
        if validator.truncated_errors:
            print(f"  - {validator.omitted_errors} additional error(s) omitted after --max-errors={validator.max_errors}")
    else:
        print("Errors: none")


def parse_args(argv: list[str]) -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Validate human-style OracleMem natural-example JSONL files.",
    )
    parser.add_argument("jsonl_paths", nargs="+", type=Path, help="One or more JSONL files to validate.")
    parser.add_argument(
        "--max-errors",
        type=int,
        default=100,
        help="Maximum number of validation errors to print before truncating output.",
    )
    return parser.parse_args(argv)


def main(argv: list[str] | None = None) -> int:
    args = parse_args(sys.argv[1:] if argv is None else argv)
    max_errors = args.max_errors if args.max_errors > 0 else 1
    validator = Validator(max_errors=max_errors)

    for path in args.jsonl_paths:
        validate_path(validator, path)

    print_summary(validator, args.jsonl_paths)
    return 1 if validator.errors else 0


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