| |
| 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() |
|
|
