Datasets:
License:
| #!/usr/bin/env python3 | |
| """Local publish checks for PHM-Vibench without upload/download traffic.""" | |
| from __future__ import annotations | |
| import argparse | |
| import hashlib | |
| import importlib.metadata | |
| import json | |
| import os | |
| import subprocess | |
| import sys | |
| from contextlib import redirect_stdout | |
| from io import StringIO | |
| from pathlib import Path | |
| from types import SimpleNamespace | |
| from urllib.parse import urlencode | |
| from urllib.request import ProxyHandler, Request, build_opener | |
| from phm_vibench_manifest import ( | |
| ARCHIVED_FILES, | |
| DATASET_TO_FILE, | |
| DEMO_FILES, | |
| FILE_SIZES, | |
| HF_ENDPOINT, | |
| HF_REVISION, | |
| LOCAL_ONLY_PATHS, | |
| MODELSCOPE_ENDPOINT, | |
| MODELSCOPE_REVISION, | |
| NETWORK_REDIRECT_ENV_KEYS, | |
| PLATFORM_TARGET_CHOICES, | |
| PUBLISHED_FILES, | |
| PUBLISHED_SMALL_FILES, | |
| PROXY_ENV_KEYS, | |
| REPO_ID, | |
| RM_H5_FILES, | |
| HF_ENDPOINT_ENV_KEYS, | |
| configure_hf_no_proxy, | |
| enforce_no_network_redirects, | |
| expand_platform_targets, | |
| format_bytes, | |
| total_size, | |
| ) | |
| REPO_ROOT = Path(__file__).resolve().parents[1] | |
| README_CARD_MARKERS = [ | |
| "license: apache-2.0", | |
| "task_categories:", | |
| "time-series-classification", | |
| "tags:", | |
| "pretty_name: PHM-Vibench", | |
| "configs:", | |
| "path: RM_*.h5", | |
| ] | |
| PLAIN_TEXT_PUBLISHED_FILES = ["dataset_infos.json", "published_manifest.json", "requirements.txt"] | |
| REMOTE_TIMEOUT_SECONDS = 30 | |
| REQUIRED_PACKAGES = [ | |
| ("huggingface_hub", "0.25"), | |
| ("modelscope", "1.20"), | |
| ("pandas", "1.5"), | |
| ("openpyxl", "3.1"), | |
| ("h5py", "3.8"), | |
| ("numpy", "1.23"), | |
| ] | |
| def sha256_of(path: Path) -> str: | |
| h = hashlib.sha256() | |
| with path.open("rb") as f: | |
| for block in iter(lambda: f.read(1024 * 1024), b""): | |
| h.update(block) | |
| return h.hexdigest() | |
| def build_manifest(*, include_sha256: bool) -> dict: | |
| items = [] | |
| for rel in PUBLISHED_FILES: | |
| path = REPO_ROOT / rel | |
| item = { | |
| "path": rel, | |
| "size_bytes": path.stat().st_size if path.exists() else FILE_SIZES[rel], | |
| "expected_size_bytes": FILE_SIZES[rel], | |
| "targets": ["modelscope", "hf"], | |
| } | |
| if include_sha256: | |
| if not path.exists(): | |
| raise SystemExit(f"Cannot hash missing file: {rel}") | |
| item["sha256"] = sha256_of(path) | |
| items.append(item) | |
| return { | |
| "schema_version": 1, | |
| "repo_id": REPO_ID, | |
| "hf_revision": HF_REVISION, | |
| "modelscope_revision": MODELSCOPE_REVISION, | |
| "platforms": { | |
| "modelscope": {"revision": MODELSCOPE_REVISION, "endpoint": MODELSCOPE_ENDPOINT}, | |
| "hf": {"revision": HF_REVISION, "endpoint": HF_ENDPOINT}, | |
| }, | |
| "presets": { | |
| "metadata": { | |
| "files": ["metadata.xlsx"], | |
| "size_bytes": total_size(["metadata.xlsx"]), | |
| "requires_yes": False, | |
| }, | |
| "docs": { | |
| "files": PUBLISHED_SMALL_FILES, | |
| "size_bytes": total_size(PUBLISHED_SMALL_FILES), | |
| "requires_yes": False, | |
| }, | |
| "demo": { | |
| "files": DEMO_FILES, | |
| "size_bytes": total_size(DEMO_FILES), | |
| "requires_yes": False, | |
| }, | |
| "all": { | |
| "files": PUBLISHED_FILES, | |
| "size_bytes": total_size(PUBLISHED_FILES), | |
| "requires_yes": True, | |
| }, | |
| }, | |
| "datasets": [ | |
| {"id": dataset, "path": path, "size_bytes": FILE_SIZES[path]} | |
| for dataset, path in DATASET_TO_FILE.items() | |
| ], | |
| "published": items, | |
| "archived": [{"path": path, "reason": "legacy metadata superseded by metadata.xlsx"} for path in ARCHIVED_FILES], | |
| "local_only": [{"path": path, "reason": "not part of rolling platform release"} for path in LOCAL_ONLY_PATHS], | |
| } | |
| def cmd_manifest(args: argparse.Namespace) -> int: | |
| manifest = build_manifest(include_sha256=args.sha256) | |
| text = json.dumps(manifest, ensure_ascii=False, indent=2) | |
| if args.output: | |
| args.output.write_text(text + "\n", encoding="utf-8") | |
| print("wrote", args.output) | |
| else: | |
| print(text) | |
| return 0 | |
| def cmd_local_check(_: argparse.Namespace) -> int: | |
| ok = True | |
| print("Published files:", len(PUBLISHED_FILES), format_bytes(total_size(PUBLISHED_FILES))) | |
| for rel in PUBLISHED_FILES: | |
| path = REPO_ROOT / rel | |
| if not path.exists(): | |
| print("MISSING", rel) | |
| ok = False | |
| continue | |
| actual = path.stat().st_size | |
| expected = FILE_SIZES[rel] | |
| status = "OK" if actual == expected else "SIZE-MISMATCH" | |
| print(f"{status:<13} {rel:<36} {format_bytes(actual)}") | |
| if actual != expected: | |
| ok = False | |
| published = set(PUBLISHED_FILES) | |
| accidental = sorted(path for path in ARCHIVED_FILES + LOCAL_ONLY_PATHS if path.rstrip("/") in published) | |
| if accidental: | |
| print("BUG: non-published paths appear in published manifest:", ", ".join(accidental)) | |
| ok = False | |
| present_local_only = [path for path in LOCAL_ONLY_PATHS if (REPO_ROOT / path.rstrip("/")).exists()] | |
| if present_local_only: | |
| print("Local-only paths present locally, intentionally excluded:", ", ".join(present_local_only)) | |
| present_archived = [path for path in ARCHIVED_FILES if (REPO_ROOT / path).exists()] | |
| if present_archived: | |
| print("Archived legacy files present locally, intentionally excluded:", ", ".join(present_archived)) | |
| readme = (REPO_ROOT / "README.md").read_text(encoding="utf-8", errors="replace") | |
| missing_markers = [marker for marker in README_CARD_MARKERS if marker not in readme] | |
| if missing_markers: | |
| print("README card metadata missing:", ", ".join(missing_markers)) | |
| ok = False | |
| else: | |
| print("OK README HF dataset card metadata present") | |
| for rel in PLAIN_TEXT_PUBLISHED_FILES: | |
| attr = subprocess.run( | |
| ["git", "check-attr", "-a", "--", rel], | |
| cwd=REPO_ROOT, | |
| check=False, | |
| text=True, | |
| capture_output=True, | |
| ) | |
| if attr.returncode != 0: | |
| print(f"git check-attr failed for {rel}: {attr.stderr.strip()}") | |
| ok = False | |
| continue | |
| output = attr.stdout | |
| if "filter: unset" not in output or "text: set" not in output or "ignore: set" in output: | |
| print(f"Attribute issue for {rel}: expected plain text and no ignore") | |
| print(output.strip()) | |
| ok = False | |
| else: | |
| print(f"OK {rel} published as plain text") | |
| return 0 if ok else 1 | |
| def cmd_dry_run(args: argparse.Namespace) -> int: | |
| removed = enforce_no_network_redirects() | |
| if removed: | |
| print("Disabled network redirect env vars:", ", ".join(removed)) | |
| targets = expand_platform_targets(args.platform) | |
| print("dry-run only: no network request, upload, download, or delete will be performed") | |
| for target in targets: | |
| revision = HF_REVISION if target == "hf" else MODELSCOPE_REVISION | |
| endpoint = HF_ENDPOINT if target == "hf" else "https://www.modelscope.cn" | |
| print(f"[{target}] repo={REPO_ID} revision={revision} endpoint={endpoint}") | |
| print(f" upload {len(PUBLISHED_FILES)} files ({format_bytes(total_size(PUBLISHED_FILES))})") | |
| for rel in PUBLISHED_FILES: | |
| print(f" + {rel:<36} {format_bytes(FILE_SIZES[rel])}") | |
| print(f" ensure archived files absent: {', '.join(ARCHIVED_FILES)}") | |
| print(f" never publish: {', '.join(LOCAL_ONLY_PATHS)}") | |
| return 0 | |
| def cmd_list_datasets(_: argparse.Namespace) -> int: | |
| print("Demo:", ", ".join(DEMO_FILES), format_bytes(total_size(DEMO_FILES))) | |
| for dataset, rel in DATASET_TO_FILE.items(): | |
| print(f"{dataset:<18} {rel:<22} {format_bytes(FILE_SIZES[rel])}") | |
| return 0 | |
| def version_tuple(version: str) -> tuple[int, ...]: | |
| parts = [] | |
| for part in version.replace("-", ".").split("."): | |
| if not part.isdigit(): | |
| break | |
| parts.append(int(part)) | |
| return tuple(parts) | |
| def version_at_least(actual: str, minimum: str) -> bool: | |
| actual_parts = version_tuple(actual) | |
| minimum_parts = version_tuple(minimum) | |
| if not actual_parts: | |
| return False | |
| width = max(len(actual_parts), len(minimum_parts)) | |
| return actual_parts + (0,) * (width - len(actual_parts)) >= minimum_parts + (0,) * (width - len(minimum_parts)) | |
| def cmd_doctor(_: argparse.Namespace) -> int: | |
| ok = True | |
| print(f"python: {sys.version.split()[0]}") | |
| for package, minimum in REQUIRED_PACKAGES: | |
| try: | |
| actual = importlib.metadata.version(package) | |
| except importlib.metadata.PackageNotFoundError: | |
| print(f"MISSING {package:<18} required>={minimum}") | |
| ok = False | |
| continue | |
| status = "OK" if version_at_least(actual, minimum) else "TOO-OLD" | |
| print(f"{status:<13} {package:<18} installed={actual} required>={minimum}") | |
| if status != "OK": | |
| ok = False | |
| set_redirects = [key for key in NETWORK_REDIRECT_ENV_KEYS if os.environ.get(key)] | |
| if set_redirects: | |
| print("WARN network redirect env vars currently set:", ", ".join(sorted(set_redirects))) | |
| print(" transfer tools strip these by default before platform API calls") | |
| else: | |
| print("OK no proxy/mirror env vars currently set") | |
| missing = [rel for rel in PUBLISHED_FILES if not (REPO_ROOT / rel).exists()] | |
| if missing: | |
| print("MISSING published files:", ", ".join(missing)) | |
| ok = False | |
| else: | |
| print("OK all published manifest files exist locally") | |
| return 0 if ok else 1 | |
| def require_no_network_redirects() -> None: | |
| removed = enforce_no_network_redirects() | |
| if removed: | |
| print("Disabled network redirect env vars:", ", ".join(removed)) | |
| def parse_remote_size(value) -> int | None: | |
| if value is None or value == "": | |
| return None | |
| try: | |
| return int(value) | |
| except (TypeError, ValueError): | |
| return None | |
| def fetch_hf_tree() -> dict[str, int | None]: | |
| configure_hf_no_proxy() | |
| try: | |
| from huggingface_hub import HfApi | |
| except ImportError as exc: | |
| raise SystemExit( | |
| "Missing dependency: huggingface_hub. Install it with `pip install -r requirements.txt`." | |
| ) from exc | |
| api = HfApi(endpoint=HF_ENDPOINT) | |
| try: | |
| entries = api.list_repo_tree( | |
| repo_id=REPO_ID, | |
| repo_type="dataset", | |
| revision=HF_REVISION, | |
| recursive=True, | |
| expand=True, | |
| ) | |
| remote = {} | |
| for entry in entries: | |
| path = getattr(entry, "path", None) | |
| if path and getattr(entry, "type", "file") != "directory": | |
| remote[path] = parse_remote_size(getattr(entry, "size", None)) | |
| return remote | |
| except (AttributeError, TypeError): | |
| info = api.dataset_info( | |
| REPO_ID, | |
| revision=HF_REVISION, | |
| files_metadata=True, | |
| timeout=REMOTE_TIMEOUT_SECONDS, | |
| ) | |
| return { | |
| sibling.rfilename: parse_remote_size(getattr(sibling, "size", None)) | |
| for sibling in info.siblings | |
| if getattr(sibling, "rfilename", None) | |
| } | |
| def extract_modelscope_rows(payload) -> list[dict]: | |
| if isinstance(payload, list): | |
| return [item for item in payload if isinstance(item, dict)] | |
| if not isinstance(payload, dict): | |
| return [] | |
| candidates = [payload] | |
| for key in ("Data", "data"): | |
| value = payload.get(key) | |
| if isinstance(value, list): | |
| return [item for item in value if isinstance(item, dict)] | |
| if isinstance(value, dict): | |
| candidates.append(value) | |
| for candidate in candidates: | |
| for key in ("Files", "files", "Tree", "tree"): | |
| value = candidate.get(key) | |
| if isinstance(value, list): | |
| return [item for item in value if isinstance(item, dict)] | |
| return [] | |
| def fetch_modelscope_tree() -> dict[str, int | None]: | |
| query = urlencode({"Revision": MODELSCOPE_REVISION, "Recursive": "true"}) | |
| url = f"{MODELSCOPE_ENDPOINT}/api/v1/datasets/{REPO_ID}/repo/tree?{query}" | |
| request = Request(url, headers={"User-Agent": "PHM-Vibench-publish-check/1.0"}) | |
| opener = build_opener(ProxyHandler({})) | |
| with opener.open(request, timeout=REMOTE_TIMEOUT_SECONDS) as response: | |
| payload = json.loads(response.read().decode("utf-8")) | |
| remote = {} | |
| for item in extract_modelscope_rows(payload): | |
| path = item.get("Path") or item.get("path") or item.get("Name") or item.get("name") | |
| if not path: | |
| continue | |
| if item.get("Type") in {"tree", "directory"} or item.get("type") in {"tree", "directory"}: | |
| continue | |
| remote[path] = parse_remote_size(item.get("Size", item.get("size"))) | |
| return remote | |
| def remote_has_path(remote: dict[str, int | None], path: str) -> bool: | |
| if path.endswith("/"): | |
| return any(rel.startswith(path) for rel in remote) | |
| return path in remote | |
| def compare_remote_tree(target: str, remote: dict[str, int | None]) -> bool: | |
| ok = True | |
| print(f"[{target}] remote files listed:", len(remote)) | |
| for rel in PUBLISHED_FILES: | |
| if rel not in remote: | |
| print(f"MISSING {rel}") | |
| ok = False | |
| continue | |
| actual = remote[rel] | |
| expected = FILE_SIZES[rel] | |
| if actual is None: | |
| print(f"SIZE-UNKNOWN {rel:<36} expected={expected}") | |
| ok = False | |
| continue | |
| status = "OK" if actual == expected else "SIZE-MISMATCH" | |
| print(f"{status:<13} {rel:<36} {format_bytes(actual)}") | |
| if actual != expected: | |
| ok = False | |
| for rel in ARCHIVED_FILES: | |
| if remote_has_path(remote, rel): | |
| print(f"UNEXPECTED archived file still present: {rel}") | |
| ok = False | |
| for rel in LOCAL_ONLY_PATHS: | |
| if remote_has_path(remote, rel): | |
| print(f"UNEXPECTED local-only path published: {rel}") | |
| ok = False | |
| return ok | |
| def cmd_remote_verify(args: argparse.Namespace) -> int: | |
| require_no_network_redirects() | |
| targets = expand_platform_targets(args.platform) | |
| print("remote-verify: listing remote files only; no file upload or download is performed") | |
| ok = True | |
| for target in targets: | |
| try: | |
| if target == "hf": | |
| print(f"[hf] repo={REPO_ID} revision={HF_REVISION} endpoint={HF_ENDPOINT}") | |
| remote = fetch_hf_tree() | |
| else: | |
| print(f"[modelscope] repo={REPO_ID} revision={MODELSCOPE_REVISION} endpoint={MODELSCOPE_ENDPOINT}") | |
| remote = fetch_modelscope_tree() | |
| except Exception as exc: | |
| print(f"REMOTE-ERROR {target}: {type(exc).__name__}: {exc}") | |
| ok = False | |
| continue | |
| ok = compare_remote_tree(target, remote) and ok | |
| return 0 if ok else 1 | |
| def cmd_self_test(_: argparse.Namespace) -> int: | |
| from download_phm_vibench import build_download_plan, build_file_index, resolve_files, verify_local | |
| from inspect_phm_vibench import choose_smoke_dataset, normalize_dataset_id | |
| from publish_phm_vibench import selected_files | |
| published = set(PUBLISHED_FILES) | |
| assert "RM_101_THU_GEARBOX.h5" not in published | |
| assert "cache.h5" not in published | |
| assert "metadata_25_10_30.xlsx" not in published | |
| assert all(path in FILE_SIZES for path in PUBLISHED_FILES) | |
| assert version_at_least("0.25.0", "0.25") | |
| assert version_at_least("1.20.1", "1.20") | |
| assert not version_at_least("0.24.9", "0.25") | |
| download_args = SimpleNamespace( | |
| include_metadata=False, | |
| include_docs=False, | |
| dataset=["RM_006_THU"], | |
| no_metadata=False, | |
| file=None, | |
| preset="metadata", | |
| yes=False, | |
| ) | |
| assert resolve_files(download_args) == ["metadata.xlsx", "RM_006_THU.h5"] | |
| no_metadata_args = SimpleNamespace(**{**vars(download_args), "no_metadata": True}) | |
| assert resolve_files(no_metadata_args) == ["RM_006_THU.h5"] | |
| assert normalize_dataset_id("rm_007_mfpt") == "RM_007_MFPT" | |
| assert choose_smoke_dataset(REPO_ROOT) == "RM_007_MFPT" | |
| comma_dataset_args = SimpleNamespace( | |
| include_metadata=False, | |
| include_docs=False, | |
| dataset=["rm_006_thu, RM_007_MFPT", "RM_007_MFPT"], | |
| no_metadata=False, | |
| file=None, | |
| preset="metadata", | |
| yes=False, | |
| ) | |
| assert resolve_files(comma_dataset_args) == ["metadata.xlsx", "RM_006_THU.h5", "RM_007_MFPT.h5"] | |
| comma_file_args = SimpleNamespace( | |
| include_metadata=False, | |
| include_docs=False, | |
| dataset=None, | |
| no_metadata=False, | |
| file=["README.md, published_manifest.json"], | |
| preset="metadata", | |
| yes=False, | |
| ) | |
| assert resolve_files(comma_file_args) == ["README.md", "published_manifest.json"] | |
| docs_preset_args = SimpleNamespace( | |
| include_metadata=False, | |
| include_docs=False, | |
| dataset=None, | |
| no_metadata=False, | |
| file=None, | |
| preset="docs", | |
| yes=False, | |
| ) | |
| assert resolve_files(docs_preset_args) == PUBLISHED_SMALL_FILES | |
| assert not any(path.endswith(".h5") for path in resolve_files(docs_preset_args)) | |
| file_index = build_file_index() | |
| assert file_index["platforms"]["modelscope"]["endpoint"] == MODELSCOPE_ENDPOINT | |
| assert file_index["presets"]["docs"]["files"] == PUBLISHED_SMALL_FILES | |
| assert file_index["presets"]["all"]["requires_yes"] is True | |
| assert file_index["datasets"][0]["id"] == "RM_001_CWRU" | |
| plan = build_download_plan( | |
| platform="hf", | |
| revision=HF_REVISION, | |
| out_dir=REPO_ROOT / "PHM-Vibench", | |
| files=["metadata.xlsx", "README.md"], | |
| disabled_network_redirect_env_vars=["HTTP_PROXY"], | |
| ) | |
| assert plan["network_request"] is False | |
| assert plan["dry_run"] is True | |
| assert plan["total_size_bytes"] == FILE_SIZES["metadata.xlsx"] + FILE_SIZES["README.md"] | |
| assert plan["disabled_network_redirect_env_vars"] == ["HTTP_PROXY"] | |
| manifest = build_manifest(include_sha256=False) | |
| assert manifest["platforms"]["hf"]["endpoint"] == HF_ENDPOINT | |
| assert manifest["presets"]["docs"]["files"] == PUBLISHED_SMALL_FILES | |
| assert manifest["presets"]["all"]["requires_yes"] is True | |
| assert manifest["datasets"][0] == { | |
| "id": "RM_001_CWRU", | |
| "path": "RM_001_CWRU.h5", | |
| "size_bytes": FILE_SIZES["RM_001_CWRU.h5"], | |
| } | |
| all_dry_run_args = SimpleNamespace( | |
| include_metadata=False, | |
| include_docs=False, | |
| dataset=None, | |
| no_metadata=False, | |
| file=None, | |
| preset="all", | |
| yes=False, | |
| dry_run=True, | |
| verify_local=False, | |
| ) | |
| assert resolve_files(all_dry_run_args) == PUBLISHED_FILES | |
| all_download_args = SimpleNamespace(**{**vars(all_dry_run_args), "dry_run": False}) | |
| try: | |
| resolve_files(all_download_args) | |
| except SystemExit: | |
| pass | |
| else: | |
| raise AssertionError("resolve_files accepted --preset all download without --yes") | |
| with redirect_stdout(StringIO()) as verify_ok_out: | |
| assert verify_local(["README.md"], REPO_ROOT) | |
| assert "summary: checked=1 ok=1 missing=0 size_mismatch=0" in verify_ok_out.getvalue() | |
| with redirect_stdout(StringIO()) as verify_missing_out: | |
| assert not verify_local(["README.md"], REPO_ROOT / "__missing_phm_vibench__") | |
| assert "summary: checked=1 ok=0 missing=1 size_mismatch=0" in verify_missing_out.getvalue() | |
| with redirect_stdout(StringIO()): | |
| fake_remote = {path: FILE_SIZES[path] for path in PUBLISHED_FILES} | |
| assert compare_remote_tree("fake", fake_remote) | |
| assert extract_modelscope_rows({"Data": [{"Path": "metadata.xlsx", "Size": "1"}]}) == [ | |
| {"Path": "metadata.xlsx", "Size": "1"} | |
| ] | |
| assert extract_modelscope_rows({"data": {"files": [{"Path": "README.md"}]}}) == [{"Path": "README.md"}] | |
| assert not compare_remote_tree("fake", {**fake_remote, "README.md": None}) | |
| assert not compare_remote_tree("fake", {**fake_remote, "metadata.xlsx": 1}) | |
| assert not compare_remote_tree("fake", {**fake_remote, ARCHIVED_FILES[0]: FILE_SIZES["metadata.xlsx"]}) | |
| assert not compare_remote_tree("fake", {**fake_remote, "raw/leaked.bin": 1}) | |
| publish_args = SimpleNamespace(file=["metadata.xlsx"]) | |
| assert selected_files(publish_args) == ["metadata.xlsx"] | |
| assert expand_platform_targets("ms") == ["modelscope"] | |
| assert expand_platform_targets("huggingface") == ["hf"] | |
| assert expand_platform_targets("all") == ["hf", "modelscope"] | |
| bad_publish_args = SimpleNamespace(file=["cache.h5"]) | |
| try: | |
| selected_files(bad_publish_args) | |
| except SystemExit: | |
| pass | |
| else: | |
| raise AssertionError("publish selected_files accepted cache.h5") | |
| keys = list(PROXY_ENV_KEYS) + list(HF_ENDPOINT_ENV_KEYS) + ["NO_PROXY", "no_proxy"] | |
| saved = {key: os.environ.get(key) for key in keys} | |
| try: | |
| for key in PROXY_ENV_KEYS: | |
| os.environ[key] = "http://127.0.0.1:9" | |
| for key in HF_ENDPOINT_ENV_KEYS: | |
| os.environ[key] = "https://example.invalid" | |
| removed = enforce_no_network_redirects() | |
| assert "HTTP_PROXY" in removed and "HTTPS_PROXY" in removed | |
| assert "HF_ENDPOINT" in removed | |
| assert not any(os.environ.get(key) for key in PROXY_ENV_KEYS + HF_ENDPOINT_ENV_KEYS) | |
| assert os.environ["NO_PROXY"] == "*" | |
| assert os.environ["no_proxy"] == "*" | |
| finally: | |
| for key, value in saved.items(): | |
| if value is None: | |
| os.environ.pop(key, None) | |
| else: | |
| os.environ[key] = value | |
| print( | |
| "self-test OK: manifest exclusions, no-proxy guard, download selection, " | |
| "local verify, remote compare, publish selection" | |
| ) | |
| return 0 | |
| def parse_args() -> argparse.Namespace: | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| sub = parser.add_subparsers(dest="cmd", required=True) | |
| sub.add_parser("local-check", help="Validate local published files and exclusions") | |
| sub.add_parser("doctor", help="Check local dependencies and no-proxy environment status") | |
| dry = sub.add_parser("dry-run-upload", help="Print upload/delete plan without network access") | |
| dry.add_argument("--platform", choices=PLATFORM_TARGET_CHOICES, default="all") | |
| remote = sub.add_parser("remote-verify", help="List remote files and compare them with the manifest") | |
| remote.add_argument("--platform", choices=PLATFORM_TARGET_CHOICES, default="all") | |
| manifest = sub.add_parser("manifest", help="Print or write the publish manifest") | |
| manifest.add_argument("--sha256", action="store_true", help="Compute SHA256 for all files; reads about 84GB locally") | |
| manifest.add_argument("--output", type=Path, help="Optional output JSON path") | |
| sub.add_parser("list-datasets", help="List dataset ids and expected sizes") | |
| sub.add_parser("self-test", help="Run no-network checks for manifest and guardrails") | |
| return parser.parse_args() | |
| def main() -> int: | |
| args = parse_args() | |
| if args.cmd == "local-check": | |
| return cmd_local_check(args) | |
| if args.cmd == "doctor": | |
| return cmd_doctor(args) | |
| if args.cmd == "dry-run-upload": | |
| return cmd_dry_run(args) | |
| if args.cmd == "remote-verify": | |
| return cmd_remote_verify(args) | |
| if args.cmd == "manifest": | |
| return cmd_manifest(args) | |
| if args.cmd == "list-datasets": | |
| return cmd_list_datasets(args) | |
| if args.cmd == "self-test": | |
| return cmd_self_test(args) | |
| raise AssertionError(f"unknown command: {args.cmd}") | |
| if __name__ == "__main__": | |
| sys.exit(main()) | |