scripts/generate_dataset.py

from __future__ import annotations

import argparse
import bz2
import csv
import hashlib
import json
import math
import random
import re
import time
import unicodedata
from dataclasses import dataclass
from pathlib import Path
from typing import Iterable
from urllib.parse import urlencode
from urllib.request import Request, urlopen

USER_AGENT = "TurkishChatNormalizationMini/1.0 (local dataset builder)"
DEFAULT_TARGET_ROWS = 20000
DEFAULT_TRAIN_RATIO = 0.8
DEFAULT_SEED = 42


@dataclass(frozen=True)
class SourceSite:
    name: str
    api_url: str
    license: str


SITE_CONFIGS: tuple[SourceSite, ...] = (
    SourceSite("turkish_wikipedia", "https://tr.wikipedia.org/w/api.php", "CC BY-SA 4.0"),
    SourceSite("turkish_wikibooks", "https://tr.wikibooks.org/w/api.php", "CC BY-SA 4.0"),
    SourceSite("turkish_wikiquote", "https://tr.wikiquote.org/w/api.php", "CC BY-SA 4.0"),
    SourceSite("turkish_wikisource", "https://tr.wikisource.org/w/api.php", "CC BY-SA 4.0"),
)

TASKS: tuple[str, ...] = (
    "typo_correction",
    "diacritics_restoration",
    "grammar_fix",
    "informal_to_standard",
    "informal_to_formal",
    "message_polishing",
    "academic_polishing",
)

TASK_STYLE = {
    "typo_correction": "casual",
    "diacritics_restoration": "casual",
    "grammar_fix": "standard",
    "informal_to_standard": "standard",
    "informal_to_formal": "formal",
    "message_polishing": "formal",
    "academic_polishing": "academic",
}

TECH_KEYWORDS = (
    "bilgisayar",
    "yazılım",
    "program",
    "internet",
    "ağ",
    "veri",
    "sistem",
    "uygulama",
    "kod",
    "donanım",
    "algoritma",
    "veritabanı",
)

EDU_KEYWORDS = (
    "üniversite",
    "öğrenci",
    "okul",
    "ders",
    "eğitim",
    "öğretim",
    "tez",
    "makale",
    "akademi",
    "fakülte",
    "sınav",
)

REVIEW_KEYWORDS = (
    "ürün",
    "kargo",
    "satın",
    "sipariş",
    "yorum",
    "teslimat",
    "fiyat",
    "alışveriş",
)

COMMON_ABBREVIATIONS = (
    ("çünkü", "cunku"),
    ("göreceğim", "gorcegim"),
    ("gideceğim", "gidicem"),
    ("yapacağım", "yapcam"),
    ("olacağım", "olucam"),
    ("olacaktır", "olucak"),
    ("değil", "degil"),
    ("bir", "bi"),
    ("çok", "cok"),
    ("şey", "sey"),
    ("için", "icin"),
    ("güzel", "guzel"),
    ("söyle", "soyle"),
)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Build a Turkish normalization dataset from open web sources.")
    parser.add_argument("--target-rows", type=int, default=DEFAULT_TARGET_ROWS)
    parser.add_argument("--train-ratio", type=float, default=DEFAULT_TRAIN_RATIO)
    parser.add_argument("--seed", type=int, default=DEFAULT_SEED)
    parser.add_argument("--output-dir", type=Path, default=Path("data"))
    parser.add_argument("--batch-size", type=int, default=10)
    parser.add_argument("--variants-per-sentence", type=int, default=6)
    parser.add_argument("--pause-seconds", type=float, default=0.75)
    parser.add_argument("--source-mode", choices=("mixed", "api", "tatoeba", "wikipedia", "wikimedia"), default="mixed")
    parser.add_argument("--wikimedia-share", type=float, default=0.2)
    parser.add_argument("--wikipedia-share", type=float, default=None, help="Deprecated alias for --wikimedia-share.")
    return parser.parse_args()


