Update app.py

app.py

@@ -24,8 +24,6 @@ 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
 
@@ -42,42 +40,33 @@ from models import SynthesizerTrn
 from text.symbols import symbols
 import sys
 import re
-from tools.translate import translate
+
+import random
+import hashlib
 
 from fugashi import Tagger
 import jaconv
 import unidic
 import subprocess
 
-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.")
-
+import requests
 
-def kanji_to_hiragana(text):
-    global tagger
-    output = ""
-
-    # 更新正则表达式以更准确地区分文本和标点符号
-    segments = re.findall(r'[一-龥ぁ-んァ-ン\w]+|[^\一-龥ぁ-んァ-ン\w\s]', text, re.UNICODE)
+from ebooklib import epub
+import PyPDF2
+from PyPDF2 import PdfReader
+from bs4 import BeautifulSoup
+import jieba 
+import romajitable
 
-    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
+webBase = {
+    'pyopenjtalk-V2.3-Katakana': 'https://mahiruoshi-mygo-vits-bert.hf.space/',
+    'fugashi-V2.3-Katakana': 'https://mahiruoshi-mygo-vits-bert.hf.space/',
+}
 
-    return output
+languages = [ "Auto", "ZH", "JP"]
+modelPaths = []
+modes = ['pyopenjtalk-V2.3','fugashi-V2.3','pyopenjtalk-V2.3-Katakana','fugashi-V2.3-Katakana','onnx-V2.3']
+sentence_modes = ['sentence','paragraph']
 
 net_g = None
 
@@ -102,8 +91,354 @@ BandList = {
         "Morfonica":["ましろ","瑠唯","つくし","七深","透子"],
         "MyGo":["燈","愛音","そよ","立希","楽奈"],
         "AveMujica":["祥子","睦","海鈴","にゃむ","初華"],
+        "圣翔音乐学园":["華戀","光","香子","雙葉","真晝","純那","克洛迪娜","真矢","奈奈"],
+        "凛明馆女子学校":["珠緒","壘","文","悠悠子","一愛"],
+        "弗隆提亚艺术学校":["艾露","艾露露","菈樂菲","司","靜羽"],
+        "西克菲尔特音乐学院":["晶","未知留","八千代","栞","美帆"]
 }
 
+#翻译
+
+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),
@@ -158,7 +493,6 @@ 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,
@@ -169,12 +503,22 @@ def infer(
     style_text=None,
     style_weight=0.7,
     language = "Auto",
-    fugashi = True
+    mode = 'pyopenjtalk-V2.3',
+    skip_start=False,
+    skip_end=False,
 ):
-    if fugashi:
+    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,
@@ -183,6 +527,20 @@ 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)
@@ -225,186 +583,208 @@ def infer(
         )  # , emo
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
-        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
+    print("Success.")
+    return audio
 
 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,spealerList,silenceTime,language_force,fugashi = True):
+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,
+    ):
     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:
-            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':
-                text = (remove_annotations(sentence.split("|")[-1]).replace(" ","")+"。").replace("，。","。")
-                audio = infer_simple(
-                    text,
-                    sdp_ratio,
-                    noise_scale,
-                    noise_scale_w,
-                    length_scale,
-                    speaker,
-                    language_force,
-                    fugashi
-                )
-                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
+            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
         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, np.concatenate(audio_fin))
+    write(wav_filename, sampling_rate, gr.processing_utils.convert_to_16_bit_wav(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, np.concatenate(audio_fin))
-
-def audiobook(inputFile, groupsize, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale,spealerList,silenceTime,filepath,raw_text,language_force,fugashi):
-    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
-    if language_force == 'None':
-        sentences = extrac(extract_and_convert(text))
-    else:
-        sentences = extrac(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,language_force,fugashi)
-        if not torch.cuda.is_available():
-            return result
-    return result
-
-def infer_simple(
+    return (hps.data.sampling_rate, gr.processing_utils.convert_to_16_bit_wav(np.concatenate(audio_fin)))
+
+def generate_audio(
+    inputFile,
+    groupSize,
+    filepath,
+    silenceTime,
+    speakerList,
     text,
     sdp_ratio,
     noise_scale,
     noise_scale_w,
     length_scale,
     sid,
-    language_force = "None",
-    fugashi = True
+    style_text=None,
+    style_weight=0.7,
+    language = "Auto",
+    mode = 'pyopenjtalk-V2.3',
+    sentence_mode = 'sentence',
+    skip_start=False,
+    skip_end=False,
 ):
-    
-    if language_force == "JP":
-        text = translate(text,"jp")
-    if language_force == "ZH":
-        text = translate(text,"zh")
-    if fugashi:
-        text = kanji_to_hiragana(text) if is_japanese(text) else text
-    print(text)
-    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 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 __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))
@@ -412,12 +792,14 @@ if __name__ == "__main__":
     net_g = get_net_g(
         model_path="Data/BangDream/models/G_1536000.pth", device=device, hps=hps
     )
+    net_g = get_net_g(
+        model_path=modelPaths[-1], device=device, hps=hps
+    )
     speaker_ids = hps.data.spk2id
     speakers = list(speaker_ids.keys())
     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
@@ -439,37 +821,60 @@ if __name__ == "__main__":
                                         f'<img style="width:auto;height:400px;" src="https://mahiruoshi-bangdream-bert-vits2.hf.space/file/image/{name}.png">' 
                                         '</div>'
                                     )
-                                length_scale = gr.Slider(
-                                        minimum=0.1, maximum=2, value=1, step=0.01, label="语速调节"
-                                    )
-                                language = gr.Dropdown(
-                                        choices=languages, value="Auto", label="语言"
-                                    )
-                                fugashi = gr.Checkbox(label="转化为片假名")
-                                with gr.Accordion(label="参数设定", open=True):
+                                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="感情调节"
+                                        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="音素长度"
+                                        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=speakers, value=name, label="说话人"
-                                    ) 
-                                with gr.Accordion(label="切换模型", open=False):
+                                    )
+                                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=modes, value="fugashi-V2.3", label="TTS模式"
+                                    )
+                                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="输入纯日语或者中文",
-                                    value="我是来结束这个乐队的。",
-                                )
+                                        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)",
@@ -489,10 +894,14 @@ if __name__ == "__main__":
                                 btntran = gr.Button("快速中翻日")
                                 translateResult = gr.TextArea(label="使用百度翻译",placeholder="从这里复制翻译后的文本")
                                 btntran.click(translate, inputs=[text], outputs = [translateResult])
-                                
                     btn.click(
-                        infer,
+                        generate_audio,
                         inputs=[
+                            inputFile,
+                            groupSize,
+                            filepath,
+                            silenceTime,
+                            speakerList,
                             text,
                             sdp_ratio,
                             noise_scale,
@@ -502,82 +911,12 @@ if __name__ == "__main__":
                             style_text,
                             style_weight,
                             language,
-                            fugashi
+                            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="筑紫|我是来结束这个乐队的。",
-                    )
-                    language_force = gr.Dropdown(
-                                        choices=[ "None", "ZH", "JP"], value="None", label="将文本翻译为目标语言"
-                    )
-                    fugashi = gr.Checkbox(label="转化为片假名")
-                    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}",
-                                        value = "ましろ|真白\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.5, 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,
-                        language_force,
-                        fugashi
-                    ],
-                    outputs=[LastAudioOutput],
-                )
     print("推理页面已开启!")
     app.launch()