scripts/download_fineweb2.py

from __future__ import annotations

import argparse
import gzip
import json
import os
import time
from pathlib import Path
from typing import Any, TextIO

from datasets import load_dataset
from huggingface_hub import HfApi
from tqdm import tqdm

from kawk50m.cli import configure_utf8_stdio


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Stream a reproducible Korean FineWeb2 sample to sharded JSONL.gz."
    )
    parser.add_argument("--dataset", default="HuggingFaceFW/fineweb-2")
    parser.add_argument("--subset", default="kor_Hang")
    parser.add_argument("--split", default="train")
    parser.add_argument(
        "--revision",
        default=None,
        help="Hub commit SHA. The current dataset SHA is resolved when omitted.",
    )
    parser.add_argument(
        "--output-dir", default="data/raw/fineweb2-kor-pilot"
    )
    parser.add_argument("--max-documents", type=int, default=300_000)
    parser.add_argument("--documents-per-shard", type=int, default=50_000)
    parser.add_argument("--shuffle-buffer", type=int, default=10_000)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument(
        "--dataset-num-shards",
        type=int,
        default=1,
        help="Split the streaming dataset into disjoint workers.",
    )
    parser.add_argument(
        "--dataset-shard-index",
        type=int,
        default=0,
        help="Zero-based worker index within --dataset-num-shards.",
    )
    parser.add_argument("--compression-level", type=int, default=6)
    parser.add_argument(
        "--cache-dir", default=".cache/huggingface/datasets"
    )
    parser.add_argument(
        "--resume",
        action="store_true",
        help="Continue after completed shards recorded in download_state.json.",
    )
    return parser.parse_args()


def atomic_json(path: Path, value: dict[str, Any]) -> None:
    temporary = path.with_suffix(path.suffix + ".tmp")
    with temporary.open("w", encoding="utf-8") as handle:
        json.dump(value, handle, ensure_ascii=False, indent=2)
        handle.write("\n")
    os.replace(temporary, path)


