Update app.py

app.py

@@ -24,6 +24,8 @@ import torch.nn as nn
 from torch.utils.data import Dataset
 from torch.utils.data import DataLoader, Dataset
 from tqdm import tqdm
+from tools.sentence import extrac, is_japanese, is_chinese, seconds_to_ass_time, extract_text_from_file, remove_annotations,extract_and_convert
+
 
 import gradio as gr
 
@@ -40,33 +42,7 @@ from models import SynthesizerTrn
 from text.symbols import symbols
 import sys
 import re
-
-import random
-import hashlib
-
-from fugashi import Tagger
-import jaconv
-import unidic
-import subprocess
-
-import requests
-
-from ebooklib import epub
-import PyPDF2
-from PyPDF2 import PdfReader
-from bs4 import BeautifulSoup
-import jieba 
-import romajitable
-
-webBase = {
-    'pyopenjtalk-V2.3-Katakana': 'https://mahiruoshi-mygo-vits-bert.hf.space/',
-    'fugashi-V2.3-Katakana': 'https://mahiruoshi-mygo-vits-bert.hf.space/',
-}
-
-languages = [ "Auto", "ZH", "JP"]
-modelPaths = []
-modes = ['pyopenjtalk-V2.3','pyopenjtalk-V2.3-Katakana']
-sentence_modes = ['sentence','paragraph']
+from tools.translate import translate
 
 net_g = None
 
@@ -93,355 +69,6 @@ BandList = {
         "AveMujica":["祥子","睦","海鈴","にゃむ","初華"],
 }
 
