scriptconv-copyleft 0.1.0a1__py3-none-any.whl

scriptconv_copyleft/phonemizers/eu.py

@@ -0,0 +1,112 @@
+from typing import Optional
+
+from scriptconv.phonemizers.base import BasePhonemizer
+from scriptconv.phonemizers.enums import Alphabet
+
+
+# AhoTTS engine variant, selected per-voice via ``phonemizer_model`` in the
+# voice config.  Each maps to an ``ahotts_g2p.phonemize`` call.
+ENGINES = {
+    "classic": {"version": "classic"},    # original AhoTTS engine (HiTZ VITS voices)
+    "modern": {"version": "modern"},      # StyleTTS-era build (HiTZ/StyleTTS2-eu)
+    "northern": {"dialect": "northern"},  # Northern (Iparralde / Iparrahotsa) dialect
+}
+DEFAULT_ENGINE = "modern"
+
+
+class AhoTTSPhonemizer(BasePhonemizer):
+    """
+    AhoTTS phonemizer backed by ``ahotts-g2p``, a pure-Python port of the
+    AhoTTS engine (no C build, no runtime dependencies).
+
+    Covers the two AhoTTS-frontend languages: Basque (``eu``) and Spanish
+    (``es``).  The target language is taken from the per-call ``lang`` argument
+    (so the same phonemizer instance serves both); ``ahotts_g2p.phonemize``
+    dispatches on it.
+
+    The engine variant is chosen per-voice with ``phonemizer_model`` in the
+    voice config (passed to the constructor as ``engine``):
+
+      * ``classic``  -- the original AhoTTS engine; the HiTZ VITS voices (eu+es).
+      * ``modern``   -- the StyleTTS-era build; HiTZ/StyleTTS2-eu.  The default.
+      * ``northern`` -- the Northern (Iparralde / Iparrahotsa) Basque dialect:
+        pronounced /h/, French vowels (ü -> /y/), uvular /ʁ/, a remapped
+        sibilant system.  Basque only.
+
+    ``ahotts_g2p.phonemize`` already returns the collapsed single-char training
+    string, so no further token folding is needed.  It is imported lazily so
+    importing ``scriptconv`` does not hard-require it.
+    """
+
+    engine_distribution = "ahotts_g2p"
+
+    SUPPORTED_LANGS = ["eu-ES", "es-ES"]
+
+    def __init__(self, engine: Optional[str] = None,
+                 alphabet: Alphabet = Alphabet.IPA):
+        """
+        Args:
+            engine (Optional[str]): AhoTTS variant -- ``"classic"``, ``"modern"``
+                or ``"northern"`` (from the voice's ``phonemizer_model``).
+                Defaults to ``"modern"``.
+            alphabet (Alphabet): Accepted for signature parity; AhoTTS always
+                produces IPA-derived single-char tokens.
+        """
+        engine = (engine or DEFAULT_ENGINE).lower()
+        if engine not in ENGINES:
+            raise ValueError(
+                f"unknown AhoTTS engine {engine!r} "
+                f"(supported: {', '.join(ENGINES)})"
+            )
+        self.engine = engine
+        self._phonemize = None
+        super().__init__(alphabet)
+
+    @property
+    def phonemize_fn(self):
+        """Lazily import and cache ``ahotts_g2p.phonemize``."""
+        if self._phonemize is None:
+            try:
+                from ahotts_g2p import phonemize
+            except ImportError as e:
+                raise ImportError(
+                    "ahotts-g2p is required for the AhoTTS Basque phonemizer. "
+                    "Install it with 'pip install ahotts-g2p' "
+                    "(or 'pip install scriptconv[eu]')."
+                ) from e
+            self._phonemize = phonemize
+        return self._phonemize
+
+    @classmethod
+    def get_lang(cls, target_lang: str) -> str:
+        """
+        Validate and return the closest supported language code (eu or es).
+
+        Raises:
+            ValueError: If the language code is unsupported.
+        """
+        return cls.match_lang(target_lang, cls.SUPPORTED_LANGS)
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        """
+        Convert Basque or Spanish text into the AhoTTS single-char IPA training
+        string.
+
+        Args:
+            text (str): The input text to phonemize.
+            lang (str): The language code (``eu`` or ``es``).  The ``northern``
+                dialect engine is Basque-only; combining it with ``es`` raises.
+
+        Returns:
+            str: Space-separated single-char phoneme tokens.
+        """
+        g2p_lang = self.get_lang(lang).split("-")[0]
+        kwargs = dict(ENGINES[self.engine])
+        if g2p_lang != "eu" and "dialect" in kwargs:
+            raise ValueError(
+                f"the {self.engine!r} AhoTTS engine (dialect) is Basque-only; "
+                f"it cannot phonemize lang={lang!r}"
+            )
+        return self.phonemize_fn(text, lang=g2p_lang, **kwargs)
+
+

scriptconv_copyleft/phonemizers/fa.py

