Upload app.py with huggingface_hub

app.py

@@ -1,3 +1,34 @@
+# ```python
+#!/usr/bin/env python3
+"""
+ChatTTS Gradio 应用 - 改编为使用 ChatterboxTTS
+适配 Hugging Face Spaces 运行环境
+基于 Chatterbox-TTS 实现: https://huggingface.co/spaces/ResembleAI/Chatterbox
+"""
+
+import os
+import random
+import argparse
+import torch
+import numpy as np
+import gradio as gr
+from scipy.io.wavfile import write
+import logging
+from pathlib import Path
+import sys
+import re
+import subprocess
+from textblob import TextBlob
+import pandas as pd
+import base64
+import threading
+import io
+import zipfile
+import shutil
+import math
+from queue import Queue
+from pydub import AudioSegment
+import tempfile
 import json
 import os
 import sys
@@ -18,15 +49,16 @@ parser.add_argument("--port", type=int, default=7860, help="Port to run the web
 parser.add_argument("--host", type=str, default="127.0.0.1", help="Host to run the web UI on")  # WebUI 主机地址
 parser.add_argument("--model_dir", type=str, default="checkpoints", help="Model checkpoints directory")  # 模型目录
 cmd_args = parser.parse_args()
+model_dir="checkpoints"
 
 # ----------------- 设置模块搜索路径 -----------------
 current_dir = os.path.dirname(os.path.abspath(__file__))
 sys.path.append(current_dir)
 sys.path.append(os.path.join(current_dir, "indextts"))
 
-# ----------------- 下载模型 -----------------
-MODE = 'local'
-snapshot_download("IndexTeam/IndexTTS-1.5", local_dir="checkpoints")  # 从 Hugging Face 下载模型到本地
+# # ----------------- 下载模型 -----------------
+# MODE = 'local'
+# snapshot_download("IndexTeam/IndexTTS-1.5", local_dir="checkpoints")  # 从 Hugging Face 下载模型到本地
 
 # ----------------- 检查模型文件完整性 -----------------
 if not os.path.exists(cmd_args.model_dir):
@@ -43,6 +75,45 @@ for file in [
     if not os.path.exists(file_path):
         print(f"Required file {file_path} does not exist. Please download it.")
         sys.exit(1)
+def analyze_sentiment(text):
+    """使用 TextBlob 分析文本情感，返回优化后的 IndexTTS 参数字典"""
+    try:
+        blob = TextBlob(text)
+        polarity = blob.sentiment.polarity  # -1 (负面) ~ 1 (正面)
+        subjectivity = blob.sentiment.subjectivity  # 0 (客观) ~ 1 (主观)
+
+        # temperature: 正面高 (生动)，负面低 (平淡)；范围 0.5~1.5
+        temperature = 1.0 + math.tanh(polarity) * 0.9  # 0.5 ~ 1.5
+        # top_p: 主观高 (多样)，客观低 (保守)；范围 0.7~0.95
+        top_p = 0.7 + subjectivity * 0.25
+        # top_k: 主观高 (创意)，但固定上限；范围 20~50
+        top_k = int(20 + subjectivity * 30)
+        # repetition_penalty: 客观高 (避免重复)，主观低 (允许强调)；范围 5.0~15.0
+        repetition_penalty = 10.0 + (1 - subjectivity) * 5.0 - polarity * 2.0
+        # length_penalty: 正面正 (长表达)，负面负 (短)；范围 -1.0~1.0
+        length_penalty = math.tanh(polarity) * 1.0
+        # num_beams: 正面高 (自然)，但固定以控制速度；范围 2~5
+        num_beams = int(2 + (polarity + 1) * 1.5)
+
+        return {
+            "temperature": max(0.3, min(2, temperature)),
+            "top_p": max(0.7, min(0.95, top_p)),
+            "top_k": max(20, min(50, top_k)),
+            "repetition_penalty": max(5.0, min(15.0, repetition_penalty)),
+            "length_penalty": max(-1.0, min(1.0, length_penalty)),
+            "num_beams": max(2, min(5, num_beams))
+        }
+    except Exception as e:
+        print(f"情感分析失败: {str(e)}")
+        return {  # 默认值
+            "temperature": 1.0,
+            "top_p": 0.8,
+            "top_k": 30,
+            "repetition_penalty": 10.0,
+            "length_penalty": 0.0,
+            "num_beams": 3
+        }
+
 
 # ----------------- 导入 Gradio 和其他模块 -----------------
 import gradio as gr
@@ -52,12 +123,12 @@ from indextts.infer import IndexTTS  # 核心 TTS 推理类
 from tools.i18n.i18n import I18nAuto  # 国际化工具
 
 # ----------------- 初始化 TTS 模型 -----------------
-i18n = I18nAuto(language="zh_CN")  # 设置默认中文
+i18n = I18nAuto(language="en")  # 设置默认中文
 tts = IndexTTS(model_dir=cmd_args.model_dir, cfg_path=os.path.join(cmd_args.model_dir, "config.yaml"))  # 加载模型
 
-# ----------------- 创建输出目录 -----------------
-os.makedirs("outputs/tasks", exist_ok=True)
-os.makedirs("prompts", exist_ok=True)
+# # ----------------- 创建输出目录 -----------------
+# os.makedirs("outputs/tasks", exist_ok=True)
+# os.makedirs("prompts", exist_ok=True)
 
 # ----------------- 核心函数 -----------------
 
@@ -73,142 +144,888 @@ def ensure_wav(file_path):
         return wav_path
     return file_path
 
-def progress_print(step, total, info=""):
-    """
-    打印生成音频的进度到终端
-    step: 当前步骤
-    total: 总步骤数
-    info: 附加信息
-    """
-    percent = int(step / total * 100)
-    print(f"\r[{percent}%] {info}", end="", flush=True)
+# def progress_print(step, total, info=""):
+#     """
+#     ��印生成音频的进度到终端
+#     step: 当前步骤
+#     total: 总步骤数
+#     info: 附加信息
+#     """
+#     percent = int(step / total * 100)
+#     print(f"\r[{percent}%] {info}", end="", flush=True)
 
-def gen_single(prompt, text, max_text_tokens_per_sentence=120, *args, progress=gr.Progress()):
-    """
-    单句音频生成函数
-    prompt: 参考音频路径
-    text: 目标文本
-    max_text_tokens_per_sentence: 分句最大 Token 数
-    *args: 高级生成参数（do_sample, top_p, top_k, temperature 等）
-    progress: Gradio 进度条对象
-
-    返回生成的音频路径
-    """
-    prompt = ensure_wav(prompt)  # 转换为 WAV
-    output_path = os.path.join("outputs", f"spk_{int(time.time())}.wav")  # 输出文件名
-    tts.gr_progress = progress
-    tts.print_progress = progress_print  # 设置进度打印函数
-
-    # 解包高级参数
-    do_sample, top_p, top_k, temperature, \
-        length_penalty, num_beams, repetition_penalty, max_mel_tokens = args
-    kwargs = {
-        "do_sample": bool(do_sample),                # 是否启用随机采样，True生成多样化音频，False贪婪生成固定结果
-        "top_p": float(top_p),                       # 核采样概率阈值，只从累计概率 >= top_p 的词集合中采样，值越大生成越自由
-        "top_k": int(top_k) if int(top_k) > 0 else None,  # 从概率最高的 top_k 个词中采样，None表示不限制，值越大多样性越高
-        "temperature": float(temperature),           # 采样温度，值越高随机性越大，值越低生成更确定平稳
-        "length_penalty": float(length_penalty),     # 长度惩罚，正值鼓励生成更长序列，负值鼓励生成更短序列
-        "num_beams": num_beams,                      # Beam Search 的束宽，值越大生成越平滑自然，但速度慢
-        "repetition_penalty": float(repetition_penalty),  # 重复惩罚，值越大重复可能性越低
-        "max_mel_tokens": int(max_mel_tokens),       # 最大 mel 频谱长度，控制生成音频最大帧数，值越大生成音频越长，占用显存越多
-    }
 
-    # 调用 TTS 推理
-    output = tts.infer(prompt, text, output_path, verbose=cmd_args.verbose,
-                       max_text_tokens_per_sentence=int(max_text_tokens_per_sentence),
-                       **kwargs)
+# 设置日志
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# 全局变量用于存储最后上传的文件
+last_uploaded_file = None
+
+# 全局取消标志
+cancel_generation = threading.Event()
+
+# 全局生成状态和队列
+is_generating = threading.Event()
+generation_queue = []  # 存储 {'role_index': i, 'txt': str, 'start_idx': int, 'spk_emb_seed_id': str, 'ref_wav': str}
+queued_roles = set()
+
+# 存储每个角色的 make_bulk 函数
+make_bulk_functions = [None] * 40
+
+# 临时目录用于缓存音频
+audio_cache_dir = tempfile.mkdtemp(prefix='audio_cache_')
 
-    print("\n生成完成:", output_path)
-    return gr.update(value=output, visible=True)
+# 在脚本启动时清空缓存文件夹
+def clear_audio_cache_dir():
+    """清空或重新创建 audio_cache_dir"""
+    global audio_cache_dir
+    try:
+        if os.path.exists(audio_cache_dir):
+            shutil.rmtree(audio_cache_dir)
+            print(f"\033[92m✅ 已清空缓存文件夹: {audio_cache_dir}\033[0m")
+        os.makedirs(audio_cache_dir)
+        print(f"\033[92m✅ 创建新的缓存文件夹: {audio_cache_dir}\033[0m")
+    except Exception as e:
+        print(f"\033[91m❌ 清空缓存文件夹失败: {str(e)}\033[0m")
 
-def update_prompt_audio():
+# Monkey patch torch.load 以处理设备映射
+original_torch_load = torch.load
+
+def patched_torch_load(f, map_location=None, **kwargs):
     """
-    上传参考音频时触发
-    激活生成按钮
+    修补后的 torch.load，自动将 CUDA 张量映射到 CPU/CUDA
     """
-    return gr.update(interactive=True)
-
-# ----------------- Gradio WebUI 构建 -----------------
-with gr.Blocks(title="IndexTTS Demo") as demo:
-    mutex = threading.Lock()
-    gr.HTML('''
-    标题
-    ''')
-    with gr.Tab("音频生成"):
+    if map_location is None:
+        map_location = 'cpu'
+    logger.info(f"🔧 使用 map_location={map_location} 加载")
+    return original_torch_load(f, map_location=map_location, **kwargs)
+
+# 在 torch 导入后立即应用补丁
+torch.load = patched_torch_load
+if 'torch' in sys.modules:
+    sys.modules['torch'].load = patched_torch_load
+
+logger.info("✅ 成功应用 torch.load 设备映射补丁")
+
+# 设备检测，适配 Hugging Face Spaces
+if torch.cuda.is_available():
+    DEVICE = "cuda"
+    logger.info("🚀 使用 CUDA GPU 运行")
+else:
+    DEVICE = "cpu"
+    logger.info("🚀 使用 CPU 运行")
+
+print(f"🚀 在设备上运行: {DEVICE}")
+
+# 全局模型变量
+MODEL = True
+
+def get_or_load_model():
+    """加载 ChatterboxTTS 模型（如果尚未加载），并确保其在正确的设备上运行"""
+    global MODEL, DEVICE
+    if MODEL is None:
+        print("模型未加载，正在初始化...")
+        try:
+            # 优先尝试官方导入路径
+            try:
+                from chatterbox.src.chatterbox.tts import ChatterboxTTS
+                logger.info("✅ 使用官方 chatterbox.src 导入路径")
+            except ImportError:
+                # 回退到备用导入路径
+                from chatterbox import ChatterboxTTS
+                logger.info("✅ 使用 chatterbox 直接导入路径")
+            
+            # 先将模型加载到 CPU 以避免设备问题
+            MODEL = ChatterboxTTS.from_pretrained("cpu")
+            
+            # 如果是 CUDA，移动到目标设备
+            if DEVICE == "cuda":
+                logger.info(f"将模型组件移动到 {DEVICE}...")
+                try:
+                    if hasattr(MODEL, 't3'):
+                        MODEL.t3 = MODEL.t3.to(DEVICE)
+                    if hasattr(MODEL, 's3gen'):
+                        MODEL.s3gen = MODEL.s3gen.to(DEVICE)
+                    if hasattr(MODEL, 've'):
+                        MODEL.ve = MODEL.ve.to(DEVICE)
+                    
+                    MODEL.device = DEVICE
+                    logger.info(f"✅ 所有模型组件已移动到 {DEVICE}")
+                except Exception as e:
+                    logger.warning(f"⚠️ 无法将某些组件移动到 {DEVICE}: {e}")
+                    logger.info("🔄 为确保稳定性回退到 CPU 模式")
+                    DEVICE = "cpu"
+                    MODEL.device = "cpu"
+            
+            logger.info(f"✅ 模型在 {DEVICE} 上加载成功")
+            return MODEL, "模型加载成功"
+            
+        except Exception as e:
+            logger.error(f"❌ 加载模型失败: {e}")
+            return None, f"模型加载失败: {str(e)}"
+    return MODEL, "模型已加载"
+
+def parse_role_mappings(mapping_text):
+    """解析角色映射文本，返回 {角色代号: {'display_name': 显示名, 'voice_file': 'xxx.wav', 'seed_id': seed_id}} 字典"""
+    role_map = {}
+    if not mapping_text:
+        return role_map
+    lines = mapping_text.strip().splitlines()
+    pattern = re.compile(r'角色代号:\s*(\w+)\s*→\s*显示名:\s*([^→]+?)(?:\s+voice:\s*([\w_-]+))?(?:\s+seed_id:\s*(\w+))?\s*$')
+    
+    for line in lines:
+        match = pattern.match(line.strip())
+        if match:
+            role_code = match.group(1).strip()
+            display_name = match.group(2).strip()
+            voice_name = match.group(3).strip() if match.group(3) else None
+            seed_id = match.group(4).strip() if match.group(4) else None
+            
+            voice_file = None
+            if voice_name:
+                voice_file = voice_name + ".wav"
+                
+            role_map[role_code] = {'display_name': display_name, 'voice_file': voice_file, 'seed_id': seed_id}
+    
+    return role_map
+
+def filter_lines(lines, filter_text):
+    """根据筛选条件过滤对话行"""
+    if not filter_text:
+        return lines
+    filtered = []
+    conditions = filter_text.strip().split(';')
+    for line in lines:
+        include = True
+        for condition in conditions:
+            condition = condition.strip()
+            if not condition:
+                continue
+            if condition.startswith('min_len='):
+                try:
+                    min_len = int(condition.split('=')[1])
+                    if len(re.sub(r'[^A-Za-z0-9]', '', line)) < min_len:
+                        include = False
+                except ValueError:
+                    print(f"警告: 无效的 min_len 条件: {condition}")
+            elif condition.startswith('keyword='):
+                keyword = condition.split('=')[1].lower()
+                if keyword not in line.lower():
+                    include = False
+            else:
+                print(f"警告: 未知筛选条件: {condition}")
+        if include:
+            filtered.append(line)
+    return filtered
+
+def parse_roles_from_rpy_file(file_bytes, filter_text=""):
+    try:
+        lines = file_bytes.decode("utf-8").splitlines()
+        role_pattern = re.compile(r'^#\s*(?:(\w+)\s*)?\"(.*?)\"')
+        role_dict = {}
+
+        for line in lines:
+            match = role_pattern.match(line.strip())
+            if match:
+                role = match.group(1) if match.group(1) else 'noname'
+                content = match.group(2)
+                if '(' in content or ')' in content:
+                    continue
+                content = re.sub(r'\[.*?\]', ',', content)
+                content = re.sub(r'\{.*?\}', '', content)
+                content = re.sub(r'\\', '', content)
+                content = re.sub(r'\*.*?\*', '', content)
+                content = re.sub(r'\s+', ' ', content).strip()
+                if len(content) < 2:
+                    continue
+                if role not in role_dict:
+                    role_dict[role] = []
+                role_dict[role].append(content)
+
+        for role in role_dict:
+            role_dict[role] = filter_lines(role_dict[role], filter_text)
+
+        return role_dict, lines
+    except Exception as e:
+        raise ValueError(f"解析 .rpy 文件失败: {str(e)}")
+
+def save_wav(audio_data, sample_rate, output_path):
+    try:
+        if audio_data.dtype != np.int16:
+            audio_int16 = np.clip(audio_data * 32767, -32768, 32767).astype(np.int16)
+        else:
+            audio_int16 = audio_data
+        write(output_path, sample_rate, audio_int16)
+    except Exception as e:
+        raise RuntimeError(f"保存音频文件失败: {str(e)}")
+
+# def analyze_sentiment(text):
+#     """使用 TextBlob 分析文本情感，返回 temperature, cfg_weight 和 exaggeration 参数"""
+#     try:
+#         blob = TextBlob(text)
+#         polarity = blob.sentiment.polarity
+#         subjectivity = blob.sentiment.subjectivity
+
+#         temperature = 0.5 + math.tanh(polarity) * 0.75
+#         temperature = max(0.05, min(2.0, temperature))
+
+#         cfg_weight = 0.5 + (1 - subjectivity) * 0.45
+#         cfg_weight = max(0.1, min(1.0, cfg_weight))
+
+#         exaggeration = 0.55 + math.tanh(polarity) * 0.45
+#         exaggeration = max(0.1, min(1.0, exaggeration))
+
+#         return temperature, cfg_weight, exaggeration
+#     except Exception as e:
+#         print(f"情感分析失败: {str(e)}")
+#         return 0.3, 0.5, 0.25
+def pre_analyze_lines(texts):
+    """为每行文本分析情感，返回参数字典列表"""
+    context_window = 2
+    params_list = []
+    for idx, line in enumerate(texts):
+        if not line.strip():
+            params_list.append({
+                "temperature": 1.0,
+                "top_p": 0.8,
+                "top_k": 30,
+                "repetition_penalty": 10.0,
+                "length_penalty": 0.0,
+                "num_beams": 3
+            })
+            continue
+        start_idx = max(0, idx - context_window)
+        end_idx = min(len(texts), idx + context_window + 1)
+        context_text = " ".join(texts[start_idx:end_idx])
+        params = analyze_sentiment(context_text)
+        params_list.append(params)
+    return params_list
+
+def get_pt_file(seed_id, csv_path=os.path.join(os.path.dirname(__file__), "evaluation_results.csv")):
+    """根据 seed_id 从 CSV 文件获取 .pt 数据并加载为 PyTorch tensor"""
+    try:
+        if seed_id and not seed_id.startswith("seed_"):
+            seed_id = f"seed_{seed_id}"
+        
+        df = pd.read_csv(csv_path, encoding="utf-8")
+        row = df[df["seed_id"] == seed_id]
+        if row.empty:
+            return None, f"未找到 seed_id: {seed_id}"
+        
+        emb_data = row.iloc[0]["emb_data"]
+        emb_bytes = base64.b64decode(emb_data)
+        emb_buffer = io.BytesIO(emb_bytes)
+        spk_emb = torch.load(emb_buffer)
+        
+        return spk_emb, f"成功加载 seed_id: {seed_id} 的 spk_emb 数据"
+    except Exception as e:
+        return None, f"加载 spk_emb 数据失败: {str(e)}"
+
+def zip_outputs_folder():
+    try:
+        outputs_dir = "Outputs"
+        zip_path = os.path.join("tmp", "outputs.zip")
+        os.makedirs("tmp", exist_ok=True)
+        
+        if os.path.exists(outputs_dir) and os.path.isdir(outputs_dir):
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                for root, _, files in os.walk(outputs_dir):
+                    for file in files:
+                        file_path = os.path.join(root, file)
+                        arcname = os.path.relpath(file_path, outputs_dir)
+                        zipf.write(file_path, os.path.join("Outputs", arcname))
+            return zip_path, "Outputs 文件夹已成功打包为 outputs.zip"
+        else:
+            return None, "Outputs 文件夹不存在或为空"
+    except Exception as e:
+        return None, f"打包 Outputs 文件夹失败: {str(e)}"
+
+def compress_wav_to_mp3():
+    """将 Outputs 文件夹及其子目录中的 .wav 文件转换为 80kbps 的 .mp3 文件，并替换原文件"""
+    try:
+        outputs_dir = "Outputs"
+        if not os.path.exists(outputs_dir) or not os.path.isdir(outputs_dir):
+            return "Outputs 文件夹不存在或为空"
+        
+        converted_files = 0
+        for root, _, files in os.walk(outputs_dir):
+            for file in files:
+                if file.lower().endswith(".wav"):
+                    wav_path = os.path.join(root, file)
+                    mp3_path = os.path.join(root, file[:-4] + ".mp3")
+                    try:
+                        # 读取 WAV 文件
+                        audio = AudioSegment.from_wav(wav_path)
+                        # 转换为 MP3，设置比特率为 80kbps
+                        audio.export(mp3_path, format="mp3", bitrate="80k")
+                        # 删除原 WAV 文件
+                        os.remove(wav_path)
+                        print(f"\033[92m✅ 转换并替换: {wav_path} -> {mp3_path}\033[0m")
+                        converted_files += 1
+                    except Exception as e:
+                        print(f"\033[91m❌ 转换 {wav_path} 失败: {str(e)}\033[0m")
+                        continue
+        
+        if converted_files == 0:
+            return "未找到 .wav 文件进行转换"
+        return f"成功将 {converted_files} 个 .wav 文件转换为 .mp3 并替换"
+    except Exception as e:
+        print(f"\033[91m❌ 压缩 WAV 到 MP3 失败: {str(e)}\033[0m")
+        return f"压缩 WAV 到 MP3 失败: {str(e)}"
+
+
+def generate_all_lines_audio(role, texts, lines, start_index, role_map, spk_emb_seed_id=None, ref_wav=None, role_index=0, button=None, status_output=None, use_sentiment=True):
+    """批量生成角色语音，基于情感分析动态调整 IndexTTS 参数"""
+    try:
+        display_name = role_map.get(role, {'display_name': role})['display_name']
+        
+        if cancel_generation.is_set():
+            return None, f"{display_name}：生成已取消", button
+
+        # 检查是否提供 spk_emb_seed_id 或 ref_wav
+        if not spk_emb_seed_id and not ref_wav:
+            print(f"\033[93m⚠️ 角色 {display_name} 未提供 spk_emb_seed_id 或参考音频，跳过生成\033[0m")
+            return None, f"{display_name}：未提供 spk_emb_seed_id 或参考音频，跳过生成", gr.Button(interactive=True)
+
+        current_model = get_or_load_model()
+        if current_model[0] is None:
+            raise RuntimeError(f"ChatterboxTTS 模型未加载：{current_model[1]}")
+
+        params_list = pre_analyze_lines(texts[start_index-1:])
+        saved_paths = []
+        os.makedirs("Outputs", exist_ok=True)
+
+        role_pattern = re.compile(r'^#\s*(?:' + re.escape(role) + r'\s*)?\"(.*?)\"')
+        translate_pattern = re.compile(r'^translate\s+\w+\s+([\w_-]+)\s*:')
+
+        print(f"\033[94m🚀 开始生成角色 {display_name} 的语音，从第 {start_index} 条开始，共 {len(texts[start_index-1:])} 条\033[0m")
+
+        def generate_single_line(idx, line, params):
+            if cancel_generation.is_set():
+                return None
+            if not line.strip():
+                return None
+            text_index = None
+            for i, file_line in enumerate(lines):
+                if role_pattern.match(file_line.strip()):
+                    raw_content = role_pattern.match(file_line.strip()).group(1)
+                    raw_content = re.sub(r'\[.*?\]', ',', raw_content)
+                    raw_content = re.sub(r'\{.*?\}', '', raw_content)
+                    raw_content = re.sub(r'\\', '', raw_content)
+                    raw_content = re.sub(r'\*.*?\*', '', raw_content)
+                    if line == raw_content.strip():
+                        text_index = i
+                        break
+            identifier = None
+            if text_index is not None:
+                for j in range(1, 5):
+                    if text_index - j >= 0:
+                        line_to_check = lines[text_index - j].strip()
+                        translate_match = translate_pattern.match(line_to_check)
+                        if translate_match:
+                            identifier = translate_match.group(1)
+                            break
+            if identifier is None:
+                print(f"\033[93m跳过: 未找到 translate id for {line} [角色: {display_name}, 索引: {idx+1}]\033[0m")
+                return None
+
+            processed_line = line
+            # print(f"\033[92m📢 生成 {display_name} 第 {idx+1}/{len(texts)} 条语音：{processed_line[:30]}...\033[0m")
+
+            filename = f"{identifier}.wav"
+            output_path = os.path.join("Outputs", filename)
+
+            # 默认参数
+            kwargs = {
+                "do_sample": True,
+                "top_p": 0.8,
+                "top_k": 30,
+                "temperature": 1.0,
+                "length_penalty": 0.0,
+                "num_beams": 3,
+                "repetition_penalty": 10.0,
+                "max_mel_tokens": 600
+            }
+
+            # 如果启用情感分析，覆盖参数
+            if use_sentiment:
+                kwargs.update(params)
+
+            # 调用 TTS 推理
+            output = tts.infer(ref_wav, processed_line, output_path, verbose=cmd_args.verbose,
+                               max_text_tokens_per_sentence=120, **kwargs)
+
+            print(f"\033[91m-------\n温度: {kwargs['temperature']:.2f}, Top_p: {kwargs['top_p']:.2f}, Top_k: {kwargs['top_k']}, "
+                  f"RP: {kwargs['repetition_penalty']:.2f}, Length_penalty: {kwargs['length_penalty']:.2f}, "
+                  f"Num_beams: {kwargs['num_beams']} {line}\n[角色: {display_name}: {idx+1}/{len(texts)}]{line}\n----------\033[0m")
+            return output_path
+
+        for idx, (line, params) in enumerate(zip(texts[start_index-1:], params_list), start=start_index-1):
+            if cancel_generation.is_set():
+                print(f"\033[93m⚠️ {display_name}：生成被取消，停止于第 {idx+1} 条\033[0m")
+                return None, f"{display_name}：生成已取消", button
+            result = generate_single_line(idx, line, params)
+            if result:
+                saved_paths.append(result)
+
+        print(f"\033[94m✅ {display_name}：生成完成，共生成 {len(saved_paths)} 条语音\033[0m")
+        return None, f"{display_name}：从第 {start_index} 条开始，共生成 {len(saved_paths)} 条语音", gr.Button(interactive=True)
+    except Exception as e:
+        print(f"\033[91m❌ {display_name}：批量生成失败: {str(e)}\033[0m")
+        return None, f"{display_name}：批量生成失败: {str(e)}", gr.Button(interactive=True)
+    finally:
+        queued_roles.discard(role_index)
+        is_generating.clear()
+        process_queue()
+
+def process_queue():
+    """处理队列中的下一个角色"""
+    global generation_queue, is_generating, queued_roles
+    while generation_queue and not is_generating.is_set() and not cancel_generation.is_set():
+        role_config = generation_queue.pop(0)
+        role_index = role_config['role_index']
+        role_data = role_texts[role_index]
+        if not role_data:
+            continue
+        role = role_data.get("role", f"角色{role_index+1}")
+        display_name = role_data.get("display_name", role)
+        txt = role_config['txt']
+        start_idx = role_config['start_idx']
+        spk_emb_seed_id = role_config['spk_emb_seed_id']
+        ref_wav = role_config['ref_wav']
+        
+        # 检查是否提供 spk_emb_seed_id 或 ref_wav
+        if not spk_emb_seed_id and not ref_wav:
+            print(f"\033[93m⚠️ 角色 {display_name} 未提供 spk_emb_seed_id 或参考音频，跳过生成\033[0m")
+            role_components[role_index][4].value = f"{display_name}：未提供 spk_emb_seed_id 或参考音频，跳过生成"
+            role_components[role_index][-1].value = gr.Button(interactive=True)
+            queued_roles.discard(role_index)
+            continue
+        
+        print(f"\033[94m🚀 从队列中取出角色 {display_name} 开始生成\033[0m")
+        # 设置 UI 状态
+        role_components[role_index][4].value = f"{display_name}：开始生成"
+        role_components[role_index][0].value = txt
+        role_components[role_index][1].value = start_idx
+        role_components[role_index][2].value = spk_emb_seed_id
+        role_components[role_index][3].value = ref_wav
+        is_generating.set()
+        # 使用缓存的配置调用 generate_all_lines_audio
+        file_lines = []
+        if last_uploaded_file:
+            try:
+                _, file_lines = parse_roles_from_rpy_file(last_uploaded_file, "")
+            except Exception as e:
+                role_components[role_index][4].value = f"文件解析失败: {str(e)}"
+                role_components[role_index][-1].value = gr.Button(interactive=True)
+                queued_roles.discard(role_index)
+                is_generating.clear()
+                continue
+        role_map = parse_role_mappings(role_mapping_input.value)
+        result = generate_all_lines_audio(
+            role, role_data.get("lines", []), file_lines, int(start_idx), role_map, 
+            spk_emb_seed_id, ref_wav, role_index=role_index, 
+            button=role_components[role_index][-1], status_output=role_components[role_index][4]
+        )
+        # 更新 UI 组件
+        role_components[role_index][4].value = result[1]
+        role_components[role_index][-1].value = result[2]
+        break
+
+role_texts = [{} for _ in range(40)]
+role_components = []  # 全局存储角色组件
+role_mapping_input = None  # 全局存储 role_mapping_input
+
+def process_file(file, mapping_text, filter_text):
+    global last_uploaded_file
+    last_uploaded_file = file
+    if file is None:
+        return ["", 1, "", None, "", f"### 角色{i+1}", False, True] * 40 + ["请上传文件"]
+
+    try:
+        mapping_file_path = os.path.join(os.path.dirname(__file__), "角色映射.txt")
+        with open(mapping_file_path, "w", encoding="utf-8") as f:
+            f.write(mapping_text.strip() if mapping_text else "")
+
+        role_map = parse_role_mappings(mapping_text)
+        role_dict, lines = parse_roles_from_rpy_file(file, filter_text)
+        
+        filtered_role_dict = {}
+        for role, lines in role_dict.items():
+            if len(lines) >= 100:
+                filtered_role_dict[role] = lines
+            else:
+                print(f"角色 {role} 的对话条数 ({len(lines)}) 小于100，已被过滤")
+        
+        # 按 display_name 字母顺序排序
+        role_items = [(role, lines) for role, lines in filtered_role_dict.items()]
+        role_items.sort(key=lambda x: role_map.get(x[0], {'display_name': x[0]})['display_name'].lower())
+        # print(f"\033[94m📋 角色按字母顺序排序：{[role_map.get(role, {'display_name': role})['display_name'] for role, _ in role_items]}\033[0m")
+
+    except Exception as e:
+        return ["", 1, "", None, "", f"### 角色{i+1}", False, True] * 40 + [f"文件解析失败: {str(e)}"]
+
+    return_values = []
+    for i in range(40):
+        if i < len(role_items):
+            role, lines = role_items[i]
+            display_name = role_map.get(role, {'display_name': role, 'voice_file': None, 'seed_id': None})['display_name']
+            seed_id = role_map.get(role, {'display_name': role, 'voice_file': None, 'seed_id': None})['seed_id']
+            voice_file = role_map.get(role, {'display_name': role, 'voice_file': None, 'seed_id': None})['voice_file']
+            ref_wav_original = None
+            if voice_file:
+                ref_wav_original = os.path.join('voice', voice_file)
+            # 如果 voice_file 未指定或不存在，尝试使用 display_name.wav
+            if not ref_wav_original or not os.path.exists(ref_wav_original):
+                ref_wav_original = os.path.join('voice', display_name + '.wav')
+            if ref_wav_original and os.path.exists(ref_wav_original):
+                # 缓存到临时目录
+                cached_path = os.path.join(audio_cache_dir, f"role_{i}_{display_name}.wav")
+                shutil.copy(ref_wav_original, cached_path)
+                ref_wav_path = cached_path
+                print(f"\033[92m✅ 加载并缓存参考音频 for {display_name}: {ref_wav_original} -> {cached_path}\033[0m")
+            else:
+                ref_wav_path = None
+                # print(f"\033[93m⚠️ 未找到参考音频 for {display_name}: {ref_wav_original}\033[0m")
+            role_texts[i] = {"role": role, "display_name": display_name, "lines": lines, "ref_wav": ref_wav_path, "seed_id": seed_id}
+            joined = "\n".join(lines)
+            return_values.extend([joined, 1, seed_id, ref_wav_path, f"{display_name}：共 {len(lines)} 句", f"### {display_name}", True, True])
+        else:
+            role_texts[i] = {}
+            return_values.extend(["", 1, "", None, "", f"### 角色{i+1}", False, True])
+
+    return_values.append("文件处理成功，请为每个角色点击批量生成")
+    return return_values
+
+def stop_all_generation():
+    """停止所有正在进行的生成任务，并释放所有按钮"""
+    global generation_queue, is_generating, queued_roles
+    cancel_generation.set()
+    generation_queue.clear()
+    queued_roles.clear()
+    is_generating.clear()
+    print(f"\033[93m🛑 停止所有生成任务\033[0m")
+    button_states = [gr.Button(interactive=True) for _ in range(40)]
+    status_outputs = [f"{role_texts[i].get('display_name', f'角色{i+1}')}：生成已取消" if role_texts[i] else "" for i in range(40)]
+    # 确保所有按钮恢复为可交互状态
+    for i in range(40):
+        if role_components[i][-1]:  # bulk_btn
+            role_components[i][-1].value = gr.Button(interactive=True)
+    return "正在停止所有生成任务...", status_outputs, button_states
+
+def get_pt_file_for_download(seed_id):
+    """为下载按钮生成 .pt 文件并返回路径和状态"""
+    spk_emb, message = get_pt_file(seed_id)
+    if spk_emb is not None:
+        os.makedirs("tmp", exist_ok=True)
+        output_path = os.path.join("tmp", f"{seed_id}_restored_emb.pt")
+        torch.save(spk_emb, output_path)
+        return gr.DownloadButton(value=output_path, label=f"Download .pt File [{seed_id}]", visible=True), message
+    return gr.DownloadButton(value=None, label="Download .pt File", visible=False), message
+
+def get_download_zip_state():
+    """检查 zip 文件状态并返回下载按钮状态"""
+    if os.path.exists(os.path.join("tmp", "outputs.zip")):
+        return gr.DownloadButton(value=os.path.join("tmp", "outputs.zip"), label="Download Outputs.zip", visible=True), "已准备好下载 outputs.zip"
+    return gr.DownloadButton(value=None, label="Download Outputs.zip", visible=False), "未找到 outputs.zip"
+
+def main():
+    # 在脚本启动时清空缓存文件夹
+    # clear_audio_cache_dir()
+
+    global role_components, make_bulk_functions, audio_cache_dir, role_mapping_input
+    MAX_ROLES = 40
+    mapping_file_path = os.path.join(os.path.dirname(__file__), "角色映射.txt")
+    try:
+        with open(mapping_file_path, "r", encoding="utf-8") as f:
+            role_mapping_placeholder = f.read().strip()
+    except FileNotFoundError:
+        role_mapping_placeholder = "角色代号: jud → 显示名: Judge voice:jud seed_id:1403\n角色代号: jury → 显示名: Members of The Jury voice:jury seed_id:1404\n角色代号: noname → 显示名: 无名角色"
+
+    with gr.Blocks() as demo:
+        gr.Markdown("https://huggingface.co/spaces/ResembleAI/Chatterbox")
+        
+        model_status = gr.Textbox(label="模型加载状态", interactive=False, value="正在加载模型...")
+
         with gr.Row():
-            os.makedirs("prompts", exist_ok=True)
-            prompt_audio = gr.Audio(label="参考音频", key="prompt_audio",
-                                    sources=["upload","microphone"], type="filepath")
+            default_rpy_path = os.path.join(os.path.dirname(__file__), "dialogue.rpy")
+            file_input = gr.File(
+                label="上传 .rpy 文件",
+                type="binary",
+                value=default_rpy_path if os.path.exists(default_rpy_path) else None
+            )
             with gr.Column():
-                input_text_single = gr.TextArea(label="文本", key="input_text_single", placeholder="请输入目标文本", info="当前模型版本{}".format(tts.model_version or "1.0"))
-                gen_button = gr.Button("生成语音", key="gen_button", interactive=True)
-            output_audio = gr.Audio(label="生成结果", visible=True, key="output_audio")
-        # 高级参数设置
-        with gr.Accordion("高级生成参数设置", open=False):
-            # GPT2 采样参数
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("**GPT2 采样设置** _参数会影响音频多样性和生成速度_")
-                    with gr.Row():
-                        do_sample = gr.Checkbox(label="do_sample", value=True)
-                        temperature = gr.Slider(label="temperature", minimum=0.1, maximum=2.0, value=1.0, step=0.1)
-                    with gr.Row():
-                        top_p = gr.Slider(label="top_p", minimum=0.0, maximum=1.0, value=0.8, step=0.01)
-                        top_k = gr.Slider(label="top_k", minimum=0, maximum=100, value=30, step=1)
-                        num_beams = gr.Slider(label="num_beams", value=3, minimum=1, maximum=10, step=1)
-                    with gr.Row():
-                        repetition_penalty = gr.Number(label="repetition_penalty", precision=None, value=10.0, minimum=0.1, maximum=20.0, step=0.1)
-                        length_penalty = gr.Number(label="length_penalty", precision=None, value=0.0, minimum=-2.0, maximum=2.0, step=0.1)
-                    max_mel_tokens = gr.Slider(label="max_mel_tokens", value=600, minimum=50, maximum=tts.cfg.gpt.max_mel_tokens, step=10)
-                # 分句设置
-                with gr.Column(scale=2):
-                    gr.Markdown("**分句设置**")
-                    with gr.Row():
-                        max_text_tokens_per_sentence = gr.Slider(label="分句最大Token数", value=120, minimum=20, maximum=tts.cfg.gpt.max_text_tokens, step=2)
-                    with gr.Accordion("预览分句结果", open=True) as sentences_settings:
-                        sentences_preview = gr.Dataframe(headers=["序号", "分句内容", "Token数"], key="sentences_preview", wrap=True)
-
-            advanced_params = [
-                do_sample, top_p, top_k, temperature,
-                length_penalty, num_beams, repetition_penalty, max_mel_tokens,
-            ]
-
-    # 分句预览逻辑
-    input_text_single.change(
-        lambda text, max_tokens_per_sentence: {
-            sentences_preview: gr.update(value=[
-                [i, ''.join(s), len(s)] for i, s in enumerate(
-                    tts.tokenizer.split_sentences(tts.tokenizer.tokenize(text), int(max_tokens_per_sentence))
+                role_mapping_input = gr.Textbox(
+                    label="角色映射（格式：角色代号: xxx → 显示名: xxx voice:xxx seed_id:xxx）",
+                    lines=5,
+                    placeholder=role_mapping_placeholder,
+                    value=role_mapping_placeholder
                 )
-            ]) if text else gr.update(value=pd.DataFrame([], columns=["序号","分句内容","Token数"]))
-        },
-        inputs=[input_text_single, max_text_tokens_per_sentence],
-        outputs=[sentences_preview]
-    )
-    max_text_tokens_per_sentence.change(
-        lambda text, max_tokens_per_sentence: {
-            sentences_preview: gr.update(value=[
-                [i, ''.join(s), len(s)] for i, s in enumerate(
-                    tts.tokenizer.split_sentences(tts.tokenizer.tokenize(text), int(max_tokens_per_sentence))
+                filter_input = gr.Textbox(
+                    label="对话筛选（格式：min_len=X;keyword=Y，留空显示全部）",
+                    lines=2,
+                    placeholder="示例：min_len=20;keyword=hello\n（最小长度20字符，包含'hello'的对话）",
+                    value="min_len=3"
                 )
-            ]) if text else gr.update(value=pd.DataFrame([], columns=["序号","分句内容","Token数"]))
-        },
-        inputs=[input_text_single, max_text_tokens_per_sentence],
-        outputs=[sentences_preview]
-    )
-    prompt_audio.upload(update_prompt_audio, inputs=[], outputs=[gen_button])
-
-    # 点击生成按钮调用 gen_single
-    gen_button.click(gen_single,
-                     inputs=[prompt_audio, input_text_single, max_text_tokens_per_sentence, *advanced_params],
-                     outputs=[output_audio])
-
-# ----------------- 启动函数 -----------------
-def main():
-    """
-    启动 Gradio WebUI
+        with gr.Row():
+            process_button = gr.Button("处理文件")
+            stop_button = gr.Button("停止所有生成")
+            zip_button = gr.Button("打包 Outputs 文件夹")
+            compress_button = gr.Button("压缩 WAV 到 MP3")
+        all_status = gr.Textbox(label="总状态", interactive=False, visible=False)
+        download_zip_button = gr.DownloadButton(label="Download Outputs.zip", visible=False)
+        zip_status = gr.Textbox(label="打包状态", interactive=False)
+
+        with gr.Row():
+            seed_id_input = gr.Textbox(
+                label="输入 seed_id 获取 .pt 文件",
+                placeholder="例如: 1403 或 seed_1403",
+                visible=False
+            )
+            pt_download_button = gr.DownloadButton(label="Download .pt File", visible=False)
+            pt_status = gr.Textbox(label="生成 .pt 文件状态", interactive=False)
+
+        def load_model_on_start():
+            model, status = get_or_load_model()
+            return status
+
+        demo.load(
+            fn=load_model_on_start,
+            inputs=[],
+            outputs=[model_status]
+        )
+
+        zip_button.click(
+            fn=zip_outputs_folder,
+            inputs=[],
+            outputs=[zip_status, download_zip_button]
+        )
+
+        compress_button.click(
+            fn=compress_wav_to_mp3,
+            inputs=[],
+            outputs=[zip_status]
+        )
+
+        demo.load(
+            fn=get_download_zip_state,
+            inputs=[],
+            outputs=[download_zip_button, zip_status]
+        )
+
+        seed_id_input.change(
+            fn=get_pt_file_for_download,
+            inputs=[seed_id_input],
+            outputs=[pt_download_button, pt_status]
+        )
+
+        role_components = []
+        visibility_states = [gr.State(value=False) for _ in range(MAX_ROLES)]
+        button_states = [gr.State(value=True) for _ in range(MAX_ROLES)]
+
+        ROLES_PER_ROW = 4
+        for row_idx in range((MAX_ROLES + ROLES_PER_ROW - 1) // ROLES_PER_ROW):
+            with gr.Row():
+                for i in range(row_idx * ROLES_PER_ROW, min((row_idx + 1) * ROLES_PER_ROW, MAX_ROLES)):
+                    with gr.Group(visible=False, elem_classes="compact-group") as group:
+                        role_display = gr.Markdown(f"### 角色{i+1}", elem_classes="compact-header")
+                        text_input = gr.Textbox(
+                            label="文本",
+                            lines=2,
+                            max_lines=4,
+                            elem_classes="compact-textbox",
+                            container=False
+                        )
+                        start_index = gr.Number(
+                            value=1,
+                            label="从第几条开始",
+                            minimum=1,
+                            step=1,
+                            elem_classes="compact-number"
+                        )
+                        spk_emb_seed_id = gr.Textbox(
+                            label="输入 spk_emb 的 seed_id",
+                            placeholder="例如: 1403 或 seed_1403",
+                            elem_classes="compact-textbox",
+                            visible=False
+                        )
+                        ref_wav = gr.Audio(
+                            type="filepath",
+                            label="参考音频文件（可选，建议 6 秒以上）",
+                            sources=["upload", "microphone"],
+                            elem_classes="compact-audio"
+                        )
+                        audio_output = gr.Audio(
+                            label="输出音频",
+                            elem_classes="compact-audio",
+                            visible=False
+                        )
+                        status = gr.Textbox(
+                            label="状态",
+                            interactive=False,
+                            elem_classes="compact-textbox",
+                            container=False
+                        )
+                        bulk_btn = gr.Button(
+                            f"生成角色{i+1}",
+                            size="sm",
+                            elem_classes="compact-button",
+                            interactive=True
+                        )
+
+                        role_components.append([text_input, start_index, spk_emb_seed_id, ref_wav, status, role_display, bulk_btn])
+
+                        def make_bulk(i, bulk_btn):
+                            def inner(txt, start_idx, spk_emb_seed_id, ref_wav, button):
+                                global generation_queue, is_generating, queued_roles
+                                role_data = role_texts[i]
+                                if not role_data:
+                                    return None, f"角色{i+1} 无数据", gr.Button(interactive=True)
+                                role = role_data.get("role", f"角色{i+1}")
+                                display_name = role_data.get("display_name", role)
+                                
+                                # 优先使用 UI 提供的 ref_wav，但检查是否需要缓存
+                                ref_wav_path = ref_wav
+                                if ref_wav and os.path.exists(ref_wav):
+                                    # 检查 ref_wav 是否已经是缓存目录中的文件
+                                    if not ref_wav.startswith(audio_cache_dir):
+                                        cached_path = os.path.join(audio_cache_dir, f"role_{i}_{display_name}_ui.wav")
+                                        shutil.copy(ref_wav, cached_path)
+                                        role_texts[i]["ref_wav"] = cached_path
+                                        print(f"\033[92m✅ 缓存 UI 提供的参考音频 for {display_name}: {ref_wav} -> {cached_path}\033[0m")
+                                    else:
+                                        # 已经是缓存文件，直接使用
+                                        role_texts[i]["ref_wav"] = ref_wav
+                                        print(f"\033[92m✅ 使用已缓存的参考音频 for {display_name}: {ref_wav}\033[0m")
+                                else:
+                                    ref_wav_path = role_texts[i].get("ref_wav")
+                                
+                                # 检查是否提供 spk_emb_seed_id 或 ref_wav
+                                if not spk_emb_seed_id and not ref_wav_path:
+                                    print(f"\033[93m⚠️ 角色 {display_name} 未提供 spk_emb_seed_id 或参考音频，跳过生成\033[0m")
+                                    return None, f"{display_name}：未提供 spk_emb_seed_id 或参考音频，跳过生成", gr.Button(interactive=True)
+                                
+                                # 缓存角色配置到队列
+                                role_config = {
+                                    'role_index': i,
+                                    'txt': txt,
+                                    'start_idx': int(start_idx),
+                                    'spk_emb_seed_id': spk_emb_seed_id,
+                                    'ref_wav': ref_wav_path
+                                }
+                                
+                                if is_generating.is_set():
+                                    if i not in queued_roles:
+                                        generation_queue.append(role_config)
+                                        queued_roles.add(i)
+                                        pos = len(generation_queue)
+                                        print(f"\033[94m⏳ 角色 {display_name} 已加入队列，位置 {pos}/{pos}\033[0m")
+                                        return None, f"{display_name}：等待队列中，位置 {pos}/{pos}", gr.Button(interactive=False)
+                                else:
+                                    is_generating.set()
+                                    queued_roles.add(i)
+                                    cancel_generation.clear()
+                                    print(f"\033[94m🚀 单角色生成：{display_name}，从第 {start_idx} 条开始\033[0m")
+                                    file_lines = []
+                                    if last_uploaded_file:
+                                        try:
+                                            _, file_lines = parse_roles_from_rpy_file(last_uploaded_file, "")
+                                        except Exception as e:
+                                            return None, f"文件解析失败: {str(e)}", gr.Button(interactive=True)
+                                    role_map = parse_role_mappings(role_mapping_input.value)
+                                    result = generate_all_lines_audio(
+                                        role, role_data.get("lines", []), file_lines, int(start_idx), role_map, 
+                                        spk_emb_seed_id, ref_wav_path, role_index=i, button=button, status_output=status
+                                    )
+                                    return result
+                            return inner
+
+                        # 存储 make_bulk 函数，传递 bulk_btn
+                        make_bulk_functions[i] = make_bulk(i, bulk_btn)
+
+                        bulk_btn.click(
+                            fn=make_bulk_functions[i],
+                            inputs=[text_input, start_index, spk_emb_seed_id, ref_wav, bulk_btn],
+                            outputs=[audio_output, status, bulk_btn]
+                        )
+
+                        visibility_states[i].change(
+                            fn=lambda x, g=group: {"__type__": "update", "visible": x},
+                            inputs=visibility_states[i],
+                            outputs=group
+                        )
+
+        outputs = []
+        for i in range(MAX_ROLES):
+            for comp in role_components[i][:-1]:
+                outputs.append(comp)
+            outputs.append(visibility_states[i])
+            outputs.append(role_components[i][-1])  # Button state
+        outputs.append(all_status)
+
+        process_button.click(
+            fn=process_file,
+            inputs=[file_input, role_mapping_input, filter_input],
+            outputs=outputs
+        )
+
+        stop_button.click(
+            fn=stop_all_generation,
+            inputs=[],
+            outputs=[all_status, *[comp[4] for comp in role_components], *button_states]
+        )
+
+    demo.css = """
+    body { 
+        background-color: #808080 !important; 
+    }
+    .compact-group { 
+        width: 250px !important; 
+        min-width: 230px !important; 
+        padding: 5px !important; 
+        margin: 5px !important;
+    }
+    .compact-header { 
+        font-size: 14px !important; 
+        margin: 2px 0 !important; 
+    }
+    .compact-textbox { 
+        font-size: 12px !important; 
+        line-height: 1.2 !important; 
+        padding: 2px !important; 
+        margin: 2px 0 !important;
+    }
+    .compact-number { 
+        width: 80px !important; 
+        font-size: 12px !important; 
+        padding: 2px !important; 
+        margin: 2px 0 !important;
+    }
+    .compact-button { 
+        font-size: 12px !important; 
+        padding: 4px !important; 
+        margin: 2px 0 !important;
+    }
+    .compact-audio { 
+        max-width: 220px !important; 
+        min-width: 200px !important; 
+        font-size: 12px !important; 
+        margin: 2px 0 !important;
+        overflow: visible !important;
+    }
     """
-    demo.launch(server_name="0.0.0.0", server_port=cmd_args.port)
 
-if __name__ == "__main__":
-    main()
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", type=str, default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=7860)
+    args = parser.parse_args()
+
+    os.environ["GRADIO_SERVER_NAME"] = args.host
+    os.environ["GRADIO_SERVER_PORT"] = str(args.port)
+
+    demo.launch(server_name=args.host, server_port=args.port, share=False)
+
+if __name__ == '__main__':
+    main()
+# ```