xinference 1.0.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

xinference/thirdparty/melo/text/fr_phonemizer/fr_symbols.json

@@ -0,0 +1,89 @@
+{
+    "symbols": [
+        "_",
+        ",",
+        ".",
+        "!",
+        "?",
+        "-",
+        "~",
+        "\u2026",
+        "N",
+        "Q",
+        "a",
+        "b",
+        "d",
+        "e",
+        "f",
+        "g",
+        "h",
+        "i",
+        "j",
+        "k",
+        "l",
+        "m",
+        "n",
+        "o",
+        "p",
+        "s",
+        "t",
+        "u",
+        "v",
+        "w",
+        "x",
+        "y",
+        "z",
+        "\u0251",
+        "\u00e6",
+        "\u0283",
+        "\u0291",
+        "\u00e7",
+        "\u026f",
+        "\u026a",
+        "\u0254",
+        "\u025b",
+        "\u0279",
+        "\u00f0",
+        "\u0259",
+        "\u026b",
+        "\u0265",
+        "\u0278",
+        "\u028a",
+        "\u027e",
+        "\u0292",
+        "\u03b8",
+        "\u03b2",
+        "\u014b",
+        "\u0266",
+        "\u207c",
+        "\u02b0",
+        "`",
+        "^",
+        "#",
+        "*",
+        "=",
+        "\u02c8",
+        "\u02cc",
+        "\u2192",
+        "\u2193",
+        "\u2191",
+        " ",
+        "\u0263",
+        "\u0261",
+        "r",
+        "\u0272",
+        "\u029d",
+        "\u028e",
+        "\u02d0",
+        
+        "\u0303",
+        "\u0153",
+        "\u00f8",
+        "\u0281",
+        "\u0252",
+        "\u028c",
+        "\u2014",
+        "\u025c",
+        "\u0250"
+    ]
+}

xinference/thirdparty/melo/text/fr_phonemizer/fr_to_ipa.py

@@ -0,0 +1,30 @@
+from .cleaner import french_cleaners
+from .gruut_wrapper import Gruut
+
+
+def remove_consecutive_t(input_str):
+    result = []
+    count = 0
+
+    for char in input_str:
+        if char == 't':
+            count += 1
+        else:
+            if count < 3:  
+                result.extend(['t'] * count)
+            count = 0
+            result.append(char)
+
+    if count < 3:
+        result.extend(['t'] * count)
+
+    return ''.join(result)
+
+def fr2ipa(text):
+    e = Gruut(language="fr-fr", keep_puncs=True, keep_stress=True, use_espeak_phonemes=True)
+    # text = french_cleaners(text)
+    phonemes = e.phonemize(text, separator="")
+    # print(phonemes)
+    phonemes = remove_consecutive_t(phonemes)
+    # print(phonemes)
+    return phonemes

xinference/thirdparty/melo/text/fr_phonemizer/french_abbreviations.py

@@ -0,0 +1,48 @@
+import re
+
+# List of (regular expression, replacement) pairs for abbreviations in french:
+abbreviations_fr = [
+    (re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1])
+    for x in [
+        ("M", "monsieur"),
+        ("Mlle", "mademoiselle"),
+        ("Mlles", "mesdemoiselles"),
+        ("Mme", "Madame"),
+        ("Mmes", "Mesdames"),
+        ("N.B", "nota bene"),
+        ("M", "monsieur"),
+        ("p.c.q", "parce que"),
+        ("Pr", "professeur"),
+        ("qqch", "quelque chose"),
+        ("rdv", "rendez-vous"),
+        ("max", "maximum"),
+        ("min", "minimum"),
+        ("no", "numéro"),
+        ("adr", "adresse"),
+        ("dr", "docteur"),
+        ("st", "saint"),
+        ("co", "companie"),
+        ("jr", "junior"),
+        ("sgt", "sergent"),
+        ("capt", "capitain"),
+        ("col", "colonel"),
+        ("av", "avenue"),
+        ("av. J.-C", "avant Jésus-Christ"),
+        ("apr. J.-C", "après Jésus-Christ"),
+        ("art", "article"),
+        ("boul", "boulevard"),
+        ("c.-à-d", "c’est-à-dire"),
+        ("etc", "et cetera"),
+        ("ex", "exemple"),
+        ("excl", "exclusivement"),
+        ("boul", "boulevard"),
+    ]
+] + [
+    (re.compile("\\b%s" % x[0]), x[1])
+    for x in [
+        ("Mlle", "mademoiselle"),
+        ("Mlles", "mesdemoiselles"),
+        ("Mme", "Madame"),
+        ("Mmes", "Mesdames"),
+    ]
+]

