| from __future__ import annotations |
|
|
| import gzip |
| import json |
| from collections.abc import Iterator, Sequence |
| from pathlib import Path |
| from typing import Any, TextIO |
| import glob |
|
|
|
|
| SUPPORTED_SUFFIXES = (".jsonl", ".jsonl.gz", ".txt", ".txt.gz") |
|
|
|
|
| def discover_paths(inputs: Sequence[str | Path]) -> list[Path]: |
| found: set[Path] = set() |
| for raw_input in inputs: |
| raw = str(raw_input) |
| path = Path(raw) |
| if path.is_dir(): |
| for candidate in path.rglob("*"): |
| if candidate.is_file() and any( |
| str(candidate).lower().endswith(suffix) |
| for suffix in SUPPORTED_SUFFIXES |
| ): |
| found.add(candidate.resolve()) |
| continue |
| matches = [Path(item) for item in glob.glob(raw, recursive=True)] |
| if matches: |
| found.update(item.resolve() for item in matches if item.is_file()) |
| elif path.is_file(): |
| found.add(path.resolve()) |
| return sorted(found) |
|
|
|
|
| def open_text(path: Path) -> TextIO: |
| if path.name.lower().endswith(".gz"): |
| return gzip.open(path, "rt", encoding="utf-8", errors="replace") |
| return path.open("r", encoding="utf-8", errors="replace") |
|
|
|
|
| def iter_documents( |
| paths: Sequence[Path], |
| *, |
| text_field: str = "text", |
| txt_mode: str = "line", |
| ) -> Iterator[dict[str, Any]]: |
| if txt_mode not in {"line", "document"}: |
| raise ValueError("txt_mode must be 'line' or 'document'") |
|
|
| for path in paths: |
| lower_name = path.name.lower() |
| source_default = path.name.removesuffix(".gz") |
| if lower_name.endswith((".jsonl", ".jsonl.gz")): |
| with open_text(path) as handle: |
| for line_number, line in enumerate(handle, start=1): |
| if not line.strip(): |
| continue |
| try: |
| row = json.loads(line) |
| except json.JSONDecodeError as error: |
| raise ValueError( |
| f"Invalid JSON at {path}:{line_number}: {error}" |
| ) from error |
| if not isinstance(row, dict): |
| raise ValueError( |
| f"Expected a JSON object at {path}:{line_number}" |
| ) |
| text = row.get(text_field) |
| if not isinstance(text, str): |
| continue |
| yield { |
| "id": row.get("id", f"{path.name}:{line_number}"), |
| "text": text, |
| "source": row.get("source", source_default), |
| "url": row.get("url"), |
| "license": row.get("license"), |
| } |
| continue |
|
|
| if lower_name.endswith((".txt", ".txt.gz")): |
| with open_text(path) as handle: |
| if txt_mode == "document": |
| text = handle.read() |
| if text.strip(): |
| yield { |
| "id": path.name, |
| "text": text, |
| "source": source_default, |
| "url": None, |
| "license": None, |
| } |
| else: |
| for line_number, line in enumerate(handle, start=1): |
| if line.strip(): |
| yield { |
| "id": f"{path.name}:{line_number}", |
| "text": line.rstrip("\n"), |
| "source": source_default, |
| "url": None, |
| "license": None, |
| } |
|
|
|
|
| class ShardedJsonlWriter: |
| def __init__( |
| self, |
| output_dir: Path, |
| split: str, |
| *, |
| documents_per_shard: int, |
| ) -> None: |
| self.output_dir = output_dir |
| self.split = split |
| self.documents_per_shard = documents_per_shard |
| self.document_count = 0 |
| self.shard_index = -1 |
| self._handle: TextIO | None = None |
|
|
| def _open_next(self) -> None: |
| if self._handle is not None: |
| self._handle.close() |
| self.shard_index += 1 |
| path = self.output_dir / f"{self.split}-{self.shard_index:05d}.jsonl" |
| self._handle = path.open("w", encoding="utf-8", newline="\n") |
|
|
| def write(self, row: dict[str, Any]) -> None: |
| if self._handle is None or self.document_count % self.documents_per_shard == 0: |
| self._open_next() |
| assert self._handle is not None |
| self._handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":"))) |
| self._handle.write("\n") |
| self.document_count += 1 |
|
|
| def close(self) -> None: |
| if self._handle is not None: |
| self._handle.close() |
| self._handle = None |
|
|
| def __enter__(self) -> "ShardedJsonlWriter": |
| return self |
|
|
| def __exit__(self, *_: object) -> None: |
| self.close() |
|
|
|
|
