File size: 4,859 Bytes
eb96d23 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 | #!/usr/bin/env python3
"""Validate the standardized AirfRANS dataset package."""
from __future__ import annotations
import argparse
import hashlib
import json
import re
import sys
from pathlib import Path
REPO_ROOT = Path(__file__).resolve().parents[1]
DATASET_ROOT = REPO_ROOT / "data" / "Dataset"
CHECKSUM_PATH = REPO_ROOT / "files_sha256.jsonl"
REQUIRED_SUFFIXES = ("internal.vtu", "freestream.vtp", "aerofoil.vtp")
SCHEMA_HINTS = {
"internal.vtu": ("UnstructuredGrid", "implicit_distance", "U", "p", "nut"),
"aerofoil.vtp": ("PolyData", "Normals", "U", "p", "nut"),
"freestream.vtp": ("PolyData", "U", "p", "nut"),
}
def fail(message: str) -> None:
print(f"[FAIL] {message}")
raise SystemExit(1)
def ok(message: str) -> None:
print(f"[OK] {message}")
def warn(message: str) -> None:
print(f"[WARN] {message}")
def sha256_file(path: Path) -> str:
h = hashlib.sha256()
with path.open("rb") as f:
for chunk in iter(lambda: f.read(1024 * 1024), b""):
h.update(chunk)
return h.hexdigest()
def load_manifest() -> dict:
manifest_path = DATASET_ROOT / "manifest.json"
if not manifest_path.exists():
fail(f"missing manifest.json: {manifest_path}")
try:
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
except json.JSONDecodeError as exc:
fail(f"manifest.json is not valid JSON: {exc}")
for key in ("full_train", "full_test"):
if key not in manifest or not isinstance(manifest[key], list) or not manifest[key]:
fail(f"manifest key is missing or empty: {key}")
return manifest
def inspect_vtk_header(path: Path, suffix: str) -> None:
blob = path.read_bytes()[:262144].decode("utf-8", errors="ignore")
if "<VTKFile" not in blob:
fail(f"not a VTK XML file: {path}")
for token in SCHEMA_HINTS[suffix]:
if token not in blob:
fail(f"schema token {token!r} not found in {path}")
piece = re.search(r"NumberOfPoints=\"(\d+)\"", blob)
if piece and int(piece.group(1)) <= 0:
fail(f"NumberOfPoints is not positive in {path}")
def validate_files(manifest: dict, sample_count: int) -> None:
actual_dirs = sorted(p for p in DATASET_ROOT.iterdir() if p.is_dir())
referenced = list(dict.fromkeys(manifest["full_train"] + manifest["full_test"]))
if len(actual_dirs) != len(referenced):
fail(f"case count mismatch: dirs={len(actual_dirs)}, manifest_unique={len(referenced)}")
missing = []
for sim_name in referenced:
sim_dir = DATASET_ROOT / sim_name
if not sim_dir.is_dir():
missing.append(str(sim_dir))
continue
for suffix in REQUIRED_SUFFIXES:
file_path = sim_dir / f"{sim_name}_{suffix}"
if not file_path.is_file():
missing.append(str(file_path))
elif file_path.stat().st_size <= 0:
fail(f"empty file: {file_path}")
if missing:
fail("missing required files, first entries: " + "; ".join(missing[:8]))
for sim_name in referenced[:sample_count]:
for suffix in REQUIRED_SUFFIXES:
inspect_vtk_header(DATASET_ROOT / sim_name / f"{sim_name}_{suffix}", suffix)
ok(f"dataset file structure and sampled VTK schema are valid: {len(referenced)} cases")
def verify_checksums(full_hash: bool) -> None:
if not CHECKSUM_PATH.exists():
warn(f"checksum manifest is not present: {CHECKSUM_PATH}")
return
checked = 0
for line in CHECKSUM_PATH.read_text(encoding="utf-8").splitlines():
if not line.strip():
continue
record = json.loads(line)
path = REPO_ROOT / record["path"]
if not path.exists():
fail(f"checksum entry points to missing file: {path}")
size = path.stat().st_size
if size != record["size"]:
fail(f"size mismatch for {path}: expected {record['size']}, got {size}")
if full_hash:
digest = sha256_file(path)
if digest != record["sha256"]:
fail(f"sha256 mismatch for {path}")
checked += 1
mode = "size+sha256" if full_hash else "size"
ok(f"checksum manifest verified in {mode} mode: {checked} files")
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--sample-count", type=int, default=3)
parser.add_argument("--full-hash", action="store_true")
args = parser.parse_args()
if args.sample_count < 1:
fail("--sample-count must be positive")
if not DATASET_ROOT.exists():
fail(f"dataset root does not exist: {DATASET_ROOT}")
manifest = load_manifest()
validate_files(manifest, args.sample_count)
verify_checksums(args.full_hash)
ok("dataset validation completed")
return 0
if __name__ == "__main__":
sys.exit(main())
|