xinference/thirdparty/melo/text/fr_phonemizer/french_symbols.txt

@@ -0,0 +1 @@
+_,.!?-~…NQabdefghijklmnopstuvwxyzɑæʃʑçɯɪɔɛɹðəɫɥɸʊɾʒθβŋɦ⁼ʰ`^#*=ˈˌ→↓↑ ɣɡrɲʝʎː̃œøʁɒʌ—ɜɐ

xinference/thirdparty/melo/text/fr_phonemizer/gruut_wrapper.py

@@ -0,0 +1,258 @@
+import importlib
+from typing import List
+
+import gruut
+from gruut_ipa import IPA # pip install gruut_ipa
+
+from .base import BasePhonemizer
+from .punctuation import Punctuation
+
+# Table for str.translate to fix gruut/TTS phoneme mismatch
+GRUUT_TRANS_TABLE = str.maketrans("g", "ɡ")
+
+
+class Gruut(BasePhonemizer):
+    """Gruut wrapper for G2P
+
+    Args:
+        language (str):
+            Valid language code for the used backend.
+
+        punctuations (str):
+            Characters to be treated as punctuation. Defaults to `Punctuation.default_puncs()`.
+
+        keep_puncs (bool):
+            If true, keep the punctuations after phonemization. Defaults to True.
+
+        use_espeak_phonemes (bool):
+            If true, use espeak lexicons instead of default Gruut lexicons. Defaults to False.
+
+        keep_stress (bool):
+            If true, keep the stress characters after phonemization. Defaults to False.
+
+    Example:
+
+        >>> from TTS.tts.utils.text.phonemizers.gruut_wrapper import Gruut
+        >>> phonemizer = Gruut('en-us')
+        >>> phonemizer.phonemize("Be a voice, not an! echo?", separator="|")
+        'b|i| ə| v|ɔ|ɪ|s, n|ɑ|t| ə|n! ɛ|k|o|ʊ?'
+    """
+
+    def __init__(
+        self,
+        language: str,
+        punctuations=Punctuation.default_puncs(),
+        keep_puncs=True,
+        use_espeak_phonemes=False,
+        keep_stress=False,
+    ):
+        super().__init__(language, punctuations=punctuations, keep_puncs=keep_puncs)
+        self.use_espeak_phonemes = use_espeak_phonemes
+        self.keep_stress = keep_stress
+
+    @staticmethod
+    def name():
+        return "gruut"
+
+    def phonemize_gruut(self, text: str, separator: str = "|", tie=False) -> str:  # pylint: disable=unused-argument
+        """Convert input text to phonemes.
+
+        Gruut phonemizes the given `str` by seperating each phoneme character with `separator`, even for characters
+        that constitude a single sound.
+
+        It doesn't affect 🐸TTS since it individually converts each character to token IDs.
+
+        Examples::
+            "hello how are you today?" -> `h|ɛ|l|o|ʊ| h|a|ʊ| ɑ|ɹ| j|u| t|ə|d|e|ɪ`
+
+        Args:
+            text (str):
+                Text to be converted to phonemes.
+
+            tie (bool, optional) : When True use a '͡' character between
+                consecutive characters of a single phoneme. Else separate phoneme
+                with '_'. This option requires espeak>=1.49. Default to False.
+        """
+        ph_list = []
+        for sentence in gruut.sentences(text, lang=self.language, espeak=self.use_espeak_phonemes):
+            for word in sentence:
+                if word.is_break:
+                    # Use actual character for break phoneme (e.g., comma)
+                    if ph_list:
+                        # Join with previous word
+                        ph_list[-1].append(word.text)
+                    else:
+                        # First word is punctuation
+                        ph_list.append([word.text])
+                elif word.phonemes:
+                    # Add phonemes for word
+                    word_phonemes = []
+
+                    for word_phoneme in word.phonemes:
+                        if not self.keep_stress:
+                            # Remove primary/secondary stress
+                            word_phoneme = IPA.without_stress(word_phoneme)
+
+                        word_phoneme = word_phoneme.translate(GRUUT_TRANS_TABLE)
+
+                        if word_phoneme:
+                            # Flatten phonemes
+                            word_phonemes.extend(word_phoneme)
+
+                    if word_phonemes:
+                        ph_list.append(word_phonemes)
+
+        ph_words = [separator.join(word_phonemes) for word_phonemes in ph_list]
+        ph = f"{separator} ".join(ph_words)
+        return ph
+
+    def _phonemize(self, text, separator):
+        return self.phonemize_gruut(text, separator, tie=False)
+
+    def is_supported_language(self, language):
+        """Returns True if `language` is supported by the backend"""
+        return gruut.is_language_supported(language)
+
+    @staticmethod
+    def supported_languages() -> List:
+        """Get a dictionary of supported languages.
+
+        Returns:
+            List: List of language codes.
+        """
+        return list(gruut.get_supported_languages())
+
+    def version(self):
+        """Get the version of the used backend.
+
+        Returns:
+            str: Version of the used backend.
+        """
+        return gruut.__version__
+
+    @classmethod
+    def is_available(cls):
+        """Return true if ESpeak is available else false"""
+        return importlib.util.find_spec("gruut") is not None
+
+
+if __name__ == "__main__":
+    from cleaner import french_cleaners
+    import json
+
+    e = Gruut(language="fr-fr", keep_puncs=True, keep_stress=True, use_espeak_phonemes=True)
+    symbols = [  # en + sp
+        "_",
+        ",",
+        ".",
+        "!",
+        "?",
+        "-",
+        "~",
+        "\u2026",
+        "N",
+        "Q",
+        "a",
+        "b",
+        "d",
+        "e",
+        "f",
+        "g",
+        "h",
+        "i",
+        "j",
+        "k",
+        "l",
+        "m",
+        "n",
+        "o",
+        "p",
+        "s",
+        "t",
+        "u",
+        "v",
+        "w",
+        "x",
+        "y",
+        "z",
+        "\u0251",
+        "\u00e6",
+        "\u0283",
+        "\u0291",
+        "\u00e7",
+        "\u026f",
+        "\u026a",
+        "\u0254",
+        "\u025b",
+        "\u0279",
+        "\u00f0",
+        "\u0259",
+        "\u026b",
+        "\u0265",
+        "\u0278",
+        "\u028a",
+        "\u027e",
+        "\u0292",
+        "\u03b8",
+        "\u03b2",
+        "\u014b",
+        "\u0266",
+        "\u207c",
+        "\u02b0",
+        "`",
+        "^",
+        "#",
+        "*",
+        "=",
+        "\u02c8",
+        "\u02cc",
+        "\u2192",
+        "\u2193",
+        "\u2191",
+        " ",
+        "ɣ",
+        "ɡ", 
+        "r", 
+        "ɲ", 
+        "ʝ", 
+        "ʎ",
+        "ː"
+    ]
+    with open('/home/xumin/workspace/VITS-Training-Multiling/230715_fr/metadata.txt', 'r') as f:
+        lines = f.readlines()
+    
+
+    used_sym = []
+    not_existed_sym = []
+    phonemes = []
+
+    for line in lines:
+        text = line.split('|')[-1].strip()
+        text = french_cleaners(text)
+        ipa =  e.phonemize(text, separator="")
+        phonemes.append(ipa)
+        for s in ipa:
+            if s not in symbols:
+                if s not in not_existed_sym:
+                    print(f'not_existed char: {s}')
+                    not_existed_sym.append(s)
+            else:
+                if s not in used_sym:
+                    # print(f'used char: {s}')
+                    used_sym.append(s)
+    
+    print(used_sym)
+    print(not_existed_sym)
+
+
+    with open('./text/fr_phonemizer/french_symbols.txt', 'w') as g:
+        g.writelines(symbols + not_existed_sym)
+        
+    with open('./text/fr_phonemizer/example_ipa.txt', 'w') as g:
+        g.writelines(phonemes)
+
+    data = {'symbols': symbols + not_existed_sym}
+
+    with open('./text/fr_phonemizer/fr_symbols.json', 'w') as f:
+        json.dump(data, f, indent=4)
+

