Update server.py

server.py

@@ -3,7 +3,6 @@ import os
 from pathlib import Path
 
 import logging
-import uuid
 import re_matching
 
 logging.getLogger("numba").setLevel(logging.WARNING)
@@ -16,8 +15,7 @@ logging.basicConfig(
 )
 
 logger = logging.getLogger(__name__)
-import shutil
-from scipy.io.wavfile import write
+
 import librosa
 import numpy as np
 import torch
@@ -25,6 +23,11 @@ import torch.nn as nn
 from torch.utils.data import Dataset
 from torch.utils.data import DataLoader, Dataset
 from tqdm import tqdm
+from clap_wrapper import get_clap_audio_feature, get_clap_text_feature
+
+import uuid
+from flask import Flask, request, jsonify, render_template_string
+from flask_cors import CORS
 
 import gradio as gr
 
@@ -40,28 +43,9 @@ import utils
 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
-
-from flask import Flask, request, jsonify, render_template_string, send_file
-from flask_cors import CORS
 from scipy.io.wavfile import write
+from threading import Thread
+
 net_g = None
 
 device = (
@@ -91,359 +75,6 @@ BandList = {
         "西克菲尔特音乐学院":["晶","未知留","八千代","栞","美帆"]
 }
 
-webBase = 'https://mahiruoshi-bangdream-bert-vits2.hf.space/'
-
-port = 8080
-
-languages = [ "Auto", "ZH", "JP"]
-modelPaths = []
-modes = ['pyopenjtalk-V2.3-Katakana','fugashi-V2.3-Katakana','pyopenjtalk-V2.3-Katakana-Katakana','fugashi-V2.3-Katakana-Katakana','onnx-V2.3']
-sentence_modes = ['sentence','paragraph']
-for dirpath, dirnames, filenames in os.walk('Data/BangDream/models/'):
-    for filename in filenames:
-        modelPaths.append(os.path.join(dirpath, filename))
-hps = utils.get_hparams_from_file('Data/BangDream/config.json')
-
-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),
@@ -498,6 +129,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,
@@ -507,23 +139,9 @@ def infer(
     sid,
     style_text=None,
     style_weight=0.7,
-    language = "Auto",
-    mode = 'pyopenjtalk-V2.3-Katakana',
-    skip_start=False,
-    skip_end=False,
 ):