def http_get_json(api_url: str, params: dict[str, str | int], pause_seconds: float, retries: int = 5) -> dict:
    url = f"{api_url}?{urlencode(params, doseq=True)}"
    request = Request(
        url,
        headers={
            "User-Agent": USER_AGENT,
            "Accept-Language": "tr-TR,tr;q=0.9,en;q=0.8",
            "From": "copilot@example.com",
        },
    )
    last_error: Exception | None = None

    for attempt in range(retries):
        try:
            with urlopen(request, timeout=30) as response:
                payload = json.loads(response.read().decode("utf-8"))
                if pause_seconds > 0:
                    time.sleep(pause_seconds)
                return payload
        except Exception as error:  # pragma: no cover - network-dependent path
            last_error = error
            status = getattr(error, "code", None)
            retry_after = 0.0
            headers = getattr(error, "headers", None)
            if headers is not None:
                header_value = headers.get("Retry-After")
                if header_value:
                    try:
                        retry_after = float(header_value)
                    except ValueError:
                        retry_after = 0.0
            if status in {429, 503} and attempt < retries - 1:
                sleep_seconds = max(retry_after, pause_seconds * (2 ** attempt), 1.0)
                time.sleep(sleep_seconds)
                continue
            raise

    if last_error is not None:
        raise last_error
    raise RuntimeError("Unable to fetch JSON payload.")


def normalize_whitespace(text: str) -> str:
    return re.sub(r"\s+", " ", text).strip()


def strip_diacritics(text: str) -> str:
    normalized = unicodedata.normalize("NFKD", text)
    return "".join(character for character in normalized if not unicodedata.combining(character))


def ensure_sentence_end(text: str) -> str:
    cleaned = normalize_whitespace(text)
    if not cleaned:
        return cleaned
    if cleaned[-1] not in ".!?…":
        cleaned += "."
    return cleaned


def stable_bucket(*parts: str) -> int:
    digest = hashlib.sha256("|".join(parts).encode("utf-8")).digest()
    return digest[0]


def classify_domain(title: str, sentence: str) -> str:
    blob = f"{title} {sentence}".lower()
    if any(keyword in blob for keyword in TECH_KEYWORDS):
        return "technical_support"
    if any(keyword in blob for keyword in EDU_KEYWORDS):
        return "student_message"
    if any(keyword in blob for keyword in REVIEW_KEYWORDS):
        return "product_review"
    return "formal_public_text"


def split_sentences(text: str) -> list[str]:
    text = re.sub(r"\[[^\]]+\]", "", text)
    text = normalize_whitespace(text)
    if not text:
        return []
    parts = re.split(r"(?<=[.!?…])\s+", text)
    return [part.strip() for part in parts if part.strip()]


def looks_like_good_sentence(sentence: str) -> bool:
    if len(sentence) < 40 or len(sentence) > 240:
        return False
    if sentence.lower().startswith(("kategori:", "şablon:", "dosya:", "başlık:")):
        return False
    if len(sentence.split()) < 5:
        return False
    if not re.search(r"[A-Za-zÇĞİÖŞÜçğıöşü]", sentence):
        return False
    return True


def fetch_random_titles(site: SourceSite, batch_size: int, pause_seconds: float) -> list[str]:
    payload = {
        "action": "query",
        "list": "random",
        "rnnamespace": 0,
        "rnlimit": batch_size,
        "format": "json",
    }
    response = http_get_json(site.api_url, payload, pause_seconds)
    random_items = response.get("query", {}).get("random", [])
    return [item["title"] for item in random_items if "title" in item]


def fetch_extracts(site: SourceSite, titles: list[str], pause_seconds: float) -> dict[str, str]:
    if not titles:
        return {}
    payload = {
        "action": "query",
        "prop": "extracts",
        "explaintext": 1,
        "exsectionformat": "plain",
        "titles": "|".join(titles),
        "format": "json",
    }
    response = http_get_json(site.api_url, payload, pause_seconds)
    pages = response.get("query", {}).get("pages", {})
    extracts: dict[str, str] = {}
    for page in pages.values():
        title = page.get("title")
        extract = page.get("extract", "")
        if title and extract:
            extracts[title] = extract
    return extracts


def fetch_wikipedia_extract_batch(site: SourceSite, batch_size: int, pause_seconds: float) -> list[dict[str, str]]:
    payload = {
        "action": "query",
        "generator": "random",
        "grnnamespace": 0,
        "grnlimit": batch_size,
        "prop": "extracts",
        "explaintext": 1,
        "exsectionformat": "plain",
        "exintro": 1,
        "format": "json",
    }
    response = http_get_json(site.api_url, payload, pause_seconds)
    pages = response.get("query", {}).get("pages", {})
    batch: list[dict[str, str]] = []
    for page in pages.values():
        title = page.get("title")
        extract = normalize_whitespace(page.get("extract", ""))
        if title and extract:
            batch.append(
                {
                    "site": site.name,
                    "license": site.license,
                    "title": title,
                    "sentence": extract,
                }
            )
    return batch


