scripts/validate_cb_telemetry.py

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import csv
import gzip
import hashlib
import json
import re
from pathlib import Path
from typing import Iterable


TEXT_SUFFIXES = {
    ".csv",
    ".json",
    ".md",
    ".txt",
    ".cff",
    ".py",
    ".sh",
    ".yaml",
    ".yml",
}

LOCAL_PATH_PATTERNS = [
    re.compile(r"/" + r"Users/"),
    re.compile(r"/home/"),
    re.compile(r"\\Users\\"),
]

DRAFT_TEXT_PATTERNS = [
    re.compile(r"\b" + "T" + "BD" + r"\b", re.IGNORECASE),
    re.compile(r"\b" + "TO" + "DO" + r"\b", re.IGNORECASE),
    re.compile("place" + "holder", re.IGNORECASE),
]

JUNK_FILE_NAMES = {".DS_Store", "Thumbs.db"}
JUNK_DIR_NAMES = {"__MACOSX"}
AUDIO_SUFFIXES = {".aac", ".flac", ".m4a", ".mp3", ".ogg", ".wav"}


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Validate a CB-Telemetry release package.")
    parser.add_argument("--root", required=True, help="CB-Telemetry release root.")
    parser.add_argument("--write-report", action="store_true", help="Write qa/validation_report.{json,md}.")
    return parser.parse_args()


def read_csv_rows(path: Path) -> list[dict[str, str]]:
    if path.suffix == ".gz":
        handle = gzip.open(path, "rt", encoding="utf-8", newline="")
    else:
        handle = path.open("r", encoding="utf-8", newline="")
    with handle:
        return list(csv.DictReader(handle))


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def add_issue(bucket: list[dict[str, str]], check: str, message: str) -> None:
    bucket.append({"check": check, "message": message})


def require_files(root: Path, rel_paths: Iterable[str], errors: list[dict[str, str]]) -> None:
    for rel_path in rel_paths:
        if not (root / rel_path).exists():
            add_issue(errors, "required_file", f"Missing required file: {rel_path}")


def validate_package_hygiene(
    root: Path,
    errors: list[dict[str, str]],
    warnings: list[dict[str, str]],
) -> None:
    for path in root.rglob("*"):
        rel = path.relative_to(root).as_posix()
        if path.name in JUNK_FILE_NAMES:
            add_issue(warnings, "package_hygiene", f"Local release directory contains OS metadata file: {rel}")
        if path.is_dir() and path.name in JUNK_DIR_NAMES:
            add_issue(errors, "package_hygiene", f"Release package contains OS metadata directory: {rel}")


def scan_text(root: Path, errors: list[dict[str, str]], warnings: list[dict[str, str]]) -> None:
    for path in root.rglob("*"):
        if not path.is_file():
            continue
        suffixes = path.suffixes
        is_gzip_csv = len(suffixes) >= 2 and suffixes[-2:] == [".csv", ".gz"]
        if path.suffix not in TEXT_SUFFIXES and not is_gzip_csv:
            continue
        try:
            if is_gzip_csv:
                text = gzip.open(path, "rt", encoding="utf-8", errors="replace").read()
            else:
                text = path.read_text(encoding="utf-8", errors="replace")
        except UnicodeDecodeError:
            continue
        rel = path.relative_to(root).as_posix()
        if rel == "scripts/validate_cb_telemetry.py" or rel in {
            "qa/validation_report.json",
            "qa/validation_report.md",
        }:
            continue
        for pattern in LOCAL_PATH_PATTERNS:
            if pattern.search(text):
                add_issue(errors, "local_path_leak", f"Local path pattern found in {rel}: {pattern.pattern}")
        for pattern in DRAFT_TEXT_PATTERNS:
            if pattern.search(text):
                add_issue(warnings, "draft_text", f"Draft-like marker found in {rel}: {pattern.pattern}")


