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())