xinference/thirdparty/melo/text/fr_phonemizer/punctuation.py

@@ -0,0 +1,172 @@
+import collections
+import re
+from enum import Enum
+
+import six
+
+_DEF_PUNCS = ';:,.!?¡¿—…"«»“”'
+
+_PUNC_IDX = collections.namedtuple("_punc_index", ["punc", "position"])
+
+
+class PuncPosition(Enum):
+    """Enum for the punctuations positions"""
+
+    BEGIN = 0
+    END = 1
+    MIDDLE = 2
+    ALONE = 3
+
+
+class Punctuation:
+    """Handle punctuations in text.
+
+    Just strip punctuations from text or strip and restore them later.
+
+    Args:
+        puncs (str): The punctuations to be processed. Defaults to `_DEF_PUNCS`.
+
+    Example:
+        >>> punc = Punctuation()
+        >>> punc.strip("This is. example !")
+        'This is example'
+
+        >>> text_striped, punc_map = punc.strip_to_restore("This is. example !")
+        >>> ' '.join(text_striped)
+        'This is example'
+
+        >>> text_restored = punc.restore(text_striped, punc_map)
+        >>> text_restored[0]
+        'This is. example !'
+    """
+
+    def __init__(self, puncs: str = _DEF_PUNCS):
+        self.puncs = puncs
+
+    @staticmethod
+    def default_puncs():
+        """Return default set of punctuations."""
+        return _DEF_PUNCS
+
+    @property
+    def puncs(self):
+        return self._puncs
+
+    @puncs.setter
+    def puncs(self, value):
+        if not isinstance(value, six.string_types):
+            raise ValueError("[!] Punctuations must be of type str.")
+        self._puncs = "".join(list(dict.fromkeys(list(value))))  # remove duplicates without changing the oreder
+        self.puncs_regular_exp = re.compile(rf"(\s*[{re.escape(self._puncs)}]+\s*)+")
+
+    def strip(self, text):
+        """Remove all the punctuations by replacing with `space`.
+
+        Args:
+            text (str): The text to be processed.
+
+        Example::
+
+            "This is. example !" -> "This is example "
+        """
+        return re.sub(self.puncs_regular_exp, " ", text).rstrip().lstrip()
+
+    def strip_to_restore(self, text):
+        """Remove punctuations from text to restore them later.
+
+        Args:
+            text (str): The text to be processed.
+
+        Examples ::
+
+            "This is. example !" -> [["This is", "example"], [".", "!"]]
+
+        """
+        text, puncs = self._strip_to_restore(text)
+        return text, puncs
+
+    def _strip_to_restore(self, text):
+        """Auxiliary method for Punctuation.preserve()"""
+        matches = list(re.finditer(self.puncs_regular_exp, text))
+        if not matches:
+            return [text], []
+        # the text is only punctuations
+        if len(matches) == 1 and matches[0].group() == text:
+            return [], [_PUNC_IDX(text, PuncPosition.ALONE)]
+        # build a punctuation map to be used later to restore punctuations
+        puncs = []
+        for match in matches:
+            position = PuncPosition.MIDDLE
+            if match == matches[0] and text.startswith(match.group()):
+                position = PuncPosition.BEGIN
+            elif match == matches[-1] and text.endswith(match.group()):
+                position = PuncPosition.END
+            puncs.append(_PUNC_IDX(match.group(), position))
+        # convert str text to a List[str], each item is separated by a punctuation
+        splitted_text = []
+        for idx, punc in enumerate(puncs):
+            split = text.split(punc.punc)
+            prefix, suffix = split[0], punc.punc.join(split[1:])
+            splitted_text.append(prefix)
+            # if the text does not end with a punctuation, add it to the last item
+            if idx == len(puncs) - 1 and len(suffix) > 0:
+                splitted_text.append(suffix)
+            text = suffix
+        return splitted_text, puncs
+
+    @classmethod
+    def restore(cls, text, puncs):
+        """Restore punctuation in a text.
+
+        Args:
+            text (str): The text to be processed.
+            puncs (List[str]): The list of punctuations map to be used for restoring.
+
+        Examples ::
+
+            ['This is', 'example'], ['.', '!'] -> "This is. example!"
+
+        """
+        return cls._restore(text, puncs, 0)
+
+    @classmethod
+    def _restore(cls, text, puncs, num):  # pylint: disable=too-many-return-statements
+        """Auxiliary method for Punctuation.restore()"""
+        if not puncs:
+            return text
+
+        # nothing have been phonemized, returns the puncs alone
+        if not text:
+            return ["".join(m.punc for m in puncs)]
+
+        current = puncs[0]
+
+        if current.position == PuncPosition.BEGIN:
+            return cls._restore([current.punc + text[0]] + text[1:], puncs[1:], num)
+
+        if current.position == PuncPosition.END:
+            return [text[0] + current.punc] + cls._restore(text[1:], puncs[1:], num + 1)
+
+        if current.position == PuncPosition.ALONE:
+            return [current.mark] + cls._restore(text, puncs[1:], num + 1)
+
+        # POSITION == MIDDLE
+        if len(text) == 1:  # pragma: nocover
+            # a corner case where the final part of an intermediate
+            # mark (I) has not been phonemized
+            return cls._restore([text[0] + current.punc], puncs[1:], num)
+
+        return cls._restore([text[0] + current.punc + text[1]] + text[2:], puncs[1:], num)
+
+
+# if __name__ == "__main__":
+#     punc = Punctuation()
+#     text = "This is. This is, example!"
+
+#     print(punc.strip(text))
+
+#     split_text, puncs = punc.strip_to_restore(text)
+#     print(split_text, " ---- ", puncs)
+
+#     restored_text = punc.restore(split_text, puncs)
+#     print(restored_text)

