phoonnx 0.0.0__py3-none-any.whl

phoonnx/phonemizers/base.py

@@ -0,0 +1,216 @@
+import abc
+import re
+import string
+import unicodedata
+from typing import List, Tuple, Optional, Literal
+
+from langcodes import tag_distance
+from quebra_frases import sentence_tokenize
+from phoonnx.config import Alphabet
+from phoonnx.util import normalize
+
+# list of (substring, terminator, end_of_sentence) tuples.
+TextChunks = List[Tuple[str, str, bool]]
+# list of (phonemes, terminator, end_of_sentence) tuples.
+RawPhonemizedChunks = List[Tuple[str, str, bool]]
+
+PhonemizedChunks = list[list[str]]
+
+
+class BasePhonemizer(metaclass=abc.ABCMeta):
+    def __init__(self, alphabet: Alphabet = Alphabet.UNICODE):
+        super().__init__()
+        self.alphabet = alphabet
+
+    @abc.abstractmethod
+    def phonemize_string(self, text: str, lang: str) -> str:
+        raise NotImplementedError
+
+    def phonemize_to_list(self, text: str, lang: str) -> List[str]:
+        return list(self.phonemize_string(text, lang))
+
+    def phonemize(self, text: str, lang: str) -> PhonemizedChunks:
+        if not text:
+            return [('', '', True)]
+        results: RawPhonemizedChunks = []
+        text = normalize(text, lang)
+        for chunk, punct, eos in self.chunk_text(text):
+            phoneme_str = self.phonemize_string(self.remove_punctuation(chunk), lang)
+            results += [(phoneme_str, punct, True)]
+        return self._process_phones(results)
+
+    @staticmethod
+    def _process_phones(raw_phones: RawPhonemizedChunks) -> PhonemizedChunks:
+        """Text to phonemes grouped by sentence."""
+        all_phonemes: list[list[str]] = []
+        sentence_phonemes: list[str] = []
+        for phonemes_str, terminator_str, end_of_sentence in raw_phones:
+            # Filter out (lang) switch (flags).
+            # These surround words from languages other than the current voice.
+            phonemes_str = re.sub(r"\([^)]+\)", "", phonemes_str)
+            sentence_phonemes.extend(list(phonemes_str))
+            if end_of_sentence:
+                all_phonemes.append(sentence_phonemes)
+                sentence_phonemes = []
+        if sentence_phonemes:
+            all_phonemes.append(sentence_phonemes)
+        return all_phonemes
+
+    @staticmethod
+    def match_lang(target_lang: str, valid_langs: List[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.
+        """
+        if target_lang in valid_langs:
+            return target_lang
+        best_lang = "und"
+        best_distance = 10000000
+        for l in valid_langs:
+            try:
+                distance: int = tag_distance(l, target_lang)
+            except:
+                try:
+                    l = f"{l.split('-')[0]}-{l.split('-')[1]}"
+                    distance: int = tag_distance(l, target_lang)
+                except:
+                    try:
+                        distance: int = tag_distance(l.split('-')[0], target_lang)
+                    except:
+                        continue
+            if distance < best_distance:
+                best_lang, best_distance = l, distance
+
+        # If the score is low (meaning a good match), return the language
+        if best_distance <= 10:
+            return best_lang
+        # Otherwise, raise an error for unsupported language
+        raise ValueError(f"unsupported language code: {target_lang}")
+
+    @staticmethod
+    def remove_punctuation(text):
+        """
+        Removes all punctuation characters from a string.
+        Punctuation characters are defined by string.punctuation.
+        """
+        # Create a regex pattern that matches any character in string.punctuation
+        punctuation_pattern = r"[" + re.escape(string.punctuation) + r"]"
+        return re.sub(punctuation_pattern, '', text).strip()
+
+    @staticmethod
+    def chunk_text(text: str, delimiters: Optional[List[str]] = None) -> TextChunks:
+        if not text:
+            return [('', '', True)]
+
+        results: TextChunks = []
+        delimiters = delimiters or [", ", ":", ";", "...", "|"]
+
+        # Create a regex pattern that matches any of the delimiters
+        delimiter_pattern = re.escape(delimiters[0])
+        for delimiter in delimiters[1:]:
+            delimiter_pattern += f"|{re.escape(delimiter)}"
+
+        for sentence in sentence_tokenize(text):
+            # Default punctuation if no specific punctuation found
+            default_punc = sentence[-1] if sentence and sentence[-1] in string.punctuation else "."
+
+            # Use regex to split the sentence by any of the delimiters
+            parts = re.split(f'({delimiter_pattern})', sentence)
+
+            # Group parts into chunks (text + delimiter)
+            chunks = []
+            for i in range(0, len(parts), 2):
+                # If there's a delimiter after the text, use it
+                delimiter = parts[i + 1] if i + 1 < len(parts) else default_punc
+
+                # Last chunk is marked as complete
+                is_last = (i + 2 >= len(parts))
+
+                chunks.append((parts[i].strip(), delimiter.strip(), is_last))
+
+            results.extend(chunks)
+
+        return results
+
+
+### all the 3 below are essentially the same thing
+# no phonemization really happens
+
+class RawPhonemes(BasePhonemizer):
+    """no phonemization, text is phonemes already"""
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        return text
+
+
+class GraphemePhonemizer(BasePhonemizer):
+    """
+    A phonemizer class that treats input text as graphemes (characters).
+    It performs text normalization and returns the normalized text as a string
+    of characters.
+    """
+    # Regular expression matching whitespace:
+    whitespace_re = re.compile(r"\s+")
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        """
+        Normalizes input text by applying a series of transformations
+        and returns it as a sequence of graphemes.
+
+        Parameters:
+            text (str): Input text to be converted to graphemes.
+            lang (str): The language code (ignored for grapheme phonemization,
+                        but required by BasePhonemizer).
+
+        Returns:
+            str: A normalized string of graphemes.
+        """
+        text = text.lower()
+        text = text.replace(";", ",")
+        text = text.replace("-", " ")
+        text = text.replace(":", ",")
+        text = re.sub(r"[\<\>\(\)\[\]\"]+", "", text)
+        text = re.sub(self.whitespace_re, " ", text).strip()
+        return text
+
+
+class UnicodeCodepointPhonemizer(BasePhonemizer):
+    """Phonemes = codepoints
+    normalization also splits accents and punctuation into it's own codepoints
+    """
+
+    def __init__(self, form: Literal["NFC", "NFD", "NFKC", "NFKD"] = "NFD"):
+        self.form = form
+        super().__init__(Alphabet.UNICODE)
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        # Phonemes = codepoints
+        return unicodedata.normalize(self.form, text)
+
+
+if __name__ == "__main__":
+    raw = RawPhonemes()
+    grap = GraphemePhonemizer()
+    uni = UnicodeCodepointPhonemizer()
+
+    text = "olá, quem são vocês?"
+    lang = "pt"
+    print(raw.phonemize(text, lang))
+    print(grap.phonemize(text, lang))
+    print(uni.phonemize(text, lang))
+
+    print(raw.phonemize_string(text, lang))
+    print(grap.phonemize_string(text, lang))
+    print(uni.phonemize_string(text, lang))
+
+    print(raw.phonemize_to_list(text, lang))
+    print(grap.phonemize_to_list(text, lang))
+    print(uni.phonemize_to_list(text, lang))

phoonnx/phonemizers/en.py

@@ -0,0 +1,250 @@
+import os
+
+import requests
+
+from phoonnx.thirdparty.arpa2ipa import arpa_to_ipa_lookup
+from phoonnx.phonemizers.base import BasePhonemizer
+from phoonnx.config import Alphabet
+
+
+class DeepPhonemizer(BasePhonemizer):
+    """
+    https://github.com/spring-media/DeepPhonemizer
+    """
+    MODELS = {
+        "latin_ipa_forward.pt": "https://public-asai-dl-models.s3.eu-central-1.amazonaws.com/DeepPhonemizer/latin_ipa_forward.pt",
+        "en_us_cmudict_ipa_forward.pt": "https://public-asai-dl-models.s3.eu-central-1.amazonaws.com/DeepPhonemizer/en_us_cmudict_ipa_forward.pt",
+        "en_us_cmudict_forward.pt": "https://public-asai-dl-models.s3.eu-central-1.amazonaws.com/DeepPhonemizer/en_us_cmudict_forward.pt"
+    }
+
+    def __init__(self, model="latin_ipa_forward.pt"):
+        import dp
+        from dp.phonemizer import Phonemizer
+        import torch
+        # needed for latest torch version
+        torch.serialization.add_safe_globals([dp.preprocessing.text.Preprocessor])
+        torch.serialization.add_safe_globals([dp.preprocessing.text.LanguageTokenizer])
+        torch.serialization.add_safe_globals([dp.preprocessing.text.SequenceTokenizer])
+
+        if "ipa" in model:
+            super().__init__(Alphabet.IPA)
+        else:
+            super().__init__(Alphabet.ARPA)
+
+        if not os.path.isfile(model):
+            if model in self.MODELS:
+                url = self.MODELS[model]
+                cache_dir = os.path.expanduser("~/.local/share/deepphonemizer")
+                os.makedirs(cache_dir, exist_ok=True)
+                model_path = os.path.join(cache_dir, model)
+                if not os.path.isfile(model_path):
+                    print(f"Downloading {model} from {url}...")
+                    with requests.get(url, stream=True) as r:
+                        r.raise_for_status()
+                        with open(model_path, 'wb') as f:
+                            for chunk in r.iter_content(chunk_size=8192):
+                                f.write(chunk)
+                    print(f"Saved model to {model_path}")
+                model = model_path
+            else:
+                raise ValueError("invalid model")
+
+        self.phonemizer = Phonemizer.from_checkpoint(model)
+
+    @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, ['de', 'en_us'])
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        """
+        Normalizes input text by applying a series of transformations
+        and returns it as a sequence of graphemes.
+
+        Parameters:
+            text (str): Input text to be converted to graphemes.
+            lang (str): The language code (ignored for grapheme phonemization,
+                        but required by BasePhonemizer).
+
+        Returns:
+            str: A normalized string of graphemes.
+        """
+        lang = self.get_lang(lang)
+        return self.phonemizer(text, lang)
+
+
+class OpenPhonemizer(BasePhonemizer):
+    """
+    https://github.com/NeuralVox/OpenPhonemizer
+    """
+
+    def __init__(self):
+        from openphonemizer import OpenPhonemizer
+        import torch
+        # needed for latest torch version
+        import dp
+        torch.serialization.add_safe_globals([dp.preprocessing.text.Preprocessor])
+        torch.serialization.add_safe_globals([dp.preprocessing.text.LanguageTokenizer])
+        torch.serialization.add_safe_globals([dp.preprocessing.text.SequenceTokenizer])
+
+        self.phonemizer = OpenPhonemizer()
+        super().__init__(Alphabet.IPA)
+
+    @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, ["en"])
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        """
+        Normalizes input text by applying a series of transformations
+        and returns it as a sequence of graphemes.
+
+        Parameters:
+            text (str): Input text to be converted to graphemes.
+            lang (str): The language code (ignored for grapheme phonemization,
+                        but required by BasePhonemizer).
+
+        Returns:
+            str: A normalized string of graphemes.
+        """
+        lang = self.get_lang(lang)
+        return self.phonemizer(text)
+
+
+class G2PEnPhonemizer(BasePhonemizer):
+    """
+    https://github.com/Kyubyong/g2p
+    """
+
+    def __init__(self, alphabet=Alphabet.IPA):
+        assert alphabet in [Alphabet.IPA, Alphabet.ARPA]
+        import nltk
+        nltk.download('averaged_perceptron_tagger_eng')
+        nltk.download('cmudict')
+        from g2p_en import G2p
+        self.g2p = G2p()
+        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, ["en"])
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        """
+        Normalizes input text by applying a series of transformations
+        and returns it as a sequence of graphemes.
+
+        Parameters:
+            text (str): Input text to be converted to graphemes.
+            lang (str): The language code (ignored for grapheme phonemization,
+                        but required by BasePhonemizer).
+
+        Returns:
+            str: A normalized string of graphemes.
+        """
+        lang = self.get_lang(lang)
+        # NOTE: this model returns ARPA not IPA, may need to map phonemes
+        if self.alphabet == Alphabet.ARPA:
+            return self.g2p(text)
+        return "".join([arpa_to_ipa_lookup.get(pho, pho) for pho in self.g2p(text)])
+
+
+
+if __name__ == "__main__":
+    # for comparison
+    from phoonnx.phonemizers.mul import (ByT5Phonemizer, EspeakPhonemizer, GruutPhonemizer,
+                                         EpitranPhonemizer, CharsiuPhonemizer)
+    byt5 = ByT5Phonemizer()
+    espeak = EspeakPhonemizer()
+    gruut = GruutPhonemizer()
+    epitr = EpitranPhonemizer()
+    charsiu = CharsiuPhonemizer()
+    openphon = OpenPhonemizer()
+    g2pen = G2PEnPhonemizer()
+    dp = DeepPhonemizer()
+
+    lang = "en-gb"
+
+    print("\n--- Getting phonemes for 'Hello, world. How are you?' ---")
+    text1 = "Hello, world. How are you?"
+    phonemes1 = espeak.phonemize(text1, lang)
+    phonemes1b = gruut.phonemize(text1, lang)
+    phonemes1c = byt5.phonemize(text1, lang)
+    phonemes1d = epitr.phonemize(text1, lang)
+    phonemes1e = charsiu.phonemize(text1, lang)
+    phonemes1f = openphon.phonemize(text1, lang)
+    phonemes1g = g2pen.phonemize(text1, lang)
+    phonemes1h = dp.phonemize(text1, lang)
+    print(f" Espeak         Phonemes: {phonemes1}")
+    print(f" Gruut          Phonemes: {phonemes1b}")
+    print(f" byt5           Phonemes: {phonemes1c}")
+    print(f" Epitran        Phonemes: {phonemes1d}")
+    print(f" Charsiu        Phonemes: {phonemes1e}")
+    print(f" OpenPhonemizer Phonemes: {phonemes1f}")
+    print(f" DeepPhonemizer Phonemes: {phonemes1h}")
+    print(f" G2P_en         Phonemes: {phonemes1g}")
+
+    print("\n--- Getting phonemes for 'This is a test: a quick one; and done!' ---")
+    text2 = "This is a test: a quick one; and done!"
+    phonemes2 = espeak.phonemize(text2, lang)
+    phonemes2b = gruut.phonemize(text2, lang)
+    phonemes2c = byt5.phonemize(text2, lang)
+    phonemes2d = epitr.phonemize(text2, lang)
+    phonemes2e = charsiu.phonemize(text2, lang)
+    print(f"  Espeak Phonemes: {phonemes2}")
+    print(f"  Gruut Phonemes: {phonemes2b}")
+    print(f"   byt5  Phonemes: {phonemes2c}")
+    print(f" Epitran Phonemes: {phonemes2d}")
+    print(f" Charsiu Phonemes: {phonemes2e}")
+
+    print("\n--- Getting phonemes for 'Just a phrase without punctuation' ---")
+    text3 = "Just a phrase without punctuation"
+    phonemes3 = espeak.phonemize(text3, lang)
+    phonemes3b = gruut.phonemize(text3, lang)
+    phonemes3c = byt5.phonemize(text3, lang)
+    phonemes3d = epitr.phonemize(text3, lang)
+    phonemes3e = charsiu.phonemize(text3, lang)
+    print(f"  Espeak Phonemes: {phonemes3}")
+    print(f"  Gruut Phonemes: {phonemes3b}")
+    print(f"   byt5  Phonemes: {phonemes3c}")
+    print(f" Epitran Phonemes: {phonemes3d}")
+    print(f" Charsiu Phonemes: {phonemes3e}")
+

phoonnx/phonemizers/fa.py

@@ -0,0 +1,46 @@
+from phoonnx.phonemizers.base import BasePhonemizer
+from phoonnx.config import Alphabet
+
+
+class PersianPhonemizer(BasePhonemizer):
+    """https://github.com/de-mh/persian_phonemizer"""
+    def __init__(self, alphabet=Alphabet.IPA):
+        from persian_phonemizer import Phonemizer
+        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)
+
+
+if __name__ == "__main__":
+    text = "دوچرخه جدید علی گم شد."
+
+    pho = PersianPhonemizer()
+    lang = "fa"
+
+    print(f"\n--- Getting phonemes for '{text}' ---")
+    phonemes_cotovia = pho.phonemize(text, lang)
+    print(f"  Phonemes: {phonemes_cotovia}")

phoonnx/phonemizers/gl.py

@@ -0,0 +1,142 @@
+import os
+import platform
+import re
+import subprocess
+from typing import Optional
+
+from phoonnx.phonemizers.base import BasePhonemizer
+from phoonnx.config import Alphabet
+
+class CotoviaError(Exception):
+    """Custom exception for cotovia related errors."""
+    pass
+
+
+class CotoviaPhonemizer(BasePhonemizer):
+    """
+    A phonemizer class that uses the Cotovia TTS binary to convert text into phonemes.
+    It processes the input sentence through a command-line phonemization tool, applying multiple
+    regular expression transformations to clean and normalize the phonetic representation.
+    """
+
+    def __init__(self, cotovia_bin_path: Optional[str] = None):
+        """
+        Initializes the CotoviaPhonemizer.
+
+        Args:
+            cotovia_bin_path (str, optional): Path to the Cotovia TTS binary.
+                                              If None, it will try to find it in common locations.
+        """
+        self.cotovia_bin = cotovia_bin_path or self.find_cotovia()
+        if not os.path.exists(self.cotovia_bin):
+            raise FileNotFoundError(f"Cotovia binary not found at {self.cotovia_bin}. "
+                                    "Please ensure it's installed or provide the correct path.")
+        super().__init__(Alphabet.COTOVIA)
+
+    @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, ["gl-ES"])
+
+    @staticmethod
+    def find_cotovia() -> str:
+        """
+        Attempts to find the cotovia binary in common locations.
+        """
+        path = subprocess.run(["which", "cotovia"], capture_output=True, text=True).stdout.strip()
+        if path and os.path.isfile(path):
+            return path
+
+        # Fallback to bundled binaries
+        local_path = f"{os.path.dirname(os.path.dirname(__file__))}/thirdparty/cotovia/cotovia_{platform.machine()}"
+        if os.path.isfile(local_path):
+            return local_path
+
+        # Last resort common system path
+        if os.path.isfile("/usr/bin/cotovia"):
+            return "/usr/bin/cotovia"
+
+        return "cotovia"  # Return "cotovia" to let subprocess raise FileNotFoundError if not found in PATH
+
+    def phonemize_string(self, text: str, lang: str) -> str:
+        """
+        Converts a given sentence into phonemes using the Cotovia TTS binary.
+
+        Processes the input sentence through a command-line phonemization tool, applying multiple regular expression transformations to clean and normalize the phonetic representation.
+
+        Parameters:
+            text (str): The input text to be phonemized
+            lang (str): The language code (ignored by Cotovia, but required by BasePhonemizer)
+
+        Returns:
+            str: A cleaned and normalized phonetic representation of the input sentence
+
+        Notes:
+            - Uses subprocess to execute the Cotovia TTS binary
+            - Applies multiple regex substitutions to improve punctuation and spacing
+            - Converts text from ISO-8859-1 to UTF-8 encoding
+        """
+        lang = self.get_lang(lang)
+        cmd = f'echo "{text}" | {self.cotovia_bin} -t -n -S | iconv -f iso88591 -t utf8'
+        str_ext = subprocess.check_output(cmd, shell=True).decode("utf-8")
+
+        ## fix punctuation in cotovia output - from official inference script
+
+        # substitute ' ·\n' by ...
+        str_ext = re.sub(r" ·", r"...", str_ext)
+
+        # remove spaces before , . ! ? ; : ) ] of the extended string
+        str_ext = re.sub(r"\s+([.,!?;:)\]])", r"\1", str_ext)
+
+        # remove spaces after ( [ ¡ ¿ of the extended string
+        str_ext = re.sub(r"([\(\[¡¿])\s+", r"\1", str_ext)
+
+        # remove unwanted spaces between quotations marks
+        str_ext = re.sub(r'"\s*([^"]*?)\s*"', r'"\1"', str_ext)
+
+        # substitute '- text -' to '-text-'
+        str_ext = re.sub(r"-\s*([^-]*?)\s*-", r"-\1-", str_ext)
+
+        # remove initial question marks
+        str_ext = re.sub(r"[¿¡]", r"", str_ext)
+
+        # eliminate extra spaces
+        str_ext = re.sub(r"\s+", r" ", str_ext)
+
+        str_ext = re.sub(r"(\d+)\s*-\s*(\d+)", r"\1 \2", str_ext)
+
+        ### - , ' and () by commas
+        # substitute '- text -' to ', text,'
+        str_ext = re.sub(r"(\w+)\s+-([^-]*?)-\s+([^-]*?)", r"\1, \\2, ", str_ext)
+
+        # substitute ' - ' by ', '
+        str_ext = re.sub(r"(\w+[!\?]?)\s+-\s*", r"\1, ", str_ext)
+
+        # substitute ' ( text )' to ', text,'
+        str_ext = re.sub(r"(\w+)\s*\(\s*([^\(\)]*?)\s*\)", r"\1, \\2,", str_ext)
+
+        return str_ext
+
+
+
+if __name__ == "__main__":
+
+    cotovia = CotoviaPhonemizer()
+
+    lang = "gl"
+    text_gl = "Este é un sistema de conversión de texto a voz en lingua galega baseado en redes neuronais artificiais. Ten en conta que as funcionalidades incluídas nesta páxina ofrécense unicamente con fins de demostración. Se tes algún comentario, suxestión ou detectas algún problema durante a demostración, ponte en contacto connosco."
+    print(f"\n--- Getting phonemes for '{text_gl}' (Cotovia) ---")
+    phonemes_cotovia = cotovia.phonemize(text_gl, lang)
+    print(f"  Cotovia Phonemes: {phonemes_cotovia}")