code/scripts/01_upload_hf.py

"""Upload the payload the Colab lanes need, to Jyo-K/PopTurk.



    export HF_TOKEN=hf_...

    python scripts/01_upload_hf.py --what code shards models --split test



WHAT GOES UP, AND WHAT DELIBERATELY DOES NOT



  code    this source tree (~120 KB). The notebook imports berx from it, so there is exactly

          one copy of the scoring logic and a fix on the box reaches Colab on the next push.

  shards  the self-contained cross-encoder work units from 04_make_shards.py. Text included,

          so a lane needs nothing else.

  models  the fine-tuned cross-encoder checkpoints. Weights ONLY - the optimiser state is

          4.5 GB of AdamW moments that inference never reads.

  geo     the mined administrative-equivalence tables (a few MB).



  NOT the embeddings. They are already in the three channel repos and they are 42 GB; a Colab

  lane does cross-encoder scoring, which needs no embeddings at all. Anything that pulls them

  into a Colab VM has misunderstood the split of work.

  NOT the raw dataset in full. The shards already carry the text they need.



PRIVACY. Every repo is created PRIVATE. The competition data is licensed to participants, not

to the public, and a public dataset repo is a redistribution. Passing --public is an explicit

decision to publish; think before you do.

"""
from __future__ import annotations

import argparse
import glob
import os
import re
import shutil
import sys
import tempfile

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from berx import io_hf  # noqa: E402
from berx import paths as P  # noqa: E402

ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Matches the assignment `HF_TOKEN = "hf_..."` so it can be blanked, and any bare hf_ token
# anywhere else as a backstop.
TOKEN_RE = re.compile(r'^(HF_TOKEN\s*=\s*).*$', re.M)
LEAK_RE = re.compile(r'hf_[A-Za-z0-9]{20,}')
# Backreference to group 1 (the `HF_TOKEN = ` prefix) plus an EMPTY STRING LITERAL. The empty
# literal is not decoration: dropping it leaves `HF_TOKEN =` with no value, which is a
# SyntaxError, and the published code/ tree would fail to import on every Colab lane.
REDACTED = r'\1""  # redacted for upload'
# Inference reads none of these; they are the bulk of a checkpoint directory.
SKIP_IN_MODEL = {"opt.pt", "optimizer.pt", "scheduler.pt", "rng_state.pth",
                 "trainer_state.json", "training_args.bin"}


def push_code(repo: str, public: bool):
    """Upload the source tree, with the embedded token REDACTED.



    The token now lives in berx/io_hf.py so it does not have to be exported. That makes this

    function the one place it could leak: uploading the tree verbatim would publish the

    token inside the very repo it authenticates to. The redaction below is asserted, and the

    upload is refused outright if any token-shaped string survives it - a silent failure here

    means a live credential in a dataset repo.

    """
    tmp = tempfile.mkdtemp()
    dst = os.path.join(tmp, "code")
    shutil.copytree(os.path.join(ROOT, "berx"), os.path.join(dst, "berx"),
                    ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
    shutil.copytree(os.path.join(ROOT, "scripts"), os.path.join(dst, "scripts"),
                    ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
    for f in ("hf_token.txt",):                      # never ships, whatever else happens
        q = os.path.join(dst, f)
        if os.path.exists(q):
            os.remove(q)

    redacted = 0
    for root, _, files in os.walk(dst):
        for fn in files:
            if not fn.endswith((".py", ".sh", ".md", ".txt", ".json", ".ipynb")):
                continue
            fp = os.path.join(root, fn)
            try:
                txt = open(fp, encoding="utf-8").read()
            except (UnicodeDecodeError, OSError):
                continue
            new_txt = TOKEN_RE.sub(REDACTED, txt)
            if new_txt != txt:
                open(fp, "w", encoding="utf-8").write(new_txt)
                redacted += 1
            leak = LEAK_RE.search(new_txt)
            assert not leak, (
                f"REFUSING TO UPLOAD: {fp} still contains something token-shaped "
                f"({leak.group(0)[:12]}...). Fix the redaction before publishing.")
    io_hf.upload(dst, "code", repo, public)
    shutil.rmtree(tmp, ignore_errors=True)
    print(f"  code/ uploaded  (token redacted in {redacted} file(s))")


def push_shards(repo: str, split: str, public: bool):
    files = sorted(glob.glob(P.work("shards", f"{split}_shard*.parquet")))
    files += glob.glob(P.work("shards", f"{split}_manifest.json"))
    assert files, "no shards found - run 04_make_shards.py first"
    total = 0
    for f in files:
        mb = os.path.getsize(f) / 2 ** 20
        total += mb
        io_hf.upload(f, f"shards/{os.path.basename(f)}", repo, public)
        print(f"  shards/{os.path.basename(f)}  {mb:.1f} MB")
    print(f"  {total:.1f} MB total")


def push_model(repo: str, local: str, name: str, public: bool):
    assert os.path.isdir(local), f"not a directory: {local}"
    tmp = tempfile.mkdtemp()
    dst = os.path.join(tmp, name)
    os.makedirs(dst)
    kept = 0
    for f in os.listdir(local):
        if f in SKIP_IN_MODEL or f == "ckpt":
            continue
        src = os.path.join(local, f)
        if os.path.isfile(src):
            shutil.copy2(src, os.path.join(dst, f))
            kept += os.path.getsize(src)
    io_hf.upload(dst, f"models/{name}", repo, public)
    shutil.rmtree(tmp, ignore_errors=True)
    print(f"  models/{name}  {kept/2**30:.2f} GiB (optimiser state excluded)")


def push_geo(repo: str, public: bool):
    for f in glob.glob(P.work("geo", "*.json")):
        io_hf.upload(f, f"geo/{os.path.basename(f)}", repo, public)
        print(f"  geo/{os.path.basename(f)}")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--what", nargs="+", required=True,
                    choices=["code", "shards", "models", "geo", "all"])
    ap.add_argument("--split", default="test")
    ap.add_argument("--repo", default=P.PAYLOAD_REPO)
    ap.add_argument("--model-dirs", nargs="*", default=[],
                    help="LOCAL_DIR:NAME pairs, e.g. work/ce_model_A:bge_reranker_ft")
    ap.add_argument("--token", default="", help="overrides every other token source")
    ap.add_argument("--public", action="store_true",
                    help="publish instead of keeping the repo private - think first")
    a = ap.parse_args()

    if a.token:
        io_hf.set_token(a.token)
    if not io_hf.token():
        sys.exit("No token. Set HF_TOKEN in berx/io_hf.py, or pass --token, or put it in "
                 "hf_token.txt, or export HF_TOKEN.")
    print(f"token from {io_hf.token_source()}")
    what = set(a.what)
    if "all" in what:
        what = {"code", "shards", "models", "geo"}

    io_hf.ensure_repo(a.repo, a.public)
    print(f"repo {a.repo}  ({'PUBLIC' if a.public else 'private'})")

    if "code" in what:
        push_code(a.repo, a.public)
    if "shards" in what:
        push_shards(a.repo, a.split, a.public)
    if "geo" in what:
        push_geo(a.repo, a.public)
    if "models" in what:
        if not a.model_dirs:
            print("  --model-dirs not given; skipping models")
        for spec in a.model_dirs:
            local, _, name = spec.partition(":")
            push_model(a.repo, local, name or os.path.basename(local.rstrip("/")), a.public)

    print(f"\nhttps://huggingface.co/datasets/{a.repo}")


if __name__ == "__main__":
    main()