| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from pathlib import Path |
| from typing import Any |
|
|
| from kawk50m.cli import configure_utf8_stdio |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description="Concatenate uint16 token parts with an optional exact limit." |
| ) |
| parser.add_argument("--input-dir", required=True) |
| parser.add_argument("--output", required=True) |
| parser.add_argument("--max-tokens", type=int, default=None) |
| parser.add_argument("--copy-buffer-mib", type=int, default=8) |
| return parser.parse_args() |
|
|
|
|
| def main() -> None: |
| configure_utf8_stdio() |
| args = parse_args() |
| if args.max_tokens is not None and args.max_tokens <= 0: |
| raise ValueError("--max-tokens must be positive") |
| if args.copy_buffer_mib <= 0: |
| raise ValueError("--copy-buffer-mib must be positive") |
|
|
| input_dir = Path(args.input_dir) |
| parts = sorted(input_dir.glob("*.bin")) |
| if not parts: |
| raise FileNotFoundError(f"No token parts found in {input_dir}") |
| output_path = Path(args.output) |
| metadata_path = output_path.with_suffix(".metadata.json") |
| if output_path.exists() or metadata_path.exists(): |
| raise FileExistsError(f"Refusing to overwrite combined output: {output_path}") |
| output_path.parent.mkdir(parents=True, exist_ok=True) |
|
|
| max_bytes = args.max_tokens * 2 if args.max_tokens is not None else None |
| buffer_size = args.copy_buffer_mib * 1024**2 |
| bytes_written = 0 |
| parts_used = 0 |
| with output_path.open("wb") as target: |
| for part in parts: |
| part_size = part.stat().st_size |
| if part_size % 2: |
| raise ValueError(f"Odd byte size for uint16 part: {part}") |
| remaining = ( |
| part_size |
| if max_bytes is None |
| else min(part_size, max_bytes - bytes_written) |
| ) |
| if remaining <= 0: |
| break |
| with part.open("rb") as source: |
| while remaining: |
| chunk = source.read(min(buffer_size, remaining)) |
| if not chunk: |
| raise IOError(f"Unexpected EOF while reading {part}") |
| target.write(chunk) |
| bytes_written += len(chunk) |
| remaining -= len(chunk) |
| parts_used += 1 |
|
|
| summaries: list[dict[str, Any]] = [] |
| for path in sorted(input_dir.glob("*.json")): |
| summaries.append(json.loads(path.read_text(encoding="utf-8"))) |
| result = { |
| "output": str(output_path), |
| "tokens": bytes_written // 2, |
| "bytes": bytes_written, |
| "dtype": "uint16", |
| "available_part_tokens": sum(part.stat().st_size for part in parts) // 2, |
| "parts_available": len(parts), |
| "parts_used": parts_used, |
| "documents_seen": sum(int(row["documents_seen"]) for row in summaries), |
| "documents_written": sum( |
| int(row["documents_written"]) for row in summaries |
| ), |
| } |
| metadata_path.write_text( |
| json.dumps(result, ensure_ascii=False, indent=2) + "\n", |
| encoding="utf-8", |
| ) |
| print(json.dumps(result, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