@@ -0,0 +1,44 @@
+from scriptconv.phonemizers.base import BasePhonemizer
+from scriptconv.phonemizers.enums import Alphabet
+
+
+class PersianPhonemizer(BasePhonemizer):
+    """https://github.com/de-mh/persian_phonemizer"""
+
+    engine_distribution = "persian_phonemizer"
+    def __init__(self, alphabet=Alphabet.IPA):
+        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)
+        super().__init__(alphabet)
+
+    @classmethod
+    def get_lang(cls, target_lang: str) -> str:
+        """
+        Validates and returns the closest supported language code.
+
+        Args:
+            target_lang (str): The language code to validate.
+
+        Returns:
+            str: The validated language code.
+
+        Raises:
+            ValueError: If the language code is unsupported.
+        """
+        # this check is here only to throw an exception if invalid language is provided
+        return cls.match_lang(target_lang, ["fa"])
+
+    def phonemize_string(self, text: str, lang: str = "fa") -> str:
+        """
+        """
+        lang = self.get_lang(lang)
+        return self.g2p.phonemize(text)

scriptconv_copyleft/phonemizers/gl.py

@@ -0,0 +1,81 @@
+from typing import Any, Optional
+
+from scriptconv.phonemizers.base import BasePhonemizer
+from scriptconv.phonemizers.enums import Alphabet
+
+
+class CotoviaPhonemizer(BasePhonemizer):
+    """
+    Galician phonemizer backed by pycotovia — a pure-Python port of the Cotovia
+    G2P engine that has verified parity with the original C binary.
+
+    Output alphabets:
+    - ``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
+    notation strings as before because pycotovia is binary-parity-tested
+    (see pycotovia/docs/parity.md).
+
+    ``pycotovia`` is an optional dependency (the ``gl`` extra); it is imported
+    lazily so that ``import scriptconv.phonemizers`` works without it installed.
+    """
+
+    engine_distribution = "pycotovia"
+
+    def __init__(self, alphabet: Alphabet = Alphabet.COTOVIA,
+                 model: Optional[str] = None):
+        """
+        Args:
+            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.
+                ``"o^la"``) and multi-char phonemes preserved -- matching the
+                AhoTTS Cotovia front-end the HiTZ gl VITS voices were trained on,
+                whose tokenizer gives stressed vowels their own ids.  The default
+                (``None``) is the original stressless transcription used by the
+                proxectonos gl voices.
+        """
+        self._engine: Optional[Any] = None
+        self.model = (model or "").lower() or None
+        super().__init__(alphabet)
+
+    @property
+    def engine(self) -> Any:
+        if self._engine is None:
+            try:
+                from pycotovia import Phonemizer as _PycotoviaPhonemizer
+            except ImportError as e:
+                raise ImportError(
+                    "pycotovia is required for the Galician (Cotovia) phonemizer. "
+                    "Install it with 'pip install pycotovia' or 'pip install scriptconv[gl]'."
+                ) from e
+            self._engine = _PycotoviaPhonemizer()
+        return self._engine
+
+    @classmethod
+    def get_lang(cls, target_lang: str) -> str:
+        return cls.match_lang(target_lang, ["gl-ES"])
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        self.get_lang(lang)
+        if self.model == "stress":
+            # tra=2 -> stressed vowel followed by '^'.  The trailing space the
+            # engine appends per word is kept (word separator); the tokenizer
+            # folds 'V^' and multi-char phonemes (tS, rr, ...) back into single
+            # tokens via the voice's phoneme_id_map compound keys.
+            return self.engine.phonemize(text, tra=2)
+        cotovia_output = self.engine.phonemize(text)
+        if self.alphabet == Alphabet.IPA:
+            try:
+                from pycotovia import cotovia_to_ipa as _cotovia_to_ipa
+            except ImportError as e:
+                raise ImportError(
+                    "pycotovia is required for the Galician (Cotovia) phonemizer. "
+                    "Install it with 'pip install pycotovia' or 'pip install scriptconv[gl]'."
+                ) from e
+            return _cotovia_to_ipa(cotovia_output)
+        return cotovia_output

scriptconv_copyleft/phonemizers/ja.py