def validate_ids(root: Path, errors: list[dict[str, str]], warnings: list[dict[str, str]]) -> dict[str, int]:
    stats: dict[str, int] = {}
    scored_path = root / "manifests" / "scored_snapshot_manifest.csv"
    splits_path = root / "manifests" / "splits.csv"
    default_features_path = root / "features" / "feature_table_default.csv.gz"
    strict_features_path = root / "features" / "feature_table_strict_clean.csv.gz"

    scored = read_csv_rows(scored_path)
    splits = read_csv_rows(splits_path)
    default_features = read_csv_rows(default_features_path)
    strict_features = read_csv_rows(strict_features_path)

    scored_ids = [row.get("recording_id", "") for row in scored]
    split_ids = [row.get("recording_id", "") for row in splits]
    default_ids = [row.get("recording_id", "") for row in default_features]
    strict_ids = [row.get("recording_id", "") for row in strict_features]

    stats["scored_rows"] = len(scored)
    stats["split_rows"] = len(splits)
    stats["default_feature_rows"] = len(default_features)
    stats["strict_feature_rows"] = len(strict_features)

    if len(set(scored_ids)) != len(scored_ids):
        add_issue(errors, "recording_id_unique", "scored_snapshot_manifest.csv contains duplicate recording_id values.")
    if set(scored_ids) != set(split_ids):
        add_issue(errors, "split_alignment", "splits.csv recording_id set does not match scored snapshot.")
    if set(scored_ids) != set(default_ids):
        add_issue(errors, "default_feature_alignment", "default feature recording_id set does not match scored snapshot.")
    strict_split_ids = {row["recording_id"] for row in splits if row.get("subset_strict_clean") == "1"}
    if strict_split_ids != set(strict_ids):
        add_issue(errors, "strict_feature_alignment", "strict feature recording_id set does not match strict-clean split.")

    years = {row.get("year", "") for row in scored}
    if "2011" in years:
        add_issue(errors, "scored_year_boundary", "2011 rows are present in the scored snapshot.")
    if not years or min(years) < "2012":
        add_issue(errors, "scored_year_boundary", f"Unexpected scored year range: {sorted(years)}")
    if max(years) > "2024":
        add_issue(errors, "scored_year_boundary", f"Scored rows exceed J-STAGE 2012-2024 range: {sorted(years)}")

    matched = sum(1 for row in scored if int(float(row.get("jstage_event_count") or 0)) > 0)
    stats["jstage_matched_recordings"] = matched
    if matched == 0:
        add_issue(errors, "jstage_alignment", "No scored recordings have J-STAGE expert-overlap counts.")
    elif matched < len(scored):
        add_issue(
            warnings,
            "jstage_alignment",
            f"{len(scored) - matched} scored recordings have no J-STAGE observation-minute overlap.",
        )
    expert_counts = [
        int(float(row.get("expert_overlap_event_count") or 0))
        for row in scored
        if "expert_overlap_event_count" in row
    ]
    if expert_counts and any(count <= 0 for count in expert_counts):
        add_issue(errors, "expert_overlap", "Scored snapshot contains non-positive expert_overlap_event_count values.")

    return stats