def collect_source_sentences(target_sentences: int, rng: random.Random, batch_size: int, pause_seconds: float) -> list[dict[str, str]]:
    collected: list[dict[str, str]] = []
    seen: set[tuple[str, str]] = set()
    attempts = 0
    max_attempts = max(target_sentences * 25, 250)

    while len(collected) < target_sentences and attempts < max_attempts:
        attempts += 1
        site = rng.choice(SITE_CONFIGS)
        titles = fetch_random_titles(site, batch_size, pause_seconds)
        extracts = fetch_extracts(site, titles, pause_seconds)

        for title, extract in extracts.items():
            for sentence in split_sentences(extract):
                cleaned = ensure_sentence_end(sentence)
                if not looks_like_good_sentence(cleaned):
                    continue
                key = (site.name, cleaned.lower())
                if key in seen:
                    continue
                seen.add(key)
                collected.append(
                    {
                        "site": site.name,
                        "license": site.license,
                        "title": title,
                        "sentence": cleaned,
                    }
                )
                if len(collected) >= target_sentences:
                    return collected
    if len(collected) < target_sentences:
        raise RuntimeError(
            f"Could only collect {len(collected)} source sentences after {attempts} attempts. "
            "Try lowering the target or running again later."
        )
    return collected


def collect_source_sentences_tatoeba(target_sentences: int) -> list[dict[str, str]]:
    request = Request(
        "https://downloads.tatoeba.org/exports/per_language/tur/tur_sentences.tsv.bz2",
        headers={"User-Agent": USER_AGENT},
    )
    with urlopen(request, timeout=120) as response:
        compressed = response.read()

    text = bz2.decompress(compressed).decode("utf-8", errors="replace")
    collected: list[dict[str, str]] = []
    seen: set[str] = set()

    for line in text.splitlines():
        parts = line.split("\t", 2)
        if len(parts) < 3:
            continue
        sentence = ensure_sentence_end(parts[2])
        if not looks_like_good_sentence(sentence):
            continue
        key = sentence.lower()
        if key in seen:
            continue
        seen.add(key)
        collected.append(
            {
                "site": "tatoeba_tur",
                "license": "CC BY 2.0 FR",
                "title": "tur_sentences.tsv",
                "sentence": sentence,
            }
        )
        if len(collected) >= target_sentences:
            return collected

    raise RuntimeError(f"Could only collect {len(collected)} sentences from Tatoeba.")


def collect_source_sentences_mediawiki(
    site: SourceSite,
    target_sentences: int,
    batch_size: int,
    pause_seconds: float,
) -> list[dict[str, str]]:
    collected: list[dict[str, str]] = []
    seen: set[str] = set()
    attempts = 0
    max_attempts = max(target_sentences * 20, 200)

    while len(collected) < target_sentences and attempts < max_attempts:
        attempts += 1
        batch = fetch_wikipedia_extract_batch(site, batch_size, pause_seconds)
        for item in batch:
            for sentence in split_sentences(item["sentence"]):
                cleaned = ensure_sentence_end(sentence)
                if not looks_like_good_sentence(cleaned):
                    continue
                key = cleaned.lower()
                if key in seen:
                    continue
                seen.add(key)
                collected.append(
                    {
                        "site": site.name,
                        "license": site.license,
                        "title": item["title"],
                        "sentence": cleaned,
                    }
                )
                if len(collected) >= target_sentences:
                    return collected

    if len(collected) < target_sentences:
        raise RuntimeError(
            f"Could only collect {len(collected)} source sentences from {site.name} after {attempts} attempts."
        )
    return collected


def collect_source_sentences_wikimedia(target_sentences: int, batch_size: int, pause_seconds: float) -> list[dict[str, str]]:
    collected: list[dict[str, str]] = []
    per_site_target = math.ceil(target_sentences / len(SITE_CONFIGS))

    for site in SITE_CONFIGS:
        remaining = target_sentences - len(collected)
        if remaining <= 0:
            break
        site_target = min(per_site_target, remaining)
        collected.extend(collect_source_sentences_mediawiki(site, site_target, batch_size, pause_seconds))

    return collected[:target_sentences]


