| |
| """Robust one-click uploader for the CHISA-RSI Hugging Face release. |
| |
| Works with: |
| * HF_TOKEN environment variable, or |
| * an existing `hf auth login`, or |
| * interactive Hugging Face login when run from a terminal. |
| |
| HF_REPO_ID is optional. If omitted, the script derives the authenticated |
| username and proposes the release's default repository name. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import os |
| import sys |
| from pathlib import Path |
|
|
| DEFAULT_SLUG = "CHISA-RSI-Proof-Carrying-Continuous-Capability-Closure-v1.0.0" |
| REQUIRED_FILES = ( |
| "README.md", |
| "CHISA_RSI_v1.0.0.pdf", |
| "CLAIMS_AND_SCOPE.md", |
| "THEOREMS.json", |
| "AI_AGENT_INDEX.json", |
| "CITATION.cff", |
| ) |
|
|
|
|
| def die(message: str, code: int = 1) -> "NoReturn": |
| print(f"\nERROR: {message}", file=sys.stderr) |
| raise SystemExit(code) |
|
|
|
|
| def package_check(folder: Path) -> None: |
| missing = [name for name in REQUIRED_FILES if not (folder / name).is_file()] |
| if missing: |
| die("Release package is incomplete. Missing: " + ", ".join(missing), 2) |
| print(f"Package check: OK ({len(REQUIRED_FILES)} required files found)") |
|
|
|
|
| def load_hf(): |
| try: |
| import huggingface_hub |
| from huggingface_hub import HfApi, get_token, login |
| except Exception as exc: |
| die( |
| "huggingface_hub is not installed or failed to import. " |
| "Run: python -m pip install -U huggingface_hub\n" |
| f"Details: {exc}" |
| ) |
| return huggingface_hub, HfApi, get_token, login |
|
|
|
|
| def obtain_token(api, get_token, login) -> str: |
| |
| token = os.environ.get("HF_TOKEN") or get_token() |
|
|
| if token: |
| try: |
| who = api.whoami(token=token) |
| except Exception as exc: |
| die( |
| "A Hugging Face token was found, but authentication failed. " |
| "Use a current personal User Access Token with WRITE permission.\n" |
| f"Details: {exc}", |
| 3, |
| ) |
| name = who.get("name") or who.get("fullname") or "authenticated user" |
| print(f"Authentication: OK ({name})") |
| return token |
|
|
| if not sys.stdin.isatty(): |
| die( |
| "No Hugging Face authentication was found. Set HF_TOKEN to a WRITE token " |
| "or run `hf auth login` first.", |
| 3, |
| ) |
|
|
| print("\nNo HF_TOKEN or cached login was found.") |
| print("Starting Hugging Face login. Your token is not written into this release folder.") |
| try: |
| try: |
| login(skip_if_logged_in=False) |
| except TypeError: |
| |
| login() |
| except Exception as exc: |
| die( |
| "Interactive Hugging Face login failed. You can instead run `hf auth login` " |
| "in a terminal and then launch this uploader again.\n" |
| f"Details: {exc}", |
| 3, |
| ) |
|
|
| token = get_token() |
| if not token: |
| die("Login finished without producing an accessible Hugging Face token.", 3) |
|
|
| try: |
| who = api.whoami(token=token) |
| except Exception as exc: |
| die(f"Authentication verification failed after login: {exc}", 3) |
|
|
| name = who.get("name") or who.get("fullname") or "authenticated user" |
| print(f"Authentication: OK ({name})") |
| return token |
|
|
|
|
| def choose_repo_id(api, token: str, cli_repo_id: str | None) -> str: |
| repo_id = cli_repo_id or os.environ.get("HF_REPO_ID") |
| if repo_id: |
| return repo_id.strip() |
|
|
| who = api.whoami(token=token) |
| username = who.get("name") |
| if not username: |
| die("Could not determine your Hugging Face username from the authenticated account.", 3) |
|
|
| default = f"{username}/{DEFAULT_SLUG}" |
| if sys.stdin.isatty(): |
| print(f"\nDefault repository: {default}") |
| entered = input("Repository ID [press Enter to accept]: ").strip() |
| repo_id = entered or default |
| else: |
| repo_id = default |
|
|
| if "/" not in repo_id or repo_id.startswith("/") or repo_id.endswith("/"): |
| die("HF_REPO_ID must look like `username-or-org/repository-name`.", 2) |
| return repo_id |
|
|
|
|
| def repo_url(repo_id: str, repo_type: str) -> str: |
| if repo_type == "dataset": |
| return f"https://huggingface.co/datasets/{repo_id}" |
| if repo_type == "space": |
| return f"https://huggingface.co/spaces/{repo_id}" |
| return f"https://huggingface.co/{repo_id}" |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description="Upload CHISA-RSI v1.0.0 to Hugging Face.") |
| parser.add_argument("--repo-id", help="Override HF_REPO_ID (username-or-org/repo-name).") |
| parser.add_argument( |
| "--repo-type", |
| choices=("model", "dataset", "space"), |
| default=os.environ.get("HF_REPO_TYPE", "model"), |
| help="Hugging Face repository type (default: model).", |
| ) |
| parser.add_argument( |
| "--check-only", |
| action="store_true", |
| help="Validate the local package and Python dependency without contacting Hugging Face.", |
| ) |
| args = parser.parse_args() |
|
|
| folder = Path(__file__).resolve().parent |
| os.chdir(folder) |
| package_check(folder) |
|
|
| hub, HfApi, get_token, login = load_hf() |
| print(f"huggingface_hub: {hub.__version__}") |
|
|
| if args.check_only: |
| print("Uploader self-test: OK") |
| return 0 |
|
|
| api = HfApi() |
| token = obtain_token(api, get_token, login) |
| repo_id = choose_repo_id(api, token, args.repo_id) |
| repo_type = args.repo_type |
|
|
| print("\nUpload target") |
| print(f" repo: {repo_id}") |
| print(f" type: {repo_type}") |
| print(" visibility: public") |
|
|
| try: |
| |
| try: |
| api.create_repo( |
| repo_id=repo_id, |
| repo_type=repo_type, |
| visibility="public", |
| exist_ok=True, |
| token=token, |
| ) |
| except TypeError: |
| api.create_repo( |
| repo_id=repo_id, |
| repo_type=repo_type, |
| private=False, |
| exist_ok=True, |
| token=token, |
| ) |
| except Exception as exc: |
| die( |
| "Could not create/open the target repository. Check that the token has WRITE " |
| "permission and that you own the namespace (or have write access to the organization).\n" |
| f"Details: {exc}", |
| 4, |
| ) |
|
|
| try: |
| result = api.upload_folder( |
| repo_id=repo_id, |
| repo_type=repo_type, |
| folder_path=str(folder), |
| path_in_repo="", |
| commit_message="Release CHISA-RSI v1.0.0", |
| token=token, |
| ignore_patterns=[ |
| "*.zip", |
| "__pycache__/**", |
| "*.pyc", |
| ".git/**", |
| "hf_upload.log", |
| ], |
| ) |
| if result is not None: |
| print(f"Upload commit: {getattr(result, 'commit_url', result)}") |
| except Exception as exc: |
| die( |
| "Upload failed. Re-running is safe: Hugging Face upload_folder is resumable and " |
| "skips content already committed.\n" |
| f"Details: {exc}", |
| 5, |
| ) |
|
|
| |
| try: |
| remote = set(api.list_repo_files(repo_id=repo_id, repo_type=repo_type, token=token)) |
| missing_remote = [name for name in REQUIRED_FILES if name not in remote] |
| if missing_remote: |
| die( |
| "Hugging Face accepted the upload, but verification found missing files: " |
| + ", ".join(missing_remote), |
| 6, |
| ) |
| except SystemExit: |
| raise |
| except Exception as exc: |
| die(f"Upload finished but remote verification failed: {exc}", 6) |
|
|
| url = repo_url(repo_id, repo_type) |
| print("\nSUCCESS: upload and remote verification both passed.") |
| print(url) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| raise SystemExit(main()) |
| except KeyboardInterrupt: |
| print("\nCancelled by user.") |
| raise SystemExit(130) |
|
|