def validate_audio_samples(root: Path, errors: list[dict[str, str]], warnings: list[dict[str, str]]) -> dict[str, int]:
    sample_path = root / "manifests" / "audio_sample_manifest.csv"
    hf_metadata_path = root / "audio_sample" / "metadata.csv"
    rows = read_csv_rows(sample_path)
    hf_metadata_rows = read_csv_rows(hf_metadata_path) if hf_metadata_path.exists() else []
    stats = {"audio_sample_rows": len(rows)}
    if not rows:
        add_issue(errors, "audio_sample", "audio_sample_manifest.csv is empty.")
        return stats

    sites = {row.get("site_en", "") for row in rows}
    behaviors: set[str] = set()
    referenced_paths: set[str] = set()
    expected_hf_files: set[str] = set()
    required_clip_columns = [
        "audio_sample_format",
        "clip_start_sec",
        "clip_duration_sec",
        "segment_start_sec",
        "segment_end_sec",
        "segment_duration_sec",
        "clip_source_audio_path",
        "clip_generation_tool",
    ]
    for row in rows:
        behaviors.update(item for item in row.get("behavior_types", "").split("|") if item)
        audio_rel = row.get("audio_sample_path", "")
        if not audio_rel:
            add_issue(errors, "audio_sample_path", "Audio sample row has empty audio_sample_path.")
            continue
        referenced_paths.add(audio_rel)
        try:
            expected_hf_files.add(Path(audio_rel).relative_to("audio_sample").as_posix())
        except ValueError:
            add_issue(errors, "audio_sample_path", f"Audio sample path should be under audio_sample/: {audio_rel}")
        for column in required_clip_columns:
            if column not in row or row.get(column, "") == "":
                add_issue(errors, "audio_sample_schema", f"Audio sample row missing {column}: {audio_rel}")
        if row.get("audio_sample_format") != "m4a":
            add_issue(errors, "audio_sample_format", f"Reviewer audio clip should be m4a: {audio_rel}")
        try:
            clip_start = float(row.get("clip_start_sec") or "nan")
            clip_duration = float(row.get("clip_duration_sec") or "nan")
            segment_start = float(row.get("segment_start_sec") or "nan")
            segment_end = float(row.get("segment_end_sec") or "nan")
        except ValueError:
            add_issue(errors, "audio_sample_window", f"Invalid clip or segment window values: {audio_rel}")
            continue
        if clip_start < 0 or clip_duration <= 0:
            add_issue(errors, "audio_sample_window", f"Invalid non-positive clip window: {audio_rel}")
        if clip_duration > 30:
            add_issue(errors, "audio_sample_window", f"Reviewer clip exceeds 30 seconds: {audio_rel}")
        if segment_end < segment_start:
            add_issue(errors, "audio_sample_window", f"Segment end precedes start: {audio_rel}")
        audio_path = root / audio_rel
        if not audio_path.exists():
            add_issue(errors, "audio_sample_exists", f"Missing audio sample file: {audio_rel}")
            continue
        expected = row.get("sha256", "")
        if expected and sha256(audio_path) != expected:
            add_issue(errors, "audio_sample_sha256", f"SHA256 mismatch for {audio_rel}")
        if int(audio_path.stat().st_size) > 10 * 1024 * 1024:
            add_issue(warnings, "audio_sample_size", f"Reviewer audio clip is larger than 10MB: {audio_rel}")

    audio_sample_dir = root / "audio_sample"
    if audio_sample_dir.exists():
        for path in audio_sample_dir.rglob("*"):
            if not path.is_file():
                continue
            if path.suffix.lower() not in AUDIO_SUFFIXES:
                continue
            rel = path.relative_to(root).as_posix()
            if rel not in referenced_paths:
                add_issue(errors, "audio_sample_orphan", f"Unreferenced audio sample file: {rel}")

    if not hf_metadata_rows:
        add_issue(errors, "hf_audio_metadata", "audio_sample/metadata.csv is missing or empty.")
    else:
        hf_files = {row.get("file_name", "") for row in hf_metadata_rows}
        if hf_files != expected_hf_files:
            add_issue(errors, "hf_audio_metadata", "audio_sample/metadata.csv file_name set does not match audio samples.")

    stats["audio_sample_sites"] = len(sites)
    stats["audio_sample_behaviors"] = len(behaviors)
    if len(sites) < 3:
        add_issue(warnings, "audio_sample_coverage", f"Audio sample covers only {len(sites)} sites.")
    if not {"S", "C", "D"}.issubset(behaviors):
        add_issue(warnings, "audio_sample_coverage", f"Audio sample behavior coverage is {sorted(behaviors)}.")
    return stats


def validate_croissant(root: Path, errors: list[dict[str, str]]) -> None:
    path = root / "croissant.json"
    try:
        data = json.loads(path.read_text(encoding="utf-8"))
    except json.JSONDecodeError as exc:
        add_issue(errors, "croissant_json", f"croissant.json is invalid JSON: {exc}")
        return
    required = [
        "@context",
        "@type",
        "name",
        "description",
        "url",
        "license",
        "conformsTo",
        "distribution",
        "recordSet",
    ]
    for key in required:
        if key not in data:
            add_issue(errors, "croissant_required_key", f"croissant.json missing required key: {key}")
    if data.get("@type") != "sc:Dataset":
        add_issue(errors, "croissant_dataset_type", 'croissant.json @type should be "sc:Dataset".')
    if "by-nc-sa" not in str(data.get("license", "")).lower():
        add_issue(errors, "croissant_license", "croissant.json license should identify CC BY-NC-SA 4.0.")
    rai_required = [
        "rai:dataLimitations",
        "rai:dataBiases",
        "rai:personalSensitiveInformation",
        "rai:dataUseCases",
        "rai:dataSocialImpact",
        "rai:hasSyntheticData",
        "prov:wasDerivedFrom",
        "prov:wasGeneratedBy",
    ]
    for key in rai_required:
        value = data.get(key)
        if key not in data or value is None or value == "" or value == []:
            add_issue(errors, "croissant_rai_required_key", f"croissant.json missing required RAI/provenance key: {key}")
    for item in data.get("distribution", []):
        if item.get("@type") not in {"cr:FileObject", "sc:FileObject", "FileObject"}:
            add_issue(errors, "croissant_distribution_type", f"croissant distribution {item.get('@id', item.get('name'))} is not a FileObject.")
        for key in ["@id", "contentUrl", "encodingFormat"]:
            if key not in item:
                add_issue(errors, "croissant_distribution_required_key", f"croissant distribution missing {key}: {item}")
    for record_set in data.get("recordSet", []):
        if not record_set.get("@id"):
            add_issue(errors, "croissant_recordset_id", f"croissant recordSet missing @id: {record_set.get('name')}")
        for field in record_set.get("field", []):
            if not (field.get("source") or "value" in field):
                add_issue(errors, "croissant_field_source", f"croissant field missing source/value: {field.get('name')}")