@@ -0,0 +1,47 @@
+from scriptconv.phonemizers.base import BasePhonemizer, _check_alphabet
+from scriptconv.phonemizers.enums import Alphabet
+
+
+class PyKakasiPhonemizer(BasePhonemizer):
+    engine_distribution = "pykakasi"
+
+    def __init__(self, alphabet=Alphabet.HEPBURN):
+        _check_alphabet(self, alphabet,
+                        [Alphabet.HEPBURN, Alphabet.KANA, Alphabet.HIRA])
+        # kana, hira, hepburn
+        try:
+            import pykakasi
+        except ImportError as e:
+            raise ImportError(
+                "pykakasi is required for the PyKakasi phonemizer. "
+                "Install it with 'pip install pykakasi' "
+                "(or 'pip install scriptconv[ja-phonemizers]')."
+            ) from e
+        self.g2p = pykakasi.kakasi()
+        super().__init__(alphabet)
+
+    @classmethod
+    def get_lang(cls, target_lang: str) -> str:
+        """
+        Validates and returns the closest supported language code.
+
+        Args:
+            target_lang (str): The language code to validate.
+
+        Returns:
+            str: The validated language code.
+
+        Raises:
+            ValueError: If the language code is unsupported.
+        """
+        # this check is here only to throw an exception if invalid language is provided
+        return cls.match_lang(target_lang, ["ja"])
+
+    def phonemize_string(self, text: str, lang: str = "ja") -> str:
+        """
+        """
+        lang = self.get_lang(lang)
+        return " ".join([
+            a[self.alphabet] for a in
+            self.g2p.convert(text)
+        ])

scriptconv_copyleft/phonemizers/ko.py

@@ -0,0 +1,102 @@
+
+
+import sys
+from importlib import metadata
+from typing import Tuple
+
+from scriptconv.phonemizers.base import BasePhonemizer, _check_alphabet
+from scriptconv.phonemizers._thirdparty.hangul2ipa import hangul2ipa
+from scriptconv.phonemizers.enums import Alphabet
+
+
+class G2PKPhonemizer(BasePhonemizer):
+    engine_distribution = "g2pk"
+
+    def __init__(self, descriptive=True, group_vowels=True, to_syl=True,
+                 alphabet=Alphabet.IPA):
+        _check_alphabet(self, alphabet, [Alphabet.IPA, Alphabet.HANGUL])
+        try:
+            from g2pk import G2p
+        except ImportError as e:
+            if sys.version_info >= (3, 13):
+                raise ImportError(
+                    "g2pk is required for the G2PK phonemizer. Its dependency "
+                    "python-mecab-ko has wheels up to CPython 3.12 only, so on "
+                    "Python 3.13 and later pip builds it from source. Install "
+                    "MeCab-ko first, so that mecab-config is on PATH, then run "
+                    "'pip install g2pk'."
+                ) from e
+            raise ImportError(
+                "g2pk is required for the G2PK phonemizer. "
+                "Install it with 'pip install g2pk' "
+                "(or 'pip install scriptconv[ko]')."
+            ) from e
+        self.g2p = G2p()
+        self.descriptive = descriptive
+        self.group_vowels = group_vowels
+        self.to_syl = to_syl
+        super().__init__(alphabet)
+
+    @classmethod
+    def get_lang(cls, target_lang: str) -> str:
+        """
+        Validates and returns the closest supported language code.
+
+        Args:
+            target_lang (str): The language code to validate.
+
+        Returns:
+            str: The validated language code.
+
+        Raises:
+            ValueError: If the language code is unsupported.
+        """
+        # this check is here only to throw an exception if invalid language is provided
+        return cls.match_lang(target_lang, ["ko"])
+
+    def phonemize_string(self, text: str, lang: str = "ko") -> str:
+        """
+        """
+        lang = self.get_lang(lang)
+        p = self.g2p(text, descriptive=self.descriptive,
+                     group_vowels=self.group_vowels,
+                     to_syl=self.to_syl)
+        if self.alphabet == Alphabet.IPA:
+            return hangul2ipa(p)
+        return p
+
+
+class KoG2PPhonemizer(BasePhonemizer):
+    """Korean phonemizer wrapping an external ``kog2p`` distribution.
+
+    Uses an externally-installed ``kog2p`` when present, otherwise the
+    quarantined vendored copy under ``_vendored/kog2p`` — GPL-3.0 under its
+    own license, NOT this library's Apache-2.0.  Never selected
+    automatically; :class:`G2PKPhonemizer` is the unencumbered default.
+    """
+
+    def __init__(self, alphabet: Alphabet = Alphabet.IPA):
+        super().__init__(alphabet)
+        try:
+            # an externally-installed kog2p distribution wins
+            from kog2p import runKoG2P
+        except ImportError:
+            # quarantined vendored copy, GPL-3.0 under its own license
+            # (see _vendored/kog2p/LICENSE.md); explicit opt-in by
+            # requesting this phonemizer
+            from scriptconv_copyleft.phonemizers._vendored.kog2p import runKoG2P
+        self.g2p = runKoG2P
+
+    def _engine_release(self) -> Tuple[str, str]:
+        """An installed ``kog2p`` runs in place of the vendored copy."""
+        if self.g2p.__module__.startswith("scriptconv_copyleft."):
+            return super()._engine_release()
+        return "kog2p", metadata.version("kog2p")
+
+    @classmethod
+    def get_lang(cls, target_lang: str) -> str:
+        return cls.match_lang(target_lang, ["ko"])
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        # contract: the installed module's runKoG2P(text) -> phoneme string
+        return self.g2p(text)