| |
| """Read every output record, validate its schemas and independently recompute its key.""" |
| import argparse |
| from collections import Counter |
| import gzip |
| import hashlib |
| import json |
| from pathlib import Path |
| import re |
|
|
| import fastjsonschema |
| import xxhash |
|
|
| DOI_NAME = re.compile(r"\A10\.[0-9]+(?:\.[0-9]+)*/.+\Z") |
| CONTROL = re.compile(r"[\x00-\x1f\x7f-\x9f]") |
|
|
|
|
| def is_lowercase_doi_name(value: str) -> bool: |
| return (value.strip() == value and not CONTROL.search(value) |
| and DOI_NAME.match(value) is not None and value == value.lower()) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("dataset_dir", type=Path) |
| args = parser.parse_args() |
| root = args.dataset_dir |
| manifest = json.loads((root / "manifest.json").read_text()) |
| check_enrichment = fastjsonschema.compile(json.loads( |
| (root / "provenance/enrichment_input_schema.json").read_text())) |
| check_value = fastjsonschema.compile(json.loads( |
| (root / "provenance/related_identifier_subset_schema.json").read_text())) |
| expected = manifest["counts"] |
| counts = Counter() |
| keys = set() |
| dois = set() |
| files = manifest["data_files"] |
| |
| |
| on_disk = {str(p.relative_to(root)) for p in (root / "data").rglob("*") if p.is_file()} |
| listed = {item["path"] for item in files} |
| assert on_disk == listed, f"unlisted {sorted(on_disk - listed)}, missing {sorted(listed - on_disk)}" |
| for item in files: |
| path = root / item["path"] |
| with path.open("rb") as stream: |
| digest = hashlib.file_digest(stream, "sha256").hexdigest() |
| assert digest == item["sha256"], f"{item['path']}: sha256 {digest} != manifest {item['sha256']}" |
| n = 0 |
| with gzip.open(path, "rt", encoding="utf-8") as stream: |
| for line in stream: |
| row = json.loads(line) |
| check_enrichment(row) |
| value = row["enrichedValue"] |
| check_value(value) |
| assert set(row) == {"doi", "action", "field", "enrichedValue", "sourceId", "contentKey"} |
| assert row["action"] == "insert" and row["field"] == "relatedIdentifiers" |
| assert row["sourceId"] == manifest["source_id"], f"sourceId {row['sourceId']!r}" |
| assert is_lowercase_doi_name(row["doi"]), row["doi"] |
| assert is_lowercase_doi_name(value["relatedIdentifier"]), value["relatedIdentifier"] |
| |
| |
| |
| canonical = json.dumps( |
| [manifest["method"]["name"], row["doi"], row["field"], row["action"], value], |
| ensure_ascii=False, sort_keys=True, separators=(",", ":"), |
| ).encode("utf-8") |
| expected_key = xxhash.xxh3_128_hexdigest(canonical) |
| assert row["contentKey"] == expected_key, ( |
| f"{item['path']}: contentKey {row['contentKey']} != recomputed {expected_key}") |
| key = bytes.fromhex(expected_key) |
| assert key not in keys, f"{item['path']}: duplicate contentKey {expected_key}" |
| keys.add(key) |
| dois.add(row["doi"]) |
| counts["enrichments"] += 1 |
| counts["to_arxiv_dois"] += row["doi"].startswith("10.48550/") |
| n += 1 |
| assert n == item["rows"], f"{item['path']}: {n} records != manifest {item['rows']}" |
| print(f"Validated {item['path']}: {n:,} records", flush=True) |
| assert counts["enrichments"] == expected["enrichments"] |
| assert len(dois) == expected["unique_enriched_dois"] |
| assert counts["to_arxiv_dois"] == expected["enrichments_to_arxiv_dois"] |
| report = {"status": "passed", "records_read_and_validated": counts["enrichments"], |
| "unique_target_dois": len(dois), "data_shards": len(files), |
| "enrichments_to_arxiv_dois": counts["to_arxiv_dois"], |
| "schema_errors": 0, "content_key_mismatches": 0, "duplicate_content_keys": 0, |
| "file_checksum_mismatches": 0} |
| (root / "validation_report.json").write_text(json.dumps(report, indent=2) + "\n") |
| print(json.dumps(report, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