def collect_source_sentences_mixed(
    target_sentences: int,
    rng: random.Random,
    batch_size: int,
    pause_seconds: float,
    wikimedia_share: float,
) -> list[dict[str, str]]:
    wikimedia_share = min(max(wikimedia_share, 0.0), 1.0)
    wikimedia_target = max(len(SITE_CONFIGS) * 100, int(target_sentences * wikimedia_share))
    wikimedia_target = min(wikimedia_target, target_sentences - 100)
    tatoeba_target = target_sentences - wikimedia_target

    tatoeba_sentences = collect_source_sentences_tatoeba(tatoeba_target)
    wikimedia_sentences = collect_source_sentences_wikimedia(wikimedia_target, batch_size, pause_seconds)

    combined = tatoeba_sentences + wikimedia_sentences
    rng.shuffle(combined)
    return combined


def introduce_typo(word: str, rng: random.Random) -> str:
    if len(word) < 4:
        return word
    letters = list(word)
    operation = rng.choice(("swap", "drop", "duplicate"))
    if operation == "swap" and len(letters) > 3:
        index = rng.randint(0, len(letters) - 2)
        letters[index], letters[index + 1] = letters[index + 1], letters[index]
        return "".join(letters)
    if operation == "drop":
        index = rng.randint(0, len(letters) - 1)
        del letters[index]
        return "".join(letters)
    index = rng.randint(0, len(letters) - 1)
    letters.insert(index, letters[index])
    return "".join(letters)


def add_typos(text: str, rng: random.Random) -> str:
    words = text.split()
    if not words:
        return text
    candidates = [index for index, word in enumerate(words) if len(word) >= 4]
    if not candidates:
        return text
    for index in rng.sample(candidates, k=min(2, len(candidates))):
        words[index] = introduce_typo(words[index], rng)
    return normalize_whitespace(" ".join(words))


def apply_abbreviations(text: str) -> str:
    updated = text
    for source, replacement in COMMON_ABBREVIATIONS:
        updated = re.sub(rf"\b{re.escape(source)}\b", replacement, updated, flags=re.IGNORECASE)
    return normalize_whitespace(updated)


def remove_some_connectors(text: str, rng: random.Random) -> str:
    connectors = ("ve", "ama", "fakat", "çünkü", "ancak", "için", "üzere")
    words = text.split()
    filtered: list[str] = []
    for word in words:
        if word.lower().strip(".,!?;") in connectors and rng.random() < 0.4:
            continue
        filtered.append(word)
    return normalize_whitespace(" ".join(filtered))


def make_noisy_input(sentence: str, task: str, rng: random.Random) -> str:
    text = ensure_sentence_end(sentence)
    if task == "diacritics_restoration":
        text = strip_diacritics(text)
        text = text.replace("’", "'")
        return normalize_whitespace(text)
    if task == "typo_correction":
        text = strip_diacritics(text)
        text = text.lower()
        text = add_typos(text, rng)
        text = re.sub(r"[.!?…]$", "", text)
        return normalize_whitespace(text)
    if task == "grammar_fix":
        text = strip_diacritics(text)
        text = remove_some_connectors(text, rng)
        text = re.sub(r"[,:;]+", "", text)
        return normalize_whitespace(text.lower())
    if task == "informal_to_standard":
        text = strip_diacritics(text)
        text = text.lower()
        text = apply_abbreviations(text)
        text = re.sub(r"[,:;]+", "", text)
        return normalize_whitespace(text)
    if task == "informal_to_formal":
        text = strip_diacritics(text)
        text = text.lower()
        text = apply_abbreviations(text)
        text = re.sub(r"[,:;]+", "", text)
        return normalize_whitespace(f"hocam {text}")
    if task == "message_polishing":
        text = strip_diacritics(text)
        text = text.lower()
        text = remove_some_connectors(text, rng)
        text = re.sub(r"[,:;]+", "", text)
        return normalize_whitespace(text)
    if task == "academic_polishing":
        text = strip_diacritics(text)
        text = text.lower()
        text = remove_some_connectors(text, rng)
        text = re.sub(r"[,:;]+", "", text)
        return normalize_whitespace(text)
    return normalize_whitespace(text)


