add pauses and controls

app.py

@@ -3,20 +3,7 @@ import numpy as np
 from scipy.io.wavfile import write
 import gradio as gr
 from transformers import VitsTokenizer, VitsModel, set_seed, pipeline
-
-
-class CustomFlagging(gr.FlaggingCallback):
-    def setup(self, *args, **kwargs):
-        pass  # Optional setup steps
-
-    def flag(self, flag_data, flag_option=None, username=None):
-        print(f"Аудио: {flag_data}, Сообщение: {flag_option}")
-
-
-# Custom options
-flagging_callback = CustomFlagging()
-flagging_options = ["Хорошая озвучка", "Слышен механический треск", "Не совпадает произношение букв", 'Проглочены буквы']  # Customize options
-
+from numToLez import numToLez
 
 # Load your fine-tuned model
 model_name = "leks-forever/vits_lez_tts"  # Replace with your Hugging Face model name
@@ -25,15 +12,33 @@ model = VitsModel.from_pretrained(model_name)
 
 tts_pipeline = pipeline("text-to-speech", model=model_name)
 
+new_sentence = '!.?'
+in_sentence = ',-.:;'
 
-def tts_function(input_text):
-    inputs = tokenizer(text=input_text, return_tensors="pt")
+
+def canonize_lez(text):
+    for abruptive_letter in ['к', 'К', 'п', 'П', 'т', 'Т', 'ц', 'Ц', 'ч', 'Ч']:
+        for abruptive_symbol in ['1', 'l', 'i', 'I', '|', 'ӏ', 'Ӏ', 'ӏ']:
+            text = text.replace(abruptive_letter+abruptive_symbol, abruptive_letter+'Ӏ')
+    return text
+
+
+def tts_function(input_text, speaking_rate, noise_scale, add_pauses):
+    fixed_text = canonize_lez(input_text)
+    if add_pauses:
+        for symb in new_sentence:
+            fixed_text = fixed_text.replace(symb, '   ')
+
+        for symb in in_sentence:
+            fixed_text = fixed_text.replace(symb, ' ')
+
+    inputs = tokenizer(text=fixed_text, return_tensors="pt")
     speech = tts_pipeline(input_text)
     set_seed(900)  
 
     # make speech faster and more noisy
-    model.speaking_rate = 0.9
-    model.noise_scale = 0
+    model.speaking_rate = speaking_rate
+    model.noise_scale = noise_scale
 
     sampling_rate = speech["sampling_rate"]
 
@@ -46,13 +51,42 @@ def tts_function(input_text):
         return tmpfile.name  # Return the filepath
 
 
-interface = gr.Interface(
-    fn=tts_function,
-    inputs=gr.Textbox(label="Введите текст на лезгинском"),
-    outputs=gr.Audio(label="Аудио"),
-    title="Text-to-speech Лезги ЧIалал",
-    flagging_mode="auto",  # Enable the flagging button
-)
-
+# interface = gr.Interface(
+#     fn=tts_function,
+#     inputs=[
+#         gr.Textbox(label="Введите текст на лезгинском"),
+#         gr.Slider(label="Скорость речи", minimum=0, maximum=2, step=0.1, value=0.9),
+#         gr.Slider(label="Шум", minimum=0, maximum=5, step=0.1, value=0),
+#         gr.Checkbox(label="Сделать паузы длиннее", value=False),  
+#     ],
+#     outputs=gr.Audio(label="Аудио"),
+#     title="Text-to-speech Лезги ЧIалал",
+#     submit_button=gr.Button("Сгенерировать"),
+    
+#     flagging_mode="auto",  # Enable the flagging button
+# )
+
+with gr.Blocks() as interface:
+    gr.Markdown("### Text-to-speech Лезги ЧIалал")
+
+    with gr.Row():
+        # Left Column: Inputs
+        with gr.Column():
+            input_text = gr.Textbox(label="Введите текст на лезгинском", elem_id="custom-input")
+            add_pauses = gr.Checkbox(label="Добавить больше пауз у знаков препинания", value=False)
+            speaking_rate = gr.Slider(label="Скорость речи (speaking_rate)", minimum=0, maximum=2, step=0.1, value=0.9)
+            noise_scale = gr.Slider(label="Шум (noise_scale)", minimum=0, maximum=5, step=0.1, value=0)
+            submit_button = gr.Button("Сгенерировать")
+        
+        # Right Column: Output
+        with gr.Column():
+            output_audio = gr.Audio(label="Аудио")
+
+    # Link function to button
+    submit_button.click(
+        fn=tts_function,
+        inputs=[input_text, speaking_rate, noise_scale, add_pauses],
+        outputs=output_audio,
+    )
 # Launch the app
 interface.launch()