xinference/thirdparty/melo/text/french.py

@@ -0,0 +1,94 @@
+import pickle
+import os
+import re
+
+from . import symbols
+from .fr_phonemizer import cleaner as fr_cleaner
+from .fr_phonemizer import fr_to_ipa
+from transformers import AutoTokenizer
+
+
+def distribute_phone(n_phone, n_word):
+    phones_per_word = [0] * n_word
+    for task in range(n_phone):
+        min_tasks = min(phones_per_word)
+        min_index = phones_per_word.index(min_tasks)
+        phones_per_word[min_index] += 1
+    return phones_per_word
+
+def text_normalize(text):
+    text = fr_cleaner.french_cleaners(text)
+    return text
+
+model_id = 'dbmdz/bert-base-french-europeana-cased'
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+def g2p(text, pad_start_end=True, tokenized=None):
+    if tokenized is None:
+        tokenized = tokenizer.tokenize(text)
+    # import pdb; pdb.set_trace()
+    phs = []
+    ph_groups = []
+    for t in tokenized:
+        if not t.startswith("#"):
+            ph_groups.append([t])
+        else:
+            ph_groups[-1].append(t.replace("#", ""))
+    
+    phones = []
+    tones = []
+    word2ph = []
+    # print(ph_groups)
+    for group in ph_groups:
+        w = "".join(group)
+        phone_len = 0
+        word_len = len(group)
+        if w == '[UNK]':
+            phone_list = ['UNK']
+        else:
+            phone_list = list(filter(lambda p: p != " ", fr_to_ipa.fr2ipa(w)))
+        
+        for ph in phone_list:
+            phones.append(ph)
+            tones.append(0)
+            phone_len += 1
+        aaa = distribute_phone(phone_len, word_len)
+        word2ph += aaa
+        # print(phone_list, aaa)
+        # print('=' * 10)
+
+    if pad_start_end:
+        phones = ["_"] + phones + ["_"]
+        tones = [0] + tones + [0]
+        word2ph = [1] + word2ph + [1]
+    return phones, tones, word2ph
+
+def get_bert_feature(text, word2ph, device=None):
+    from text import french_bert
+    return french_bert.get_bert_feature(text, word2ph, device=device)
+
+if __name__ == "__main__":
+    ori_text = 'Ce service gratuit est“”"" 【disponible》 en chinois 【simplifié] et autres 123'
+    # ori_text = "Ils essayaient vainement de faire comprendre à ma mère qu'avec les cent mille francs que m'avait laissé mon père,"
+    # print(ori_text)
+    text = text_normalize(ori_text)
+    print(text)
+    phoneme = fr_to_ipa.fr2ipa(text)
+    print(phoneme)
+
+    
+    from TTS.tts.utils.text.phonemizers.multi_phonemizer import MultiPhonemizer
+    from text.cleaner_multiling import unicleaners
+
+    def text_normalize(text):
+        text = unicleaners(text, cased=True, lang='fr')
+        return text
+
+    # print(ori_text)
+    text = text_normalize(ori_text)
+    print(text)
+    phonemizer = MultiPhonemizer({"fr-fr": "espeak"})
+    # phonemizer.lang_to_phonemizer['fr'].keep_stress = True
+    # phonemizer.lang_to_phonemizer['fr'].use_espeak_phonemes = True
+    phoneme = phonemizer.phonemize(text, separator="", language='fr-fr')
+    print(phoneme)