| |
| """Materialize MedWeave images from user-provided, legally obtained roots.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import os |
| import shutil |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def load_manifest(path: Path) -> dict[str, dict[str, Any]]: |
| required: dict[str, dict[str, Any]] = {} |
| with path.open(encoding="utf-8") as handle: |
| for line_number, line in enumerate(handle, 1): |
| if not line.strip(): |
| continue |
| row = json.loads(line) |
| digest = str(row["sha256"]) |
| expected_path = str(row["expected_path"]) |
| previous = required.get(digest) |
| if previous and previous["expected_path"] != expected_path: |
| raise ValueError( |
| f"Digest {digest} has conflicting paths at line {line_number}: " |
| f"{previous['expected_path']} vs {expected_path}" |
| ) |
| required[digest] = row |
| return required |
|
|
|
|
| def write_missing(path: Path, rows: list[dict[str, Any]]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("w", encoding="utf-8", newline="\n") as handle: |
| for row in rows: |
| handle.write(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n") |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser( |
| description=( |
| "Hash user-provided files and materialize exact matches into the " |
| "MedWeave snapshot layout. The command never downloads source data." |
| ) |
| ) |
| parser.add_argument("--manifest", type=Path, required=True) |
| parser.add_argument("--output-root", type=Path, required=True) |
| parser.add_argument("--search-root", type=Path, action="append", required=True) |
| parser.add_argument("--copy", action="store_true", help="Copy instead of creating symlinks") |
| parser.add_argument( |
| "--missing-report", |
| type=Path, |
| default=None, |
| help="Default: <output-root>/missing_images.jsonl", |
| ) |
| parser.add_argument( |
| "--allow-missing", |
| action="store_true", |
| help="Return success even when some assets remain unresolved", |
| ) |
| args = parser.parse_args() |
|
|
| required = load_manifest(args.manifest) |
| already_present: set[str] = set() |
| unresolved: dict[str, dict[str, Any]] = {} |
|
|
| for digest, row in required.items(): |
| target = args.output_root / row["expected_path"] |
| if target.is_file() and sha256_file(target) == digest: |
| already_present.add(digest) |
| else: |
| unresolved[digest] = row |
|
|
| found: dict[str, Path] = {} |
| scanned_files = 0 |
| for root in args.search_root: |
| if not root.is_dir(): |
| raise NotADirectoryError(root) |
| for path in root.rglob("*"): |
| if not path.is_file(): |
| continue |
| scanned_files += 1 |
| digest = sha256_file(path) |
| if digest in unresolved and digest not in found: |
| found[digest] = path.resolve() |
| if len(found) == len(unresolved): |
| break |
| if len(found) == len(unresolved): |
| break |
|
|
| for digest, source in found.items(): |
| target = args.output_root / unresolved[digest]["expected_path"] |
| target.parent.mkdir(parents=True, exist_ok=True) |
| if target.exists() or target.is_symlink(): |
| if target.is_file() and sha256_file(target) == digest: |
| continue |
| raise RuntimeError(f"Refusing to overwrite non-matching file: {target}") |
| if args.copy: |
| shutil.copy2(source, target) |
| else: |
| os.symlink(source, target) |
|
|
| missing_digests = sorted(set(unresolved) - set(found)) |
| missing_rows = [required[digest] for digest in missing_digests] |
| missing_report = args.missing_report or (args.output_root / "missing_images.jsonl") |
| write_missing(missing_report, missing_rows) |
|
|
| summary = { |
| "assets_in_manifest": len(required), |
| "already_present": len(already_present), |
| "scanned_files": scanned_files, |
| "materialized_now": len(found), |
| "still_missing": len(missing_rows), |
| "missing_report": str(missing_report), |
| "mode": "copy" if args.copy else "symlink", |
| } |
| print(json.dumps(summary, indent=2, sort_keys=True)) |
| if missing_rows and not args.allow_missing: |
| raise SystemExit(2) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
