build_parquet.py

#!/usr/bin/env python3
"""Build the normalized tokenizer comparison table from the raw JSON files."""

import argparse
import csv
import hashlib
import json
from pathlib import Path

import pyarrow as pa
import pyarrow.parquet as pq


SOURCE_COMMIT = "1a5cd2c2e4df2287b4c19b3dbf5051f5d460fdc1"
KACPER_SOURCE_COMMIT = "8a273e6fd6e05b56d9d05e15e0de8232f8be3548"
GITHUB_AUTHORS = {
    "Arek": "Maggio333",
    "KasiaMP": "KateMajzel",
    "dawidm": "dawidmajewski",
    "ola": "olajachymiak",
    "Janek": "janbanot",
    "patryk": "p4pryk",
    "Konrad": "ktalik",
}
BULK_KEYS = {
    "model",
    "vocab",
    "merges",
    "reguly_merge",
    "token_to_id",
    "id_to_token",
}


def extract_metadata(document: dict) -> dict:
    """Keep explicit metadata and compact non-vocabulary configuration fields."""
    metadata = {}
    if isinstance(document.get("meta"), dict):
        metadata.update(document["meta"])

    for key, value in document.items():
        if key in BULK_KEYS or key == "meta":
            continue
        # Avoid duplicating large experimental token dumps in the metadata cell.
        if key.startswith("tokeny_") or key == "przykladowy_tekst":
            continue
        metadata[key] = value
    return metadata


def component_name(value) -> str:
    if value is None:
        return "none"
    if isinstance(value, dict):
        return str(value.get("type", "configured"))
    return str(value)


def merge_count(document: dict) -> int | None:
    model = document.get("model")
    candidates = []
    if isinstance(model, dict):
        candidates.append(model.get("merges"))
    candidates.extend((document.get("merges"), document.get("reguly_merge")))
    for value in candidates:
        if isinstance(value, (list, dict)):
            return len(value)
    for key in ("liczba_regul_merge", "n_merges"):
        if isinstance(document.get(key), int):
            return document[key]
    return None


def extract_reported_metrics(document: dict) -> dict:
    markers = ("eval", "metr", "fert", "znaki_na_token", "tokens_per_word", "sweep", "compression")
    metrics = {}
    for key, value in document.items():
        if any(marker in key.lower() for marker in markers):
            metrics[key] = value
    if isinstance(document.get("meta"), dict):
        for key, value in document["meta"].items():
            if any(marker in key.lower() for marker in markers):
                metrics[f"meta.{key}"] = value
    return metrics


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--source-root", type=Path, default=Path("."))
    parser.add_argument("--manifest", type=Path, default=Path("manifest.csv"))
    parser.add_argument("--output", type=Path, default=Path("data/train-00000-of-00001.parquet"))
    parser.add_argument("--kacper-tokenizer", type=Path)
    args = parser.parse_args()

    rows = []
    with args.manifest.open(newline="", encoding="utf-8") as handle:
        for item in csv.DictReader(handle):
            source_path = item["source_path"]
            raw_json = (args.source_root / source_path).read_text(encoding="utf-8")
            document = json.loads(raw_json)
            model = document.get("model") if isinstance(document.get("model"), dict) else {}
            metrics = extract_reported_metrics(document)
            hf_loadable = item["format"] == "hf_tokenizers"
            rows.append(
                {
                    "author": GITHUB_AUTHORS[item["contributor"]],
                    "size": int(item["vocab_size"]),
                    "name": Path(source_path).name,
                    "quick_status": "ready_hf_tokenizers" if hf_loadable else "custom_conversion_required",
                    "hf_loadable": hf_loadable,
                    "format": item["format"],
                    "model_type": item["model_type"],
                    "merge_count": merge_count(document),
                    "normalizer": component_name(document.get("normalizer")),
                    "pre_tokenizer": component_name(document.get("pre_tokenizer")),
                    "decoder": component_name(document.get("decoder")),
                    "unk_token": str(model.get("unk_token") or ""),
                    "added_tokens_count": len(document.get("added_tokens", [])),
                    "reported_metrics": json.dumps(metrics, ensure_ascii=False, sort_keys=True),
                    "metadata": json.dumps(
                        extract_metadata(document), ensure_ascii=False, sort_keys=True
                    ),
                    "tokenizer_json": raw_json,
                    "source_repo": "https://github.com/slayerlabs/tokenizer",
                    "source_path": source_path,
                    "source_commit": SOURCE_COMMIT,
                    "bytes": int(item["bytes"]),
                    "sha256": item["sha256"],
                }
            )

    if args.kacper_tokenizer:
        raw_json = args.kacper_tokenizer.read_text(encoding="utf-8")
        document = json.loads(raw_json)
        model = document["model"]
        metrics = extract_reported_metrics(document)
        rows.append(
            {
                "author": "kacperwikiel",
                "size": len(model["vocab"]),
                "name": "polish_bpe_32k.json",
                "quick_status": "ready_hf_tokenizers",
                "hf_loadable": True,
                "format": "hf_tokenizers",
                "model_type": model["type"],
                "merge_count": merge_count(document),
                "normalizer": component_name(document.get("normalizer")),
                "pre_tokenizer": component_name(document.get("pre_tokenizer")),
                "decoder": component_name(document.get("decoder")),
                "unk_token": str(model.get("unk_token") or ""),
                "added_tokens_count": len(document.get("added_tokens", [])),
                "reported_metrics": json.dumps(metrics, ensure_ascii=False, sort_keys=True),
                "metadata": json.dumps(
                    extract_metadata(document), ensure_ascii=False, sort_keys=True
                ),
                "tokenizer_json": raw_json,
                "source_repo": "https://huggingface.co/SlayerLab/slayer-scratch",
                "source_path": "tokenizers/polish_bpe_32k.json",
                "source_commit": KACPER_SOURCE_COMMIT,
                "bytes": len(raw_json.encode("utf-8")),
                "sha256": hashlib.sha256(raw_json.encode("utf-8")).hexdigest(),
            }
        )

    schema = pa.schema(
        [
            ("author", pa.string()),
            ("size", pa.int64()),
            ("name", pa.string()),
            ("quick_status", pa.string()),
            ("hf_loadable", pa.bool_()),
            ("format", pa.string()),
            ("model_type", pa.string()),
            ("merge_count", pa.int64()),
            ("normalizer", pa.string()),
            ("pre_tokenizer", pa.string()),
            ("decoder", pa.string()),
            ("unk_token", pa.string()),
            ("added_tokens_count", pa.int64()),
            ("reported_metrics", pa.string()),
            ("metadata", pa.string()),
            ("tokenizer_json", pa.large_string()),
            ("source_repo", pa.string()),
            ("source_path", pa.string()),
            ("source_commit", pa.string()),
            ("bytes", pa.int64()),
            ("sha256", pa.string()),
        ]
    )
    args.output.parent.mkdir(parents=True, exist_ok=True)
    pq.write_table(
        pa.Table.from_pylist(rows, schema=schema),
        args.output,
        compression="zstd",
        compression_level=9,
    )


if __name__ == "__main__":
    main()