| |
| """Migrate the adjacent shared-v1.0 tree of this dataset to shared-v1.1. |
| |
| Only the tensor layout changes (CONTRACT 1-5): numeric tensors and their validity |
| move into per-group bundles, metainfo references gain ``data_key``/``valid_key`` |
| with ``pt/tensor_bundle/v1`` storage, and the two version fields are bumped. |
| Sampling, frame counts, dtypes, values, NaN bit patterns, validity judgements, |
| units, coordinate frames, hand slots, split and ``valid_policy`` are carried over |
| untouched (CONTRACT 6.3). |
| |
| The source tree is never written to: this is a copy-out. Unchanged media and |
| JSONL are hardlinked by default, so nothing is re-encoded and no bytes are |
| duplicated (MIGRATION 2, 6). Every view is checkpointed with source and output |
| digests so ``--resume`` re-verifies rather than trusting file existence |
| (MIGRATION 4.4). |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import fcntl |
| import json |
| import os |
| import shutil |
| import sys |
| import time |
| import traceback |
| from contextlib import contextmanager |
| from pathlib import Path |
|
|
| import torch |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
|
|
| from warehouse import ( |
| BUNDLE_PROFILE, |
| DATA_TERMINAL, |
| RELEASE_ID, |
| SCHEMA_VERSION, |
| VALID_TERMINAL, |
| BundleWriter, |
| Registry, |
| expanded_all_known, |
| sha256_bytes, |
| sha256_file, |
| same_tensor, |
| ) |
|
|
| V10_SCHEMA_VERSION = "hand-warehouse/1.0" |
| TOOL_ID = "hw11-migrate" |
| TOOL_REVISION = "1" |
|
|
| |
| |
| RELEASE_ROOT = Path(__file__).resolve().parent.parent.parent |
| DATASET_ROOT = RELEASE_ROOT.parent |
|
|
|
|
| |
| |
| |
|
|
| @contextmanager |
| def migration_lock(work: Path): |
| """MIGRATION 3: one migrator per dataset, held for the whole run. |
| |
| The lock file lives in ``tmp/`` beside the checkpoints it protects, outside |
| the release tree. A second run is refused rather than interleaved: two |
| processes writing the same destination view would each leave behind a |
| checkpoint describing a tree the other had already overwritten, and a |
| checkpoint that cannot be trusted is worse than none. |
| """ |
| work.mkdir(parents=True, exist_ok=True) |
| path = work / "migration.lock" |
| with path.open("a+", encoding="utf-8") as stream: |
| try: |
| fcntl.flock(stream, fcntl.LOCK_EX | fcntl.LOCK_NB) |
| except BlockingIOError as error: |
| holder = path.read_text(encoding="utf-8").strip() or "unknown" |
| raise SystemExit( |
| f"another migration already holds {path} ({holder}); " |
| "refusing to run two at once (MIGRATION 3)" |
| ) from error |
| stream.seek(0) |
| stream.truncate() |
| stream.write(f"pid {os.getpid()} started {time.strftime('%Y-%m-%dT%H:%M:%S%z')}\n") |
| stream.flush() |
| try: |
| yield |
| finally: |
| fcntl.flock(stream, fcntl.LOCK_UN) |
|
|
|
|
| def _clone(src: Path, dst: Path) -> None: |
| """FICLONE (reflink) copy where the filesystem supports it.""" |
| with open(src, "rb") as reader, open(dst, "wb") as writer: |
| fcntl.ioctl(writer.fileno(), 0x40049409, reader.fileno()) |
|
|
|
|
| def materialise(src: Path, dst: Path, mode: str) -> str: |
| """Place an unchanged file at ``dst`` without ever re-encoding it. |
| |
| An existing destination is never trusted on existence alone: it must be the |
| same inode as the source, or match it by SHA256, otherwise it is replaced. |
| """ |
| dst.parent.mkdir(parents=True, exist_ok=True) |
| if dst.exists(): |
| if os.path.samefile(src, dst): |
| return "same-inode" |
| if dst.stat().st_size == src.stat().st_size and sha256_file(dst) == sha256_file(src): |
| return "present-verified" |
| temp = dst.with_name(dst.name + ".hw11-tmp") |
| temp.unlink(missing_ok=True) |
| shutil.copy2(src, temp) |
| os.replace(temp, dst) |
| if mode in ("hardlink", "reflink"): |
| link = os.link if mode == "hardlink" else (lambda a, b: _clone(Path(a), Path(b))) |
| try: |
| link(src, dst) |
| return mode |
| except OSError: |
| pass |
| shutil.copy2(src, dst) |
| return "copy" |
|
|
|
|
| def load_tensor(path: Path) -> torch.Tensor: |
| tensor = torch.load(path, map_location="cpu", weights_only=True) |
| if not isinstance(tensor, torch.Tensor): |
| raise TypeError(f"{path}: expected a Tensor, got {type(tensor).__name__}") |
| return tensor |
|
|
|
|
| |
| |
| |
|
|
| |
| SCHEMA_IDENTITY_FIELDS = ("dtype", "shape", "valid_shape", "unit") |
|
|
|
|
| def schema_id_note(registry: Registry, owner: str, spec: dict, entry: dict, |
| bundle_rel: str, field: str): |
| """Reconcile a v1.0 ``schema_id`` with the bundle entry's ``schema_ids`` list. |
| |
| A mismatch is recorded as a note, not raised. CONTRACT 6.3 forbids changing |
| ``schema_id``, so a v1.0 label the registry words differently cannot be |
| corrected here; ``schema_ids`` is documented nowhere in CONTRACT.md or |
| MIGRATION.md; and the registry's own ``note`` calls it "a declarative registry, |
| not a JSON Schema document or executable validator". The check keeps its real |
| purpose by refusing only when the declared schema is not *structurally* the |
| field the entry allows (dtype, shape, valid_shape, unit) -- which is what a |
| wrong bundle entry actually looks like. |
| |
| The case this was written for is a v1.0 that labels a field with one of the |
| entry's ``schema_ids`` while declaring a ``convention`` the registry pairs with |
| a *different* one of them, the two definitions being identical in every identity |
| field. ``notes`` stays empty as long as no view does that; the pilot asserts it, |
| and the check is the guard that keeps a schema mismatch from being silently |
| accepted if one ever appears. |
| """ |
| allowed = entry.get("schema_ids") |
| schema_id = spec.get("schema_id") |
| if allowed is None or schema_id in allowed: |
| return None |
| declared = registry.components.get(schema_id) |
| if declared is None: |
| raise ValueError(f"{owner}: schema_id {schema_id!r} is not registered") |
| equivalent = [name for name in allowed |
| if all(declared.get(key) == (registry.components.get(name) or {}).get(key) |
| for key in SCHEMA_IDENTITY_FIELDS)] |
| if not equivalent: |
| raise ValueError( |
| f"{owner}: schema_id {schema_id!r} not allowed in {bundle_rel}:{field} and " |
| f"is not structurally equivalent to any of {list(allowed)}") |
| return { |
| "owner": owner, |
| "entry": f"{bundle_rel}:{field}", |
| "declared_schema_id": schema_id, |
| "entry_schema_ids": list(allowed), |
| "structurally_equivalent_to": equivalent, |
| "reason": "CONTRACT 6.3 forbids changing schema_id; the entry allows a " |
| "schema identical in dtype, shape, valid_shape and unit", |
| } |
|
|
|
|
| def shared_distortion_valid(registry: Registry, owner: dict, entry: dict, |
| data: torch.Tensor, owner_valid): |
| """The bool an existing camera model pairs between intrinsic and distortion. |
| |
| CONTRACT 3: "既有相机模型要求内参与单独畸变向量共用有效性时，在两个字段内保存 |
| 相同 bool 值并校验一致". This is the path for a v1.0 that declares |
| ``distortion_ref`` with no distortion validity of its own: the owning component's |
| intrinsic validity is the pairing the model already had, so this restates it |
| rather than expanding an all-true tensor that was never declared. |
| |
| ReInterHand's ego views reach this helper, and it is the interesting case. Their |
| v1.0 splits the two roles across two declarations: ``intrinsic`` carries the |
| pointer (``distortion_ref``, no validity) while the standalone ``distortion`` |
| component carries the bool (``valid_ref = camera/distortion_valid.pt``). The |
| search below keys on the pointer, so ``camera_meta`` is ``intrinsic``, its |
| ``distortion_valid_ref`` is absent, and the pairing falls to this helper -- which |
| is exactly the CONTRACT 3 relationship the model requires. The verdict is |
| checked against the component's own declaration rather than trusted; see the |
| staged-identity guard at the call site. |
| """ |
| required = (registry.components.get(owner.get("schema_id")) or {}).get( |
| "required_metadata") or [] |
| if not any(key.startswith("distortion") for key in required) or owner_valid is None: |
| return None |
| declared = _distortion_valid_shape(registry, entry, data) |
| if declared is None or list(owner_valid.shape) != declared: |
| return None |
| return owner_valid |
|
|
|
|
| def _distortion_valid_shape(registry: Registry, entry: dict, data: torch.Tensor): |
| """Resolve the declared ``valid_shape`` of whichever distortion schema fits ``data``. |
| |
| Which of the entry's schemas applies is decided structurally, by the declared |
| ``shape`` matching the tensor, so nothing is assumed from the model's name. |
| """ |
| for schema_id in entry.get("schema_ids") or []: |
| shape = (registry.components.get(schema_id) or {}).get("shape") |
| if not shape or len(shape) != data.ndim: |
| continue |
| if not all(isinstance(dim, str) or int(dim) == size |
| for dim, size in zip(shape, data.shape)): |
| continue |
| valid_shape = (registry.components.get(schema_id) or {}).get("valid_shape") or [] |
| return [data.shape[axis] if isinstance(dim, str) else int(dim) |
| for axis, dim in enumerate(valid_shape)] |
| return None |
|
|
|
|
| |
| |
| |
|
|
| def _declared_shape(registry: Registry, owner: str, spec: dict, kind: str): |
| """The registry's declared ``(shape, valid_shape)`` for this field.""" |
| if kind == "attribute": |
| return None, registry.visibility_valid_shape(spec["axes"]) |
| schema_id = spec.get("schema_id") |
| entry = registry.components.get(schema_id) |
| if entry is None: |
| raise KeyError(f"{owner}: schema_id {schema_id!r} is not registered") |
| return entry.get("shape"), entry.get("valid_shape") |
|
|
|
|
| def _rewrite_reference(spec: dict, bundle_rel: str, keys: list, valid: torch.Tensor) -> dict: |
| """CONTRACT 5: same-file data/valid refs plus explicit dictionary keys.""" |
| before = { |
| "data_ref": spec.get("data_ref"), |
| "valid_ref": spec.get("valid_ref"), |
| "valid": spec.pop("valid", "<absent>"), |
| "valid_axes": spec.get("valid_axes"), |
| } |
| spec["data_ref"] = bundle_rel |
| spec["data_key"] = list(keys) + [DATA_TERMINAL] |
| spec["valid_ref"] = bundle_rel |
| spec["valid_key"] = list(keys) + [VALID_TERMINAL] |
| spec["storage"] = {"profile": BUNDLE_PROFILE} |
| spec["valid_storage"] = {"profile": BUNDLE_PROFILE} |
| |
| |
| axes = spec.get("axes") |
| if axes and not spec.get("valid_axes"): |
| spec["valid_axes"] = list(axes)[:valid.ndim] |
| return before |
|
|
|
|
| def _stage(registry, src_view, dst_view, writers, consumed, records, staged, notes, |
| owner, spec, kind, num_frames): |
| """Stage one registered numeric field into its bundle. No-op when unmerged. |
| |
| Returns the field's bool validity Tensor, or ``None`` when the reference is not |
| a registered numeric field (media / JSONL / assets, preserved verbatim). The |
| caller needs that Tensor because this function rewrites ``spec`` in place via |
| `_rewrite_reference`, so the same spec can no longer be resolved to its source |
| field once staged. |
| """ |
| ref = spec.get("data_ref") |
| if not ref: |
| return None |
| resolved = registry.resolve(ref) |
| if resolved is None: |
| return None |
| bundle_rel, keys, entry = resolved |
| field = "/".join(keys) |
|
|
| note = schema_id_note(registry, owner, spec, entry, bundle_rel, field) |
| if note is not None: |
| notes.append(note) |
| if entry.get("attribute_id") and kind != "attribute": |
| raise ValueError(f"{owner}: {bundle_rel}:{field} is an attribute entry") |
| if kind == "attribute" and not entry.get("attribute_id"): |
| raise ValueError(f"{owner}: {bundle_rel}:{field} is not declared as an attribute") |
|
|
| source = src_view / ref |
| if not source.is_file(): |
| raise FileNotFoundError(f"{owner}: {ref} is registered but missing") |
|
|
| data = load_tensor(source) |
| declared_shape, declared_valid_shape = _declared_shape(registry, owner, spec, kind) |
| if declared_shape and declared_shape[0] == "T" and data.shape[0] != num_frames: |
| raise ValueError( |
| f"{owner}: {ref} has {data.shape[0]} frames but metainfo says {num_frames}") |
|
|
| valid_ref = spec.get("valid_ref") |
| if valid_ref: |
| valid = load_tensor(src_view / valid_ref) |
| consumed.add(valid_ref) |
| origin = f"source tensor {valid_ref}" |
| else: |
| if spec.get("valid") is not True: |
| raise ValueError(f"{owner}: {ref} has neither valid_ref nor a declared all-known scalar") |
| valid = expanded_all_known(data, declared_valid_shape) |
| origin = "expanded declared all-known scalar (CONTRACT 3)" |
|
|
| writer = writers.get(bundle_rel) |
| if writer is None: |
| writer = writers[bundle_rel] = BundleWriter(dst_view, bundle_rel) |
|
|
| |
| |
| |
| identity = (bundle_rel, field) |
| prior = staged.get(identity) |
| if prior is None: |
| writer.put(keys, data, valid) |
| staged[identity] = {"data": data, "valid": valid, "owners": [owner], |
| "source_data_ref": ref, "source_valid_ref": valid_ref} |
| shared_with = None |
| else: |
| if not (same_tensor(prior["data"], data) and same_tensor(prior["valid"], valid)): |
| raise ValueError( |
| f"{owner}: {identity[0]}:{field} is already staged from " |
| f"{prior['source_data_ref']} with different values") |
| prior["owners"].append(owner) |
| shared_with = list(prior["owners"]) |
| consumed.add(ref) |
|
|
| before = _rewrite_reference(spec, bundle_rel, keys, valid) |
| records.append({ |
| "owner": owner, |
| "kind": kind, |
| "entry": f"{bundle_rel}:{field}", |
| "source_data_ref": before["data_ref"], |
| "source_valid_ref": before["valid_ref"], |
| "source_scalar_valid": before["valid"], |
| "source_valid_axes": before["valid_axes"], |
| "valid_origin": origin, |
| "shared_entry_owners": shared_with, |
| "dtype": str(data.dtype), |
| "shape": list(data.shape), |
| "valid_shape": list(valid.shape), |
| "valid_true": int(valid.sum()), |
| "valid_false": int((~valid).sum()), |
| "nan_count": int(torch.isnan(data).sum()) if data.is_floating_point() else None, |
| }) |
| return valid |
|
|
|
|
| def normalize_storage_revision(registry: Registry, meta: dict) -> bool: |
| """Point the view's ``storage_revision`` at the revision the registry itself declares. |
| |
| v1.0's converter stamped ``lossless-video-2026-09-25`` into all 6,750 views, and |
| ``doc/schema.json`` -- including the copy v1.0 shipped -- declares no such revision: |
| its own is ``lossless-video-2026-09-18``, the value the published v1.1 siblings |
| (RHD, ARCTIC) carry in every view. Nothing else about the key is a claim this |
| migration may touch, so the value is read off the schema rather than restated here, |
| and a view that declares no ``storage_revision`` keeps declaring none (the registry |
| does not require the key, and H2O's published v1.1 omits it outright). Returns |
| whether this view's value actually changed. |
| """ |
| if "storage_revision" not in meta: |
| return False |
| declared = registry.schema["storage_revision"] |
| changed = meta["storage_revision"] != declared |
| meta["storage_revision"] = declared |
| return changed |
|
|
|
|
| def migrate_view(registry, src_root, dst_root, sequence, camera, link_mode): |
| """Migrate one ``<sequence>/<camera>`` view and return its report entry.""" |
| src_view = src_root / sequence / camera |
| dst_view = dst_root / sequence / camera |
| meta_path = src_view / "metainfo.json" |
| meta = json.loads(meta_path.read_text(encoding="utf-8")) |
| if meta.get("schema_version") != V10_SCHEMA_VERSION: |
| raise ValueError(f"{meta_path}: not {V10_SCHEMA_VERSION}") |
| if (meta.get("sequence_id"), meta.get("camera_id")) != (sequence, camera): |
| raise ValueError(f"{meta_path}: sequence_id/camera_id do not match the directory") |
| num_frames = meta["num_frames"] |
|
|
| dst_view.mkdir(parents=True, exist_ok=True) |
| writers, consumed, records, staged, notes = {}, set(), [], {}, [] |
|
|
| |
| |
| |
| |
| staged_valid = {} |
| for name, component in meta["components"].items(): |
| if not component.get("available", True): |
| continue |
| staged_valid[name] = _stage( |
| registry, src_view, dst_view, writers, consumed, records, staged, notes, |
| name, component, "component", num_frames) |
| for attribute, spec in (component.get("attributes") or {}).items(): |
| _stage(registry, src_view, dst_view, writers, consumed, records, staged, notes, |
| f"{name}.{attribute}", spec, "attribute", num_frames) |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| distortion_meta, distortion_owner = None, None |
| for name, component in meta["components"].items(): |
| if component.get("distortion_ref"): |
| distortion_meta, distortion_owner = component, name |
| break |
| if distortion_meta is None and (meta.get("camera") or {}).get("distortion_ref"): |
| distortion_meta = meta["camera"] |
| if distortion_meta is not None: |
| camera_meta = distortion_meta |
| owner_label = (f"{distortion_owner}.distortion" if distortion_owner |
| else "camera.distortion") |
| ref = camera_meta["distortion_ref"] |
| resolved = registry.resolve(ref) |
| if resolved is None: |
| raise ValueError(f"camera.distortion_ref {ref!r} does not resolve to a bundle") |
| bundle_rel, keys, entry = resolved |
| data = load_tensor(src_view / ref) |
| valid_ref = camera_meta.get("distortion_valid_ref") |
| if valid_ref: |
| valid = load_tensor(src_view / valid_ref) |
| consumed.add(valid_ref) |
| origin = f"source tensor {valid_ref}" |
| else: |
| valid = shared_distortion_valid(registry, distortion_meta, entry, data, |
| staged_valid.get(distortion_owner)) |
| if valid is not None: |
| origin = "shared with intrinsic validity (CONTRACT 3)" |
| else: |
| valid = expanded_all_known(data, camera_meta.get("distortion_valid_shape")) |
| origin = "expanded declared all-known scalar (CONTRACT 3)" |
| writer = writers.get(bundle_rel) or writers.setdefault( |
| bundle_rel, BundleWriter(dst_view, bundle_rel)) |
| identity = (bundle_rel, "/".join(keys)) |
| prior = staged.get(identity) |
| if prior is None: |
| writer.put(keys, data, valid) |
| staged[identity] = {"data": data, "valid": valid, "owners": [owner_label], |
| "source_data_ref": ref, "source_valid_ref": valid_ref} |
| shared_with = None |
| else: |
| if not (same_tensor(prior["data"], data) and same_tensor(prior["valid"], valid)): |
| raise ValueError( |
| f"{owner_label}: {identity[0]}:{identity[1]} is already staged from " |
| f"{prior['source_data_ref']} with different values") |
| prior["owners"].append(owner_label) |
| shared_with = list(prior["owners"]) |
| origin = (f"entry already staged from {prior['source_data_ref']}; " |
| f"{origin} agrees byte-for-byte") |
| consumed.add(ref) |
| camera_meta["distortion_ref"] = bundle_rel |
| camera_meta["distortion_key"] = list(keys) + [DATA_TERMINAL] |
| camera_meta["distortion_valid_ref"] = bundle_rel |
| camera_meta["distortion_valid_key"] = list(keys) + [VALID_TERMINAL] |
| records.append({ |
| "owner": owner_label, |
| "kind": "component", |
| "entry": f"{bundle_rel}:{'/'.join(keys)}", |
| "source_data_ref": ref, |
| "source_valid_ref": valid_ref, |
| "source_scalar_valid": "<absent>", |
| "source_valid_axes": camera_meta.get("distortion_valid_axes"), |
| "valid_origin": origin, |
| "shared_entry_owners": shared_with, |
| "dtype": str(data.dtype), |
| "shape": list(data.shape), |
| "valid_shape": list(valid.shape), |
| "valid_true": int(valid.sum()), |
| "valid_false": int((~valid).sum()), |
| "nan_count": int(torch.isnan(data).sum()) if data.is_floating_point() else None, |
| }) |
|
|
| |
| passthrough = {} |
| for path in sorted(src_view.rglob("*")): |
| if not path.is_file(): |
| continue |
| rel = path.relative_to(src_view).as_posix() |
| if rel in consumed or rel == "metainfo.json": |
| continue |
| passthrough[rel] = materialise(path, dst_view / rel, link_mode) |
|
|
| |
| verification = [] |
| for bundle_rel, writer in sorted(writers.items()): |
| path = writer.save() |
| if path is None: |
| continue |
| reloaded = torch.load(path, map_location="cpu", weights_only=True) |
| for keys, leaf in _walk_leaf(writer.tree): |
| node = reloaded |
| for key in keys: |
| node = node[key] |
| for terminal in (DATA_TERMINAL, VALID_TERMINAL): |
| if not same_tensor(leaf[terminal], node[terminal]): |
| raise AssertionError(f"{bundle_rel}:{'/'.join(keys)}:{terminal} not byte-identical") |
| verification.append({ |
| "bundle": bundle_rel, |
| "sha256": sha256_file(path), |
| "size": path.stat().st_size, |
| "fields": sum(1 for _ in _walk_leaf(writer.tree)), |
| "comparison": "byte_view_exact_no_tolerance", |
| }) |
|
|
| meta["schema_version"] = SCHEMA_VERSION |
| meta["release_id"] = RELEASE_ID |
| storage_revision_changed = normalize_storage_revision(registry, meta) |
| _write_json(dst_view / "metainfo.json", meta) |
|
|
| return { |
| "sequence_id": sequence, |
| "camera_id": camera, |
| "num_frames": num_frames, |
| "storage_revision_changed": storage_revision_changed, |
| "source_metainfo_sha256": sha256_file(meta_path), |
| "source_metainfo_size": meta_path.stat().st_size, |
| "output_metainfo_sha256": sha256_file(dst_view / "metainfo.json"), |
| "bundles": verification, |
| "fields": records, |
| "schema_notes": notes, |
| "passthrough_files": len(passthrough), |
| "passthrough_modes": sorted(set(passthrough.values())), |
| "replaced_source_refs": sorted( |
| {r["source_data_ref"] for r in records} | {r["source_valid_ref"] for r in records if r["source_valid_ref"]}), |
| } |
|
|
|
|
| def _walk_leaf(tree, prefix=()): |
| for key, value in tree.items(): |
| if isinstance(value, dict) and set(value) == {DATA_TERMINAL, VALID_TERMINAL}: |
| yield prefix + (key,), value |
| elif isinstance(value, dict): |
| yield from _walk_leaf(value, prefix + (key,)) |
|
|
|
|
| def _write_json(path: Path, value) -> None: |
| path = Path(path) |
| path.parent.mkdir(parents=True, exist_ok=True) |
| temp = path.with_name(path.name + ".tmp") |
| temp.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + "\n", |
| encoding="utf-8") |
| temp.replace(path) |
|
|
|
|
| |
| |
| |
|
|
| def discover_views(src_root: Path): |
| views = [] |
| for meta in sorted(src_root.glob("data/*/*/metainfo.json")): |
| views.append((meta.parent.parent.name, meta.parent.name)) |
| return views |
|
|
|
|
| def tool_digest(script_dir: Path, schema_path: Path) -> dict: |
| return { |
| "tool": f"{TOOL_ID}/{TOOL_REVISION}", |
| "migrate_sha256": sha256_file(Path(__file__).resolve()), |
| "layout_sha256": sha256_file(script_dir / "warehouse.py"), |
| "schema_sha256": sha256_file(schema_path), |
| "python": sys.version.split()[0], |
| "torch": torch.__version__, |
| } |
|
|
|
|
| def source_manifest(path: Path | None) -> dict | None: |
| """Describe the tree-API manifest the source bytes were pulled against. |
| |
| The registration has to be readable on its own: "this tree came from revision |
| X" means little without the file list and digests that revision published, so |
| the manifest's own digest and size travel with it (MIGRATION 3). |
| """ |
| if path is None: |
| return None |
| entries = json.loads(path.read_text(encoding="utf-8")) |
| entries = entries["files"] if isinstance(entries, dict) else entries |
| return { |
| "path": str(path.resolve()), |
| "sha256": sha256_file(path), |
| "files": len(entries), |
| "bytes": sum(int(entry.get("size", 0)) for entry in entries), |
| } |
|
|
|
|
| def checkpoint_ok(state_path: Path, expected: dict, digest: dict) -> bool: |
| """MIGRATION 4.4: re-verify inputs, tool revision and artefacts, not existence.""" |
| if not state_path.is_file(): |
| return False |
| try: |
| prior = json.loads(state_path.read_text(encoding="utf-8")) |
| except (json.JSONDecodeError, OSError): |
| return False |
| if prior.get("tool") != digest: |
| return False |
| |
| if prior.get("dst_view") != str(expected["dst_view"]): |
| return False |
| if prior.get("source_metainfo_sha256") != expected["source_metainfo_sha256"]: |
| return False |
| for bundle in prior.get("bundles", []): |
| path = Path(prior["dst_view"]) / bundle["bundle"] |
| if not path.is_file() or sha256_file(path) != bundle["sha256"]: |
| return False |
| meta = Path(prior["dst_view"]) / "metainfo.json" |
| if not meta.is_file() or sha256_file(meta) != prior["output_metainfo_sha256"]: |
| return False |
| return True |
|
|
|
|
| def main(argv=None): |
| parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) |
| parser.add_argument("--src", type=Path, default=DATASET_ROOT, |
| help="dataset root holding shared-v1.0 (default: the dataset " |
| "this package is installed in)") |
| parser.add_argument("--dst", type=Path, default=RELEASE_ROOT, |
| help="output release directory (default <src>/shared-v1.1)") |
| parser.add_argument("--schema", type=Path, default=RELEASE_ROOT / "doc" / "schema.json", |
| help="v1.1 schema.json (default <dst>/doc/schema.json)") |
| parser.add_argument("--link", default="hardlink", choices=["hardlink", "reflink", "copy"], |
| help="how unchanged media/JSONL is placed (default hardlink)") |
| parser.add_argument("--views", nargs="*", default=None, |
| help="restrict to these sequence ids") |
| parser.add_argument("--limit", type=int, default=None, help="migrate at most N views") |
| parser.add_argument("--resume", action="store_true", |
| help="skip views whose checkpoint re-verifies") |
| parser.add_argument("--dry-run", action="store_true") |
| parser.add_argument("--source-revision", default=None, metavar="SHA", |
| help="the pinned revision the shared-v1.0 bytes came from; " |
| "recorded in the registration (MIGRATION 3)") |
| parser.add_argument("--source-manifest", type=Path, default=None, |
| help="tree-API manifest of that revision; its digest and file " |
| "count are recorded so the registration is self-contained") |
| args = parser.parse_args(argv) |
|
|
| src_release = args.src / "shared-v1.0" |
| dst_release = args.dst or (args.src / "shared-v1.1") |
| if not src_release.is_dir(): |
| parser.error(f"{src_release} is not a directory") |
| schema_path = args.schema or (dst_release / "doc" / "schema.json") |
| if not schema_path.is_file(): |
| parser.error(f"v1.1 schema not found at {schema_path} (pass --schema)") |
| registry = Registry.load(schema_path) |
|
|
| src_root, dst_root = src_release / "data", dst_release / "data" |
| views = discover_views(src_release) |
| if not views: |
| parser.error(f"no <sequence>/<camera>/metainfo.json found under {src_root}") |
| first = src_root / views[0][0] / views[0][1] / "metainfo.json" |
| dataset_id = json.loads(first.read_text(encoding="utf-8"))["dataset_id"] |
|
|
| work = args.src / "tmp" / "migration-v11" |
| state_dir = work / "checkpoints" |
| if args.views: |
| wanted = set(args.views) |
| views = [v for v in views if v[0] in wanted] |
| if args.limit: |
| views = views[:args.limit] |
|
|
| digest = tool_digest(Path(__file__).resolve().parent, schema_path) |
| print(f"dataset={dataset_id} views={len(views)} src={src_release} dst={dst_release}") |
| print(f"tool={digest['tool']} link={args.link}") |
| if args.dry_run: |
| for sequence, camera in views: |
| print(f" would migrate {sequence}/{camera}") |
| return 0 |
|
|
| with migration_lock(work): |
| registration = { |
| "dataset_id": dataset_id, |
| "source": {"release": "shared-v1.0", "schema_version": V10_SCHEMA_VERSION, |
| "schema_sha256": sha256_file(src_release / "doc" / "schema.json") |
| if (src_release / "doc" / "schema.json").is_file() else None, |
| "path": str(src_release.resolve()), |
| "revision": args.source_revision, |
| "manifest": source_manifest(args.source_manifest)}, |
| "target": {"release": RELEASE_ID, "schema_version": SCHEMA_VERSION, |
| "schema_sha256": sha256_file(schema_path), "path": str(dst_release.resolve())}, |
| "tool": digest, |
| "started": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), |
| "views_total": len(views), |
| "views": [], |
| "errors": [], |
| } |
|
|
| done = skipped = failed = 0 |
| for index, (sequence, camera) in enumerate(views, 1): |
| state_path = state_dir / f"{sequence}__{camera}.json" |
| dst_view = dst_root / sequence / camera |
| try: |
| if args.resume and checkpoint_ok(state_path, { |
| "dst_view": str(dst_view), |
| "source_metainfo_sha256": sha256_file(src_root / sequence / camera / "metainfo.json"), |
| }, digest): |
| skipped += 1 |
| print(f"[{index}/{len(views)}] {sequence}/{camera} skip (checkpoint re-verified)") |
| continue |
| entry = migrate_view(registry, src_root, dst_root, sequence, camera, args.link) |
| entry["dst_view"] = str(dst_view) |
| entry["tool"] = digest |
| entry["timestamp"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) |
| _write_json(state_path, entry) |
| registration["views"].append({k: entry[k] for k in ( |
| "sequence_id", "camera_id", "num_frames", "source_metainfo_sha256", |
| "output_metainfo_sha256", "bundles", "passthrough_files", |
| "replaced_source_refs", "schema_notes")}) |
| done += 1 |
| print(f"[{index}/{len(views)}] {sequence}/{camera} ok " |
| f"fields={len(entry['fields'])} bundles={len(entry['bundles'])} " |
| f"passthrough={entry['passthrough_files']}") |
| except Exception as error: |
| failed += 1 |
| registration["errors"].append({ |
| "sequence_id": sequence, "camera_id": camera, |
| "error": f"{type(error).__name__}: {error}", |
| "traceback": traceback.format_exc(), |
| }) |
| print(f"[{index}/{len(views)}] {sequence}/{camera} FAILED: {error}", file=sys.stderr) |
| _write_json(work / "registration.json", registration) |
|
|
| registration["finished"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) |
| registration["stage"] = "complete" if failed == 0 else "failed" |
| registration["counts"] = {"migrated": done, "skipped": skipped, "failed": failed} |
| _write_json(work / "registration.json", registration) |
| print(f"done={done} skipped={skipped} failed={failed}") |
| print(f"registration: {work / 'registration.json'}") |
| return 1 if failed else 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
