turkce-normalize 0.1.0__py3-none-any.whl

turkce_normalize/__init__.py

@@ -0,0 +1,48 @@
+"""
+turkce-normalize — TTS için Türkçe metin normalizasyonu.
+
+Sayıları, tarihleri, saatleri, para tutarlarını, kısaltmaları, Roma
+rakamlarını, kesirleri, e-posta ve web adreslerini Türkçe okunuşlarına
+çevirir. Bağımlılığı yoktur.
+
+    >>> from turkce_normalize import normalize
+    >>> normalize("Toplantı 14:30'da, %18 KDV dahil 1.250,50 ₺.")
+    'Toplantı on dört otuzda, yüzde on sekiz katma değer vergisi dahil bin iki yüz elli lira elli kuruş.'
+"""
+from .cografi import cografi_uygula
+from .cumle import CumleAyirici, cumle_akisi, cumle_akisi_async, cumleleri_ayir
+from .isaretler import (
+    EN_UZUN_DURAKLAMA, VARSAYILAN_DURAKLAMA, Parca,
+    isaret_var, isaretleri_ayir, isaretleri_temizle,
+)
+from .normalize import (
+    BILINEN_KELIMELER, BIRIMLER, KELIME_GIBI_OKUNANLAR, KISALTMALAR, ROMA_KARA_LISTE,
+    araliklari_oku, eposta_ve_adres_oku, kesirleri_oku, kisaltmalari_oku,
+    normalize, roma_coz, simgeleri_oku,
+)
+from .sayilar import (
+    HARF_OKUNUSU, bulunma_eki, harf_oku, ondalik_oku, rakamlari_tek_tek,
+    sayi_oku, sayiyi_coz, sira_oku, turkce_buyuk, turkce_kucuk,
+)
+from .telaffuz import CBS_TERIMLERI, VARSAYILAN_SOZLUK, sozluk_birlestir, telaffuz_uygula
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "normalize",
+    # sayılar
+    "sayi_oku", "sira_oku", "ondalik_oku", "rakamlari_tek_tek", "sayiyi_coz",
+    "bulunma_eki", "harf_oku", "turkce_buyuk", "turkce_kucuk", "HARF_OKUNUSU",
+    # alt adımlar
+    "cografi_uygula", "telaffuz_uygula", "eposta_ve_adres_oku", "simgeleri_oku",
+    "kesirleri_oku", "araliklari_oku", "kisaltmalari_oku", "roma_coz",
+    # sözlükler
+    "KISALTMALAR", "BIRIMLER", "KELIME_GIBI_OKUNANLAR", "BILINEN_KELIMELER",
+    "ROMA_KARA_LISTE", "CBS_TERIMLERI", "VARSAYILAN_SOZLUK", "sozluk_birlestir",
+    # cümle ayırıcı
+    "CumleAyirici", "cumleleri_ayir", "cumle_akisi", "cumle_akisi_async",
+    # işaretler
+    "Parca", "isaretleri_ayir", "isaret_var", "isaretleri_temizle",
+    "VARSAYILAN_DURAKLAMA", "EN_UZUN_DURAKLAMA",
+    "__version__",
+]

turkce_normalize/__main__.py

