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()