def write_report(root: Path, report: dict[str, object]) -> None:
    qa_dir = root / "qa"
    qa_dir.mkdir(parents=True, exist_ok=True)
    (qa_dir / "validation_report.json").write_text(
        json.dumps(report, indent=2, ensure_ascii=False) + "\n",
        encoding="utf-8",
    )
    lines = [
        "# CB-Telemetry Validation Report",
        "",
        f"- status: `{report['status']}`",
        f"- errors: `{len(report['errors'])}`",
        f"- warnings: `{len(report['warnings'])}`",
        "",
        "## Stats",
        "",
    ]
    for key, value in sorted(report["stats"].items()):
        lines.append(f"- {key}: `{value}`")
    lines += ["", "## Errors", ""]
    if report["errors"]:
        for issue in report["errors"]:
            lines.append(f"- `{issue['check']}`: {issue['message']}")
    else:
        lines.append("- none")
    lines += ["", "## Warnings", ""]
    if report["warnings"]:
        for issue in report["warnings"]:
            lines.append(f"- `{issue['check']}`: {issue['message']}")
    else:
        lines.append("- none")
    (qa_dir / "validation_report.md").write_text("\n".join(lines) + "\n", encoding="utf-8")


def main() -> None:
    args = parse_args()
    root = Path(args.root).expanduser().resolve()
    errors: list[dict[str, str]] = []
    warnings: list[dict[str, str]] = []
    stats: dict[str, int] = {}

    require_files(
        root,
        [
            "README.md",
            "DATASET_CARD.md",
            "LICENSE",
            "LICENSE_MATRIX.md",
            "CITATION.cff",
            "croissant.json",
            "annotations/cb_telemetry_annotations.csv.gz",
            "manifests/audio_manifest.csv",
            "manifests/audio_sample_manifest.csv",
            "audio_sample/metadata.csv",
            "manifests/scored_snapshot_manifest.csv",
            "manifests/splits.csv",
            "features/feature_table_default.csv.gz",
            "features/feature_table_strict_clean.csv.gz",
            "features/bottlenecks/default/standard_rvq_8bit_feature_table.csv.gz",
            "features/bottlenecks/default/pq_8bit_feature_table.csv.gz",
            "features/bottlenecks/default/opq_8bit_feature_table.csv.gz",
            "features/bottlenecks/strict_clean/standard_rvq_8bit_feature_table.csv.gz",
            "features/bottlenecks/strict_clean/pq_8bit_feature_table.csv.gz",
            "features/bottlenecks/strict_clean/opq_8bit_feature_table.csv.gz",
            "baselines/table_2_representation_structure.csv",
            "baselines/table_3_retrieval_baselines_and_controls.csv",
            "requirements.txt",
            "scripts/download_audio_recordings.py",
            "scripts/run_smoke_eval.py",
            "scripts/run_retrieval_eval.py",
            "scripts/run_release_evaluation.py",
        ],
        errors,
    )

    if not errors:
        validate_package_hygiene(root, errors, warnings)
        stats.update(validate_ids(root, errors, warnings))
        stats.update(validate_audio_samples(root, errors, warnings))
        validate_croissant(root, errors)
    scan_text(root, errors, warnings)

    report = {
        "status": "pass" if not errors else "fail",
        "root": root.name,
        "stats": stats,
        "errors": errors,
        "warnings": warnings,
    }
    if args.write_report:
        write_report(root, report)
    print(json.dumps(report, indent=2, ensure_ascii=False))
    raise SystemExit(0 if not errors else 1)


if __name__ == "__main__":
    main()