| """Serialization helpers for stackbuild samples.""" |
|
|
| from __future__ import annotations |
|
|
| from dataclasses import asdict |
| import json |
| from pathlib import Path |
| from typing import Iterable |
|
|
| from .model import Sample |
|
|
|
|
| def sample_to_dict(sample: Sample) -> dict: |
| return asdict(sample) |
|
|
|
|
| def write_jsonl(samples: Iterable[Sample], path: str | Path) -> None: |
| target = Path(path) |
| temporary = target.with_suffix(target.suffix + ".part") |
| with temporary.open("w", encoding="utf-8") as stream: |
| for sample in samples: |
| stream.write(json.dumps(sample_to_dict(sample), ensure_ascii=False, separators=(",", ":"))) |
| stream.write("\n") |
| temporary.replace(target) |
|
|
|
|
| def _parquet_row(sample: Sample) -> dict: |
| row = sample_to_dict(sample) |
| row["files"] = list(row["files"]) |
| row["metadata_json"] = json.dumps( |
| row.pop("metadata"), ensure_ascii=False, separators=(",", ":"), sort_keys=True, |
| ) |
| return row |
|
|
|
|
| class ParquetSampleWriter: |
| """Buffered, atomic Parquet writer with a stable nested schema.""" |
|
|
| def __init__(self, path: str | Path, *, batch_size: int = 2048) -> None: |
| import pyarrow as pa |
|
|
| self.target = Path(path) |
| self.temporary = self.target.with_suffix(self.target.suffix + ".part") |
| self.target.parent.mkdir(parents=True, exist_ok=True) |
| self.batch_size = batch_size |
| self.buffer: list[dict] = [] |
| self.schema = pa.schema([ |
| ("sample_id", pa.string()), |
| ("repo_id", pa.string()), |
| ("revision_id", pa.string()), |
| ("kind", pa.string()), |
| ("text", pa.large_string()), |
| ("files", pa.list_(pa.struct([ |
| ("path", pa.string()), |
| ("relation", pa.string()), |
| ("content_policy", pa.string()), |
| ("role", pa.string()), |
| ("language", pa.string()), |
| ("bytes", pa.int64()), |
| ("part", pa.int32()), |
| ("parts", pa.int32()), |
| ]))), |
| ("token_count", pa.int32()), |
| ("metadata_json", pa.large_string()), |
| ]) |
| self.writer = None |
|
|
| def write(self, samples: Iterable[Sample]) -> None: |
| for sample in samples: |
| self.buffer.append(_parquet_row(sample)) |
| if len(self.buffer) >= self.batch_size: |
| self._flush() |
|
|
| def _flush(self) -> None: |
| if not self.buffer: |
| return |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| table = pa.Table.from_pylist(self.buffer, schema=self.schema) |
| if self.writer is None: |
| self.writer = pq.ParquetWriter( |
| self.temporary, self.schema, compression="zstd", |
| compression_level=6, use_dictionary=True, |
| ) |
| self.writer.write_table(table, row_group_size=self.batch_size) |
| self.buffer.clear() |
|
|
| def close(self) -> None: |
| self._flush() |
| if self.writer is None: |
| import pyarrow.parquet as pq |
| pq.write_table(self.schema.empty_table(), self.temporary, compression="zstd") |
| else: |
| self.writer.close() |
| self.temporary.replace(self.target) |
|
|
| def __enter__(self): |
| return self |
|
|
| def __exit__(self, exc_type, exc, traceback) -> None: |
| if exc_type is None: |
| self.close() |
| elif self.writer is not None: |
| self.writer.close() |
|
|
|
|
| def write_parquet(samples: Iterable[Sample], path: str | Path) -> None: |
| with ParquetSampleWriter(path) as writer: |
| writer.write(samples) |
|
|
