generation/common.py

#!/usr/bin/env python3
"""Shared deterministic helpers for the Zbyňka synthetic-data expansion.

The generator deliberately uses only Python's standard library.  Every output row
contains one ChatML conversation in the repository's existing `text` schema.
"""
from __future__ import annotations

import csv
import hashlib
import json
import math
import os
import re
from dataclasses import dataclass
from pathlib import Path
from typing import Callable, Iterable, Sequence

REPO = Path(__file__).resolve().parents[1]
OUT = REPO / "data" / "additions"
OUT.mkdir(parents=True, exist_ok=True)

NAMES = [
    "Adam", "Alena", "Barbora", "Cyril", "Daniel", "Dana", "Eliška", "Filip",
    "Hana", "Irena", "Jakub", "Jana", "Klára", "Kryštof", "Lucie", "Marek",
    "Marie", "Matěj", "Nina", "Ondřej", "Pavel", "Petra", "Radek", "Simona",
    "Tereza", "Tomáš", "Václav", "Veronika", "Viktor", "Zuzana",
]
DAYS = ["pondělí", "úterý", "středu", "čtvrtek", "pátek", "sobotu", "neděli"]
CITIES = [
    "Praze", "Brně", "Ostravě", "Plzni", "Liberci", "Olomouci",
    "Pardubicích", "Jihlavě", "Zlíně", "Táboře", "Klatovech", "Opavě",
]
REQUEST_ENDINGS = [
    "Odpověz stručně a prakticky.",
    "Vysvětli také hlavní důvod.",
    "Ukaž rozhodující krok.",
    "Napiš odpověď srozumitelně pro začátečníka.",
    "Nejdřív uveď závěr a potom vysvětlení.",
    "Zkontroluj výsledek zdravým rozumem.",
    "Rozliš jistý závěr od pouhého odhadu.",
    "Přidej jednu užitečnou zásadu.",
]

_TAGS = (
    "<|im_start|>system", "<|im_start|>user", "<|im_start|>assistant",
    "<|im_end|>", "<thought>", "</thought>",
)


def clean(value: object) -> str:
    """Normalize generated content without flattening intentional newlines."""
    text = str(value).replace("\r\n", "\n").replace("\r", "\n")
    text = re.sub(r"[ \t]+\n", "\n", text)
    text = re.sub(r"\n{4,}", "\n\n\n", text)
    return text.strip()


def chatml(system: str, user: str, thought: str, answer: str) -> str:
    system, user, thought, answer = map(clean, (system, user, thought, answer))
    for label, value in (("system", system), ("user", user), ("thought", thought), ("answer", answer)):
        if not value:
            raise ValueError(f"Empty {label}")
    return (
        f"<|im_start|>system\n{system}<|im_end|>\n"
        f"<|im_start|>user\n{user}<|im_end|>\n"
        f"<|im_start|>assistant\n<thought>\n{thought}\n</thought>\n"
        f"{answer}<|im_end|>"
    )


def pick(seq: Sequence, i: int, divisor: int = 1):
    return seq[(i // divisor) % len(seq)]


def digits(i: int, radices: Sequence[int]) -> list[int]:
    """Mixed-radix digits, useful for deterministic combinatorics."""
    out: list[int] = []
    for radix in radices:
        out.append(i % radix)
        i //= radix
    return out


def cz_number(value: float | int, decimals: int = 2) -> str:
    if isinstance(value, int) or float(value).is_integer():
        return f"{int(value):,}".replace(",", " ")
    result = f"{value:.{decimals}f}".rstrip("0").rstrip(".")
    return result.replace(".", ",")


def money(value: float) -> str:
    return f"{value:.2f}".replace(".", ",") + " Kč"


def stable_code(i: int, alphabet: str, length: int) -> str:
    chars = []
    n = i
    for _ in range(length):
        chars.append(alphabet[n % len(alphabet)])
        n = (n // len(alphabet)) + 1
    return "".join(chars)


def text_sha256(path: Path) -> str:
    h = hashlib.sha256()
    with path.open("rb") as f:
        for block in iter(lambda: f.read(1024 * 1024), b""):
            h.update(block)
    return h.hexdigest()


def validate_chatml(text: str) -> None:
    expected = {
        "<|im_start|>system": 1,
        "<|im_start|>user": 1,
        "<|im_start|>assistant": 1,
        "<thought>": 1,
        "</thought>": 1,
        "<|im_end|>": 3,
    }
    for tag, count in expected.items():
        actual = text.count(tag)
        if actual != count:
            raise ValueError(f"Tag {tag!r}: expected {count}, got {actual}")
    if "\x00" in text:
        raise ValueError("NUL byte in generated text")


@dataclass
class WriteStats:
    path: str
    rows: int
    bytes: int
    sha256: str
    unique_rows: int
    min_chars: int
    max_chars: int
    avg_chars: float

    def as_dict(self) -> dict:
        return self.__dict__.copy()


def write_dataset(
    relative_path: str,
    count: int,
    generator: Callable[[int], str],
    *,
    forbidden: Iterable[str] = (),
) -> WriteStats:
    """Generate a one-column CSV atomically and enforce exact uniqueness."""
    path = OUT / relative_path
    path.parent.mkdir(parents=True, exist_ok=True)
    tmp = path.with_suffix(path.suffix + ".part")
    seen: set[bytes] = set()
    lengths: list[int] = []
    forbidden_folded = tuple(x.casefold() for x in forbidden)

    with tmp.open("w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["text"], lineterminator="\n")
        writer.writeheader()
        for i in range(count):
            text = generator(i)
            validate_chatml(text)
            folded = text.casefold()
            for term in forbidden_folded:
                if term in folded:
                    raise ValueError(f"Forbidden fragment {term!r} in {relative_path}, row {i + 1}")
            digest = hashlib.blake2b(text.encode("utf-8"), digest_size=16).digest()
            if digest in seen:
                raise ValueError(f"Duplicate generated row in {relative_path}: {i + 1}")
            seen.add(digest)
            lengths.append(len(text))
            writer.writerow({"text": text})
        f.flush()
        os.fsync(f.fileno())
    tmp.replace(path)

    stats = WriteStats(
        path=str(path.relative_to(REPO)),
        rows=count,
        bytes=path.stat().st_size,
        sha256=text_sha256(path),
        unique_rows=len(seen),
        min_chars=min(lengths),
        max_chars=max(lengths),
        avg_chars=round(sum(lengths) / len(lengths), 2),
    )
    print(json.dumps(stats.as_dict(), ensure_ascii=False))
    return stats


def save_stats(name: str, stats: Sequence[WriteStats]) -> None:
    stats_dir = REPO / "generation" / "stats"
    stats_dir.mkdir(parents=True, exist_ok=True)
    target = stats_dir / f"{name}.json"
    target.write_text(
        json.dumps([s.as_dict() for s in stats], ensure_ascii=False, indent=2) + "\n",
        encoding="utf-8",
    )


def ceil_div(a: int, b: int) -> int:
    return (a + b - 1) // b


def hhmm(minutes: int) -> str:
    minutes %= 24 * 60
    return f"{minutes // 60:02d}:{minutes % 60:02d}"


def join_czech(items: Sequence[str]) -> str:
    if not items:
        return ""
    if len(items) == 1:
        return items[0]
    return ", ".join(items[:-1]) + " a " + items[-1]