Hand-Datasets-Raw / ReInterHand /shared-v1.1 /script /provenance /operations /build_reinterhand_docs.py
| #!/usr/bin/env python3 | |
| """Assemble ReInterHand's ``doc/`` tree from the canonical v1.1 spec and the v1.0 record. | |
| Every published v1.1 release carries the same three spec documents, and each | |
| dataset edits exactly the same three things in ``CONTRACT.md``: a status banner on | |
| line 1, its own 状态 line, and the v1.0 link retargeted from the shared | |
| ``../hand-warehouse-1.0/CONTRACT.md`` to the copy kept as ``V1_0_SEMANTICS.md``. | |
| Doing that by hand is how a release ends up with a banner that overstates what was | |
| actually verified, so this script derives the banner and the 状态 line from | |
| ``doc/FULL_MIGRATION_SUMMARY.json`` -- the record of what the run actually did -- | |
| and refuses to write a claim the record does not support. | |
| Adapted from ``RHD/shared-v1.1/script/provenance/operations/build_rhd_docs.py``, the | |
| second-generation builder. Three things differ for ReInterHand, and all three are | |
| about v1.0 material rather than about the v1.1 spec (which is shared, and checked | |
| against its canonical digests below): | |
| * ``RAW_MAPPING.md`` keeps its v1.0-era name, as RHD's does, instead of the | |
| ``RAW_TO_SHARED.md`` that ARCTIC, H2O and dex-ycb use. It is *checked*, not | |
| rewritten: the mapping record is the dataset's own, and a builder that regenerated | |
| it could silently drop a row. | |
| * The v1.0 ``script/`` tree is snapshotted into ``script/v1_0_snapshot/script`` | |
| alongside the v1.0 contract and schema in ``script/v1_0_snapshot/doc``. RHD's | |
| builder leaves that copy alone; ReInterHand's produces it, because its v1.0 | |
| ``script/`` is where the release's own producer lives (``preprocess_reinterhand.py``) | |
| and a snapshot that is made by hand is one nobody can re-derive. | |
| * ``doc/history-v1.0/`` is 752 MB, not 7 MB: ReInterHand's v1.0 ``doc/validation/`` | |
| carries 114 rendered review clips. ARCTIC carries 412 MB the same way, so the whole | |
| set is reproduced, verbatim and complete -- a "history" tree whose pages link to | |
| videos that were left behind is not a reproduction. | |
| Run: python shared-v1.1/script/provenance/operations/build_reinterhand_docs.py | |
| Order inside a run: the two carried-over trees are produced first, then | |
| ``doc/RAW_MAPPING.md`` is checked, then the four spec documents are written. The | |
| mapping record names ``script/v1_0_snapshot/`` as where the v1.0 scripts live, and this | |
| script is what puts them there, so checking it first would fail on a tree built from | |
| scratch -- the case where the check matters most. | |
| Idempotent: it rewrites the two transformed files, copies the two verbatim ones, | |
| refreshes ``doc/history-v1.0/`` and re-snapshots the v1.0 scripts, so re-running after | |
| the migration finishes refreshes the banner. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import hashlib | |
| import json | |
| import re | |
| import shutil | |
| import sys | |
| from pathlib import Path | |
| OPERATIONS = Path(__file__).resolve().parent | |
| SCRIPT_DIR = OPERATIONS.parent.parent # <release>/script | |
| RELEASE_ROOT = SCRIPT_DIR.parent # <dataset>/shared-v1.1 | |
| DATASET_ROOT = RELEASE_ROOT.parent # <dataset> | |
| SPEC = SCRIPT_DIR / "reinterhand_v1_1" / "spec" | |
| DOC = RELEASE_ROOT / "doc" | |
| V10 = DATASET_ROOT / "shared-v1.0" | |
| HISTORY = DOC / "history-v1.0" | |
| SNAPSHOT = SCRIPT_DIR / "v1_0_snapshot" | |
| #: the canonical spec, shared by every dataset. Checked rather than trusted: if | |
| #: these do not match, the release would ship a spec it did not migrate against. | |
| CANONICAL = { | |
| "CONTRACT.md": "502dde9ac0549551237f684472489ddf6372bad3a26b1f6cca96f360c5dff158", | |
| "MIGRATION.md": "773f5146d49f5060bfc13ef92c143c59b683a6dc633cad44897414d5299088a0", | |
| "schema.json": "9f3769f950b36f75f3d571c77b5a661ca8e72afae20c9f1ddd1deef140e6cca8", | |
| } | |
| #: ``../hand-warehouse-1.0/CONTRACT.md`` in the canonical text; the release keeps | |
| #: its own copy of the v1.0 semantics beside it instead of reaching outside the tree | |
| V10_LINK = "../hand-warehouse-1.0/CONTRACT.md" | |
| V10_LINK_LOCAL = "V1_0_SEMANTICS.md" | |
| STATES = { | |
| #: no summary yet: the migration has not finished, so claim nothing about it | |
| "in_progress": { | |
| "banner": "> ReInterHand shared-v1.1 本地全量迁移进行中；自动验收、人工复查与 HF 发布均未完成。", | |
| "status": "状态：ReInterHand shared-v1.1 配套注册表与读写工具已适配；本地迁移、自动验收、人工复查与 HF 发布均未完成。", | |
| }, | |
| #: full acceptance recorded, human review and upload still outstanding | |
| "accepted_pending_review": { | |
| "banner": "> ReInterHand shared-v1.1 已完成本地全量迁移与自动验收（逐字段字节级比对）；人工复查与 HF 发布尚未完成。", | |
| "status": "状态：ReInterHand shared-v1.1 配套注册表与读写工具已适配；本地全量数值一致性及结构检查通过，发布清单已在发布树外重建（`tmp/reinterhand-tools/PUBLISH_MANIFEST.json`，树内不含清单）。人工复查不属于自动验收，尚未完成；HF 发布尚未进行。", | |
| }, | |
| } | |
| def sha256(path): | |
| digest = hashlib.sha256() | |
| with Path(path).open("rb") as stream: | |
| for chunk in iter(lambda: stream.read(1 << 22), b""): | |
| digest.update(chunk) | |
| return digest.hexdigest() | |
| def canonical_bytes(name): | |
| """The shared spec verbatim, with its canonical digest confirmed.""" | |
| path = SPEC / name | |
| got = sha256(path) | |
| if got != CANONICAL[name]: | |
| raise SystemExit(f"{path} is not the canonical {name}: {got} != {CANONICAL[name]}") | |
| return path.read_bytes() | |
| def canonical_text(name): | |
| """The shared spec as LF text, for a file this release transforms. | |
| The canonical ``CONTRACT.md`` and ``schema.json`` are CRLF; only the documents | |
| this release edits are normalised. A file that is *copied* keeps its bytes -- | |
| both published releases ship ``schema.json`` at the canonical 39043 bytes with | |
| its CRLF intact -- so the two paths are kept apart rather than sharing one | |
| round-trip through ``str``. | |
| """ | |
| return canonical_bytes(name).replace(b"\r\n", b"\n").decode("utf-8") | |
| def state_name(): | |
| """Which of STATES the recorded migration summary supports.""" | |
| summary = DOC / "FULL_MIGRATION_SUMMARY.json" | |
| if not summary.is_file(): | |
| return "in_progress" | |
| record = json.loads(summary.read_text(encoding="utf-8")) | |
| if record.get("phase") != "local_finalized_not_uploaded": | |
| raise SystemExit(f"{summary}: unexpected phase {record.get('phase')!r}") | |
| if record.get("human_full_approval"): | |
| raise SystemExit( | |
| f"{summary}: records a human approval, but no published wording is " | |
| "defined here; a published release needs its own banner" | |
| ) | |
| return "accepted_pending_review" | |
| def build_contract(state): | |
| """The canonical contract with the three dataset-specific edits applied.""" | |
| text = canonical_text("CONTRACT.md") | |
| lines = text.split("\n") | |
| status_index = next( | |
| index for index, line in enumerate(lines) if line.startswith("状态：") | |
| ) | |
| if lines[status_index].count("状态：") != 1 or not lines[status_index].startswith( | |
| "状态：合同草案" | |
| ): | |
| raise SystemExit(f"line {status_index + 1} is not the canonical 状态 line") | |
| if text.count(V10_LINK) != 1: | |
| raise SystemExit(f"the canonical text no longer links {V10_LINK} exactly once") | |
| lines[status_index] = STATES[state]["status"] | |
| body = "\n".join(lines).replace(V10_LINK, V10_LINK_LOCAL) | |
| #: banner, one blank line, then the canonical text; and no trailing newline, | |
| #: which is how both published releases ship it | |
| return f"{STATES[state]['banner']}\n\n{body}".rstrip("\n") | |
| def check_mapping_record(dry_run=False): | |
| """ReInterHand's own field mapping, kept under its v1.0-era name and cross-checked. | |
| This release does not rewrite the file, so the builder does the next best | |
| thing: it confirms the mapping record is there and that every ``script/...`` | |
| path it points a reader at actually exists. A restructured ``script/`` that | |
| left these references stale would send the reviewer to a file that is gone. | |
| ``dry_run`` only relaxes the case a dry run cannot satisfy: the carried-over | |
| trees are produced by this same script, and a dry run produces nothing, so a | |
| reference into ``script/v1_0_snapshot/`` is reported as pending instead of | |
| failing. Everything else is checked in both modes. | |
| """ | |
| path = DOC / "RAW_MAPPING.md" | |
| if not path.is_file(): | |
| raise SystemExit(f"{path} is missing; it is the 字段映射 CONTRACT 2 requires") | |
| text = path.read_text(encoding="utf-8") | |
| #: the record points a reader at entry points, not only at Python ones: it also | |
| #: names the tool package's README, which is the file that documents how to run | |
| #: the chain. Matching only ``.py`` would let that reference go stale unnoticed. | |
| referenced = sorted( | |
| set(re.findall(r"`(script/[A-Za-z0-9_./-]+\.(?:py|md|sh))`", text)) | |
| | set(re.findall(r"`(script/v1_0_snapshot/[A-Za-z0-9_./-]*)`", text)) | |
| ) | |
| if not referenced: | |
| raise SystemExit(f"{path} names no script/ entry point") | |
| missing = [rel for rel in referenced if not (RELEASE_ROOT / rel).exists()] | |
| if missing and not dry_run: | |
| raise SystemExit(f"{path} points at {len(missing)} file(s) that are not in " | |
| f"the release: {missing}") | |
| if missing: | |
| print(f" (dry run) {len(missing)} reference(s) do not exist yet and this run " | |
| f"is what creates them: {missing}") | |
| return path, referenced | |
| def sync_tree(source, target, label): | |
| """Reproduce ``source`` under ``target``, and drop what the source no longer has. | |
| Used for both carried-over sets: the v1.0 document tree and the v1.0 scripts. A | |
| copy that only ever adds cannot drift *towards* the source, but it can keep a file | |
| the source has since dropped, which would misrepresent what v1.0 was. | |
| """ | |
| if not source.is_dir(): | |
| raise SystemExit(f"{source} is missing; it is what {label} reproduces") | |
| wanted = {p.relative_to(source).as_posix() for p in source.rglob("*") if p.is_file()} | |
| for path in sorted(source.rglob("*")): | |
| if not path.is_file(): | |
| continue | |
| destination = target / path.relative_to(source) | |
| destination.parent.mkdir(parents=True, exist_ok=True) | |
| shutil.copy2(path, destination) | |
| removed = [] | |
| if target.is_dir(): | |
| for path in sorted(target.rglob("*")): | |
| if path.is_file() and path.relative_to(target).as_posix() not in wanted: | |
| path.unlink() | |
| removed.append(path.relative_to(RELEASE_ROOT).as_posix()) | |
| return len(wanted), removed | |
| def sync_history(): | |
| """``doc/history-v1.0/`` is the v1.0 document set, reproduced. | |
| The published releases keep the previous version's documents here, so a reader | |
| can compare the two without leaving the release. ReInterHand's v1.0 ``doc/`` is | |
| the contract, its schema, the raw mapping and the release's own review pages -- | |
| 548 files, 752 MB of which 749 MB is the 114 review clips those pages link to. | |
| The whole set is carried (ARCTIC carries 412 MB the same way): dropping the clips | |
| would leave ``validation/index.html`` pointing at nothing. | |
| """ | |
| return sync_tree(V10 / "doc", HISTORY, "history-v1.0") | |
| def sync_snapshot(): | |
| """``script/v1_0_snapshot/`` is the v1.0 scripts and the v1.0 contract pair. | |
| RHD keeps these two sets as well, but its builder does not produce them. Here the | |
| snapshot is derived, so it can be re-made: the v1.0 ``script/`` is where this | |
| release's producer lives, and the contract and schema pair is the document set the | |
| data was written against. | |
| """ | |
| script_count, script_removed = sync_tree(V10 / "script", SNAPSHOT / "script", | |
| "the v1.0 scripts") | |
| doc_target = SNAPSHOT / "doc" | |
| doc_target.mkdir(parents=True, exist_ok=True) | |
| wanted = [] | |
| for name in ("CONTRACT.md", "schema.json"): | |
| source = V10 / "doc" / name | |
| if not source.is_file(): | |
| raise SystemExit(f"{source} is missing; the v1.0 contract pair is incomplete") | |
| shutil.copy2(source, doc_target / name) | |
| wanted.append(name) | |
| removed = [rel for rel in script_removed] | |
| for path in sorted(doc_target.iterdir()): | |
| if path.is_file() and path.name not in wanted: | |
| path.unlink() | |
| removed.append(path.relative_to(RELEASE_ROOT).as_posix()) | |
| return script_count, len(wanted), removed | |
| def main(argv=None): | |
| parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) | |
| parser.add_argument("--dry-run", action="store_true", | |
| help="report what would be written and change nothing") | |
| args = parser.parse_args(argv) | |
| state = state_name() | |
| print(f"banner state: {state}") | |
| #: The carried-over trees are produced *before* the mapping record is checked, | |
| #: because that record is where a reader is told the v1.0 scripts live in | |
| #: ``script/v1_0_snapshot/`` -- and this script is what puts them there. Checking | |
| #: first would fail on a tree built from scratch, which is exactly the case the | |
| #: check exists for; it would also mean the first run of a fresh build reports a | |
| #: broken mapping record that is in fact correct. | |
| if args.dry_run: | |
| source = V10 / "doc" | |
| print(f" would sync doc/history-v1.0/ from {source} " | |
| f"({sum(1 for p in source.rglob('*') if p.is_file())} files)") | |
| print(f" would snapshot {V10 / 'script'} into script/v1_0_snapshot/script") | |
| else: | |
| count, removed = sync_history() | |
| print(f" doc/history-v1.0/: {count} files synced from {V10 / 'doc'}" | |
| f"{f', {len(removed)} stale file(s) removed' if removed else ''}") | |
| script_count, doc_count, removed = sync_snapshot() | |
| print(f" script/v1_0_snapshot/: {script_count} script files + {doc_count} " | |
| f"contract files synced from {V10}" | |
| f"{f', {len(removed)} stale file(s) removed' if removed else ''}") | |
| mapping, referenced = check_mapping_record(args.dry_run) | |
| print(f" doc/RAW_MAPPING.md: {sha256(mapping)[:16]} {mapping.stat().st_size} B " | |
| f"(ReInterHand's own record, name kept; {len(referenced)} script reference(s) resolve)") | |
| #: transformed documents are authored here and normalised to LF; copied ones | |
| #: are other artifacts reproduced byte for byte, line endings included | |
| transformed = { | |
| "CONTRACT.md": build_contract(state).encode("utf-8"), | |
| "MIGRATION.md": canonical_bytes("MIGRATION.md"), | |
| } | |
| copied = { | |
| "schema.json": canonical_bytes("schema.json"), | |
| "V1_0_SEMANTICS.md": (V10 / "doc" / "CONTRACT.md").read_bytes(), | |
| } | |
| for name, payload in transformed.items(): | |
| write(DOC / name, payload, "transformed", args.dry_run) | |
| for name, payload in copied.items(): | |
| write(DOC / name, payload, "copied", args.dry_run) | |
| if not args.dry_run: | |
| print(f" doc/CONTRACT.md banner: {STATES[state]['banner']}") | |
| return 0 | |
| def write(target, payload, kind, dry_run): | |
| if dry_run: | |
| print(f" would write doc/{target.name} ({len(payload)} bytes, {kind})") | |
| return | |
| before = sha256(target) if target.is_file() else None | |
| target.write_bytes(payload) | |
| after = sha256(target) | |
| print(f" doc/{target.name}: {len(payload)} bytes, {kind}, sha256 {after[:16]}" | |
| f"{'' if before != after else ' (unchanged)'}") | |
| if __name__ == "__main__": | |
| sys.dont_write_bytecode = True | |
| raise SystemExit(main()) |