@@ -0,0 +1,45 @@
+"""
+Komut satırı: ``python -m turkce_normalize "metin"``
+
+Metin verilmezse standart girdiden satır satır okur::
+
+    echo "Toplantı 14:30'da." | python -m turkce_normalize
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from . import __version__, normalize
+
+
+def main(argv=None) -> int:
+    ayristirici = argparse.ArgumentParser(
+        prog="python -m turkce_normalize",
+        description="Türkçe metni TTS için okunur hale getirir.",
+    )
+    ayristirici.add_argument("metin", nargs="*", help="normalize edilecek metin (yoksa stdin)")
+    ayristirici.add_argument("--cografi-kapali", action="store_true",
+                             help="koordinat, ölçek, pafta kurallarını uygulama")
+    ayristirici.add_argument("--version", action="version", version=__version__)
+    secenek = ayristirici.parse_args(argv)
+
+    # Windows konsolunda Türkçe karakterler bozulmasın
+    for akis in (sys.stdout, sys.stdin):
+        if hasattr(akis, "reconfigure"):
+            try:
+                akis.reconfigure(encoding="utf-8")
+            except (OSError, ValueError):
+                pass
+
+    cografi = not secenek.cografi_kapali
+    if secenek.metin:
+        print(normalize(" ".join(secenek.metin), cografi=cografi))
+    else:
+        for satir in sys.stdin:
+            print(normalize(satir, cografi=cografi))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

turkce_normalize/cografi.py

@@ -0,0 +1,153 @@
+"""
+Coğrafi ve kadastral gösterimlerin okunuşu.
+
+Genel amaçlı TTS servisleri bu gösterimleri bilmez: koordinatı ondalık sayı
+sanır, ölçeği bölme işlemi sanır, pafta kodunu hecelemeye çalışır. CBS
+uygulamasında bunlar her ekranda geçer.
+
+En kritik olan koordinat çifti. Normalizasyonun ondalık kuralı
+``39.9334, 32.8597`` gösterimini tek bir ondalık sayı sanıp
+"üç yüz doksan dokuz bin üç yüz otuz dört virgül otuz iki" diye okur —
+tamamen yanlış. Bu yüzden coğrafi kurallar sayı kurallarından ÖNCE çalışır.
+
+Koordinat kesirleri rakam rakam okunur: "otuz dokuz virgül dokuz üç üç dört".
+Sayı olarak okumak ("dokuz bin üç yüz otuz dört") hem uzun hem yanıltıcı.
+
+``normalize()`` bu modülü varsayılan olarak kullanır; ``cografi=False`` ile
+kapatılır. Tek başına da çağrılabilir: ``cografi_uygula(metin)``.
+"""
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from .sayilar import bulunma_eki, harf_oku, rakamlari_tek_tek, sayi_oku, sira_oku
+
+#: Yön harfleri — hem Türkçe (K/G/D/B) hem İngilizce (N/S/E/W) gösterim.
+YONLER = {
+    "K": "kuzey", "G": "güney", "D": "doğu", "B": "batı",
+    "N": "kuzey", "S": "güney", "E": "doğu", "W": "batı",
+    "KD": "kuzeydoğu", "KB": "kuzeybatı", "GD": "güneydoğu", "GB": "güneybatı",
+    "NE": "kuzeydoğu", "NW": "kuzeybatı", "SE": "güneydoğu", "SW": "güneybatı",
+}
+
+#: Alan ve uzunluk birimleri.
+#:
+#: Hepsi rakamın ardından gelmek zorunda. "da" (dekar) aynı zamanda Türkçe bir
+#: ektir — "bu da", "orada" — rakam şartı olmadan sözlüğe koymak felaket olur.
+OLCU_BIRIMLERI = {
+    "ha": "hektar",
+    "da": "dekar",
+    "km²": "kilometrekare", "km2": "kilometrekare",
+    "cm²": "santimetrekare", "cm2": "santimetrekare",
+    "mm²": "milimetrekare", "mm2": "milimetrekare",
+    "km³": "kilometreküp", "km3": "kilometreküp",
+}
+
+# Yön harfinin ardından harf gelmemeli: "39°56' Doğu" içindeki "D" yön sanılmasın.
+_YON = r"(?:([KGDBNSEW])(?![^\W\d_]))?"
+
+_DMS = re.compile(
+    r"(\d{1,3})\s*°\s*(\d{1,2})\s*['′]\s*(?:(\d{1,2}(?:[.,]\d+)?)\s*[\"″]\s*)?" + _YON
+)
+_ONDALIK_DERECE = re.compile(r"(\d{1,3})[.,](\d+)\s*°\s*" + _YON)
+_KOORDINAT_CIFTI = re.compile(r"(?<![\w.-])(-?\d{1,3})\.(\d{4,})\s*,\s*(-?\d{1,3})\.(\d{4,})\b", re.ASCII)
+_OLCEK = re.compile(r"\b1\s*[/:]\s*([\d.]{3,})\b", re.ASCII)
+_PAFTA = re.compile(r"\b([A-ZĞÜŞİÖÇ])(\d{1,2})((?:-[a-d0-9]{1,3})+)\b", re.ASCII)
+_EPSG = re.compile(r"\bEPSG\s*:?\s*(\d{4,6})\b", re.ASCII | re.IGNORECASE)
+_UTM = re.compile(r"\bUTM\s*(\d{1,2})(?:\s*([NS]))?\b", re.ASCII | re.IGNORECASE)
+_OLCU = [
+    (re.compile(r"(?:(?<=\d)|(?<=\d\s))" + re.escape(kisa) + r"(?![^\W_])"), OLCU_BIRIMLERI[kisa])
+    for kisa in sorted(OLCU_BIRIMLERI, key=len, reverse=True)
+]
+
+
+def _kesir_oku(kesir: str) -> str:
+    """Ondalık kısmı rakam rakam okur: "9334" -> "dokuz üç üç dört"."""
+    return rakamlari_tek_tek(kesir)
+
+
+def _yon_oku(harf: Optional[str]) -> str:
+    if not harf:
+        return ""
+    return " " + YONLER.get(harf.upper(), harf)
+
+
+def _dms_oku(e: re.Match) -> str:
+    """Derece-dakika-saniye: 39°56'12"K"""
+    derece, dakika, saniye, yon = e.groups()
+    parcalar = [f"{sayi_oku(derece)} derece", f"{sayi_oku(dakika)} dakika"]
+    if saniye is not None:
+        tam, _, kesir = saniye.replace(",", ".").partition(".")
+        parcalar.append(
+            f"{sayi_oku(tam)} virgül {_kesir_oku(kesir)} saniye" if kesir else f"{sayi_oku(tam)} saniye"
+        )
+    return " ".join(parcalar) + _yon_oku(yon)
+
+
+def _pafta_oku(e: re.Match) -> str:
+    """Pafta kodu — G22-b-14c-2d. Harf harf ve parça parça okunur."""
+    harf, sayi, kuyruk = e.groups()
+    parcalar = [harf_oku(harf), sayi_oku(sayi)]
+    for p in filter(None, kuyruk.split("-")):
+        for oge in re.findall(r"\d+|[a-d]", p):
+            parcalar.append(sayi_oku(oge) if oge.isdigit() else harf_oku(oge))
+    return " ".join(parcalar)
+
+
+def _olcek_oku(e: re.Match) -> str:
+    """Ölçek — 1/25.000 -> "yirmi beş binde bir", 1:1.000.000 -> "bir milyonda bir"."""
+    payda = sayi_oku(e.group(1).replace(".", ""))
+    return f"{payda}{bulunma_eki(payda)} bir"
+
+
+def _utm_oku(e: re.Match) -> str:
+    """UTM dilimi — "UTM 35N" -> "u te me otuz beşinci dilim kuzey".
+
+    Metin zaten "dilim" kelimesiyle devam ediyorsa ("UTM 35 dilimi") tekrar eklenmez.
+    """
+    devami = e.string[e.end():].lstrip()
+    dilim = "" if devami.startswith("dilim") else " dilim"
+    return f"u te me {sira_oku(int(e.group(1)))}{dilim}{_yon_oku(e.group(2))}"
+
+
+def cografi_uygula(metin: str) -> str:
+    """Koordinat, ölçek, pafta, EPSG, UTM ve alan birimlerini okunur hale getirir."""
+    m = metin
+
+    # 1) Derece-dakika-saniye — 39°56'12"K / 39° 56' 12" K
+    m = _DMS.sub(_dms_oku, m)
+
+    # 2) Ondalık derece — 39.9334° K / 39,9334° K
+    m = _ONDALIK_DERECE.sub(
+        lambda e: f"{sayi_oku(e.group(1))} virgül {_kesir_oku(e.group(2))} derece{_yon_oku(e.group(3))}",
+        m,
+    )
+
+    # 3) Derece işaretsiz koordinat çifti — 39.9334, 32.8597
+    #    Dört ve üzeri ondalık basamak koordinat sayılır; para ve ölçüm bu kadar
+    #    hassas yazılmaz. Enlem/boylam sırası CBS'de standarttır, adıyla okunur.
+    m = _KOORDINAT_CIFTI.sub(
+        lambda e: f"enlem {sayi_oku(e.group(1))} virgül {_kesir_oku(e.group(2))}, "
+                  f"boylam {sayi_oku(e.group(3))} virgül {_kesir_oku(e.group(4))}",
+        m,
+    )
+
+    # 4) Ölçek — 1/25.000 ve 1:25000 -> "yirmi beş binde bir"
+    m = _OLCEK.sub(_olcek_oku, m)
+
+    # 5) Pafta kodu — G22-b-14c-2d
+    #    Harf harf ve parça parça okunur; hecelemeye çalışmak anlaşılmaz çıkarır.
+    m = _PAFTA.sub(_pafta_oku, m)
+
+    # 6) EPSG kodu — EPSG:5254. Kod, sayı değil; rakam rakam okunur.
+    m = _EPSG.sub(lambda e: f"e pe es ge {rakamlari_tek_tek(e.group(1))}", m)
+
+    # 7) UTM dilimi — UTM 35N
+    m = _UTM.sub(_utm_oku, m)
+
+    # 8) Alan ve uzunluk birimleri — yalnızca rakamın ardından
+    for desen, okunus in _OLCU:
+        m = desen.sub(okunus, m)
+
+    return m