-SchoolLilst = {
-        "圣翔音乐学园":["華戀","光","香子","雙葉","真晝","純那","克洛迪娜","真矢","奈奈"],
-        "凛明馆女子学校":["珠緒","壘","文","悠悠子","一愛"],
-        "弗隆提亚艺术学校":["艾露","艾露露","菈樂菲","司","靜羽"],
-        "西克菲尔特音乐学院":["晶","未知留","八千代","栞","美帆"]
-}
-
-#翻译
-
-def translate(Sentence: str, to_Language: str = "jp", from_Language: str = ""):
-    """
-    :param Sentence: 待翻译语句
-    :param from_Language: 待翻译语句语言
-    :param to_Language: 目标语言
-    :return: 翻译后语句 出错时返回None
-
-    常见语言代码：中文 zh 英语 en 日语 jp
-    """
-    appid = "20231117001883321"
-    key = "lMQbvZHeJveDceLof2wf"
-    if appid == "" or key == "":
-        return "请开发者在config.yml中配置app_key与secret_key"
-    url = "https://fanyi-api.baidu.com/api/trans/vip/translate"
-    texts = Sentence.splitlines()
-    outTexts = []
-    for t in texts:
-        if t != "":
-            # 签名计算 参考文档 https://api.fanyi.baidu.com/product/113
-            salt = str(random.randint(1, 100000))
-            signString = appid + t + salt + key
-            hs = hashlib.md5()
-            hs.update(signString.encode("utf-8"))
-            signString = hs.hexdigest()
-            if from_Language == "":
-                from_Language = "auto"
-            headers = {"Content-Type": "application/x-www-form-urlencoded"}
-            payload = {
-                "q": t,
-                "from": from_Language,
-                "to": to_Language,
-                "appid": appid,
-                "salt": salt,
-                "sign": signString,
-            }
-            # 发送请求
-            try:
-                response = requests.post(
-                    url=url, data=payload, headers=headers, timeout=3
-                )
-                response = response.json()
-                if "trans_result" in response.keys():
-                    result = response["trans_result"][0]
-                    if "dst" in result.keys():
-                        dst = result["dst"]
-                        outTexts.append(dst)
-            except Exception:
-                return Sentence
-        else:
-            outTexts.append(t)
-    return "\n".join(outTexts)
-
-#文本清洗工具
-def is_japanese(string):
-        for ch in string:
-            if ord(ch) > 0x3040 and ord(ch) < 0x30FF:
-                return True
-        return False
-
-def is_chinese(string):
-    for ch in string:
-        if '\u4e00' <= ch <= '\u9fff':
-            return True
-    return False
-
-def is_single_language(sentence):
-    # 检查句子是否为单一语言
-    contains_chinese = re.search(r'[\u4e00-\u9fff]', sentence) is not None
-    contains_japanese = re.search(r'[\u3040-\u30ff\u31f0-\u31ff]', sentence) is not None
-    contains_english = re.search(r'[a-zA-Z]', sentence) is not None
-    language_count = sum([contains_chinese, contains_japanese, contains_english])
-    return language_count == 1
-
-def merge_scattered_parts(sentences):
-    """合并零散的部分到相邻的句子中，并确保单一语言性"""
-    merged_sentences = []
-    buffer_sentence = ""
-
-    for sentence in sentences:
-        # 检查是否是单一语言或者太短（可能是标点或单个词）
-        if is_single_language(sentence) and len(sentence) > 1:
-            # 如果缓冲区有内容，先将缓冲区的内容添加到列表
-            if buffer_sentence:
-                merged_sentences.append(buffer_sentence)
-                buffer_sentence = ""
-            merged_sentences.append(sentence)
-        else:
-            # 如果是零散的部分，将其添加到缓冲区
-            buffer_sentence += sentence
-
-    # 确保最后的缓冲区内容被添加
-    if buffer_sentence:
-        merged_sentences.append(buffer_sentence)
-
-    return merged_sentences
-
-def is_only_punctuation(s):
-    """检查字符串是否只包含标点符号"""
-    # 此处列出中文、日文、英文常见标点符号
-    punctuation_pattern = re.compile(r'^[\s。*；，：“”（）、！？《》\u3000\.,;:"\'?!()]+$')
-    return punctuation_pattern.match(s) is not None
-
-def split_mixed_language(sentence):
-    # 分割混合语言句子
-    # 逐字符检查，分割不同语言部分
-    sub_sentences = []
-    current_language = None
-    current_part = ""
-
-    for char in sentence:
-        if re.match(r'[\u4e00-\u9fff]', char):  # Chinese character
-            if current_language != 'chinese':
-                if current_part:
-                    sub_sentences.append(current_part)
-                current_part = char
-                current_language = 'chinese'
-            else:
-                current_part += char
-        elif re.match(r'[\u3040-\u30ff\u31f0-\u31ff]', char):  # Japanese character
-            if current_language != 'japanese':
-                if current_part:
-                    sub_sentences.append(current_part)
-                current_part = char
-                current_language = 'japanese'
-            else:
-                current_part += char
-        elif re.match(r'[a-zA-Z]', char):  # English character
-            if current_language != 'english':
-                if current_part:
-                    sub_sentences.append(current_part)
-                current_part = char
-                current_language = 'english'
-            else:
-                current_part += char
-        else:
-            current_part += char  # For punctuation and other characters
-    
-    if current_part:
-        sub_sentences.append(current_part)
-
-    return sub_sentences
-
-def replace_quotes(text):
-    # 替换中文、日文引号为英文引号
-    text = re.sub(r'[“”‘’『』「」（）()]', '"', text)
-    return text
-
-def remove_numeric_annotations(text):
-    # 定义用于匹配数字注释的正则表达式
-    # 包括 “”、【】和〔〕包裹的数字
-    pattern = r'“\d+”|【\d+】|〔\d+〕'
-    # 使用正则表达式替换掉这些注释
-    cleaned_text = re.sub(pattern, '', text)
-    return cleaned_text
-
-def merge_adjacent_japanese(sentences):
-    """合并相邻且都只包含日语的句子"""
-    merged_sentences = []
-    i = 0
-    while i < len(sentences):
-        current_sentence = sentences[i]
-        if i + 1 < len(sentences) and is_japanese(current_sentence) and is_japanese(sentences[i + 1]):
-            # 当前句子和下一句都是日语，合并它们
-            while i + 1 < len(sentences) and is_japanese(sentences[i + 1]):
-                current_sentence += sentences[i + 1]
-                i += 1
-        merged_sentences.append(current_sentence)
-        i += 1
-    return merged_sentences
-
-def extrac(text):
-    text = replace_quotes(remove_numeric_annotations(text))  # 替换引号
-    text = re.sub("<[^>]*>", "", text)  # 移除 HTML 标签
-    # 使用换行符和标点符号进行初步分割
-    preliminary_sentences = re.split(r'([\n。；！？\.\?!])', text)
-    final_sentences = []
-
-    preliminary_sentences = re.split(r'([\n。；！？\.\?!])', text)
-
-    for piece in preliminary_sentences:
-        if is_single_language(piece):
-            final_sentences.append(piece)
-        else:
-            sub_sentences = split_mixed_language(piece)
-            final_sentences.extend(sub_sentences)
-    
-    # 处理长句子，使用jieba进行分词
-    split_sentences = []
-    for sentence in final_sentences:
-        split_sentences.extend(split_long_sentences(sentence))
-
-    # 合并相邻的日语句子
-    merged_japanese_sentences = merge_adjacent_japanese(split_sentences)
-
-    # 剔除只包含标点符号的元素
-    clean_sentences = [s for s in merged_japanese_sentences if not is_only_punctuation(s)]
-
-    # 移除空字符串并去除多余引号
-    return [s.replace('"','').strip() for s in clean_sentences if s]
-
-
-
-  # 移除空字符串
-
-def is_mixed_language(sentence):
-    contains_chinese = re.search(r'[\u4e00-\u9fff]', sentence) is not None
-    contains_japanese = re.search(r'[\u3040-\u30ff\u31f0-\u31ff]', sentence) is not None
-    contains_english = re.search(r'[a-zA-Z]', sentence) is not None
-    languages_count = sum([contains_chinese, contains_japanese, contains_english])
-    return languages_count > 1
-
-def split_mixed_language(sentence):
-    # 分割混合语言句子
-    sub_sentences = re.split(r'(?<=[。！？\.\?!])(?=")|(?<=")(?=[\u4e00-\u9fff\u3040-\u30ff\u31f0-\u31ff]|[a-zA-Z])', sentence)
-    return [s.strip() for s in sub_sentences if s.strip()]
-
-def seconds_to_ass_time(seconds):
-    """将秒数转换为ASS时间格式"""
-    hours = int(seconds / 3600)
-    minutes = int((seconds % 3600) / 60)
-    seconds = int(seconds) % 60
-    milliseconds = int((seconds - int(seconds)) * 1000)
-    return "{:01d}:{:02d}:{:02d}.{:02d}".format(hours, minutes, seconds, int(milliseconds / 10))
-
-def extract_text_from_epub(file_path):
-    book = epub.read_epub(file_path)
-    content = []
-    for item in book.items:
-        if isinstance(item, epub.EpubHtml):
-            soup = BeautifulSoup(item.content, 'html.parser')
-            content.append(soup.get_text())
-    return '\n'.join(content)
-
-def extract_text_from_pdf(file_path):
-    with open(file_path, 'rb') as file:
-        reader = PdfReader(file)
-        content = [page.extract_text() for page in reader.pages]
-    return '\n'.join(content)
-
-def remove_annotations(text):
-    # 移除方括号、尖括号和中文方括号中的内容
-    text = re.sub(r'\[.*?\]', '', text)
-    text = re.sub(r'\<.*?\>', '', text)
-    text = re.sub(r'&#8203;``【oaicite:1】``&#8203;', '', text)
-    return text
-
-def extract_text_from_file(inputFile):
-    file_extension = os.path.splitext(inputFile)[1].lower()
-    if file_extension == ".epub":
-        return extract_text_from_epub(inputFile)
-    elif file_extension == ".pdf":
-        return extract_text_from_pdf(inputFile)
-    elif file_extension == ".txt":
-        with open(inputFile, 'r', encoding='utf-8') as f:
-            return f.read()
-    else:
-        raise ValueError(f"Unsupported file format: {file_extension}")
-
-def split_by_punctuation(sentence):
-    """按照中文次级标点符号分割句子"""
-    # 常见的中文次级分隔符号：逗号、分号等
-    parts = re.split(r'([，,；;])', sentence)
-    # 将标点符号与前面的词语合并，避免单独标点符号成为一个部分
-    merged_parts = []
-    for part in parts:
-        if part and not part in '，,；;':
-            merged_parts.append(part)
-        elif merged_parts:
-            merged_parts[-1] += part
-    return merged_parts
-
-def split_long_sentences(sentence, max_length=30):
-    """如果中文句子太长，先按标点分割，必要时使用jieba进行分词并分割"""
-    if len(sentence) > max_length and is_chinese(sentence):
-        # 首先尝试按照次级标点符号分割
-        preliminary_parts = split_by_punctuation(sentence)
-        new_sentences = []
-
-        for part in preliminary_parts:
-            # 如果部分仍然太长，使用jieba进行分词
-            if len(part) > max_length:
-                words = jieba.lcut(part)
-                current_sentence = ""
-                for word in words:
-                    if len(current_sentence) + len(word) > max_length:
-                        new_sentences.append(current_sentence)
-                        current_sentence = word
-                    else:
-                        current_sentence += word
-                if current_sentence:
-                    new_sentences.append(current_sentence)
-            else:
-                new_sentences.append(part)
-
-        return new_sentences
-    return [sentence]  # 如果句子不长或不是中文，直接返回
-
-def extract_and_convert(text):
-
-    # 使用正则表达式找出所有英文单词
-    english_parts = re.findall(r'\b[A-Za-z]+\b', text)  # \b为单词边界标识
-    
-    # 对每个英文单词进行片假名转换
-    kana_parts = ['\n{}\n'.format(romajitable.to_kana(word).katakana) for word in english_parts]
-
-    # 替换原文本中的英文部分
-    for eng, kana in zip(english_parts, kana_parts):
-        text = text.replace(eng, kana, 1)  # 限制每次只替换一个实例
-    
-    return text
-# 推理工具
-def download_unidic():
-    try:
-        Tagger()
-        print("Tagger launch successfully.")
-    except Exception as e:
-        print("UNIDIC dictionary not found, downloading...")
-        subprocess.run([sys.executable, "-m", "unidic", "download"])
-        print("Download completed.")
-
-def kanji_to_hiragana(text):
-    global tagger
-    output = ""
-
-    # 更新正则表达式以更准确地区分文本和标点符号
-    segments = re.findall(r'[一-龥ぁ-んァ-ン\w]+|[^\一-龥ぁ-んァ-ン\w\s]', text, re.UNICODE)
-
-    for segment in segments:
-        if re.match(r'[一-龥ぁ-んァ-ン\w]+', segment):
-            # 如果是单词或汉字，转换为平假名
-            for word in tagger(segment):
-                kana = word.feature.kana or word.surface
-                hiragana = jaconv.kata2hira(kana)  # 将片假名转换为平假名
-                output += hiragana
-        else:
-            # 如果是标点符号，保持不变
-            output += segment
-
-    return output
-
 def get_net_g(model_path: str,  device: str, hps):
     net_g = SynthesizerTrn(
         len(symbols),
@@ -496,6 +123,7 @@ def get_text(text, language_str, hps, device, style_text=None, style_weight=0.7)
     language = torch.LongTensor(language)
     return bert, ja_bert, en_bert, phone, tone, language
 
+
 def infer(
     text,
     sdp_ratio,
@@ -506,22 +134,9 @@ def infer(
     style_text=None,
     style_weight=0.7,
     language = "Auto",
-    mode = 'pyopenjtalk-V2.3',
-    skip_start=False,
-    skip_end=False,
 ):
-    if style_text == None:
-        style_text = ""
-        style_weight=0,
-    if mode == 'fugashi-V2.3':
-        text = kanji_to_hiragana(text) if is_japanese(text) else text
-    if language == "JP":
-        text = translate(text,"jp")
-    if language == "ZH":
-        text = translate(text,"zh")
     if language == "Auto":
         language= 'JP' if is_japanese(text) else 'ZH'
-    #print(f'{text}:{sdp_ratio}:{noise_scale}:{noise_scale_w}:{length_scale}:{length_scale}:{sid}:{language}:{mode}:{skip_start}:{skip_end}')            
     bert, ja_bert, en_bert, phones, tones, lang_ids = get_text(
         text,
         language,
@@ -530,20 +145,6 @@ def infer(
         style_text=style_text,
         style_weight=style_weight,
     )
-    if skip_start:
-        phones = phones[3:]
-        tones = tones[3:]
-        lang_ids = lang_ids[3:]
-        bert = bert[:, 3:]
-        ja_bert = ja_bert[:, 3:]
-        en_bert = en_bert[:, 3:]
-    if skip_end:
-        phones = phones[:-2]
-        tones = tones[:-2]
-        lang_ids = lang_ids[:-2]
-        bert = bert[:, :-2]
-        ja_bert = ja_bert[:, :-2]
-        en_bert = en_bert[:, :-2]
     with torch.no_grad():
         x_tst = phones.to(device).unsqueeze(0)
         tones = tones.to(device).unsqueeze(0)
@@ -586,106 +187,95 @@ def infer(
         )  # , emo
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
-    print("Success.")
-    return audio
+        return (hps.data.sampling_rate,gr.processing_utils.convert_to_16_bit_wav(audio))
+
+def is_japanese(string):
+        for ch in string:
+            if ord(ch) > 0x3040 and ord(ch) < 0x30FF:
+                return True
+        return False
 
 def loadmodel(model):
     _ = net_g.eval()
     _ = utils.load_checkpoint(model, net_g, None, skip_optimizer=True)
     return "success"
 
-def generate_audio_and_srt_for_group(
-    group,
-    outputPath,
-    group_index,
-    sampling_rate,
-    speaker,
-    sdp_ratio,
-    noise_scale,
-    noise_scale_w,
-    length_scale,
-    speakerList,
-    silenceTime,
-    language,
-    mode,
-    skip_start,
-    skip_end,
-    style_text,
-    style_weight,
-    ):
+def generate_audio_and_srt_for_group(group, outputPath, group_index, sampling_rate, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale,spealerList,silenceTime):
     audio_fin = []
     ass_entries = []
     start_time = 0
     #speaker = random.choice(cara_list)
     ass_header = """[Script Info]
-        ; 我没意见
-        Title: Audiobook
-        ScriptType: v4.00+
-        WrapStyle: 0
-        PlayResX: 640
-        PlayResY: 360
-        ScaledBorderAndShadow: yes
-        [V4+ Styles]
-        Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-        Style: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,1,1,2,10,10,10,1
-        [Events]
-        Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-        """
+; 我没意见
+Title: Audiobook
+ScriptType: v4.00+
+WrapStyle: 0
+PlayResX: 640
+PlayResY: 360
+ScaledBorderAndShadow: yes
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,1,1,2,10,10,10,1
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+"""
 
     for sentence in group:
         try:
-            if len(sentence) > 1:
-                FakeSpeaker = sentence.split("|")[0]
-                print(FakeSpeaker)
-                SpeakersList = re.split('\n', speakerList)
-                if FakeSpeaker in list(hps.data.spk2id.keys()):
-                    speaker = FakeSpeaker
-                for i in SpeakersList:
-                    if FakeSpeaker == i.split("|")[1]:
-                        speaker = i.split("|")[0]
-                if sentence != '\n':
-                    text = (remove_annotations(sentence.split("|")[-1]).replace(" ","")+"。").replace("，。","。")
-                    if mode == 'pyopenjtalk-V2.3' or mode == 'fugashi-V2.3':
-                        #print(f'{text}:{sdp_ratio}:{noise_scale}:{noise_scale_w}:{length_scale}:{length_scale}:{speaker}:{language}:{mode}:{skip_start}:{skip_end}')
-                        audio = infer(
-                            text,
-                            sdp_ratio,
-                            noise_scale,
-                            noise_scale_w,
-                            length_scale,
-                            speaker,
-                            style_text,
-                            style_weight,
-                            language,
-                            mode,
-                            skip_start,
-                            skip_end,
-                        )
-                    silence_frames = int(silenceTime * 44010) if is_chinese(sentence) else int(silenceTime * 44010)
-                    silence_data = np.zeros((silence_frames,), dtype=audio.dtype)
-                    audio_fin.append(audio)
-                    audio_fin.append(silence_data)
-                    duration = len(audio) / sampling_rate
-                    print(duration)
-                    end_time = start_time + duration + silenceTime
-                    ass_entries.append("Dialogue: 0,{},{},".format(seconds_to_ass_time(start_time), seconds_to_ass_time(end_time)) + "Default,,0,0,0,,{}".format(sentence.replace("|","：")))
-                    start_time = end_time
+            FakeSpeaker = sentence.split("|")[0]
+            print(FakeSpeaker)
+            SpeakersList = re.split('\n', spealerList)
+            if FakeSpeaker in list(hps.data.spk2id.keys()):
+                speaker = FakeSpeaker
+            for i in SpeakersList:
+                if FakeSpeaker == i.split("|")[1]:
+                    speaker = i.split("|")[0]
+            if sentence != '\n':
+                audio = infer_simple((remove_annotations(sentence.split("|")[-1]).replace(" ","")+"。").replace("，。","。").replace("。。","。"), sdp_ratio, noise_scale, noise_scale_w, length_scale,speaker)
+                silence_frames = int(silenceTime * 44010) if is_chinese(sentence) else int(silenceTime * 44010)
+                silence_data = np.zeros((silence_frames,), dtype=audio.dtype)
+                audio_fin.append(audio)
+                audio_fin.append(silence_data)
+
+                duration = len(audio) / sampling_rate
+                print(duration)
+                end_time = start_time + duration + silenceTime
+                ass_entries.append("Dialogue: 0,{},{},".format(seconds_to_ass_time(start_time), seconds_to_ass_time(end_time)) + "Default,,0,0,0,,{}".format(sentence.replace("|","：")))
+                start_time = end_time
         except:
             pass
     wav_filename = os.path.join(outputPath, f'audiobook_part_{group_index}.wav')
     ass_filename = os.path.join(outputPath, f'audiobook_part_{group_index}.ass')
-    write(wav_filename, sampling_rate, gr.processing_utils.convert_to_16_bit_wav(np.concatenate(audio_fin)))
+
+    write(wav_filename, sampling_rate, np.concatenate(audio_fin))
 
     with open(ass_filename, 'w', encoding='utf-8') as f:
         f.write(ass_header + '\n'.join(ass_entries))
-    return (hps.data.sampling_rate, gr.processing_utils.convert_to_16_bit_wav(np.concatenate(audio_fin)))
+    return (hps.data.sampling_rate, np.concatenate(audio_fin))
+
+def audiobook(inputFile, groupsize, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale,spealerList,silenceTime,filepath,raw_text):
+    directory_path = filepath if torch.cuda.is_available() else "books"
+ 
+    if os.path.exists(directory_path):
+        shutil.rmtree(directory_path)
+
+    os.makedirs(directory_path)
+    if inputFile:
+        text = extract_text_from_file(inputFile.name)
+    else:
+        text = raw_text
+    sentences = extrac(extract_and_convert(text))
+    GROUP_SIZE = groupsize
+    for i in range(0, len(sentences), GROUP_SIZE):
+        group = sentences[i:i+GROUP_SIZE]
+        if spealerList == "":
+            spealerList = "无"
+        result = generate_audio_and_srt_for_group(group,directory_path, i//GROUP_SIZE + 1, 44100, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale,spealerList,silenceTime)
+        if not torch.cuda.is_available():
+            return result
+    return result
 
-def generate_audio(
-    inputFile,
-    groupSize,
-    filepath,
-    silenceTime,
-    speakerList,
+def infer_simple(
     text,
     sdp_ratio,
     noise_scale,
@@ -694,100 +284,65 @@ def generate_audio(
     sid,
     style_text=None,
     style_weight=0.7,
-    language = "Auto",
-    mode = 'pyopenjtalk-V2.3',
-    sentence_mode = 'sentence',
-    skip_start=False,
-    skip_end=False,
 ):
-    if inputFile:
-        text = extract_text_from_file(inputFile.name)
-        sentence_mode = 'paragraph'
-    if mode == 'pyopenjtalk-V2.3' or mode == 'fugashi-V2.3':
-        if sentence_mode == 'sentence':
-            audio = infer(
-                        text,
-                        sdp_ratio,
-                        noise_scale,
-                        noise_scale_w,
-                        length_scale,
-                        sid,
-                        style_text,
-                        style_weight,
-                        language,
-                        mode,
-                        skip_start,
-                        skip_end,
-                    )
-            return (hps.data.sampling_rate,gr.processing_utils.convert_to_16_bit_wav(audio))
-        if sentence_mode == 'paragraph':
-            GROUP_SIZE = groupSize
-            directory_path = filepath if torch.cuda.is_available() else "books"
-            if os.path.exists(directory_path):
-                shutil.rmtree(directory_path)
-            os.makedirs(directory_path)
-            if language == 'Auto':
-                sentences = extrac(extract_and_convert(text))
-            else:
-                sentences = extrac(text)
-            for i in range(0, len(sentences), GROUP_SIZE):
-                group = sentences[i:i+GROUP_SIZE]
-                if speakerList == "":
-                    speakerList = "无"
-                result = generate_audio_and_srt_for_group(
-                    group,
-                    directory_path,
-                    i//GROUP_SIZE + 1,
-                    44100,
-                    sid,
-                    sdp_ratio,
-                    noise_scale,
-                    noise_scale_w,
-                    length_scale,
-                    speakerList,
-                    silenceTime,
-                    language,
-                    mode,
-                    skip_start,
-                    skip_end,
-                    style_text,
-                    style_weight,       
-                    )
-                if not torch.cuda.is_available():
-                    return result
-            return result
-    #url = f'{webBase[mode]}?text={text}&speaker={sid}&sdp_ratio={sdp_ratio}&noise_scale={noise_scale}&noise_scale_w={noise_scale_w}&length_scale={length_scale}&language={language}&skip_start={skip_start}&skip_end={skip_end}'
-    #print(url)
-    #res = requests.get(url)
-    #改用post
-    res = requests.post(webBase[mode], json = {
-        "groupSize": groupSize,
-        "filepath": filepath,
-        "silenceTime": silenceTime,
-        "speakerList": speakerList,
-        "text": text,
-        "speaker": sid,
-        "sdp_ratio": sdp_ratio,
-        "noise_scale": noise_scale,
-        "noise_scale_w": noise_scale_w,
-        "length_scale": length_scale,
-        "language": language,
-        "skip_start": skip_start,
-        "skip_end": skip_end,
-        "mode": mode,
-        "sentence_mode": sentence_mode,
-        "style_text": style_text,
-        "style_weight": style_weight
-    })
-    audio = res.content
-    with open('output.wav', 'wb') as code:
-        code.write(audio)
-    file_path = "output.wav"
-    return file_path
+    if is_chinese(text) or is_japanese(text):
+        if len(text) > 1:
+            language= 'JP' if is_japanese(text) else 'ZH'
+            bert, ja_bert, en_bert, phones, tones, lang_ids = get_text(
+                text,
+                language,
+                hps,
+                device,
+                style_text="",
+                style_weight=0,
+            )
+            with torch.no_grad():
+                x_tst = phones.to(device).unsqueeze(0)
+                tones = tones.to(device).unsqueeze(0)
+                lang_ids = lang_ids.to(device).unsqueeze(0)
+                bert = bert.to(device).unsqueeze(0)
+                ja_bert = ja_bert.to(device).unsqueeze(0)
+                en_bert = en_bert.to(device).unsqueeze(0)
+                x_tst_lengths = torch.LongTensor([phones.size(0)]).to(device)
+                # emo = emo.to(device).unsqueeze(0)
+                del phones
+                speakers = torch.LongTensor([hps.data.spk2id[sid]]).to(device)
+                audio = (
+                    net_g.infer(
+                        x_tst,
+                        x_tst_lengths,
+                        speakers,
+                        tones,
+                        lang_ids,
+                        bert,
+                        ja_bert,
+                        en_bert,
+                        sdp_ratio=sdp_ratio,
+                        noise_scale=noise_scale,
+                        noise_scale_w=noise_scale_w,
+                        length_scale=length_scale,
+                    )[0][0, 0]
+                    .data.cpu()
+                    .float()
+                    .numpy()
+                )
+                del (
+                    x_tst,
+                    tones,
+                    lang_ids,
+                    bert,
+                    x_tst_lengths,
+                    speakers,
+                    ja_bert,
+                    en_bert,
+                )  # , emo
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                return audio
 
 if __name__ == "__main__":
-    #download_unidic()
-    #tagger = Tagger()
+    languages = [ "Auto", "ZH", "JP"]
+    modelPaths = []
     for dirpath, dirnames, filenames in os.walk('Data/BangDream/models/'):
         for filename in filenames:
             modelPaths.append(os.path.join(dirpath, filename))
@@ -800,6 +355,7 @@ if __name__ == "__main__":
     with gr.Blocks() as app:
         gr.Markdown(value="""
             ([Bert-Vits2](https://github.com/Stardust-minus/Bert-VITS2) V2.3)少歌邦邦全员在线语音合成\n
+            镜像 [V2.2](https://huggingface.co/spaces/Mahiruoshi/MyGO_VIts-bert)\n
             [好玩的](http://love.soyorin.top/)\n
             该界面的真实链接(国内可用): https://mahiruoshi-bangdream-bert-vits2.hf.space/\n
             API: https://mahiruoshi-bert-vits2-api.hf.space/ \n
@@ -821,169 +377,36 @@ if __name__ == "__main__":
                                         f'<img style="width:auto;height:400px;" src="https://mahiruoshi-bangdream-bert-vits2.hf.space/file/image/{name}.png">' 
                                         '</div>'
                                     )
-                                with gr.Accordion(label="参数设定", open=False):
-                                    sdp_ratio = gr.Slider(
-                                    minimum=0, maximum=1, value=0.5, step=0.01, label="SDP/DP混合比"
-                                    )
-                                    noise_scale = gr.Slider(
-                                        minimum=0.1, maximum=2, value=0.6, step=0.01, label="Noise:感情调节"
-                                    )
-                                    noise_scale_w = gr.Slider(
-                                        minimum=0.1, maximum=2, value=0.667, step=0.01, label="Noise_W:音素长度"
-                                    )
-                                    skip_start = gr.Checkbox(label="skip_start")
-                                    skip_end = gr.Checkbox(label="skip_end")
-                                    speaker = gr.Dropdown(
-                                        choices=[name], value=name, label="说话人"
-                                    )
                                 length_scale = gr.Slider(
                                         minimum=0.1, maximum=2, value=1, step=0.01, label="语速调节"
                                     )
                                 language = gr.Dropdown(
-                                        choices=languages, value="Auto", label="语言选择,若不选自动则会将输入语言翻译为日语或中文"
-                                    )
-                                mode = gr.Dropdown(
-                                        choices=["pyopenjtalk-V2.3"], value="pyopenjtalk-V2.3", label="TTS模式，合成少歌角色需要切换成 pyopenjtalk-V2.3-Katakana "
-                                    )
-                                sentence_mode = gr.Dropdown(
-                                        choices=sentence_modes, value="sentence", label="文本合成模式"
-                                    )
-                                with gr.Accordion(label="扩展选项", open=False):
-                                    inputFile = gr.UploadButton(label="txt文件输入")
-                                    speakerList = gr.TextArea(
-                                        label="角色对应表,如果你记不住角色名可以这样,左边是你想要在每一句话合成中用到的speaker(见角色清单)右边是你上传文本时分隔符左边设置的说话人:{ChoseSpeakerFromConfigList}|{SeakerInUploadText}",
-                                        value = "ましろ|真白\n七深|七深\n透子|透子\nつくし|筑紫\n瑠唯|瑠唯\nそよ|素世\n祥子|祥子",
-                                    )
-                                    groupSize = gr.Slider(
-                                        minimum=10, maximum=1000 if  torch.cuda.is_available() else 50,value = 50, step=1, label="单个音频文件包含的最大句子数"
-                                    )
-                                    filepath = gr.TextArea(
-                                        label="本地合成时的音频存储文件夹(会清空文件夹,别把C盘删了)",
-                                        value = "D:/audiobook/book1",
-                                    )
-                                    silenceTime = gr.Slider(
-                                        minimum=0, maximum=1, value=0.5, step=0.01, label="句子的间隔"
-                                    )
-                                    modelstrs = gr.Dropdown(label = "模型", choices = modelPaths, value = modelPaths[0], type = "value")
-                                    btnMod = gr.Button("载入模型")
-                                    statusa = gr.TextArea(label = "模型加载状态")
-                                    btnMod.click(loadmodel, inputs=[modelstrs], outputs = [statusa])
-                            with gr.Column():
-                                text = gr.TextArea(
-                                        label="文本输入,可用'|'分割说话人和文本,注意换行",
-                                        info="输入纯日语或者中文",
-                                        placeholder=f"{name}|你觉得你是职业歌手吗\n真白|我觉得我是",
-                                        value=f"私は{name}です。 " 
-                                    )
-                                style_text = gr.Textbox(
-                                    label="情感辅助文本",
-                                    info="语言保持跟主文本一致,文本可以参考训练集:https://huggingface.co/spaces/Mahiruoshi/BangDream-Bert-VITS2/blob/main/filelists/Mygo.list)",
-                                    placeholder="使用辅助文本的语意来辅助生成对话（语言保持与主文本相同）\n\n"
-                        "**注意**：不要使用**指令式文本**（如：开心），要使用**带有强烈情感的文本**（如：我好快乐！！！）"
-                                                        )
-                                style_weight = gr.Slider(
-                                        minimum=0,
-                                        maximum=1,
-                                        value=0.7,
-                                        step=0.1,
-                                        label="Weight",
-                                        info="主文本和辅助文本的bert混合比率，0表示仅主文本，1表示仅辅助文本",
-                                    )
-                                btn = gr.Button("点击生成", variant="primary")
-                                audio_output = gr.Audio(label="Output Audio")
-                                btntran = gr.Button("快速中翻日")
-                                translateResult = gr.TextArea(label="使用百度翻译",placeholder="从这里复制翻译后的文本")
-                                btntran.click(translate, inputs=[text], outputs = [translateResult])
-                    btn.click(
-                        generate_audio,
-                        inputs=[
-                            inputFile,
-                            groupSize,
-                            filepath,
-                            silenceTime,
-                            speakerList,
-                            text,
-                            sdp_ratio,
-                            noise_scale,
-                            noise_scale_w,
-                            length_scale,
-                            speaker,
-                            style_text,
-                            style_weight,
-                            language,
-                            mode,
-                            sentence_mode,
-                            skip_start,
-                            skip_end
-                        ],
-                        outputs=[audio_output],
-                    )
-        for band in SchoolLilst:
-            with gr.TabItem(band):
-                for name in SchoolLilst[band]:
-                    with gr.TabItem(name):
-                        with gr.Row():
-                            with gr.Column():
-                                with gr.Row():
-                                    gr.Markdown(
-                                        '<div align="center">'
-                                        f'<img style="width:auto;height:400px;" src="https://mahiruoshi-bangdream-bert-vits2.hf.space/file/image/{name}.png">' 
-                                        '</div>'
+                                        choices=languages, value="Auto", label="语言"
                                     )
-                                with gr.Accordion(label="参数设定", open=False):
+                                with gr.Accordion(label="参数设定", open=True):
                                     sdp_ratio = gr.Slider(
                                     minimum=0, maximum=1, value=0.5, step=0.01, label="SDP/DP混合比"
                                     )
                                     noise_scale = gr.Slider(
-                                        minimum=0.1, maximum=2, value=0.6, step=0.01, label="Noise:感情调节"
+                                        minimum=0.1, maximum=2, value=0.6, step=0.01, label="感情调节"
                                     )
                                     noise_scale_w = gr.Slider(
-                                        minimum=0.1, maximum=2, value=0.667, step=0.01, label="Noise_W:音素长度"
+                                        minimum=0.1, maximum=2, value=0.667, step=0.01, label="音素长度"
                                     )
-                                    skip_start = gr.Checkbox(label="skip_start")
-                                    skip_end = gr.Checkbox(label="skip_end")
                                     speaker = gr.Dropdown(
-                                        choices=[name], value=name, label="说话人"
-                                    )
-                                length_scale = gr.Slider(
-                                        minimum=0.1, maximum=2, value=1, step=0.01, label="语速调节"
-                                    )
-                                language = gr.Dropdown(
-                                        choices=languages, value="Auto", label="语言选择,若不选自动则会将输入语言翻译为日语或中文"
-                                    )
-                                mode = gr.Dropdown(
-                                        choices=["pyopenjtalk-V2.3-Katakana"], value="pyopenjtalk-V2.3-Katakana", label="TTS模式，合成少歌角色需要切换成 pyopenjtalk-V2.3-Katakana "
-                                    )
-                                sentence_mode = gr.Dropdown(
-                                        choices=sentence_modes, value="sentence", label="文本合成模式"
-                                    )
-                                with gr.Accordion(label="扩展选项", open=False):
-                                    inputFile = gr.UploadButton(label="txt文件输入")
-                                    speakerList = gr.TextArea(
-                                        label="角色对应表,如果你记不住角色名可以这样,左边是你想要在每一句话合成中用到的speaker(见角色清单)右边是你上传文本时分隔符左边设置的说话人:{ChoseSpeakerFromConfigList}|{SeakerInUploadText}",
-                                        value = "ましろ|真白\n七深|七深\n透子|透子\nつくし|筑紫\n瑠唯|瑠唯\nそよ|素世\n祥子|祥子",
-                                    )
-                                    groupSize = gr.Slider(
-                                        minimum=10, maximum=1000 if  torch.cuda.is_available() else 50,value = 50, step=1, label="单个音频文件包含的最大句子数"
-                                    )
-                                    filepath = gr.TextArea(
-                                        label="本地合成时的音频存储文件夹(会清空文件夹,别把C盘删了)",
-                                        value = "D:/audiobook/book1",
-                                    )
-                                    silenceTime = gr.Slider(
-                                        minimum=0, maximum=1, value=0.5, step=0.01, label="句子的间隔"
-                                    )
+                                        choices=speakers, value=name, label="说话人"
+                                    ) 
+                                with gr.Accordion(label="切换模型", open=False):
                                     modelstrs = gr.Dropdown(label = "模型", choices = modelPaths, value = modelPaths[0], type = "value")
                                     btnMod = gr.Button("载入模型")
                                     statusa = gr.TextArea(label = "模型加载状态")
                                     btnMod.click(loadmodel, inputs=[modelstrs], outputs = [statusa])
                             with gr.Column():
                                 text = gr.TextArea(
-                                        label="文本输入,可用'|'分割说话人和文本,注意换行",
-                                        info="输入纯日语或者中文",
-                                        placeholder=f"{name}|你觉得你是职业歌手吗\n真白|我觉得我是",
-                                        value=f"私は{name}です。 " 
-                                    )
+                                    label="文本输入",
+                                    info="输入纯日语或者中文",
+                                    value="我是来结束这个乐队的。",
+                                )
                                 style_text = gr.Textbox(
                                     label="情感辅助文本",
                                     info="语言保持跟主文本一致,文本可以参考训练集:https://huggingface.co/spaces/Mahiruoshi/BangDream-Bert-VITS2/blob/main/filelists/Mygo.list)",
@@ -1003,14 +426,10 @@ if __name__ == "__main__":
                                 btntran = gr.Button("快速中翻日")
                                 translateResult = gr.TextArea(label="使用百度翻译",placeholder="从这里复制翻译后的文本")
                                 btntran.click(translate, inputs=[text], outputs = [translateResult])
+                                
                     btn.click(
-                        generate_audio,
+                        infer,
                         inputs=[
-                            inputFile,
-                            groupSize,
-                            filepath,
-                            silenceTime,
-                            speakerList,
                             text,
                             sdp_ratio,
                             noise_scale,
@@ -1020,12 +439,75 @@ if __name__ == "__main__":
                             style_text,
                             style_weight,
                             language,
-                            mode,
-                            sentence_mode,
-                            skip_start,
-                            skip_end
                         ],
                         outputs=[audio_output],
                     )
+        with gr.TabItem('少歌在2.2版本'):
+            gr.Markdown(value="""
+                <div align="center">
+                <iframe style="width:100%;height:400px;" src="https://mahiruoshi-mygo-vits-bert.hf.space/" frameborder="0"></iframe>'
+                </div>"""
+            )
+        with gr.Tab('拓展功能'):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown(
+                                    f"从 <a href='https://nijigaku.top/2023/10/03/BangDreamTTS/'>我的博客站点</a> 查看自制galgame使用说明\n</a>"
+                                )
+                    inputFile = gr.UploadButton(label="txt文件输入")
+                    raw_text = gr.TextArea(
+                                        label="文本输入",
+                                        info="输入纯日语或者中文",
+                                        value="つくし|我是来结束这个乐队的。",
+                    )
+                    groupSize = gr.Slider(
+                    minimum=10, maximum=1000 if  torch.cuda.is_available() else 50,value = 50, step=1, label="单个音频文件包含的最大字数"
+                    )
+                    silenceTime = gr.Slider(
+                    minimum=0, maximum=1, value=0.5, step=0.01, label="句子的间隔"
+                    )
+                    filepath = gr.TextArea(
+                                        label="本地合成时的音频存储文件夹(会清空文件夹)",
+                                        value = "D:/audiobook/book1",
+                    )
+                    spealerList = gr.TextArea(
+                                        label="角色对应表,左边是你想要在每一句话合成中用到的speaker(见角色清单)右边是你上传文本时分隔符左边设置的说话人:{ChoseSpeakerFromConfigList}|{SeakerInUploadText}",
+                                        placeholder = "ましろ|真白\n七深|七深\n透子|透子\nつくし|筑紫\n瑠唯|瑠唯\nそよ|素世\n祥子|祥子",
+                    )                  
+                    speaker = gr.Dropdown(
+                        choices=speakers, value = "ましろ", label="选择默认说话人"
+                    )
+                with gr.Column():
+                    sdp_ratio = gr.Slider(
+                    minimum=0, maximum=1, value=0.2, step=0.01, label="SDP/DP混合比"
+                    )
+                    noise_scale = gr.Slider(
+                        minimum=0.1, maximum=2, value=0.6, step=0.01, label="感情调节"
+                    )
+                    noise_scale_w = gr.Slider(
+                        minimum=0.1, maximum=2, value=0.667, step=0.01, label="音素长度"
+                    )
+                    length_scale = gr.Slider(
+                        minimum=0.1, maximum=2, value=1, step=0.01, label="生成长度"
+                    )
+                    LastAudioOutput = gr.Audio(label="当使用cuda时才能在本地文件夹浏览全部文件")
+                    btn2 = gr.Button("点击生成", variant="primary")
+                btn2.click(
+                    audiobook,
+                    inputs=[
+                        inputFile,
+                        groupSize,
+                        speaker,
+                        sdp_ratio,
+                        noise_scale,
+                        noise_scale_w,
+                        length_scale,
+                        spealerList,
+                        silenceTime,
+                        filepath,
+                        raw_text
+                    ],
+                    outputs=[LastAudioOutput],
+                )
     print("推理页面已开启!")
-    app.launch()
+    app.launch(share=True)