numToLez.py

@@ -0,0 +1,374 @@
+numToLez = '''(input_text) => {
+    const million = 1e6; // 10^6;
+    const billion = 1e9; // 10^9;
+    const trillion = 1e12; // 10^12;
+    const quadrillion = 1e15; // 10^15;
+    const quintillion = 1e18; // 10^18;
+    const sextillion = 1e21; // 10^21;
+    const septillion = 1e24; // 10^24;
+    const octillion = 1e27; // 10^27;
+    const nonillion = 1e30; // 10^30;
+    const atomic = {
+        0: 'нул',
+        1: 'сад',
+        2: 'кьвед',
+        3: 'пуд',
+        4: 'кьуд',
+        5: 'вад',
+        6: 'ругуд',
+        7: 'ирид',
+        8: 'муьжуьд',
+        9: 'кIуьд',
+        10: 'цIуд',
+        20: 'къад',
+        40: 'яхцIур',
+        // 10^2
+        100: 'виш',
+        // 10^3
+        1000: 'агъзур',
+        // 10^6
+        [million]: 'миллион',
+        // 10^9
+        [billion]: 'миллиард',
+        // 10^12
+        [trillion]: 'триллион',
+        // 10^15
+        [quadrillion]: 'квадриллион',
+        // 10^18
+        [quintillion]: 'квинтиллион',
+        // 10^21
+        [sextillion]: 'секстиллион',
+        // 10^24
+        [septillion]: 'септиллион',
+        // 10^27
+        [octillion]: 'октиллион',
+        // 10^30
+        [nonillion]: 'нониллион',
+    };
+    const MINUS = 'минус';
+    function separateNumberIntoUnits(n) {
+        if (n == 0)
+            return [0];
+        const arr = [];
+        let i = 1;
+        while (n > 0) {
+            arr.unshift((n % 10) * i);
+            n = Math.floor(n / 10);
+            i *= 10;
+        }
+        const result = groupNumberUnitsToLezgiRange(arr);
+        return result;
+    }
+    const ranges = [
+        { start: nonillion, end: octillion }, // nonillion to octillion
+        { start: octillion, end: septillion }, // octillion to septillion
+        { start: septillion, end: sextillion }, // septillion to sextillion
+        { start: sextillion, end: quintillion }, // sextillion to quintillion
+        { start: quadrillion, end: quintillion }, // quadrillion to quintillion
+        { start: trillion, end: quadrillion }, // trillion to quadrillion
+        { start: billion, end: trillion }, // billion to trillion
+        { start: million, end: billion }, // million to billion
+        { start: 1000, end: million }, // thousand to million
+    ];
+    function groupNumberUnitsToLezgiRange(arr) {
+        let result = [];
+        for (let range of ranges) {
+            let sum = arr.reduce((acc, num) => {
+                if (num >= range.start && num < range.end) {
+                    return acc + num;
+                }
+                return acc;
+            }, 0);
+            if (sum !== 0) {
+                result.push(sum);
+            }
+            // Filter out the numbers that were added to sum
+            arr = arr.filter((num) => num < range.start || num >= range.end);
+        }
+        // Concatenate the remaining numbers to the result
+        result = result.concat(arr);
+        return result;
+    }
+    function getTenPlusBase(num) {
+        if (num < 10 || num >= 20) {
+            throw new Error('Invalid number');
+        }
+        if (num === 10) {
+            return [atomic[10]];
+        }
+        const base10 = atomic[10].slice(0, -2);
+        if (num === 11 || num === 15 || num === 16) {
+            return [base10 + 'у'];
+        }
+        else if (num < 15) {
+            return [base10 + 'и'];
+        }
+        return [base10 + 'е'];
+    }
+    function getTwentyPlusBase(num) {
+        return num === 20 ? [atomic[20]] : ['къанни'];
+    }
+    function getThirtyPlusBase(num) {
+        return [...getTwentyPlusBase(num), ...getTenPlusBase(num - 20)];
+    }
+    function getFourtyPlusBase(num) {
+        return num === 40 ? [atomic[40]] : [atomic[40], 'ни'];
+    }
+    function getFiftyPlusBase(num) {
+        return [...getFourtyPlusBase(num), ...getTenPlusBase(num - 40)];
+    }
+    function getSixtyPlusBase(num) {
+        return num === 60 ? [atomic[3], atomic[20]] : [atomic[3], ...getTwentyPlusBase(num)];
+    }
+    function getSeventyPlusBase(num) {
+        return [...getSixtyPlusBase(61), ...getTenPlusBase(num - 60)];
+    }
+    function getEightyPlusBase(num) {
+        return num === 80 ? [atomic[4], atomic[20]] : [atomic[4], ...getTwentyPlusBase(num)];
+    }
+    function getNinetyPlusBase(num) {
+        return [...getEightyPlusBase(81), ...getTenPlusBase(num - 80)];
+    }
+    function getHundredPlusBase(num) {
+        return num % 100 === 0 ? [atomic[100]] : [atomic[100], 'ни'];
+    }
+    function getHundredPlusNumCount(numCount) {
+        if (atomic[numCount] !== undefined) {
+            return numCount === 2 ? [atomic[numCount].slice(0, -1)] : [atomic[numCount]];
+        }
+        return undefined;
+    }
+    function getBetweenHundredAndThousand(num, followUpNumber) {
+        const hundredsCount = num % 100 != 0 ? num - (num % 100) : num / 100;
+        const hundredsCountInLezgi = getHundredPlusNumCount(hundredsCount);
+        return [...hundredsCountInLezgi, ' ', ...getHundredPlusBase(num + followUpNumber)];
+    }
+    function getThousandPlusBase(num) {
+        return num % 1000 === 0 ? [atomic[1000]] : [atomic[1000], 'ни'];
+    }
+    function getBetweenThousandAndMillion(num, followUpNumber) {
+        var _a;
+        const thousandsCount = num % 1000 != 0 ? num - (num % 1000) : num / 1000;
+        const thousandsCountInLezgi = (_a = getHundredPlusNumCount(thousandsCount)) !== null && _a !== void 0 ? _a : getCompound(thousandsCount);
+        return [...thousandsCountInLezgi, ' ', ...getThousandPlusBase(num + followUpNumber)];
+    }
+    function getMillionPlusBase(num) {
+        return num % million === 0 ? [atomic[million]] : [atomic[million], 'ни'];
+    }
+    function getBetweenMillionAndBillion(num, followUpNumber) {
+        var _a;
+        const millionsCount = num % million != 0 ? num - (num % million) : num / million;
+        const millionsCountInLezgi = (_a = getHundredPlusNumCount(millionsCount)) !== null && _a !== void 0 ? _a : getCompound(millionsCount);
+        return [...millionsCountInLezgi, ' ', ...getMillionPlusBase(num + followUpNumber)];
+    }
+    function getBillionPlusBase(num) {
+        return num % billion === 0 ? [atomic[billion]] : [atomic[billion], 'ни'];
+    }
+    function getBetweenBillionAndTrillion(num, followUpNumber) {
+        var _a;
+        const billionsCount = num % billion != 0 ? num - (num % billion) : num / billion;
+        const billionsCountInLezgi = (_a = getHundredPlusNumCount(billionsCount)) !== null && _a !== void 0 ? _a : getCompound(billionsCount);
+        return [...billionsCountInLezgi, ' ', ...getBillionPlusBase(num + followUpNumber)];
+    }
+    function getTrillionPlusBase(num) {
+        return num % trillion === 0 ? [atomic[trillion]] : [atomic[trillion], 'ни'];
+    }
+    function getBetweenTrillionAndQuadrillion(num, followUpNumber) {
+        var _a;
+        const trillionsCount = num % trillion != 0 ? num - (num % trillion) : num / trillion;
+        const trillionsCountInLezgi = (_a = getHundredPlusNumCount(trillionsCount)) !== null && _a !== void 0 ? _a : getCompound(trillionsCount);
+        return [...trillionsCountInLezgi, ' ', ...getTrillionPlusBase(num + followUpNumber)];
+    }
+    function getQuadrillionPlusBase(num) {
+        return num % quadrillion === 0 ? [atomic[quadrillion]] : [atomic[quadrillion], 'ни'];
+    }
+    function getBetweenQuadrillionAndQuintillion(num, followUpNumber) {
+        var _a;
+        const quadrillionsCount = num % quadrillion != 0 ? num - (num % quadrillion) : num / quadrillion;
+        const quadrillionsCountInLezgi = (_a = getHundredPlusNumCount(quadrillionsCount)) !== null && _a !== void 0 ? _a : getCompound(quadrillionsCount);
+        return [...quadrillionsCountInLezgi, ' ', ...getQuadrillionPlusBase(num + followUpNumber)];
+    }
+    function getQuintillionPlusBase(num) {
+        return num % quintillion === 0 ? [atomic[quintillion]] : [atomic[quintillion], 'ни'];
+    }
+    function getBetweenQuintillionAndSextillion(num, followUpNumber) {
+        var _a;
+        const quintillionsCount = num % quintillion != 0 ? num - (num % quintillion) : num / quintillion;
+        const quintillionsCountInLezgi = (_a = getHundredPlusNumCount(quintillionsCount)) !== null && _a !== void 0 ? _a : getCompound(quintillionsCount);
+        return [...quintillionsCountInLezgi, ' ', ...getQuintillionPlusBase(num + followUpNumber)];
+    }
+    function getSextillionPlusBase(num) {
+        return num % sextillion === 0 ? [atomic[sextillion]] : [atomic[sextillion], 'ни'];
+    }
+    function getBetweenSextillionAndSeptillion(num, followUpNumber) {
+        var _a;
+        const sextillionsCount = num % sextillion != 0 ? num - (num % sextillion) : num / sextillion;
+        const sextillionsCountInLezgi = (_a = getHundredPlusNumCount(sextillionsCount)) !== null && _a !== void 0 ? _a : getCompound(sextillionsCount);
+        return [...sextillionsCountInLezgi, ' ', ...getSextillionPlusBase(num + followUpNumber)];
+    }
+    function getSeptillionPlusBase(num) {
+        return num % septillion === 0 ? [atomic[septillion]] : [atomic[septillion], 'ни'];
+    }
+    function getBetweenSeptillionAndOctillion(num, followUpNumber) {
+        var _a;
+        const septillionsCount = num % septillion != 0 ? num - (num % septillion) : num / septillion;
+        const septillionsCountInLezgi = (_a = getHundredPlusNumCount(septillionsCount)) !== null && _a !== void 0 ? _a : getCompound(septillionsCount);
+        return [...septillionsCountInLezgi, ' ', ...getSeptillionPlusBase(num + followUpNumber)];
+    }
+    function getOctillionPlusBase(num) {
+        return num % octillion === 0 ? [atomic[octillion]] : [atomic[octillion], 'ни'];
+    }
+    function getBetweenOctillionAndNonillion(num, followUpNumber) {
+        var _a;
+        const octillionsCount = num % octillion != 0 ? num - (num % octillion) : num / octillion;
+        const octillionsCountInLezgi = (_a = getHundredPlusNumCount(octillionsCount)) !== null && _a !== void 0 ? _a : getCompound(octillionsCount);
+        return [...octillionsCountInLezgi, ' ', ...getOctillionPlusBase(num + followUpNumber)];
+    }
+    function getNonillionPlusBase(num) {
+        return num % nonillion === 0 ? [atomic[nonillion]] : [atomic[nonillion], 'ни'];
+    }
+    function getCompound(num) {
+        const units = separateNumberIntoUnits(num);
+        const result = units.map((unit, i) => {
+            if (i > 0 &&
+                unit === 7 &&
+                (units[i - 1] === 10 ||
+                    units[i - 1] === 30 ||
+                    units[i - 1] === 50 ||
+                    units[i - 1] === 70 ||
+                    units[i - 1] === 90)) {
+                return [atomic[7].slice(1)];
+            }
+            const followUpNumber = units.slice(i + 1).reduce((acc, num) => acc + num, 0);
+            if (unit === 10) {
+                return getTenPlusBase(unit + followUpNumber);
+            }
+            if (unit === 20) {
+                return getTwentyPlusBase(unit + followUpNumber);
+            }
+            if (unit === 30) {
+                return getThirtyPlusBase(unit + followUpNumber);
+            }
+            if (unit === 40) {
+                return getFourtyPlusBase(unit + followUpNumber);
+            }
+            if (unit === 50) {
+                return getFiftyPlusBase(unit + followUpNumber);
+            }
+            if (unit === 60) {
+                return getSixtyPlusBase(unit + followUpNumber);
+            }
+            if (unit === 70) {
+                return getSeventyPlusBase(unit + followUpNumber);
+            }
+            if (unit === 80) {
+                return getEightyPlusBase(unit + followUpNumber);
+            }
+            if (unit === 90) {
+                return getNinetyPlusBase(unit + followUpNumber);
+            }
+            if (unit === 100) {
+                return getHundredPlusBase(unit + followUpNumber);
+            }
+            if (unit > 100 && unit < 1000) {
+                return getBetweenHundredAndThousand(unit, followUpNumber);
+            }
+            if (unit === 1000) {
+                return getThousandPlusBase(unit + followUpNumber);
+            }
+            if (unit > 1000 && unit < million) {
+                return getBetweenThousandAndMillion(unit, followUpNumber);
+            }
+            if (unit === million) {
+                return getMillionPlusBase(unit + followUpNumber);
+            }
+            if (unit > million && unit < billion) {
+                return getBetweenMillionAndBillion(unit, followUpNumber);
+            }
+            if (unit === billion) {
+                return getBillionPlusBase(unit + followUpNumber);
+            }
+            if (unit > billion && unit < trillion) {
+                return getBetweenBillionAndTrillion(unit, followUpNumber);
+            }
+            if (unit === trillion) {
+                return getTrillionPlusBase(unit + followUpNumber);
+            }
+            if (unit > trillion && unit < quadrillion) {
+                return getBetweenTrillionAndQuadrillion(unit, followUpNumber);
+            }
+            if (unit === quadrillion) {
+                return getQuadrillionPlusBase(unit + followUpNumber);
+            }
+            if (unit > quadrillion && unit < quintillion) {
+                return getBetweenQuadrillionAndQuintillion(unit, followUpNumber);
+            }
+            if (unit === quintillion) {
+                return getQuintillionPlusBase(unit + followUpNumber);
+            }
+            if (unit > quintillion && unit < sextillion) {
+                return getBetweenQuintillionAndSextillion(unit, followUpNumber);
+            }
+            if (unit === sextillion) {
+                return getSextillionPlusBase(unit + followUpNumber);
+            }
+            if (unit > sextillion && unit < septillion) {
+                return getBetweenSextillionAndSeptillion(unit, followUpNumber);
+            }
+            if (unit === septillion) {
+                return getSeptillionPlusBase(unit + followUpNumber);
+            }
+            if (unit > septillion && unit < octillion) {
+                return getBetweenSeptillionAndOctillion(unit, followUpNumber);
+            }
+            if (unit === octillion) {
+                return getOctillionPlusBase(unit + followUpNumber);
+            }
+            if (unit > octillion && unit < nonillion) {
+                return getBetweenOctillionAndNonillion(unit, followUpNumber);
+            }
+            if (unit === nonillion) {
+                return getNonillionPlusBase(unit + followUpNumber);
+            }
+            return units.length > 1 && unit === 0 ? [''] : [atomic[unit] || unit.toString()];
+        });
+        return result.flat(); //.join('').replaceAll('  ', ' ').trim();
+    }
+    function getAtomicOrCompound(num) {
+        if (atomic[num]) {
+            return [atomic[num]];
+        }
+        else {
+            return getCompound(num);
+        }
+    }
+    function numToLezgiArray(num) {
+        if (isNaN(num)) {
+            throw new Error('Provided value is not a number');
+        }
+        if (!Number.isInteger(num)) {
+            throw new Error('Provided number is not an integer. Currently only integers are supported!');
+        }
+        const isNegative = num < 0;
+        num = Math.abs(num);
+        const result = getAtomicOrCompound(num)
+            .filter((word) => word !== '')
+            .map((word) => (word.endsWith('ни') ? [word, ' '] : word))
+            .flat();
+        return isNegative ? [MINUS, ' ', ...result] : result;
+    }
+    function numToLezgi(num) {
+        const resultArray = numToLezgiArray(num);
+        return (resultArray
+            // .map((word) => (word.endsWith('ни') || word === MINUS ? word + ' ' : word))
+            .join('')
+            .replaceAll('  ', ' ')
+            .trim());
+    }
+
+function replaceNumbersWithWords(inputString) {
+    return inputString.replaceAll(/\d+/g, (num) => numToLezgi(parseInt(num, 10)));
+}
+console.log(replaceNumbersWithWords(input_text))
+return replaceNumbersWithWords(input_text)
+}'''