def choose_task_pool(target_rows: int, rng: random.Random) -> list[str]:
    pool_size = target_rows + len(TASKS) * 4
    pool = list(TASKS) * math.ceil(pool_size / len(TASKS))
    rng.shuffle(pool)
    return pool


def build_records(
    source_sentences: list[dict[str, str]],
    target_rows: int,
    rng: random.Random,
    variants_per_sentence: int,
    train_ratio: float,
) -> list[dict[str, str]]:
    task_pool = choose_task_pool(target_rows, rng)
    task_index = 0
    records: list[dict[str, str]] = []
    seen_pairs: set[tuple[str, str, str]] = set()

    for source in source_sentences:
        for _ in range(variants_per_sentence):
            if len(records) >= target_rows:
                return records
            task = task_pool[task_index % len(task_pool)]
            task_index += 1
            normalized = source["sentence"]
            input_text = make_noisy_input(normalized, task, rng)
            if normalize_whitespace(input_text).lower() == normalize_whitespace(normalized).lower():
                input_text = make_noisy_input(normalized, task, rng)
            if normalize_whitespace(input_text).lower() == normalize_whitespace(normalized).lower():
                input_text = normalize_whitespace(f"{input_text} lütfen")
            input_key = normalize_whitespace(input_text).lower()
            output_key = normalize_whitespace(normalized).lower()
            pair_key = (input_key, output_key, task)
            if pair_key in seen_pairs:
                continue
            seen_pairs.add(pair_key)
            bucket = stable_bucket(source["site"], source["title"], normalized) % 100
            split = "train" if bucket < int(train_ratio * 100) else "test"
            records.append(
                {
                    "input_text": normalize_whitespace(input_text),
                    "normalized_text": normalized,
                    "task_type": task,
                    "style": TASK_STYLE[task],
                    "domain": classify_domain(source["title"], normalized),
                    "source": source["site"],
                    "license": source["license"],
                    "split": split,
                }
            )
    return records


def write_split_csv(path: Path, rows: Iterable[dict[str, str]]) -> None:
    fieldnames = ["id", "input_text", "normalized_text", "task_type", "style", "domain", "source", "license", "split"]
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames)
        writer.writeheader()
        for row_id, row in rows:
            writer.writerow({"id": row_id, **row})


def main() -> int:
    args = parse_args()
    rng = random.Random(args.seed)
    wikimedia_share = args.wikimedia_share if args.wikipedia_share is None else args.wikipedia_share

    source_multiplier = max(args.variants_per_sentence, 1)
    sentence_target = max(
        int(math.ceil(args.target_rows / source_multiplier) * 1.3),
        int(math.ceil(args.target_rows / source_multiplier)) + 1000,
    )
    if args.source_mode == "tatoeba":
        source_sentences = collect_source_sentences_tatoeba(sentence_target)
    elif args.source_mode == "wikipedia":
        source_sentences = collect_source_sentences_mediawiki(SITE_CONFIGS[0], sentence_target, args.batch_size, args.pause_seconds)
    elif args.source_mode == "wikimedia":
        source_sentences = collect_source_sentences_wikimedia(sentence_target, args.batch_size, args.pause_seconds)
    elif args.source_mode == "api":
        source_sentences = collect_source_sentences(sentence_target, rng, args.batch_size, args.pause_seconds)
    else:
        source_sentences = collect_source_sentences_mixed(
            sentence_target,
            rng,
            args.batch_size,
            args.pause_seconds,
            wikimedia_share,
        )
    records = build_records(source_sentences, args.target_rows, rng, args.variants_per_sentence, args.train_ratio)
    rng.shuffle(records)
    train_cutoff = int(round(len(records) * args.train_ratio))

    train_rows: list[tuple[int, dict[str, str]]] = []
    test_rows: list[tuple[int, dict[str, str]]] = []

    for index, record in enumerate(records, start=1):
        row = dict(record)
        row["split"] = "train" if index <= train_cutoff else "test"
        if row["split"] == "train":
            train_rows.append((index, row))
        else:
            test_rows.append((index, row))

    args.output_dir.mkdir(parents=True, exist_ok=True)
    write_split_csv(args.output_dir / "train.csv", train_rows)
    write_split_csv(args.output_dir / "test.csv", test_rows)

    print(f"Wrote {len(train_rows)} train rows and {len(test_rows)} test rows to {args.output_dir}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())