turkce_normalize/cumle.py

@@ -0,0 +1,110 @@
+"""
+Türkçe cümle ayırıcı — LLM token akışını cümle cümle TTS'e vermek için.
+
+Doğallık hissinin kaynağı bu: cevabın tamamı bitmeden ilk cümle
+seslendirilmeye başlar. Kısaltmalarda ve tarihlerde yanlış bölme yapmaz.
+
+    ayirici = CumleAyirici()
+    for parca in llm_akisi:
+        for cumle in ayirici.push(parca):
+            seslendir(cumle)
+    for cumle in ayirici.flush():
+        seslendir(cumle)
+"""
+from __future__ import annotations
+
+import re
+from typing import AsyncIterable, AsyncIterator, Iterable, Iterator, List
+
+from .sayilar import turkce_kucuk
+
+#: Ardından nokta gelince cümleyi bitirmeyen kısaltmalar (küçük harfle).
+KISALTMALAR = {
+    "dr", "prof", "doç", "av", "sn", "sayın", "no", "tel", "vb", "vs", "vd",
+    "bkz", "örn", "ltd", "şti", "mah", "cad", "sok", "apt", "bl", "kat",
+}
+
+_SONLANDIRICI = re.compile(r"[.!?…]+[\s\"'»)]*")
+_KISALTMA_SONU = re.compile(r"([^\W_]+)\.\s*$")
+_SAYI_SONU = re.compile(r"\d\.\s*$")
+
+_PENCERE = 64
+
+#: Bundan kısa cümleler tek başına gönderilmez, sonrakiyle birleşir ("Evet.").
+MIN_UZUNLUK = 12
+
+
+class CumleAyirici:
+    """Akış halinde cümle üretir.
+
+    LLM'den gelen token'ları ``push()`` ile besle, dönen listedeki cümleleri
+    hemen TTS kuyruğuna at. Akış bitince ``flush()`` çağır.
+    """
+
+    def __init__(self, min_uzunluk: int = MIN_UZUNLUK) -> None:
+        self.min_uzunluk = min_uzunluk
+        self._tampon = ""
+
+    def push(self, parca: str) -> List[str]:
+        self._tampon += parca
+        cikan: List[str] = []
+        ara = 0
+
+        while True:
+            eslesme = _SONLANDIRICI.search(self._tampon, ara)
+            if not eslesme:
+                break
+
+            son = eslesme.end()
+            aday = self._tampon[:son]
+            # Yalnızca adayın sonu incelenir; bütün tamponu her noktada baştan
+            # taramak uzun metinde işi ikinci dereceden yavaşlatır.
+            kuyruk = aday[-_PENCERE:]
+            kisaltma = _KISALTMA_SONU.search(kuyruk)
+            if kisaltma is not None and kisaltma.start() == 0 and aday[-_PENCERE - 1:-_PENCERE].isalnum():
+                kisaltma = None      # pencereye sığmayan uzun kelime, kısaltma olamaz
+
+            bekle = (
+                (kisaltma is not None and turkce_kucuk(kisaltma.group(1)) in KISALTMALAR)  # "Dr. Ayşe"
+                or _SAYI_SONU.search(kuyruk) is not None                                   # "15.03.2026"
+                or len(aday.strip()) < self.min_uzunluk                                    # "Evet."
+            )
+
+            if bekle:
+                ara = son            # bu noktayı atla, bir sonrakine bak
+                continue
+
+            cikan.append(aday.strip())
+            self._tampon = self._tampon[son:]
+            ara = 0
+        return cikan
+
+    def flush(self) -> List[str]:
+        """Akış bittiğinde tamponda kalanı verir."""
+        kalan = self._tampon.strip()
+        self._tampon = ""
+        return [kalan] if kalan else []
+
+
+def cumleleri_ayir(metin: str, min_uzunluk: int = MIN_UZUNLUK) -> List[str]:
+    """Tek parça metni cümlelere böler."""
+    ayirici = CumleAyirici(min_uzunluk)
+    return ayirici.push(metin) + ayirici.flush()
+
+
+def cumle_akisi(akis: Iterable[str], min_uzunluk: int = MIN_UZUNLUK) -> Iterator[str]:
+    """Parça akışını (ör. LLM stream'i) cümle akışına çevirir."""
+    ayirici = CumleAyirici(min_uzunluk)
+    for parca in akis:
+        yield from ayirici.push(parca)
+    yield from ayirici.flush()
+
+
+async def cumle_akisi_async(akis: AsyncIterable[str], min_uzunluk: int = MIN_UZUNLUK) -> AsyncIterator[str]:
+    """``cumle_akisi`` ile aynı, async akışlar için."""
+    ayirici = CumleAyirici(min_uzunluk)
+    async for parca in akis:
+        for cumle in ayirici.push(parca):
+            yield cumle
+    for cumle in ayirici.flush():
+        yield cumle

