scriptconv 0.0.4a3__tar.gz → 0.0.4a5__tar.gz

{scriptconv-0.0.4a3/scriptconv.egg-info → scriptconv-0.0.4a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.4a3
+Version: 0.0.4a5
 Summary: Zero-dependency script & phoneme-notation core — ISO-15924 detection & metadata, IPA↔ARPABET/X-SAMPA/Lexique/Kirshenbaum/Cotovía/RFE, Buckwalter↔Arabic, Hangul→jamo, kana
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/TigreGotico/scriptconv
@@ -105,6 +105,7 @@ Requires-Dist: scriptconv[phonemizers]; extra == "en-phonemizers"
 Requires-Dist: g2p_en; extra == "en-phonemizers"
 Requires-Dist: openphonemizer; extra == "en-phonemizers"
 Requires-Dist: deep-phonemizer; extra == "en-phonemizers"
+Requires-Dist: requests; extra == "en-phonemizers"
 Provides-Extra: ar-phonemizers
 Requires-Dist: scriptconv[phonemizers]; extra == "ar-phonemizers"
 Requires-Dist: arbtok; extra == "ar-phonemizers"
@@ -391,6 +392,17 @@ p = GraphemePhonemizer()
 p.add_diacritics("Tenho muita sede hoje.", "pt")   # 'Tenho muita sêde hoje.' (thirst)
 ```
 
+Diacritization also joins the graph, like phonemization, via
+`scriptconv.diacritics.register` — a `text -> text-diacritized` edge, opt-in,
+with `text -> ipa` routing unchanged:
+
+```python
+from scriptconv import diacritics
+g = DEFAULT_GRAPH.extend(diacritics.register).extend(phonemizers.register)
+g.convert("Tenho muita sede hoje.", "text", "text-diacritized", lang="pt")
+# 'Tenho muita sêde hoje.'
+```
+
 Stress is unwritten or under-marked in all 26 covered languages; East Slavic
 is the clearest case, where unstressed vowels also reduce (e.g. Russian
 о→[ɐ]/[ə]), so a missing mark corrupts more than prosody there. stressonnx is

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/README.md

@@ -265,6 +265,17 @@ p = GraphemePhonemizer()
 p.add_diacritics("Tenho muita sede hoje.", "pt")   # 'Tenho muita sêde hoje.' (thirst)
 ```
 
+Diacritization also joins the graph, like phonemization, via
+`scriptconv.diacritics.register` — a `text -> text-diacritized` edge, opt-in,
+with `text -> ipa` routing unchanged:
+
+```python
+from scriptconv import diacritics
+g = DEFAULT_GRAPH.extend(diacritics.register).extend(phonemizers.register)
+g.convert("Tenho muita sede hoje.", "text", "text-diacritized", lang="pt")
+# 'Tenho muita sêde hoje.'
+```
+
 Stress is unwritten or under-marked in all 26 covered languages; East Slavic
 is the clearest case, where unstressed vowels also reduce (e.g. Russian
 о→[ɐ]/[ə]), so a missing mark corrupts more than prosody there. stressonnx is

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/pyproject.toml

@@ -58,7 +58,7 @@ pt = ["scriptconv[phonemizers]", "bifonia>=0.1.1"]
 ja-phonemizers = ["scriptconv[phonemizers]", "pyopenjtalk", "cutlet", "pykakasi>=2.3,<3"]
 ko = ["scriptconv[phonemizers]", "g2pk", "regex"]
 zh-phonemizers = ["scriptconv[phonemizers]", "jieba", "pypinyin>=0.50,<1", "xpinyin", "g2pM", "pinyin_to_ipa"]
-en-phonemizers = ["scriptconv[phonemizers]", "g2p_en", "openphonemizer", "deep-phonemizer"]
+en-phonemizers = ["scriptconv[phonemizers]", "g2p_en", "openphonemizer", "deep-phonemizer", "requests"]
 ar-phonemizers = ["scriptconv[phonemizers]", "arbtok", "ovos-number-parser"]
 shami = ["scriptconv[phonemizers]", "regex"]
 test = ["pytest", "pytest-timeout", "pykakasi>=2.3,<3", "pypinyin>=0.50,<1", "quebra-frases", "langcodes", "regex", "ovos-number-parser", "bifonia>=0.1.1"]

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/__init__.py

@@ -69,6 +69,7 @@ from scriptconv.notation import (
     ipa_to_cotovia,
     rfe_to_ipa,
     ipa_to_rfe,
+    mantoq_to_ipa,
     looks_like_ipa,
 )
 from scriptconv.translit import (
@@ -140,6 +141,7 @@ __all__ = [
     "ipa_to_cotovia",
     "rfe_to_ipa",
     "ipa_to_rfe",
+    "mantoq_to_ipa",
     "looks_like_ipa",
     # translit
     "decompose_hangul",

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/cangjie.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 
 import gzip
 from importlib.resources import files
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 
 __all__ = ["cangjie_code", "to_cangjie"]
 
@@ -49,15 +49,16 @@ def to_cangjie(text: str, sep: str = " ") -> str:
     """
     table = _table()
     tokens = []
-    last_raw = False
+    raw_run: List[str] = []
     for ch in text:
         code = table.get(ch)
         if code is not None:
+            if raw_run:
+                tokens.append("".join(raw_run))
+                raw_run = []
             tokens.append(code)
-            last_raw = False
-        elif last_raw:
-            tokens[-1] += ch
         else:
-            tokens.append(ch)
-            last_raw = True
+            raw_run.append(ch)
+    if raw_run:
+        tokens.append("".join(raw_run))
     return sep.join(tokens)

scriptconv-0.0.4a5/scriptconv/diacritics.py

@@ -0,0 +1,162 @@
+"""Diacritization as a graph extension — parallel to :mod:`scriptconv.phonemizers`.
+
+Diacritization (Arabic tashkeel, Hebrew niqqud, East-Slavic/Turkic/Caucasian
+word stress, European-Portuguese homograph sense marks) is, architecturally,
+just another transform between text representations: it maps the ``"text"``
+node to a lang-contextual ``"text-diacritized"`` node.  Like
+:func:`scriptconv.phonemizers.register` it is opt-in — ``DEFAULT_GRAPH`` stays
+free of it until a caller extends a graph::
+
+    from scriptconv.graph import DEFAULT_GRAPH
+    from scriptconv import diacritics, phonemizers
+    g = DEFAULT_GRAPH.extend(diacritics.register).extend(phonemizers.register)
+
+    g.convert("замок стоит на горе", "text", "text-diacritized", lang="ru")
+    # 'за́мок сто́ит на горе́'    — just the diacritized text
+
+    g.convert("Tenho muita sede hoje.", "text", "text-diacritized", lang="pt")
+    # 'Tenho muita sêde hoje.'
+
+Routing ``"text" -> "ipa"`` still takes the direct phonemization edge by
+default: the diacritization edge is model-based (``lossless=False``), so it
+never out-prices a direct phonemization, and enabling this extension does not
+silently change phonemization output.  The diacritized route is taken only
+when a caller asks for ``"text-diacritized"`` explicitly.
+
+A future per-engine *stance* would push this further into topology rather than
+a flag: an engine that *requires* vocalized input would carry only a
+``"text-diacritized" -> "ipa"`` edge (forcing the detour), one that *forbids*
+diacritics would carry only ``"text" -> "ipa"`` (making the detour
+unroutable), and a tolerant engine (e.g. arbtok, which self-vocalizes) carries
+both.  The strip direction (``"text-diacritized" -> "text"``) is registered too, but
+gated to languages whose marks are removable *overlay* diacritics —
+Arabic/Hebrew vocalization and East-Slavic/Turkic/Caucasian stress. Strip
+removes only the specific overlay codepoints each backend adds (combining
+acute/grave for stress, tashkeel for Arabic, niqqud for Hebrew) — never a
+blanket combining-mark filter — so precomposed native letters survive
+(Cyrillic й/ё, Latvian macrons, Azerbaijani ç/ö, Arabic hamza carriers أ إ آ ؤ
+ئ). The gate uses exact primary-subtag matching, so Aragonese (``arg``),
+Herero (``her``), Mapudungun (``arn``) etc. are never misread as Arabic/Hebrew.
+Languages whose diacritics are native orthography (European Portuguese, via
+bifonia) refuse the strip with :class:`ValueError` instead of silently
+corrupting the spelling (``café`` must never become ``cafe``). This split
+tracks which backend/model produced the marks: overlay backends (phonikud,
+tashkeel, stressonnx) are strippable; spelling-integral backends (bifonia) are
+not.
+"""
+from scriptconv.graph import Edge
+from scriptconv.phonemizers.base import _diacritizer_family
+
+#: The lang-contextual node produced by diacritization.  Like ``"text"`` it is
+#: meaningful only with ``lang=`` context and exists only in opted-in graphs.
+DIACRITIZED = "text-diacritized"
+
+_DEFAULT_PHONEMIZER = None
+
+
+def _get_phonemizer(phonikud_model=None):
+    # any concrete BasePhonemizer subclass works here — it's just a vessel
+    # for add_diacritics(); GraphemePhonemizer is picked for having no extra
+    # runtime dependencies of its own
+    global _DEFAULT_PHONEMIZER
+    if phonikud_model:
+        from scriptconv.phonemizers.base import GraphemePhonemizer
+        return GraphemePhonemizer(phonikud_model=phonikud_model)
+    if _DEFAULT_PHONEMIZER is None:
+        from scriptconv.phonemizers.base import GraphemePhonemizer
+        _DEFAULT_PHONEMIZER = GraphemePhonemizer()
+    return _DEFAULT_PHONEMIZER
+
+
+def diacritize(text: str, lang: str = "und", model=None, **context) -> str:
+    """Add pronunciation-disambiguating diacritics to *text* for *lang*.
+
+    Thin wrapper over :meth:`BasePhonemizer.add_diacritics` — the single
+    dispatch (he→phonikud, ar→tashkeel, ru/uk/be/…→stressonnx, pt→bifonia).
+    Reuses a cached default phonemizer so repeated calls don't reload models; a
+    per-call Hebrew ``phonikud_model`` path (via context) builds a fresh one.
+    """
+    return _get_phonemizer(context.get("phonikud_model")).add_diacritics(text, lang, model)
+
+
+# Combining marks each diacritization backend overlays onto the bare text.
+# Strip removes ONLY these codepoints — never a blanket combining-mark filter,
+# which (via NFD) would decompose and destroy precomposed native letters:
+# Cyrillic й/ё, Latvian ī, Azerbaijani ç/ö, and Arabic hamza carriers أ إ آ ؤ ئ.
+_STRESS_MARKS = frozenset({0x0300, 0x0301})            # combining grave / acute
+# U+0300 is included defensively alongside the U+0301 that stressonnx
+# actually emits, in case any backend/locale marks secondary stress with a
+# grave instead of an acute; harmless to strip since native precomposed
+# letters (e.g. Cyrillic й/ё) are unaffected either way.
+_ARABIC_MARKS = frozenset(range(0x064B, 0x0660)) | frozenset({0x0670})  # tashkeel + dagger alef
+_HEBREW_MARKS = (frozenset(range(0x05B0, 0x05BE))
+                 | frozenset({0x05BF, 0x05C1, 0x05C2, 0x05C4, 0x05C5, 0x05C7}))  # niqqud
+
+
+def _overlay_marks(lang: str) -> "frozenset | None":
+    """The overlay codepoints for *lang*'s diacritization backend, or None.
+
+    Resolves the backend family through :func:`_diacritizer_family` (the shared
+    lang→backend routing), so this can never disagree with
+    :meth:`BasePhonemizer.add_diacritics` about which language a backend owns.
+    Only *overlay* families are strippable: ``"pt"`` (bifonia sense marks are
+    native orthography) and ``None`` both return None.
+    """
+    family = _diacritizer_family(lang)
+    if family == "stress":
+        return _STRESS_MARKS
+    if family == "ar":
+        return _ARABIC_MARKS
+    if family == "he":
+        return _HEBREW_MARKS
+    return None
+
+
+def _supports_strip(lang: str) -> bool:
+    """True for languages whose diacritics are removable overlays (stress marks,
+    Arabic tashkeel, Hebrew niqqud) rather than native orthography."""
+    return _overlay_marks(lang) is not None
+
+
+def strip_diacritics(text: str, lang: str = "und", **_) -> str:
+    """Remove the overlay diacritics *lang*'s backend adds, recovering the bare
+    text WITHOUT touching native letters.
+
+    Removes only the specific overlay codepoints (combining acute/grave for
+    stress, tashkeel for Arabic, niqqud for Hebrew) — precomposed native
+    letters (Cyrillic й/ё, Latvian ī, Azerbaijani ç, Arabic hamza carriers) are
+    left intact. Raises :class:`ValueError` for languages whose diacritics are
+    part of the native orthography (e.g. European Portuguese), where any removal
+    would corrupt the spelling.
+    """
+    marks = _overlay_marks(lang)
+    if marks is None:
+        raise ValueError(
+            f"cannot strip diacritics for lang={lang!r}: its diacritics are "
+            "part of the native orthography, so removal would corrupt the "
+            "spelling. strip is defined only for overlay diacritics "
+            "(Arabic/Hebrew vocalization, East-Slavic/Turkic stress).")
+    return "".join(c for c in text if ord(c) not in marks)
+
+
+def register(graph) -> None:
+    """Opt-in graph integration: add the diacritize/strip edge pair.
+
+    ``text -> text-diacritized`` is model-based (``lossless=False``), so a
+    direct ``text -> ipa`` phonemization always out-prices the detour —
+    enabling this extension is safe and non-invasive.  Pair with
+    :func:`scriptconv.phonemizers.register` to make
+    ``"text-diacritized" -> "ipa"`` reachable.
+
+    ``text-diacritized -> text`` (:func:`strip_diacritics`) is lossless and
+    cheap, but gated: it raises for languages whose diacritics are native
+    orthography rather than removable overlays.
+    """
+    graph.register(
+        Edge("text", DIACRITIZED,
+             lambda text, lang="und", model=None, **c: diacritize(text, lang, model, **c),
+             lossless=False))
+    graph.register(
+        Edge(DIACRITIZED, "text",
+             lambda text, lang="und", **_: strip_diacritics(text, lang),
+             lossless=True))

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/graph.py

@@ -38,6 +38,11 @@ from typing import Callable, Dict, List, Optional, Tuple
 __all__ = ["Representation", "Edge", "ConversionGraph", "DEFAULT_GRAPH",
            "REPRESENTATIONS"]
 
+# Chosen so a single lossy hop never wins over a lossless path unless the
+# lossless alternative is at least this many hops longer. A 10-hop lossless
+# chain (cost 10, unit edges) ties a 1-hop lossy edge (cost 10) exactly, and
+# heapq's stable tie-break then decides — a non-issue in practice since real
+# scriptconv graphs are shallow (a handful of hops at most).
 _LOSSY_COST = 10.0
 
 
@@ -56,7 +61,10 @@ class Edge:
     """One registered transform between two representations.
 
     ``fn`` is called as ``fn(text, **context)``; context keys (``lang``,
-    engine-specific options…) pass through the router opaquely.  ``requires``
+    engine-specific options…) pass through the router opaquely.  Every
+    registered ``fn`` MUST accept ``**kwargs`` for this reason — a callable
+    that only takes ``text`` raises :class:`TypeError` the moment routing
+    passes through any context. ``requires``
     names an optional extra the transform needs — metadata only; the
     transform itself raises :class:`ImportError` with an install hint.
     ``cost`` defaults from ``lossless`` so routing prefers lossless paths.

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/notation.py

@@ -41,6 +41,7 @@ __all__ = [
     "ipa_to_cotovia",
     "rfe_to_ipa",
     "ipa_to_rfe",
+    "mantoq_to_ipa",
     "looks_like_ipa",
 ]
 
@@ -1053,7 +1054,7 @@ def _tokenize_mantoq(text: str) -> list[str]:
     return tokens
 
 
-def mantoq_to_ipa(mantoq, errors: str = "pass") -> str:
+def mantoq_to_ipa(mantoq: str | list[str], errors: str = "pass") -> str:
     """Convert a Mantoq phoneme string to IPA.
 
     ``_dbl_`` lengthens/geminates the preceding symbol (``ː``), ``_+_``
@@ -1235,15 +1236,19 @@ def can_convert(src: str | Notation, dst: str | Notation) -> bool:
     src = Notation(src)
     dst = Notation(dst)
     if src == dst:
-        # historical contract: identity is not a "conversion"
+        # historical contract: identity is not a "conversion" here, unlike
+        # graph.ConversionGraph.can_convert (which deliberately returns True
+        # for identity — an empty route is a valid, zero-cost conversion there)
         return False
     from scriptconv.graph import DEFAULT_GRAPH
-    if not DEFAULT_GRAPH.can_convert(src.value, dst.value):
+    try:
+        route = DEFAULT_GRAPH.route(src.value, dst.value)
+    except ValueError:
         return False
     # only notation-to-notation reachability counts here; guard against paths
     # that would leave the notation node set (none exist today, cheap to keep)
     return all(e.src in _NOTATION_VALUES and e.dst in _NOTATION_VALUES
-               for e in DEFAULT_GRAPH.route(src.value, dst.value))
+               for e in route)
 
 
 # ---------------------------------------------------------------------------

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/phonemizers/_thirdparty/hangul2ipa.py

@@ -2,9 +2,10 @@
 import csv
 import math
 import os.path
+import threading
 from base64 import b64decode
 from pathlib import Path
-from typing import Union, List, Dict
+from typing import Union, List, Dict, Optional
 
 import regex as re
 
@@ -311,21 +312,46 @@ OBSTRUENTS = ()
 SONORANTS = ()
 
 
+_initialized_tables_dir: Optional[Path] = None
+# guards the one-time table population below. The rule functions read the
+# module globals (CT_*, CONSONANTS, VOWELS, ...) without locking, which is safe
+# only because those globals are written exactly once and never mutated
+# afterwards; this lock serialises concurrent first-time initialisation so no
+# thread can observe a half-populated set of tables.
+_init_lock = threading.Lock()
+
+
 def initialize_conversion_tables(tables_dir: Path):
-    global CT_double_codas, CT_neutral, CT_tensification, CT_assimilation, CT_aspiration, CT_convention
-    CT_double_codas = ConversionTable('double_coda', tables_dir)
-    CT_neutral = ConversionTable('neutralization', tables_dir)
-    CT_tensification = ConversionTable('tensification', tables_dir)
-    CT_assimilation = ConversionTable('assimilation', tables_dir)
-    CT_aspiration = ConversionTable('aspiration', tables_dir)
-    CT_convention = ConversionTable('ipa', tables_dir)
-
-    global CONSONANTS, VOWELS, OBSTRUENTS, SONORANTS
-    CONSONANTS = tuple(
-        list(CT_convention.C)[:-2])  # from the C column of the IPA table, remove special characters # and $
-    VOWELS = tuple(list(CT_convention.V))  # from the V column of the IPA table
-    OBSTRUENTS = tuple(set(CONSONANTS) - set(C_SONORANTS))
-    SONORANTS = VOWELS + C_SONORANTS
+    global _initialized_tables_dir
+    # the CSV tables never change at runtime, so once a given tables_dir has
+    # been parsed there is no need to re-read and re-parse it on every call.
+    # Fast path is lock-free: _initialized_tables_dir is published (assigned)
+    # last, after every table global is fully populated, so any thread that
+    # sees it set also sees the complete tables.
+    if _initialized_tables_dir == tables_dir:
+        return
+    with _init_lock:
+        # re-check under the lock: another thread may have initialised while we
+        # waited (double-checked locking)
+        if _initialized_tables_dir == tables_dir:
+            return
+        global CT_double_codas, CT_neutral, CT_tensification, CT_assimilation, CT_aspiration, CT_convention
+        CT_double_codas = ConversionTable('double_coda', tables_dir)
+        CT_neutral = ConversionTable('neutralization', tables_dir)
+        CT_tensification = ConversionTable('tensification', tables_dir)
+        CT_assimilation = ConversionTable('assimilation', tables_dir)
+        CT_aspiration = ConversionTable('aspiration', tables_dir)
+        CT_convention = ConversionTable('ipa', tables_dir)
+
+        global CONSONANTS, VOWELS, OBSTRUENTS, SONORANTS
+        CONSONANTS = tuple(
+            list(CT_convention.C)[:-2])  # from the C column of the IPA table, remove special characters # and $
+        VOWELS = tuple(list(CT_convention.V))  # from the V column of the IPA table
+        OBSTRUENTS = tuple(set(CONSONANTS) - set(C_SONORANTS))
+        SONORANTS = VOWELS + C_SONORANTS
+
+        # published last: any thread seeing this set also sees all tables above
+        _initialized_tables_dir = tables_dir
 
 
 def get_substring_ind(string: str, pattern: str) -> List[int]:

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/phonemizers/_vendored/kog2p/__init__.py

@@ -33,6 +33,7 @@ import re
 import math
 import sys
 import optparse
+from functools import lru_cache
 
 # Option
 # Import-time CLI parsing removed for library use (the upstream script
@@ -366,10 +367,19 @@ kog2p_to_hangul = {
 }
 
 
+@lru_cache(maxsize=None)
+def _cachedReadRules(pver, rule_book):
+    # rulebook.txt never changes at runtime, so parse it once per path
+    # instead of re-opening and re-parsing it on every runKoG2P call
+    rule_in, rule_out = readRules(pver, rule_book)
+    return tuple(rule_in), tuple(rule_out)
+
+
 def runKoG2P(graph, rulebook=None):
     if not rulebook:
         rulebook = f"{os.path.dirname(__file__)}/rulebook.txt"
-    [rule_in, rule_out] = readRules(ver_info[0], rulebook)
+    rule_in, rule_out = _cachedReadRules(ver_info[0], rulebook)
+    rule_in, rule_out = list(rule_in), list(rule_out)
     words = graph.split()
     phonemized = []
     for w in words:

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/phonemizers/base.py

@@ -74,6 +74,30 @@ def _is_european_portuguese(lang: str) -> bool:
     return norm == "pt" or norm == "pt-pt"
 
 
+def _diacritizer_family(lang: str) -> Optional[str]:
+    """Which diacritization backend family handles *lang*, or ``None``.
+
+    Single source of truth for lang→backend routing: both the forward
+    dispatch (:meth:`BasePhonemizer.add_diacritics`) and the strip direction
+    (:func:`scriptconv.diacritics._overlay_marks`) resolve through this, so the
+    two can never disagree about which language uses which backend. Returns one
+    of ``"he"`` (niqqud), ``"ar"`` (tashkeel), ``"stress"`` (stressonnx), ``"pt"``
+    (bifonia sense diacritics), or ``None``. Uses exact primary-subtag matching
+    (never ``startswith``), so Aragonese (``arg``), Herero (``her``) and
+    Mapudungun (``arn``) are never misread as Arabic/Hebrew.
+    """
+    p = _primary_subtag(lang)
+    if p == "he":
+        return "he"
+    if p == "ar":
+        return "ar"
+    if p in STRESS_LANGS:
+        return "stress"
+    if _is_european_portuguese(lang):
+        return "pt"
+    return None
+
+
 class BasePhonemizer(metaclass=abc.ABCMeta):
     def __init__(self, alphabet: Alphabet = Alphabet.UNICODE,
                  diacritizer_model: str = "rawi-ensemble",
@@ -199,13 +223,14 @@ class BasePhonemizer(metaclass=abc.ABCMeta):
         ``ImportError`` naming its extra when the optional dependency is
         missing — scriptconv never installs anything on the caller's behalf.
         """
-        if lang.startswith("he"):
+        family = _diacritizer_family(lang)
+        if family == "he":
             return self.phonikud.add_diacritics(text)
-        elif lang.startswith("ar"):
+        if family == "ar":
             return self.tashkeel(model).diacritize(text)
-        elif _primary_subtag(lang) in STRESS_LANGS:
+        if family == "stress":
             return self._stress(text, lang, model)
-        elif _is_european_portuguese(lang):
+        if family == "pt":
             return self._sense_diacritics_pt(text)
         return text
 

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/phonemizers/en.py

@@ -1,7 +1,3 @@
-import os
-
-import requests
-
 from scriptconv.notation import _ARPA_TO_IPA as arpa_to_ipa_lookup
 from scriptconv.phonemizers.base import BasePhonemizer
 from scriptconv.phonemizers.enums import Alphabet
@@ -18,6 +14,8 @@ class DeepPhonemizer(BasePhonemizer):
     }
 
     def __init__(self, model="latin_ipa_forward.pt"):
+        import os
+
         import dp
         from dp.phonemizer import Phonemizer
         import torch
@@ -38,6 +36,7 @@ class DeepPhonemizer(BasePhonemizer):
                 os.makedirs(cache_dir, exist_ok=True)
                 model_path = os.path.join(cache_dir, model)
                 if not os.path.isfile(model_path):
+                    import requests
                     print(f"Downloading {model} from {url}...")
                     with requests.get(url, stream=True) as r:
                         r.raise_for_status()

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/phonemizers/fa.py

@@ -5,7 +5,14 @@ from scriptconv.phonemizers.enums import Alphabet
 class PersianPhonemizer(BasePhonemizer):
     """https://github.com/de-mh/persian_phonemizer"""
     def __init__(self, alphabet=Alphabet.IPA):
-        from persian_phonemizer import Phonemizer
+        try:
+            from persian_phonemizer import Phonemizer
+        except ImportError as e:
+            raise ImportError(
+                "persian_phonemizer is required for the Persian phonemizer. "
+                "Install it with 'pip install persian_phonemizer' "
+                "(or 'pip install scriptconv[fa]')."
+            ) from e
         assert alphabet in [Alphabet.ERAAB, Alphabet.IPA]
         output_format = "IPA" if alphabet == Alphabet.IPA else 'eraab'
         self.g2p = Phonemizer(output_format)

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/phonemizers/gl.py

@@ -10,7 +10,8 @@ class CotoviaPhonemizer(BasePhonemizer):
     G2P engine that has verified parity with the original C binary.
 
     Output alphabets:
-    - ``Alphabet.COTOVIA`` — raw Cotovia phoneme notation (e.g. ``"Este e uN ..."``)
+    - ``Alphabet.COTOVIA`` (default) — raw Cotovia phoneme notation (e.g.
+      ``"Este e uN ..."``), the binary-parity-tested native phoneset
     - ``Alphabet.IPA`` — IPA string produced by pycotovia's ``cotovia_to_ipa``
 
     Voices trained on Cotovia-alphabet output continue to receive the same
@@ -21,11 +22,12 @@ class CotoviaPhonemizer(BasePhonemizer):
     lazily so that ``import scriptconv.phonemizers`` works without it installed.
     """
 
-    def __init__(self, alphabet: Alphabet = Alphabet.IPA,
+    def __init__(self, alphabet: Alphabet = Alphabet.COTOVIA,
                  model: Optional[str] = None):
         """
         Args:
-            alphabet (Alphabet): ``COTOVIA`` (raw notation) or ``IPA``.
+            alphabet (Alphabet): ``COTOVIA`` (raw notation, the default) or
+                ``IPA``.
             model (Optional[str]): phonemizer variant, from the voice's
                 ``phonemizer_model``.  ``"stress"`` emits the cotovia notation
                 with the stressed vowel marked by a trailing ``^`` (e.g.

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/phonemizers/he.py

@@ -5,7 +5,14 @@ from scriptconv.phonemizers.base import BasePhonemizer
 class PhonikudPhonemizer(BasePhonemizer):
 
     def __init__(self):
-        from phonikud import phonemize
+        try:
+            from phonikud import phonemize
+        except ImportError as e:
+            raise ImportError(
+                "phonikud is required for the Hebrew phonemizer. "
+                "Install it with 'pip install phonikud-onnx' "
+                "(or 'pip install scriptconv[he]')."
+            ) from e
         self.g2p = phonemize
         super().__init__(Alphabet.IPA)
 

{scriptconv-0.0.4a3 → scriptconv-0.0.4a5}/scriptconv/phonemizers/registry.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import importlib
 from typing import Dict, Optional, Tuple
 
+from scriptconv.phonemizers.base import _primary_subtag
 from scriptconv.phonemizers.enums import Alphabet, Phonemizer
 
 __all__ = ["PHONEMIZER_REGISTRY", "LANG_DEFAULTS", "get_phonemizer",
@@ -184,7 +185,7 @@ def phonemizer_for_lang(lang: str, alphabet: Alphabet = Alphabet.IPA,
     """
     if override is not None:
         return get_phonemizer(override, alphabet, model, **kwargs)
-    key = lang.replace("_", "-").split("-")[0].lower()
+    key = _primary_subtag(lang)
     explicit = LANG_DEFAULTS.get(key, ())
     for candidate in explicit:
         if alphabet in _EMITS.get(candidate, (Alphabet.IPA,)):
@@ -219,7 +220,9 @@ def register(graph) -> None:
     routing context, and present only in graphs that opted in (the
     :data:`scriptconv.graph.DEFAULT_GRAPH` stays orthography-only by
     design) — and one dispatching ``text -> ipa`` edge that resolves the
-    per-language default (honouring an ``override=`` context key).
+    per-language default (honouring an ``override=`` context key). It also
+    accepts already-diacritized input via a ``"text-diacritized" -> "ipa"``
+    edge (the same phonemization; pair with :func:`scriptconv.diacritics.register`).
 
     Usage::
 
@@ -236,3 +239,4 @@ def register(graph) -> None:
                                    override).phonemize_string(text, lang)
 
     graph.register(Edge("text", "ipa", _text_to_ipa, lossless=False))
+    graph.register(Edge("text-diacritized", "ipa", _text_to_ipa, lossless=False))