def open_shard(
    output_dir: Path, shard_index: int, compression_level: int
) -> tuple[Path, Path, TextIO]:
    final_path = output_dir / f"fineweb2-kor-{shard_index:05d}.jsonl.gz"
    temporary_path = final_path.with_suffix(final_path.suffix + ".tmp")
    if final_path.exists() or temporary_path.exists():
        raise FileExistsError(f"Refusing to overwrite shard: {final_path}")
    handle = gzip.open(
        temporary_path,
        "wt",
        encoding="utf-8",
        newline="\n",
        compresslevel=compression_level,
    )
    return final_path, temporary_path, handle


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    if args.max_documents <= 0:
        raise ValueError("--max-documents must be positive")
    if args.documents_per_shard <= 0:
        raise ValueError("--documents-per-shard must be positive")
    if args.shuffle_buffer < 1:
        raise ValueError("--shuffle-buffer must be positive")
    if args.dataset_num_shards <= 0:
        raise ValueError("--dataset-num-shards must be positive")
    if not 0 <= args.dataset_shard_index < args.dataset_num_shards:
        raise ValueError(
            "--dataset-shard-index must be in "
            "[0, --dataset-num-shards)"
        )

    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    state_path = output_dir / "download_state.json"
    existing_shards = sorted(output_dir.glob("fineweb2-kor-*.jsonl.gz"))

    if args.resume:
        if not state_path.is_file():
            raise FileNotFoundError(f"Resume state is missing: {state_path}")
        with state_path.open("r", encoding="utf-8") as handle:
            state = json.load(handle)
        if state["dataset"] != args.dataset or state["subset"] != args.subset:
            raise ValueError("Resume dataset/subset does not match saved state")
        if int(state.get("dataset_num_shards", 1)) != args.dataset_num_shards:
            raise ValueError("Resume dataset shard count does not match saved state")
        if int(state.get("dataset_shard_index", 0)) != args.dataset_shard_index:
            raise ValueError("Resume dataset shard index does not match saved state")
        revision = state["revision"]
        documents_written = int(state["documents_written"])
        utf8_bytes = int(state["utf8_bytes"])
        shard_index = int(state["completed_shards"])
        seed = int(state["seed"])
        shuffle_buffer = int(state["shuffle_buffer"])
        if len(existing_shards) != shard_index:
            raise RuntimeError("Completed shard count does not match resume state")
        if args.max_documents <= documents_written:
            raise RuntimeError(
                f"Download already contains {documents_written} documents; "
                "--max-documents must be larger to extend it"
            )
    else:
        if state_path.exists() or existing_shards:
            raise FileExistsError(
                f"{output_dir} already contains download artifacts; "
                "use --resume or choose a new output directory"
            )
        revision = args.revision or HfApi().dataset_info(args.dataset).sha
        documents_written = 0
        utf8_bytes = 0
        shard_index = 0
        seed = args.seed
        shuffle_buffer = args.shuffle_buffer

    dataset = load_dataset(
        args.dataset,
        name=args.subset,
        split=args.split,
        revision=revision,
        streaming=True,
        cache_dir=args.cache_dir,
    )
    if args.dataset_num_shards > 1:
        dataset = dataset.shard(
            num_shards=args.dataset_num_shards,
            index=args.dataset_shard_index,
            contiguous=True,
        )
    dataset = dataset.shuffle(seed=seed, buffer_size=shuffle_buffer)
    if documents_written:
        dataset = dataset.skip(documents_written)

    started = time.time()
    progress = tqdm(
        total=args.max_documents,
        initial=documents_written,
        unit="docs",
        desc=args.subset,
    )
    final_path: Path | None = None
    temporary_path: Path | None = None
    handle: TextIO | None = None
    documents_in_shard = 0

    def save_state(*, complete: bool) -> None:
        atomic_json(
            state_path,
            {
                "dataset": args.dataset,
                "subset": args.subset,
                "split": args.split,
                "revision": revision,
                "license": "ODC-By-1.0; subject to CommonCrawl Terms of Use",
                "seed": seed,
                "shuffle_buffer": shuffle_buffer,
                "dataset_num_shards": args.dataset_num_shards,
                "dataset_shard_index": args.dataset_shard_index,
                "max_documents": args.max_documents,
                "documents_per_shard": args.documents_per_shard,
                "documents_written": documents_written,
                "utf8_bytes": utf8_bytes,
                "completed_shards": shard_index,
                "elapsed_seconds": time.time() - started,
                "complete": complete,
            },
        )

    try:
        for row in dataset:
            if documents_written >= args.max_documents:
                break
            if handle is None:
                final_path, temporary_path, handle = open_shard(
                    output_dir, shard_index, args.compression_level
                )
                documents_in_shard = 0

            text = row.get("text")
            if not isinstance(text, str) or not text.strip():
                continue
            output_row = {
                "id": f"fineweb2:{row.get('id', documents_written)}",
                "text": text,
                "source": f"fineweb2:{args.subset}",
                "url": row.get("url"),
                "license": "ODC-By-1.0",
                "date": row.get("date"),
                "dump": row.get("dump"),
                "language": row.get("language"),
                "language_score": row.get("language_score"),
                "minhash_cluster_size": row.get("minhash_cluster_size"),
            }
            encoded = json.dumps(
                output_row, ensure_ascii=False, separators=(",", ":")
            )
            handle.write(encoded)
            handle.write("\n")
            documents_written += 1
            documents_in_shard += 1
            utf8_bytes += len(text.encode("utf-8"))
            progress.update(1)

            if documents_in_shard >= args.documents_per_shard:
                handle.close()
                handle = None
                assert final_path is not None and temporary_path is not None
                os.replace(temporary_path, final_path)
                shard_index += 1
                save_state(complete=False)

        if handle is not None:
            handle.close()
            handle = None
            assert final_path is not None and temporary_path is not None
            os.replace(temporary_path, final_path)
            shard_index += 1
        save_state(complete=documents_written >= args.max_documents)
    except BaseException:
        if handle is not None:
            handle.close()
            handle = None
            if documents_in_shard:
                assert final_path is not None and temporary_path is not None
                os.replace(temporary_path, final_path)
                shard_index += 1
        save_state(complete=False)
        raise
    finally:
        if handle is not None:
            handle.close()
        progress.close()

    print(
        json.dumps(
            {
                "output_dir": str(output_dir.resolve()),
                "revision": revision,
                "documents": documents_written,
                "utf8_text_gib": utf8_bytes / 1024**3,
                "shards": shard_index,
                "complete": documents_written >= args.max_documents,
            },
            ensure_ascii=False,
            indent=2,
        )
    )


if __name__ == "__main__":
    main()