#!/usr/bin/env python3 """Validate the multi-config public data interface (local; CI later). Checks: - hardware_re4 parquet columns/dtypes match the expected full schema - sr_pareto consolidated table has required columns and non-empty coverage - latent_routing gate: fail if README declares the config without three CSVs - bundle.json should not be the sole SR interface (warn on absolute paths) """ from __future__ import annotations import argparse import json import re import sys from pathlib import Path ROOT = Path(__file__).resolve().parents[1] # Full on-disk schema for system_telemetry_v1_batch_*.parquet HARDWARE_RE4_SCHEMA: dict[str, str] = { "timestamp_ms": "int64", "power_usage_mw": "uint32", "temperature_c": "uint32", "graphics_clock_mhz": "uint32", "memory_clock_mhz": "uint32", "pcie_rx_kbps": "uint32", "pcie_tx_kbps": "uint32", "pstate": "uint32", "throttle_reasons_bitmask": "uint64", "fan_speed_perc": "uint32", "memory_used_mb": "uint64", "memory_total_mb": "uint64", "encoder_util_perc": "uint32", "decoder_util_perc": "uint32", "cpu_tctl_c": "double", # pyarrow float -> double "cpu_ccd1_c": "double", "cpu_ccd2_c": "double", "cpu_package_power_w": "double", } SR_REQUIRED = {"model", "condition", "complexity", "loss", "equation"} LATENT_CSVS = [ ROOT / "first-day-testing-real-weights/second-test/snn_latent_telemetry.csv", ROOT / "first-day-testing-real-weights/third-test/snn_latent_telemetry.csv", ROOT / "first-day-testing-real-weights/fourth-test/snn_latent_telemetry.csv", ] def _normalize_type(t: str) -> str: t = str(t).lower() aliases = { "float": "double", "float32": "float", "float64": "double", "boolean": "bool", } return aliases.get(t, t) def check_hardware_re4(root: Path, errors: list[str], warnings: list[str]) -> None: try: import pyarrow.parquet as pq except ImportError: errors.append("pyarrow required to validate hardware_re4 parquet") return pattern = root / "origin_hardware_baselines/resident_evil_4" files = sorted(pattern.glob("system_telemetry_v1_batch_*.parquet")) if len(files) < 1: errors.append("no system_telemetry_v1_batch_*.parquet files found") return if len(files) != 48: warnings.append(f"expected 48 RE4 parquet batches, found {len(files)}") table = pq.read_table(files[0]) actual = {f.name: _normalize_type(str(f.type)) for f in table.schema} expected = {k: _normalize_type(v) for k, v in HARDWARE_RE4_SCHEMA.items()} missing = sorted(set(expected) - set(actual)) extra = sorted(set(actual) - set(expected)) if missing: errors.append(f"hardware_re4 missing columns: {missing}") if extra: warnings.append(f"hardware_re4 extra columns vs CONTEXT schema: {extra}") for name, exp_t in expected.items(): if name not in actual: continue # allow float/double flexibility for cpu temps act = actual[name] if act == exp_t: continue if {act, exp_t} <= {"float", "double"}: continue if {act, exp_t} <= {"int64", "uint64"} and name == "throttle_reasons_bitmask": continue errors.append(f"hardware_re4 dtype mismatch {name}: got {act}, expected {exp_t}") total_rows = sum(pq.read_table(f).num_rows for f in files) if total_rows < 1000: errors.append(f"hardware_re4 too few rows: {total_rows}") else: print(f" hardware_re4: {len(files)} files, {total_rows} rows, schema OK") def check_sr_pareto(root: Path, errors: list[str], warnings: list[str]) -> None: csv_path = root / "sr_benchmark/sr_pareto_all.csv" pq_path = root / "sr_benchmark/sr_pareto_all.parquet" if not csv_path.exists() and not pq_path.exists(): errors.append("sr_pareto_all.csv/.parquet missing — run scripts/build_sr_pareto_all.py") return import csv path = csv_path if csv_path.exists() else pq_path if path.suffix == ".csv": with path.open(newline="", encoding="utf-8") as f: reader = csv.DictReader(f) fields = set(reader.fieldnames or []) rows = list(reader) else: import pyarrow.parquet as pq table = pq.read_table(path) fields = set(table.column_names) rows = table.to_pylist() missing = SR_REQUIRED - fields if missing: errors.append(f"sr_pareto missing columns: {sorted(missing)}") return if not rows: errors.append("sr_pareto consolidated table is empty") return models = {r["model"] for r in rows} conditions = {r["condition"] for r in rows} if len(models) < 2: warnings.append(f"sr_pareto few models: {sorted(models)}") if not conditions: errors.append("sr_pareto has no conditions") print( f" sr_pareto: {len(rows)} rows, {len(models)} models, " f"{len(conditions)} conditions" ) bundle = root / "sr_benchmark/bundle.json" if bundle.exists(): text = bundle.read_text(encoding="utf-8") abs_hits = re.findall(r'"/home/[^"]+"', text) if abs_hits: warnings.append( f"bundle.json still has {len(abs_hits)} absolute path strings " "(consolidated table is the Hub interface; fix paths when convenient)" ) def check_latent_gate(root: Path, errors: list[str], warnings: list[str]) -> None: readme = (root / "README.md").read_text(encoding="utf-8") has_latent_config = bool( re.search(r"config_name:\s*latent_routing", readme) or re.search(r'["\']latent_routing["\']', readme.split("---", 2)[1] if readme.startswith("---") else "") ) present = [p for p in LATENT_CSVS if p.exists()] missing = [p for p in LATENT_CSVS if not p.exists()] if has_latent_config and missing: errors.append( "latent_routing config declared in README but feature CSVs missing: " + ", ".join(str(p.relative_to(root)) for p in missing) ) elif missing: warnings.append( "latent_routing gated (expected): missing " + ", ".join(str(p.relative_to(root)) for p in missing) ) else: print(" latent_routing gate: all three feature CSVs present") if present and not has_latent_config and not missing: warnings.append( "all latent CSVs present but latent_routing config not in README yet" ) def check_readme_configs(root: Path, errors: list[str], warnings: list[str]) -> None: readme = (root / "README.md").read_text(encoding="utf-8") if not readme.startswith("---"): errors.append("README.md missing YAML frontmatter") return parts = readme.split("---", 2) if len(parts) < 3: errors.append("README.md YAML frontmatter malformed") return yaml = parts[1] if re.search(r"config_name:\s*default\b", yaml): errors.append("README still has config_name: default (must force explicit configs)") for name in ("hardware_re4", "sr_pareto"): if f"config_name: {name}" not in yaml and f'config_name: "{name}"' not in yaml: errors.append(f"README YAML missing config_name: {name}") if "sr_pareto_all" not in yaml: warnings.append("README YAML may not point data_files at sr_pareto_all.*") # duplicate Usage sections if readme.count("\n## Usage\n") > 1: errors.append("README has duplicate ## Usage sections") print(" README configs: checked") def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--root", type=Path, default=ROOT) args = parser.parse_args() root: Path = args.root errors: list[str] = [] warnings: list[str] = [] print("validate_dataset") check_readme_configs(root, errors, warnings) check_hardware_re4(root, errors, warnings) check_sr_pareto(root, errors, warnings) check_latent_gate(root, errors, warnings) for w in warnings: print(f"WARN: {w}") for e in errors: print(f"ERROR: {e}") if errors: print(f"FAILED ({len(errors)} error(s), {len(warnings)} warning(s))") return 1 print(f"OK ({len(warnings)} warning(s))") return 0 if __name__ == "__main__": raise SystemExit(main())