-    if style_text == None:
-        style_text = ""
-        style_weight=0,
-    if mode == 'fugashi-V2.3-Katakana':
-        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}')            
+
+    language= 'JP' if is_japanese(text) else 'ZH'
     bert, ja_bert, en_bert, phones, tones, lang_ids = get_text(
         text,
         language,
@@ -532,20 +150,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)
@@ -588,105 +192,9 @@ 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 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,
-    ):
-    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
-        """
-
-    for sentence in group:
-
-            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-Katakana' or mode == 'fugashi-V2.3-Katakana':
-                        #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
-
-    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)))
-
-    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)))
-
-def generate_audio(
-    inputFile,
-    groupsize,
-    filepath,
-    silenceTime,
-    speakerList,
+def inferAPI(
     text,
     sdp_ratio,
     noise_scale,
@@ -695,173 +203,120 @@ def generate_audio(
     sid,
     style_text=None,
     style_weight=0.7,
-    language = "Auto",
-    mode = 'pyopenjtalk-V2.3-Katakana',
-    sentence_mode = 'sentence',
-    skip_start=False,
-    skip_end=False,
 ):
-    if mode == 'pyopenjtalk-V2.3-Katakana' or mode == 'fugashi-V2.3-Katakana':
-        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 inputFile:
-                text = extract_text_from_file(inputFile.name)
-            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
+
+    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_text,
+        style_weight=style_weight,
+    )
+    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()
+        unique_filename = f"temp{uuid.uuid4()}.wav"
+        write(unique_filename, 44100, audio)
+        return unique_filename
+
+def is_japanese(string):
+        for ch in string:
+            if ord(ch) > 0x3040 and ord(ch) < 0x30FF:
+                return True
+        return False
+
+def loadmodel(model):
+    try:
+        _ = net_g.eval()
+        _ = utils.load_checkpoint(model, net_g, None, skip_optimizer=True)
+        return "success"
+    except:
+        return "error"
 
 Flaskapp = Flask(__name__)
 CORS(Flaskapp)
-@Flaskapp.route('/', methods=['GET', 'POST'])
+@Flaskapp.route('/')
+
+@Flaskapp.route('/')
 
 def tts():
-    if request.method == 'POST':
-        input = request.json 
-        inputFile = None
-        filepath = input['filepath']
-        groupSize = input['groupSize']
-        text = input['text']
-        sdp_ratio = input['sdp_ratio']
-        noise_scale = input['noise_scale']
-        noise_scale_w = input['noise_scale_w']
-        length_scale = input['length_scale']
-        sid = input['speaker']
-        style_text = input['style_text']
-        style_weight = input['style_weight']
-        language = input['language']
-        mode = input['mode']
-        sentence_mode = input['sentence_mode']
-        skip_start = input['skip_start']
-        skip_end = input['skip_end']
-        speakerList = input['speakerList']
-        silenceTime = input['silenceTime']
-        samplerate, audio = generate_audio(
-                inputFile,
-                groupSize,
-                filepath,
-                silenceTime,
-                speakerList,
-                text,
-                sdp_ratio,
-                noise_scale,
-                noise_scale_w,
-                length_scale,
-                sid,
-                style_text,
-                style_weight,
-                language,
-                mode,
-                sentence_mode,
-                skip_start,
-                skip_end,
-            )
-        unique_filename = f"temp{uuid.uuid4()}.wav"
-        write(unique_filename, samplerate, audio)
-        with open(unique_filename ,'rb') as bit:
-            wav_bytes = bit.read()
-        os.remove(unique_filename)
-        headers = {
-                'Content-Type': 'audio/wav',
-                'Text': unique_filename .encode('utf-8')}
-        return wav_bytes, 200, headers
-    groupSize = request.args.get('groupSize', default = 50, type = int)
-    text = request.args.get('text', default = '', type = str)
-    sdp_ratio = request.args.get('sdp_ratio', default = 0.5, type = float)
-    noise_scale = request.args.get('noise_scale', default = 0.6, type = float)
-    noise_scale_w = request.args.get('noise_scale_w', default = 0.667, type = float)
-    length_scale = request.args.get('length_scale', default = 1, type = float)
-    sid = request.args.get('speaker', default = '八千代', type = str)
-    style_text = request.args.get('style_text', default = '', type = str)
-    style_weight = request.args.get('style_weight', default = 0.7, type = float)
-    language = request.args.get('language', default = 'Auto', type = str)
-    mode = request.args.get('mode', default = 'pyopenjtalk-V2.3-Katakana', type = str)
-    sentence_mode = request.args.get('sentence_mode', default = 'sentence', type = str)
-    skip_start = request.args.get('skip_start', default = False, type = bool)
-    skip_end = request.args.get('skip_end', default = False, type = bool)
-    speakerList = request.args.get('speakerList', default = '', type = str)
-    silenceTime = request.args.get('silenceTime', default = 0.1, type = float)
-    inputFile = None
-    if not sid or not text:
-        return render_template_string(f"""
-                            <!DOCTYPE html>
-                            <html>
-                            <head>
-                                <title>TTS API Documentation</title>
-                            </head>
-                            <body>
-                                <iframe src={webBase} style="width:100%; height:100vh; border:none;"></iframe>
-                            </body>
-                            </html>
-                        """)
-    samplerate, audio = generate_audio(
-                inputFile,
-                groupSize,
-                None,
-                silenceTime,
-                speakerList,
-                text,
-                sdp_ratio,
-                noise_scale,
-                noise_scale_w,
-                length_scale,
-                sid,
-                style_text,
-                style_weight,
-                language,
-                mode,
-                sentence_mode,
-                skip_start,
-                skip_end,
-            )
-    unique_filename = f"temp{uuid.uuid4()}.wav"
-    write(unique_filename, samplerate, audio)
+    global last_text, last_model
+    speaker = request.args.get('speaker')
+    sdp_ratio = float(request.args.get('sdp_ratio', 0.2))
+    noise_scale = float(request.args.get('noise_scale', 0.6))
+    noise_scale_w = float(request.args.get('noise_scale_w', 0.8))
+    length_scale = float(request.args.get('length_scale', 1))
+    style_weight = float(request.args.get('style_weight', 0.7))
+    style_text = request.args.get('style_text', 'happy')
+    text = request.args.get('text')
+    is_chat = request.args.get('is_chat', 'false').lower() == 'true'
+    model = request.args.get('model',modelPaths[-1])
+    
+    if not speaker or not text:
+        return render_template_string("""
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <title>TTS API Documentation</title>
+            </head>
+            <body>
+                <iframe src="http://127.0.0.1:7860" style="width:100%; height:100vh; border:none;"></iframe>
+            </body>
+            </html>
+        """)
+    
+    if model != last_model:
+        unique_filename  = loadmodel(model)
+        last_model = model
+    if is_chat and text == last_text:
+        # Generate 1 second of silence and return
+        unique_filename = 'blank.wav'
+        silence = np.zeros(44100, dtype=np.int16)
+        write(unique_filename , 44100, silence)
+    else:
+        last_text = text
+        unique_filename  = inferAPI(text, sdp_ratio=sdp_ratio, noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale,sid = speaker, style_text=style_text, style_weight=style_weight)
     with open(unique_filename ,'rb') as bit:
         wav_bytes = bit.read()
     os.remove(unique_filename)
@@ -870,15 +325,97 @@ def tts():
             'Text': unique_filename .encode('utf-8')}
     return wav_bytes, 200, headers
 
+def gradio_interface():
+    return app.launch(share=True)
 
 if __name__ == "__main__":
-    download_unidic()
-    tagger = Tagger()
+    languages = [ "Auto", "ZH", "JP"]
+    modelPaths = []
+    for dirpath, dirnames, filenames in os.walk('Data/Chinese/models/'):
+        for filename in filenames:
+            modelPaths.append(os.path.join(dirpath, filename))
+    hps = utils.get_hparams_from_file('Data/Chinese/config.json')
     net_g = get_net_g(
         model_path=modelPaths[-1], device=device, hps=hps
     )
     speaker_ids = hps.data.spk2id
     speakers = list(speaker_ids.keys())
-    
+    last_text = ""
+    last_model = modelPaths[-1]
+    with gr.Blocks() as app:
+        for band in BandList:
+            with gr.TabItem(band):
+                for name in BandList[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>'
+                                    )
+                                length_scale = gr.Slider(
+                                        minimum=0.1, maximum=2, value=1, step=0.01, label="语速调节"
+                                    )
+                                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_scale_w = gr.Slider(
+                                        minimum=0.1, maximum=2, value=0.667, step=0.01, label="音素长度"
+                                    )
+                                    speaker = gr.Dropdown(
+                                        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()
+                                    btnMod.click(loadmodel, inputs=[modelstrs], outputs = [statusa])
+                            with gr.Column():
+                                text = gr.TextArea(
+                                    label="输入纯日语或者中文",
+                                    placeholder="输入纯日语或者中文",
+                                    value="为什么要演奏春日影!",
+                                )
+                                style_text = gr.Textbox(label="辅助文本")
+                                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("从这复制翻译后的文本")
+                                btntran.click(translate, inputs=[text], outputs = [translateResult])
+                                '''
+                    btn.click(
+                        infer,
+                        inputs=[
+                            text,
+                            sdp_ratio,
+                            noise_scale,
+                            noise_scale_w,
+                            length_scale,
+                            speaker,
+                            style_text,
+                            style_weight,
+                        ],
+                        outputs=[audio_output],
+                    )
+
+    api_thread = Thread(target=Flaskapp.run, args=("0.0.0.0", 8000))
+    gradio_thread = Thread(target=gradio_interface)
+    gradio_thread.start()
     print("推理页面已开启!")
-    Flaskapp.run(host="0.0.0.0", port=8080,debug=True)
+    api_thread.start()
+    print("api页面已开启!运行在8000端口")