| |
| """Validate active indexes and optional Viewer/repository snapshots.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import math |
| import re |
| import statistics |
| import sys |
| from collections import Counter |
| from datetime import date |
| from pathlib import Path |
| from urllib.parse import unquote, urlparse |
|
|
|
|
| RECORD_ID_RE = re.compile(r"^tla-[0-9a-f]{16}$") |
| HASH_RE = re.compile(r"^[0-9a-f]{64}$") |
| DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$") |
| TIME_RE = re.compile(r"^(?:[01]\d|2[0-3]):[0-5]\d$") |
| DIMENSIONS_RE = re.compile(r"^\d+(?:\.\d+)?x\d+(?:\.\d+)?$") |
| DIRECT_STANDARD_RE = re.compile(r"^Standard_Time_Lapses/[^/]+\.mp4$") |
| DIRECT_PRE_STANDARD_RE = re.compile(r"^Pre_Standard_Time_Lapses/[^/]+\.mp4$") |
|
|
| REQUIRED_FIELDS = [ |
| "file_name", |
| "record_id", |
| "collection_tier", |
| "is_canonical", |
| "acquisition_protocol_version", |
| "date", |
| "time", |
| "tool", |
| "medium", |
| "support", |
| "dimensions", |
| "duration_seconds", |
| "width_px", |
| "height_px", |
| "orientation", |
| "encoded_frame_rate", |
| "video_codec", |
| "pixel_format", |
| "container", |
| "has_audio", |
| "hub_xet_hash", |
| "original_filename", |
| "provenance_status", |
| "legacy_provenance_path", |
| "legacy_related_references", |
| "evidence_method", |
| "provenance_reference_duration_delta_seconds", |
| "size_bytes", |
| "notes", |
| ] |
|
|
| PRE_STANDARD_REQUIRED_FIELDS = REQUIRED_FIELDS |
|
|
|
|
| def viewer_path(row: dict[str, object]) -> str: |
| video = row.get("video") |
| if not isinstance(video, dict) or not isinstance(video.get("src"), str): |
| return "" |
| path = unquote(urlparse(video["src"]).path) |
| marker = "/resolve/" |
| if marker not in path: |
| return "" |
| after_revision = path.split(marker, 1)[1] |
| parts = after_revision.split("/", 1) |
| return parts[1] if len(parts) == 2 else "" |
|
|
|
|
| def load_csv(path: Path) -> tuple[list[str], list[dict[str, str]]]: |
| with path.open("r", encoding="utf-8-sig", newline="") as handle: |
| reader = csv.DictReader(handle) |
| if reader.fieldnames is None: |
| raise ValueError("metadata file has no header") |
| return list(reader.fieldnames), list(reader) |
|
|
|
|
| def valid_calendar_date(value: str) -> bool: |
| if not DATE_RE.fullmatch(value): |
| return False |
| try: |
| date.fromisoformat(value) |
| except ValueError: |
| return False |
| return True |
|
|
|
|
| def validate_multi_value( |
| row: dict[str, str], label: str, field: str, errors: list[str] |
| ) -> None: |
| value = row.get(field, "") |
| if "|" in value: |
| errors.append(f"{label}: {field} still uses a pipe separator") |
| items = [item.strip() for item in value.split(";") if item.strip()] |
| if value and len(items) != len(value.split(";")): |
| errors.append(f"{label}: {field} contains an empty list item") |
| if len(items) != len(set(items)): |
| errors.append(f"{label}: {field} contains duplicate list values") |
|
|
|
|
| def validate_positive_number( |
| row: dict[str, str], |
| label: str, |
| field: str, |
| errors: list[str], |
| *, |
| integer: bool = False, |
| ) -> float | None: |
| value = row.get(field, "") |
| if not value: |
| errors.append(f"{label}: technical field {field} is blank") |
| return None |
| try: |
| parsed = float(value) |
| except ValueError: |
| errors.append(f"{label}: technical field {field} is not numeric") |
| return None |
| if not math.isfinite(parsed) or parsed <= 0: |
| errors.append(f"{label}: technical field {field} must be positive") |
| return None |
| if integer and not parsed.is_integer(): |
| errors.append(f"{label}: technical field {field} must be an integer") |
| return None |
| return parsed |
|
|
|
|
| def validate_technical_row( |
| row: dict[str, str], label: str, errors: list[str] |
| ) -> None: |
| duration = validate_positive_number(row, label, "duration_seconds", errors) |
| width = validate_positive_number(row, label, "width_px", errors, integer=True) |
| height = validate_positive_number(row, label, "height_px", errors, integer=True) |
| frame_rate = validate_positive_number(row, label, "encoded_frame_rate", errors) |
| size = validate_positive_number(row, label, "size_bytes", errors, integer=True) |
| del duration, frame_rate, size |
|
|
| for field in ("orientation", "video_codec", "pixel_format", "container"): |
| if not row.get(field, ""): |
| errors.append(f"{label}: technical field {field} is blank") |
| if row.get("has_audio", "").lower() not in {"true", "false"}: |
| errors.append(f"{label}: has_audio must be true or false") |
| if not HASH_RE.fullmatch(row.get("hub_xet_hash", "")): |
| errors.append(f"{label}: hub_xet_hash must be 64 lowercase hexadecimal characters") |
|
|
| if width is not None and height is not None: |
| expected_orientation = ( |
| "portrait" if height > width else "landscape" if width > height else "square" |
| ) |
| if row.get("orientation") != expected_orientation: |
| errors.append( |
| f"{label}: orientation {row.get('orientation')!r} conflicts with " |
| f"{int(width)}x{int(height)}" |
| ) |
|
|
|
|
| def validate( |
| metadata_csv: Path, |
| viewer_json: Path | None, |
| pre_standard_metadata: Path | None, |
| repo_files_json: Path | None, |
| ) -> dict[str, object]: |
| fields, rows = load_csv(metadata_csv) |
| errors: list[str] = [] |
| warnings: list[str] = [] |
| pre_standard_rows: list[dict[str, str]] = [] |
| repo_counts: dict[str, int] = {} |
| repo_unindexed_standard: list[str] = [] |
| repo_unindexed_pre_standard: list[str] = [] |
|
|
| missing_fields = [field for field in REQUIRED_FIELDS if field not in fields] |
| if missing_fields: |
| errors.append(f"missing required columns: {missing_fields}") |
|
|
| def duplicate_values(records: list[dict[str, str]], field: str) -> list[str]: |
| values = [row.get(field, "") for row in records if row.get(field, "")] |
| return sorted(value for value, count in Counter(values).items() if count > 1) |
|
|
| for field in ("file_name", "record_id", "hub_xet_hash"): |
| duplicates = duplicate_values(rows, field) |
| if duplicates: |
| errors.append(f"duplicate {field} values: {duplicates[:5]}") |
|
|
| for index, row in enumerate(rows, start=2): |
| label = row.get("file_name") or f"CSV row {index}" |
| if not DIRECT_STANDARD_RE.fullmatch(row.get("file_name", "")): |
| errors.append(f"{label}: canonical path must be a direct Standard_Time_Lapses MP4") |
| if not RECORD_ID_RE.fullmatch(row.get("record_id", "")): |
| errors.append(f"{label}: invalid record_id") |
| if row.get("collection_tier") != "standard": |
| errors.append(f"{label}: collection_tier must be standard") |
| if row.get("is_canonical", "").lower() != "true": |
| errors.append(f"{label}: is_canonical must be true") |
| if row.get("acquisition_protocol_version") != "standard-2025-07-15": |
| errors.append(f"{label}: unexpected acquisition protocol version") |
| if not valid_calendar_date(row.get("date", "")): |
| errors.append(f"{label}: invalid or missing finish date") |
| if row.get("time") and not TIME_RE.fullmatch(row["time"]): |
| errors.append(f"{label}: invalid finish time") |
| if not DIMENSIONS_RE.fullmatch(row.get("dimensions", "")): |
| errors.append(f"{label}: invalid dimensions") |
| if not row.get("tool", ""): |
| errors.append(f"{label}: canonical tool is blank") |
| if not row.get("medium", ""): |
| errors.append(f"{label}: canonical medium is blank") |
| if not row.get("support", ""): |
| errors.append(f"{label}: canonical support is blank") |
| for field in ("tool", "medium"): |
| validate_multi_value(row, label, field, errors) |
|
|
| basename = Path(row.get("file_name", "")).name |
| filename_parts = basename.split(".") |
| expected_time = row.get("time", "").replace(":", "") or "UnknownTime" |
| if len(filename_parts) < 2 or filename_parts[0] != row.get("date"): |
| errors.append(f"{label}: filename date differs from metadata date") |
| elif filename_parts[1] != expected_time: |
| errors.append(f"{label}: filename time differs from metadata time") |
|
|
| validate_technical_row(row, label, errors) |
|
|
| standard_30x40_paper = sum( |
| row.get("dimensions") == "30x40" and row.get("support") == "Paper" |
| for row in rows |
| ) |
| if standard_30x40_paper: |
| warnings.append( |
| f"{standard_30x40_paper} canonical 30x40 rows use support=Paper while " |
| "Archive_Specifications.md describes 30x40 Illustration Board; curator review required" |
| ) |
|
|
| if pre_standard_metadata: |
| pre_fields, pre_standard_rows = load_csv(pre_standard_metadata) |
| missing_pre_fields = [ |
| field for field in PRE_STANDARD_REQUIRED_FIELDS if field not in pre_fields |
| ] |
| if missing_pre_fields: |
| errors.append( |
| f"pre-standard metadata is missing required columns: {missing_pre_fields}" |
| ) |
| for field in ("file_name", "record_id", "hub_xet_hash"): |
| duplicates = duplicate_values(pre_standard_rows, field) |
| if duplicates: |
| errors.append(f"duplicate pre-standard {field} values: {duplicates[:5]}") |
|
|
| all_rows = rows + pre_standard_rows |
| for field in ("record_id", "hub_xet_hash"): |
| duplicates = duplicate_values(all_rows, field) |
| if duplicates: |
| errors.append(f"duplicate cross-tier {field} values: {duplicates[:5]}") |
|
|
| unknown_date_with_time = 0 |
| for index, row in enumerate(pre_standard_rows, start=2): |
| name = row.get("file_name", "") |
| label = name or f"pre-standard CSV row {index}" |
| if not name or "/" in name or "\\" in name or not name.endswith(".mp4"): |
| errors.append( |
| f"pre-standard CSV row {index}: file_name must be a direct MP4 basename" |
| ) |
| if not RECORD_ID_RE.fullmatch(row.get("record_id", "")): |
| errors.append(f"{label}: invalid record_id") |
| if row.get("collection_tier") != "pre_standard": |
| errors.append(f"{label}: collection_tier must be pre_standard") |
| if row.get("is_canonical", "").lower() != "false": |
| errors.append(f"{label}: is_canonical must be false") |
| if row.get("acquisition_protocol_version"): |
| errors.append(f"{label}: pre-standard acquisition protocol must be blank") |
|
|
| if row.get("date"): |
| if not valid_calendar_date(row["date"]): |
| errors.append(f"{label}: invalid finish date") |
| elif row.get("time"): |
| unknown_date_with_time += 1 |
| if row.get("time") and not TIME_RE.fullmatch(row["time"]): |
| errors.append(f"{label}: invalid finish time") |
| if not DIMENSIONS_RE.fullmatch(row.get("dimensions", "")): |
| errors.append(f"{label}: invalid dimensions") |
| for field in ("tool", "medium"): |
| validate_multi_value(row, label, field, errors) |
| validate_technical_row(row, label, errors) |
|
|
| if unknown_date_with_time: |
| warnings.append( |
| f"{unknown_date_with_time} pre-standard rows retain a time while the date is unknown; " |
| "confirm that 00:00 means documented midnight rather than a placeholder" |
| ) |
| missing_material_rows = sum( |
| not row.get("tool") or not row.get("medium") or not row.get("support") |
| for row in pre_standard_rows |
| ) |
| if missing_material_rows: |
| warnings.append( |
| f"{missing_material_rows} pre-standard rows retain incomplete material fields" |
| ) |
|
|
| if repo_files_json: |
| loaded_inventory = json.loads(repo_files_json.read_text(encoding="utf-8")) |
| repo_items: dict[str, dict[str, object]] = {} |
| if isinstance(loaded_inventory, list) and all( |
| isinstance(path, str) for path in loaded_inventory |
| ): |
| loaded_paths = loaded_inventory |
| elif isinstance(loaded_inventory, dict) and isinstance( |
| loaded_inventory.get("siblings"), list |
| ): |
| loaded_paths = [] |
| for item in loaded_inventory["siblings"]: |
| if not isinstance(item, dict) or not isinstance(item.get("rfilename"), str): |
| errors.append("Hub repository inventory contains an invalid sibling entry") |
| continue |
| path = item["rfilename"] |
| loaded_paths.append(path) |
| repo_items[path] = item |
| else: |
| loaded_paths = [] |
| errors.append( |
| "repository snapshot must be a JSON path list or a Hub API object with siblings" |
| ) |
|
|
| if loaded_paths: |
| repo_paths = set(loaded_paths) |
| standard_files = {path for path in repo_paths if DIRECT_STANDARD_RE.fullmatch(path)} |
| pre_standard_files = { |
| path for path in repo_paths if DIRECT_PRE_STANDARD_RE.fullmatch(path) |
| } |
| provenance_files = { |
| path |
| for path in repo_paths |
| if path.startswith("Standard_Time_Lapses/Provenance/") |
| and path.endswith(".mp4") |
| } |
| canonical_paths = {row.get("file_name", "") for row in rows} |
| active_pre_paths = { |
| f"Pre_Standard_Time_Lapses/{row.get('file_name', '')}" |
| for row in pre_standard_rows |
| if row.get("file_name") |
| } |
| missing_canonical_targets = sorted(canonical_paths.difference(repo_paths)) |
| missing_pre_targets = sorted(active_pre_paths.difference(repo_paths)) |
| repo_unindexed_standard = sorted(standard_files.difference(canonical_paths)) |
| repo_unindexed_pre_standard = sorted( |
| pre_standard_files.difference(active_pre_paths) |
| ) |
| if missing_canonical_targets: |
| errors.append( |
| f"{len(missing_canonical_targets)} canonical metadata paths have no repository file" |
| ) |
| if missing_pre_targets: |
| errors.append( |
| f"{len(missing_pre_targets)} active pre-standard metadata paths have no repository file" |
| ) |
| if repo_unindexed_pre_standard: |
| errors.append( |
| f"{len(repo_unindexed_pre_standard)} published pre-standard files are absent from the active index" |
| ) |
| if repo_unindexed_standard: |
| warnings.append( |
| f"{len(repo_unindexed_standard)} direct standard files are pending metadata ingestion" |
| ) |
|
|
| hash_mismatches: list[str] = [] |
| size_mismatches: list[str] = [] |
| missing_blob_metadata: list[str] = [] |
| if repo_items: |
| indexed_paths_and_rows = [ |
| *((row.get("file_name", ""), row) for row in rows), |
| *( |
| (f"Pre_Standard_Time_Lapses/{row.get('file_name', '')}", row) |
| for row in pre_standard_rows |
| ), |
| ] |
| for path, row in indexed_paths_and_rows: |
| item = repo_items.get(path, {}) |
| lfs = item.get("lfs") if isinstance(item, dict) else None |
| if not isinstance(lfs, dict): |
| missing_blob_metadata.append(path) |
| continue |
| expected_hash = item.get("xetHash") |
| expected_size = item.get("size") |
| if expected_size is None: |
| expected_size = lfs.get("size") |
| if not isinstance(expected_hash, str) or expected_size is None: |
| missing_blob_metadata.append(path) |
| continue |
| if row.get("hub_xet_hash", "").lower() != expected_hash.lower(): |
| hash_mismatches.append(path) |
| if row.get("size_bytes", "") != str(expected_size): |
| size_mismatches.append(path) |
|
|
| if missing_blob_metadata: |
| errors.append( |
| f"{len(missing_blob_metadata)} indexed files lack Hub LFS identity metadata" |
| ) |
| if hash_mismatches: |
| errors.append( |
| f"{len(hash_mismatches)} indexed hashes differ from the Hub inventory" |
| ) |
| if size_mismatches: |
| errors.append( |
| f"{len(size_mismatches)} indexed byte sizes differ from the Hub inventory" |
| ) |
|
|
| repo_counts = { |
| "repository_files": len(repo_paths), |
| "direct_standard_video_files": len(standard_files), |
| "direct_pre_standard_video_files": len(pre_standard_files), |
| "provenance_video_files": len(provenance_files), |
| "missing_canonical_metadata_targets": len(missing_canonical_targets), |
| "missing_pre_standard_metadata_targets": len(missing_pre_targets), |
| "missing_hub_identity_metadata": len(missing_blob_metadata), |
| "content_hash_mismatches": len(hash_mismatches), |
| "size_mismatches": len(size_mismatches), |
| } |
|
|
| viewer_rows: list[dict[str, object]] = [] |
| viewer_counts: dict[str, int] = {} |
| if viewer_json: |
| loaded = json.loads(viewer_json.read_text(encoding="utf-8")) |
| if not isinstance(loaded, list): |
| errors.append("Viewer snapshot must be a JSON list") |
| else: |
| viewer_rows = [row for row in loaded if isinstance(row, dict)] |
| paths = [viewer_path(row) for row in viewer_rows] |
| tiers = Counter(path.split("/", 1)[0] for path in paths if "/" in path) |
| viewer_counts = dict(sorted(tiers.items())) |
|
|
| canonical_viewer = { |
| viewer_path(row): row |
| for row in viewer_rows |
| if viewer_path(row).startswith("Standard_Time_Lapses/") |
| } |
| metadata_paths = {row["file_name"] for row in rows} |
| missing_from_viewer = sorted(metadata_paths.difference(canonical_viewer)) |
| missing_from_metadata = sorted(set(canonical_viewer).difference(metadata_paths)) |
| if missing_from_viewer: |
| errors.append( |
| f"{len(missing_from_viewer)} metadata paths are absent from the Viewer snapshot" |
| ) |
| if missing_from_metadata: |
| errors.append( |
| f"{len(missing_from_metadata)} canonical Viewer paths are absent from metadata.csv" |
| ) |
|
|
| by_path = {row["file_name"]: row for row in rows} |
| for path, viewer_row in canonical_viewer.items(): |
| metadata_row = by_path.get(path) |
| if not metadata_row: |
| continue |
| for field in ( |
| "date", |
| "time", |
| "support", |
| "dimensions", |
| "orientation", |
| "video_codec", |
| "pixel_format", |
| "container", |
| "hub_xet_hash", |
| ): |
| left = metadata_row.get(field, "") |
| right_value = viewer_row.get(field) |
| right = "" if right_value is None else str(right_value) |
| if left != right: |
| errors.append(f"{path}: {field} differs from Viewer snapshot") |
|
|
| pre_standard_viewer_rows = [ |
| row |
| for row in viewer_rows |
| if viewer_path(row).startswith("Pre_Standard_Time_Lapses/") |
| ] |
| pre_standard_without_technical = sum( |
| row.get("duration_seconds") is None for row in pre_standard_viewer_rows |
| ) |
| if pre_standard_without_technical: |
| warnings.append( |
| f"{pre_standard_without_technical} pre-standard Viewer rows lack duration metadata" |
| ) |
|
|
| all_active_rows = rows + pre_standard_rows |
| durations = [ |
| float(row["duration_seconds"]) |
| for row in all_active_rows |
| if row.get("duration_seconds") |
| ] |
| sizes = [int(row["size_bytes"]) for row in all_active_rows if row.get("size_bytes")] |
| orientations = Counter( |
| row.get("orientation", "") or "<missing>" for row in all_active_rows |
| ) |
| audio = Counter(row.get("has_audio", "") or "<missing>" for row in all_active_rows) |
|
|
| if audio.get("True", 0) + audio.get("true", 0) > 0: |
| warnings.append("published masters commonly retain audio streams; rights/privacy review is still required") |
| warnings.append( |
| "encoded_frame_rate is playback rate, not original drawing-time sampling" |
| ) |
|
|
| return { |
| "ok": not errors, |
| "errors": errors, |
| "warnings": warnings, |
| "statistics": { |
| "metadata_rows": len(rows), |
| "metadata_columns": len(fields), |
| "viewer_rows": len(viewer_rows), |
| "viewer_collection_counts": viewer_counts, |
| "pre_standard_metadata_rows": len(pre_standard_rows), |
| "repository_inventory": repo_counts, |
| "unindexed_direct_standard_files": repo_unindexed_standard, |
| "unindexed_direct_pre_standard_files": repo_unindexed_pre_standard, |
| "active_rows": len(all_active_rows), |
| "unique_record_ids": len( |
| {row.get("record_id", "") for row in all_active_rows if row.get("record_id")} |
| ), |
| "unique_nonempty_hashes": len( |
| { |
| row.get("hub_xet_hash", "") |
| for row in all_active_rows |
| if row.get("hub_xet_hash") |
| } |
| ), |
| "unknown_finish_dates": sum(not row.get("date") for row in all_active_rows), |
| "unknown_finish_times": sum(not row.get("time") for row in all_active_rows), |
| "orientation_counts": dict(sorted(orientations.items())), |
| "audio_counts": dict(sorted(audio.items())), |
| "playback_hours": round(sum(durations) / 3600, 2), |
| "median_playback_seconds": round(statistics.median(durations), 3), |
| "indexed_size_tb_decimal": round(sum(sizes) / 1_000_000_000_000, 3), |
| }, |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("metadata_csv", type=Path) |
| parser.add_argument("--viewer-json", type=Path) |
| parser.add_argument("--pre-standard-metadata", type=Path) |
| parser.add_argument( |
| "--repo-files-json", |
| "--repo-inventory-json", |
| dest="repo_files_json", |
| type=Path, |
| ) |
| parser.add_argument("--output", type=Path) |
| args = parser.parse_args() |
|
|
| report = validate( |
| args.metadata_csv, |
| args.viewer_json, |
| args.pre_standard_metadata, |
| args.repo_files_json, |
| ) |
| rendered = json.dumps(report, indent=2, sort_keys=True) |
| if args.output: |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| args.output.write_text(rendered + "\n", encoding="utf-8") |
| print(rendered) |
| if not report["ok"]: |
| sys.exit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