turkce_normalize/isaretler.py

@@ -0,0 +1,78 @@
+"""
+Satır içi duraklama işaretleri — SSML'in olmadığı yerde en yakın şey.
+
+Birçok açık kaynak TTS modeli SSML desteklemez. Ama metni işaretlerden bölüp
+parçaları ayrı üretir, aralarına sessizlik koyarsan duraklamayı kendin kurarsın::
+
+    Sorgu tamamlandı. [dur:0.8] Toplam üç yüz kırk hektar.
+
+``[dur]`` tek başına varsayılan duraklamadır.
+
+Vurgu için ayrı bir işaret yok ve olmamalı: çoğu modelde vurgu parametresi
+bulunmuyor, uydurulmuş bir işaret sessizce hiçbir şey yapardı.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import List
+
+#: ``[dur]`` işaretinin varsayılan uzunluğu, saniye.
+VARSAYILAN_DURAKLAMA = 0.45
+
+#: İşaretlerin izin verilen üst sınırı — 5 saniyeden uzun sessizlik hata gibi duyulur.
+EN_UZUN_DURAKLAMA = 5.0
+
+# Python'da derlenmiş desenin durumu yoktur (JavaScript'teki ``lastIndex``
+# tuzağı burada yaşanmaz); tek desen güvenle paylaşılır.
+_ISARET = re.compile(r"\[dur(?::\s*(\d+(?:[.,]\d+)?))?\]", re.IGNORECASE)
+
+
+@dataclass
+class Parca:
+    """Seslendirilecek bir parça."""
+
+    #: Seslendirilecek metin.
+    metin: str
+    #: Bu parçadan sonra bırakılacak sessizlik, saniye.
+    duraklama: float
+
+
+def isaretleri_ayir(metin: str) -> List[Parca]:
+    """Metni işaretlerden böler.
+
+    Bilinmeyen bir işaret (``[vurgu]`` gibi) metinde bırakılır — model onu okur
+    ve sen hatayı duyarsın. Sessizce silmek, işaretin çalıştığını sanmana yol açardı.
+    """
+    parcalar: List[Parca] = []
+    son = 0
+
+    for e in _ISARET.finditer(metin):
+        oncesi = metin[son:e.start()].strip()
+        uzunluk = (
+            min(float(e.group(1).replace(",", ".")), EN_UZUN_DURAKLAMA)
+            if e.group(1) else VARSAYILAN_DURAKLAMA
+        )
+
+        if oncesi:
+            parcalar.append(Parca(oncesi, uzunluk))
+        elif parcalar:
+            # Art arda iki işaret: önceki duraklamayı uzat
+            parcalar[-1].duraklama += uzunluk
+        son = e.end()
+
+    kalan = metin[son:].strip()
+    if kalan:
+        parcalar.append(Parca(kalan, 0))
+
+    return parcalar if parcalar else [Parca(metin.strip(), 0)]
+
+
+def isaret_var(metin: str) -> bool:
+    """Metinde işaret var mı — tek üretimle geçilebilecek mi diye bakmak için."""
+    return _ISARET.search(metin) is not None
+
+
+def isaretleri_temizle(metin: str) -> str:
+    """İşaretleri temizler. Altyazı metni için — okuyucu ``[dur:0.8]`` görmemeli."""
+    return re.sub(r"\s{2,}", " ", _ISARET.sub(" ", metin)).strip()