| |
| """Pack curated ds/ artifacts into Hugging Face-ready staging folders. |
| |
| Usage: .venv-hf/bin/python scripts/hf_pack.py [--out hf-staging] [--only REPO ...] |
| |
| Each repo folder is self-contained (README.md card + data). Large JSONL is |
| converted to zstd parquet shards; nested fields become JSON strings so the |
| schema is stable. Model files / small files are hard-linked (no extra disk). |
| Writes <repo>/pack_report.json with row counts and sha256 checks. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import os |
| import shutil |
| from pathlib import Path |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| import re |
|
|
| DS = Path(__file__).resolve().parents[1] |
| SHARD_BYTES = 400 * 1024 * 1024 |
| CARDS = DS / "scripts/hf_cards" |
|
|
| |
| SECRET_RE = re.compile(r"(sk-proj-[A-Za-z0-9_-]{20,}|sk-[A-Za-z0-9]{20,}|hf_[A-Za-z0-9]{30,}|ghp_[A-Za-z0-9]{20,}|AKIA[0-9A-Z]{16})") |
| TEXT_SUFFIX = {".py", ".md", ".json", ".txt", ".sh", ".yaml", ".yml", ".jsonl", ".org", ".log", ".csv", ".toml", ".cfg"} |
| REDACTED: list[str] = [] |
|
|
| |
| CBETA_IDS = set((CARDS / "kanripo_cbeta_ids.txt").read_text().split()) |
| SOURCE_LICENSE = {"ndl": "pdm-1.0", "kanripo": "cc-by-sa-4.0", "minhon": "cc-by-sa-4.0", "wikisource": "cc-by-sa-4.0"} |
|
|
|
|
| def license_for(source: str, kanripo_work: str | None = None) -> str: |
| if source == "kanripo" and kanripo_work in CBETA_IDS: |
| return "cc-by-nc-sa-3.0-tw" |
| return SOURCE_LICENSE[source] |
|
|
|
|
| |
| def link(src: Path, dst: Path) -> None: |
| dst.parent.mkdir(parents=True, exist_ok=True) |
| if dst.exists(): |
| dst.unlink() |
| if src.suffix.lower() in TEXT_SUFFIX and src.stat().st_size < 20_000_000: |
| txt = src.read_text(encoding="utf-8", errors="surrogateescape") |
| if SECRET_RE.search(txt): |
| dst.write_text(SECRET_RE.sub("<REDACTED>", txt), encoding="utf-8", errors="surrogateescape") |
| REDACTED.append(str(src.relative_to(DS))) |
| return |
| try: |
| os.link(src, dst) |
| except OSError: |
| shutil.copy2(src, dst) |
|
|
|
|
| def link_tree(src: Path, dst: Path, skip=("__pycache__", ".lock")) -> int: |
| n = 0 |
| for p in sorted(src.rglob("*")): |
| if p.is_file() and not any(s in p.parts or p.name == s for s in skip): |
| link(p, dst / p.relative_to(src)) |
| n += 1 |
| return n |
|
|
|
|
| def iter_jsonl(path: Path): |
| with path.open("r", encoding="utf-8") as f: |
| for line in f: |
| if line.strip(): |
| yield json.loads(line) |
|
|
|
|
| def infer_types(rows_iter) -> dict[str, str]: |
| """key -> 'int'|'float'|'bool'|'str'|'json' (union over all rows).""" |
| kinds: dict[str, set] = {} |
| for r in rows_iter: |
| for k, v in r.items(): |
| s = kinds.setdefault(k, set()) |
| if v is None: |
| continue |
| if isinstance(v, bool): |
| s.add("bool") |
| elif isinstance(v, int): |
| s.add("int") |
| elif isinstance(v, float): |
| s.add("float") |
| elif isinstance(v, str): |
| s.add("str") |
| else: |
| s.add("json") |
| out = {} |
| for k, s in kinds.items(): |
| if not s or s == {"str"}: |
| out[k] = "str" |
| elif s == {"int"}: |
| out[k] = "int" |
| elif s <= {"int", "float"}: |
| out[k] = "float" |
| elif s == {"bool"}: |
| out[k] = "bool" |
| else: |
| out[k] = "json" |
| return out |
|
|
|
|
| PA = {"int": pa.int64(), "float": pa.float64(), "bool": pa.bool_(), "str": pa.string(), "json": pa.string()} |
|
|
|
|
| def coerce(v, t): |
| if v is None: |
| return None |
| if t == "json": |
| return json.dumps(v, ensure_ascii=False) |
| if t == "float": |
| return float(v) |
| return v |
|
|
|
|
| class ShardWriter: |
| def __init__(self, outdir: Path, prefix: str, types: dict[str, str]): |
| self.outdir, self.prefix, self.types = outdir, prefix, types |
| self.schema = pa.schema([(k, PA[t]) for k, t in types.items()]) |
| self.buf: list[dict] = [] |
| self.bytes = 0 |
| self.files: list[Path] = [] |
| self.rows = 0 |
| outdir.mkdir(parents=True, exist_ok=True) |
|
|
| def add(self, row: dict): |
| self.buf.append({k: coerce(row.get(k), t) for k, t in self.types.items()}) |
| self.bytes += len(row.get("text") or "") * 3 + 512 |
| if self.bytes >= SHARD_BYTES: |
| self.flush() |
|
|
| def flush(self): |
| if not self.buf: |
| return |
| p = self.outdir / f"{self.prefix}-{len(self.files):05d}.parquet" |
| tbl = pa.Table.from_pylist(self.buf, schema=self.schema) |
| pq.write_table(tbl, p, compression="zstd", compression_level=9, row_group_size=2000) |
| self.files.append(p) |
| self.rows += len(self.buf) |
| self.buf, self.bytes = [], 0 |
|
|
| def close(self): |
| self.flush() |
| |
| n = len(self.files) |
| final = [] |
| for i, p in enumerate(self.files): |
| q = p.with_name(f"{self.prefix}-{i:05d}-of-{n:05d}.parquet") |
| p.rename(q) |
| final.append(q) |
| self.files = final |
| return self.rows |
|
|
|
|
| def jsonl_to_parquet(src: Path, outdir: Path, prefix: str, transform=None) -> dict: |
| tf = transform or (lambda r: r) |
| types = infer_types(tf(r) for r in iter_jsonl(src)) |
| w = ShardWriter(outdir, prefix, types) |
| h = hashlib.sha256() |
| n_src = 0 |
| for r in iter_jsonl(src): |
| n_src += 1 |
| r = tf(r) |
| h.update((r.get("text") or "").encode()) |
| w.add(r) |
| w.close() |
| return {"source": str(src.relative_to(DS)), "rows_source": n_src, "rows_written": w.rows, |
| "text_concat_sha256": h.hexdigest(), "files": [p.name for p in w.files], "types": types} |
|
|
|
|
| def verify_parquet(files: list[Path], expect_rows: int, expect_sha: str) -> dict: |
| h = hashlib.sha256() |
| n = 0 |
| for p in sorted(files): |
| pf = pq.ParquetFile(p) |
| has_text = "text" in pf.schema_arrow.names |
| for rg in range(pf.num_row_groups): |
| t = pf.read_row_group(rg, columns=["text"] if has_text else None) |
| n += t.num_rows |
| if has_text: |
| for s in t.column("text").to_pylist(): |
| h.update((s or "").encode()) |
| ok = n == expect_rows and (h.hexdigest() == expect_sha) |
| return {"rows_readback": n, "text_sha_match": h.hexdigest() == expect_sha, "ok": ok} |
|
|
|
|
| def write(path: Path, text: str): |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(text, encoding="utf-8") |
|
|
|
|
| |
| def pack_pretrain(out: Path) -> dict: |
| """unified/pretrain-v1/build-003 joined with split assignment (build-006).""" |
| src = DS / "unified/pretrain-v1/build-003/pretrain.jsonl" |
| spl = DS / "unified/training-tokens-v1/build-006/splits.jsonl" |
| split_of = {} |
| for r in iter_jsonl(spl): |
| split_of[r["id"]] = {k: r[k] for k in ("split", "era", "era_basis", "group", "tokens")} |
| keep = ["id", "source", "title", "era", "era_basis", "group", "split", "tokens", "normalized_chars", |
| "date_status", "script_profile", "license_status", "source_document_id", "work_candidate_id", |
| "unit_type", "unit_label", "license", "text_sha256", "text"] |
|
|
| def tf(r): |
| s = split_of[r["id"]] |
| row = {**r, **s} |
| meta = {k: v for k, v in r.items() if k not in keep} |
| o = {k: row.get(k) for k in keep} |
| o["license"] = license_for(r["source"], r["id"].split("/")[1] if r["source"] == "kanripo" else None) |
| o["metadata"] = json.dumps(meta, ensure_ascii=False) |
| return o |
|
|
| types = {k: "str" for k in keep} | {"tokens": "int", "normalized_chars": "int", "metadata": "str"} |
| writers = {s: ShardWriter(out / "data", s, types) for s in ("train", "validation", "test")} |
| shas = {s: hashlib.sha256() for s in writers} |
| counts = {s: 0 for s in writers} |
| lic_counts: dict = {} |
| tokens = {s: 0 for s in writers} |
| n = 0 |
| for r in iter_jsonl(src): |
| n += 1 |
| o = tf(r) |
| s = o["split"] |
| writers[s].add(o) |
| shas[s].update(o["text"].encode()) |
| counts[s] += 1 |
| tokens[s] += o["tokens"] |
| k = (o["source"], o["license"]) |
| lic_counts[k] = [lic_counts.get(k, [0, 0])[0] + 1, lic_counts.get(k, [0, 0])[1] + o["tokens"]] |
| rep = {"rows_source": n, "rows_split_file": len(split_of), "splits": {}, |
| "license_docs_tokens": {f"{a}|{b}": v for (a, b), v in sorted(lic_counts.items())}} |
| for s, w in writers.items(): |
| w.close() |
| rep["splits"][s] = {"rows": counts[s], "tokens_no_bos_eos": tokens[s], "files": [p.name for p in w.files], |
| **verify_parquet(w.files, counts[s], shas[s].hexdigest())} |
| |
| for rel in ["unified/current_pretraining.json"]: |
| link(DS / rel, out / "meta" / Path(rel).name) |
| for d, names in { |
| "unified/pretrain-v1/build-003": ["manifest.json", "report.json", "verification.json", "excluded.jsonl"], |
| "unified/split-groups-v1/build-003": ["manifest.json", "report.json", "groups.json", "joins.jsonl"], |
| "unified/training-tokens-v1/build-006": ["manifest.json", "report.json", "REPORT.md", "verification.json", |
| "evaluation-windows.jsonl", "group-joins.jsonl"], |
| }.items(): |
| for nm in names: |
| link(DS / d / nm, out / "meta" / d.replace("/", "__") / nm) |
| link_tree(DS / "scripts", out / "code/scripts", skip=("__pycache__",)) |
| link_tree(DS / "worklog", out / "code/worklog") |
| for nm in ["README.md", "agent.md", "ndl_download.py"]: |
| link(DS / nm, out / "code" / nm) |
| return rep |
|
|
|
|
| def pack_sources(out: Path) -> dict: |
| rep = {} |
| jobs = { |
| "ndl": DS / "corpus/preprocessed-v1/build-001/documents.jsonl", |
| "kanripo": DS / "kanripo/preprocessed-v1/build-002/documents.jsonl", |
| "minhon": DS / "minhon/preprocessed-v1/build-003-bibdated/clean_pages.jsonl", |
| "wikisource": DS / "wikisource/corpus-v1/documents.jsonl", |
| "wikisource_works": DS / "wikisource/corpus-v1/works.jsonl", |
| "ndl_catalog": DS / "corpus/metadata/selected_before_1868.jsonl", |
| "ndl_api_catalog": DS / "corpus/metadata/api_selected_before_1868.jsonl", |
| } |
| tfs = { |
| "ndl": lambda r: {**r, "license": license_for("ndl")}, |
| "kanripo": lambda r: {**r, "license": license_for("kanripo", r["work_id"])}, |
| "minhon": lambda r: {**r, "license": license_for("minhon")}, |
| "wikisource": lambda r: {**r, "license": license_for("wikisource")}, |
| "wikisource_works": lambda r: {**r, "license": license_for("wikisource")}, |
| } |
| for name, src in jobs.items(): |
| r = jsonl_to_parquet(src, out / "data" / name, "train", transform=tfs.get(name)) |
| r.update(verify_parquet([out / "data" / name / f for f in r["files"]], r["rows_source"], r["text_concat_sha256"])) |
| rep[name] = r |
| |
| rows = [] |
| for p in sorted((DS / "corpus/metadata").glob("*.json")): |
| rows.append({"pid": p.stem, "json": p.read_text(encoding="utf-8")}) |
| d = out / "data/ndl_api_bibliography" |
| d.mkdir(parents=True, exist_ok=True) |
| pq.write_table(pa.Table.from_pylist(rows), d / "train-00000-of-00001.parquet", compression="zstd") |
| rep["ndl_api_bibliography"] = {"rows": len(rows)} |
| |
| for d, names in { |
| "corpus/preprocessed-v1/build-001": ["manifest.json", "report.json", "verification.json", |
| "output_verification.json", "excluded.jsonl", "edits.jsonl"], |
| "kanripo/preprocessed-v1/build-002": ["manifest.json", "report.json", "verification.json", "excluded.jsonl", |
| "duplicates.jsonl", "edits.jsonl", "files.jsonl"], |
| "minhon/preprocessed-v1/build-003-bibdated": ["README.md", "manifest.json", "report.json", "verification.json", |
| "date_evidence.jsonl", "documents.csv", |
| "included_documents.csv", "excluded_documents.csv"], |
| "wikisource/corpus-v1": ["report.json", "duplicates.jsonl"], |
| }.items(): |
| for nm in names: |
| link(DS / d / nm, out / "meta" / d.replace("/", "__") / nm) |
| link(DS / "corpus/metadata/dataset_202602_k_internet.zip", out / "meta/ndl/dataset_202602_k_internet.zip") |
| link_tree(DS / "kanripo/metadata", out / "meta/kanripo/metadata") |
| link_tree(DS / "minhon/title-lists", out / "meta/minhon/title-lists") |
| link_tree(DS / "wikisource/metadata", out / "meta/wikisource/metadata") |
| for nm in ["pids_before_1868.txt", "pids_api_before_1868.txt"]: |
| link(DS / nm, out / "meta/ndl" / nm) |
| for nm in ["oncoj.csv", "lexicon.xml"]: |
| link(DS / nm, out / "extras" / nm) |
| return rep |
|
|
|
|
| def pack_sft(out: Path) -> dict: |
| exp = DS / "unified/sft-dialogue-v1/build-openai-001/exports/002" |
| by_split: dict[str, list[str]] = {} |
| for line in (exp / "dialogues.jsonl").read_text(encoding="utf-8").splitlines(): |
| if line.strip(): |
| by_split.setdefault(json.loads(line).get("split", "train"), []).append(line) |
| for s, lines in by_split.items(): |
| write(out / "data" / f"{s}.jsonl", "\n".join(lines) + "\n") |
| for p in exp.iterdir(): |
| if p.name != "dialogues.jsonl": |
| link(p, out / "meta/export-002" / p.name) |
| b = DS / "unified/sft-dialogue-v1/build-openai-001" |
| for nm in ["SUMMARY.md", "manifest.json", "coverage-verification.json"]: |
| link(b / nm, out / "meta" / nm) |
| link_tree(DS / "unified/evaluation-tasks-v1/validation-001", out / "evaluation-tasks") |
| return {"splits": {s: len(v) for s, v in by_split.items()}} |
|
|
|
|
| def pack_model(src: Path, out: Path, extra: dict[str, Path] | None = None, skip=("__pycache__", ".lock")) -> dict: |
| n = link_tree(src, out, skip=skip) |
| for nm, p in (extra or {}).items(): |
| link(p, out / nm) |
| return {"files": n + len(extra or {})} |
|
|
|
|
| REPOS = { |
| "classical-ja-pretrain": ("dataset", pack_pretrain), |
| "classical-ja-sources": ("dataset", pack_sources), |
| "classical-ja-sft-dialogue": ("dataset", pack_sft), |
| "classical-ja-tokenizer": ("model", lambda o: pack_model( |
| DS / "unified/tokenizer-v1/build-001", o, |
| {"classical_tokenizer.py": DS / "runs/classical-smollm2-trunk/export/classical_tokenizer.py", |
| "tokenizer_config.json": DS / "runs/classical-smollm2-trunk/export/tokenizer_config.json"}, |
| skip=("__pycache__", ".lock", "train.txt"))), |
| "classical-smollm2-trunk": ("model", lambda o: pack_model( |
| DS / "runs/classical-smollm2-trunk/export", o, |
| {"metrics.jsonl": DS / "runs/classical-smollm2-trunk/metrics.jsonl", |
| "run.json": DS / "runs/classical-smollm2-trunk/run.json", |
| "status.json": DS / "runs/classical-smollm2-trunk/status.json"})), |
| "classical-smollm2-sft": ("model", lambda o: pack_model( |
| DS / "runs/classical-sft-confidence2-001/checkpoint-000090", o, |
| {"SUMMARY.md": DS / "runs/classical-sft-confidence2-001/SUMMARY.md", |
| "best.json": DS / "runs/classical-sft-confidence2-001/best.json", |
| "metrics.jsonl": DS / "runs/classical-sft-confidence2-001/metrics.jsonl", |
| "training_config.json": DS / "runs/classical-sft-confidence2-001/config.json"})), |
| } |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--out", default=str(DS / "hf-staging")) |
| ap.add_argument("--only", nargs="*") |
| a = ap.parse_args() |
| for name, (kind, fn) in REPOS.items(): |
| if a.only and name not in a.only: |
| continue |
| out = Path(a.out) / name |
| if out.exists(): |
| shutil.rmtree(out) |
| out.mkdir(parents=True) |
| print(f"[pack] {name}", flush=True) |
| rep = {"repo": name, "type": kind, **fn(out)} |
| card = CARDS / f"{name}.md" |
| if card.exists(): |
| link(card, out / "README.md") |
| if kind == "dataset": |
| link_tree(CARDS / "LICENSES", out / "LICENSES") |
| else: |
| link(CARDS / "APACHE-2.0.txt", out / "LICENSE") |
| rep["redacted_files"] = sorted(set(REDACTED)); REDACTED.clear() |
| write(out / "pack_report.json", json.dumps(rep, ensure_ascii=False, indent=2)) |
| print(json.dumps(rep, ensure_ascii=False)[:2000], flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
