Update app.py

app.py

@@ -1,9 +1,9 @@
 # ```python
 #!/usr/bin/env python3
 """
-ChatTTS Gradio 应用 - 改编为使用 ChatterboxTTS
-适配 Hugging Face Spaces 运行环境
-基于 Chatterbox-TTS 实现: https://huggingface.co/spaces/ResembleAI/Chatterbox
+ChatTTS Gradio Application - Adapted to use ChatterboxTTS
+Adapted for Hugging Face Spaces runtime environment
+Based on Chatterbox-TTS implementation: https://huggingface.co/spaces/ResembleAI/Chatterbox
 """
 
 import os
@@ -42,25 +42,25 @@ warnings.filterwarnings("ignore", category=FutureWarning)
 warnings.filterwarnings("ignore", category=UserWarning)
 
 import argparse
-# ----------------- 命令行参数解析 -----------------
+# ----------------- Command Line Argument Parsing -----------------
 parser = argparse.ArgumentParser(description="IndexTTS WebUI")
-parser.add_argument("--verbose", action="store_true", default=False, help="Enable verbose mode")  # 是否打印详细日志
-parser.add_argument("--port", type=int, default=7860, help="Port to run the web UI on")  # WebUI 端口
-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")  # 模型目录
+parser.add_argument("--verbose", action="store_true", default=False, help="Enable verbose mode")
+parser.add_argument("--port", type=int, default=7860, help="Port to run the web UI on")
+parser.add_argument("--host", type=str, default="127.0.0.1", help="Host to run the web UI on")
+parser.add_argument("--model_dir", type=str, default="checkpoints", help="Model checkpoints directory")
 cmd_args = parser.parse_args()
 model_dir="checkpoints"
 
-# ----------------- 设置模块搜索路径 -----------------
+# ----------------- Set Module Search Path -----------------
 current_dir = os.path.dirname(os.path.abspath(__file__))
 sys.path.append(current_dir)
 sys.path.append(os.path.join(current_dir, "indextts"))
 
-# ----------------- 下载模型 -----------------
+# ----------------- Download Model -----------------
 MODE = 'local'
-snapshot_download("IndexTeam/IndexTTS-1.5", local_dir="checkpoints")  # 从 Hugging Face 下载模型到本地
+snapshot_download("IndexTeam/IndexTTS-1.5", local_dir="checkpoints")  # Download model from Hugging Face to local
 
-# ----------------- 检查模型文件完整性 -----------------
+# ----------------- Check Model File Integrity -----------------
 if not os.path.exists(cmd_args.model_dir):
     print(f"Model directory {cmd_args.model_dir} does not exist. Please download the model first.")
     sys.exit(1)
@@ -76,23 +76,23 @@ for file in [
         print(f"Required file {file_path} does not exist. Please download it.")
         sys.exit(1)
 def analyze_sentiment(text):
-    """使用 TextBlob 分析文本情感，返回优化后的 IndexTTS 参数字典"""
+    """Use TextBlob to analyze sentiment and return optimized IndexTTS parameter dictionary"""
     try:
         blob = TextBlob(text)
-        polarity = blob.sentiment.polarity  # -1 (负面) ~ 1 (正面)
-        subjectivity = blob.sentiment.subjectivity  # 0 (客观) ~ 1 (主观)
+        polarity = blob.sentiment.polarity  # -1 (negative) ~ 1 (positive)
+        subjectivity = blob.sentiment.subjectivity  # 0 (objective) ~ 1 (subjective)
 
-        # temperature: 正面高 (生动)，负面低 (平淡)；范围 0.5~1.5
+        # temperature: higher for positive (lively), lower for negative (plain); range 0.5~1.5
         temperature = 1.0 + math.tanh(polarity) * 0.9  # 0.5 ~ 1.5
-        # top_p: 主观高 (多样)，客观低 (保守)；范围 0.7~0.95
+        # top_p: higher for subjective (diverse), lower for objective (conservative); range 0.7~0.95
         top_p = 0.7 + subjectivity * 0.25
-        # top_k: 主观高 (创意)，但固定上限；范围 20~50
+        # top_k: higher for subjective (creative), but capped; range 20~50
         top_k = int(20 + subjectivity * 30)
-        # repetition_penalty: 客观高 (避免重复)，主观低 (允许强调)；范围 5.0~15.0
+        # repetition_penalty: higher for objective (avoid repetition), lower for subjective (allow emphasis); range 5.0~15.0
         repetition_penalty = 10.0 + (1 - subjectivity) * 5.0 - polarity * 2.0
-        # length_penalty: 正面正 (长表达)，负面负 (短)；范围 -1.0~1.0
+        # length_penalty: positive for positive (longer), negative for negative (shorter); range -1.0~1.0
         length_penalty = math.tanh(polarity) * 1.0
-        # num_beams: 正面高 (自然)，但固定以控制速度；范围 2~5
+        # num_beams: higher for positive (natural), but capped for speed; range 2~5
         num_beams = int(2 + (polarity + 1) * 1.5)
 
         return {
@@ -104,8 +104,8 @@ def analyze_sentiment(text):
             "num_beams": max(2, min(5, num_beams))
         }
     except Exception as e:
-        print(f"情感分析失败: {str(e)}")
-        return {  # 默认值
+        print(f"Sentiment analysis failed: {str(e)}")
+        return {  # Default values
             "temperature": 1.0,
             "top_p": 0.8,
             "top_k": 30,
@@ -115,28 +115,28 @@ def analyze_sentiment(text):
         }
 
 
-# ----------------- 导入 Gradio 和其他模块 -----------------
+# ----------------- Import Gradio and Other Modules -----------------
 import gradio as gr
 import pandas as pd
 
-from indextts.infer import IndexTTS  # 核心 TTS 推理类
-from tools.i18n.i18n import I18nAuto  # 国际化工具
+from indextts.infer import IndexTTS  # Core TTS inference class
+from tools.i18n.i18n import I18nAuto  # Internationalization tool
 
-# ----------------- 初始化 TTS 模型 -----------------
-i18n = I18nAuto(language="en")  # 设置默认中文
-tts = IndexTTS(model_dir=cmd_args.model_dir, cfg_path=os.path.join(cmd_args.model_dir, "config.yaml"))  # 加载模型
+# ----------------- Initialize TTS Model -----------------
+i18n = I18nAuto(language="en")  # Set default language to English
+tts = IndexTTS(model_dir=cmd_args.model_dir, cfg_path=os.path.join(cmd_args.model_dir, "config.yaml"))  # Load model
 
-# # ----------------- 创建输出目录 -----------------
-# os.makedirs("outputs/tasks", exist_ok=True)
-# os.makedirs("prompts", exist_ok=True)
+# # ----------------- Create Output Directory -----------------
+# # os.makedirs("outputs/tasks", exist_ok=True)
+# # os.makedirs("prompts", exist_ok=True)
 
-# ----------------- 核心函数 -----------------
+# ----------------- Core Functions -----------------
 
 def ensure_wav(file_path):
     """
-    确保输入音频是 WAV 格式
-    如果不是 WAV，使用 ffmpeg 转换
-    返回 WAV 文件路径
+    Ensure input audio is in WAV format.
+    If not WAV, convert using ffmpeg.
+    Return WAV file path.
     """
     if not file_path.lower().endswith(".wav"):
         wav_path = file_path.rsplit(".", 1)[0] + ".wav"
@@ -146,102 +146,102 @@ def ensure_wav(file_path):
 
 # def progress_print(step, total, info=""):
 #     """
-#     打印生成音频的进度到终端
-#     step: 当前步骤
-#     total: 总步骤数
-#     info: 附加信息
+#     Print audio generation progress to terminal
+#     step: current step
+#     total: total number of steps
+#     info: extra info
 #     """
 #     percent = int(step / total * 100)
 #     print(f"\r[{percent}%] {info}", end="", flush=True)
 
 
-# 设置日志
+# Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# 全局变量用于存储最后上传的文件
+# Global variable to store last uploaded file
 last_uploaded_file = None
 
-# 全局取消标志
+# Global cancel flag
 cancel_generation = threading.Event()
 
-# 全局生成状态和队列
+# Global generation state and queue
 is_generating = threading.Event()
-generation_queue = []  # 存储 {'role_index': i, 'txt': str, 'start_idx': int, 'spk_emb_seed_id': str, 'ref_wav': str}
+generation_queue = []  # Stores {'role_index': i, 'txt': str, 'start_idx': int, 'spk_emb_seed_id': str, 'ref_wav': str}
 queued_roles = set()
 
-# 存储每个角色的 make_bulk 函数
+# Store make_bulk function for each role
 make_bulk_functions = [None] * 40
 
-# 临时目录用于缓存音频
+# Temporary directory for audio cache
 audio_cache_dir = tempfile.mkdtemp(prefix='audio_cache_')
 
-# 在脚本启动时清空缓存文件夹
+# Clear cache folder at script start
 def clear_audio_cache_dir():
-    """清空或重新创建 audio_cache_dir"""
+    """Clear or recreate 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")
+            print(f"\033[92m✅ Cleared cache folder: {audio_cache_dir}\033[0m")
         os.makedirs(audio_cache_dir)
-        print(f"\033[92m✅ 创建新的缓存文件夹: {audio_cache_dir}\033[0m")
+        print(f"\033[92m✅ Created new cache folder: {audio_cache_dir}\033[0m")
     except Exception as e:
-        print(f"\033[91m❌ 清空缓存文件夹失败: {str(e)}\033[0m")
+        print(f"\033[91m❌ Failed to clear cache folder: {str(e)}\033[0m")
 
-# Monkey patch torch.load 以处理设备映射
+# Monkey patch torch.load to handle device mapping
 original_torch_load = torch.load
 
 def patched_torch_load(f, map_location=None, **kwargs):
     """
-    修补后的 torch.load，自动将 CUDA 张量映射到 CPU/CUDA
+    Patched torch.load, automatically maps CUDA tensors to CPU/CUDA
     """
     if map_location is None:
         map_location = 'cpu'
-    logger.info(f"🔧 使用 map_location={map_location} 加载")
+    logger.info(f"🔧 Loading with map_location={map_location}")
     return original_torch_load(f, map_location=map_location, **kwargs)
 
-# 在 torch 导入后立即应用补丁
+# Apply patch immediately after torch import
 torch.load = patched_torch_load
 if 'torch' in sys.modules:
     sys.modules['torch'].load = patched_torch_load
 
-logger.info("✅ 成功应用 torch.load 设备映射补丁")
+logger.info("✅ Successfully applied torch.load device mapping patch")
 
-# 设备检测，适配 Hugging Face Spaces
+# Device detection, adapted for Hugging Face Spaces
 if torch.cuda.is_available():
     DEVICE = "cuda"
-    logger.info("🚀 使用 CUDA GPU 运行")
+    logger.info("🚀 Running with CUDA GPU")
 else:
     DEVICE = "cpu"
-    logger.info("🚀 使用 CPU 运行")
+    logger.info("🚀 Running with CPU")
 
-print(f"🚀 在设备上运行: {DEVICE}")
+print(f"🚀 Running on device: {DEVICE}")
 
-# 全局模型变量
+# Global model variable
 MODEL = True
 
 def get_or_load_model():
-    """加载 ChatterboxTTS 模型（如果尚未加载），并确保其在正确的设备上运行"""
+    """Load ChatterboxTTS model (if not already loaded), and ensure it runs on the correct device"""
     global MODEL, DEVICE
     if MODEL is None:
-        print("模型未加载，正在初始化...")
+        print("Model not loaded, initializing...")
         try:
-            # 优先尝试官方导入路径
+            # Try official import path first
             try:
                 from chatterbox.src.chatterbox.tts import ChatterboxTTS
-                logger.info("✅ 使用官方 chatterbox.src 导入路径")
+                logger.info("✅ Using official chatterbox.src import path")
             except ImportError:
-                # 回退到备用导入路径
+                # Fallback to alternative import path
                 from chatterbox import ChatterboxTTS
-                logger.info("✅ 使用 chatterbox 直接导入路径")
+                logger.info("✅ Using chatterbox direct import path")
             
-            # 先将模型加载到 CPU 以避免设备问题
+            # Load model to CPU first to avoid device issues
             MODEL = ChatterboxTTS.from_pretrained("cpu")
             
-            # 如果是 CUDA，移动到目标设备
+            # If CUDA, move to target device
             if DEVICE == "cuda":
-                logger.info(f"将模型组件移动到 {DEVICE}...")
+                logger.info(f"Moving model components to {DEVICE}...")
                 try:
                     if hasattr(MODEL, 't3'):
                         MODEL.t3 = MODEL.t3.to(DEVICE)
@@ -251,28 +251,28 @@ def get_or_load_model():
                         MODEL.ve = MODEL.ve.to(DEVICE)
                     
                     MODEL.device = DEVICE
-                    logger.info(f"✅ 所有模型组件已移动到 {DEVICE}")
+                    logger.info(f"✅ All model components moved to {DEVICE}")
                 except Exception as e:
-                    logger.warning(f"⚠️ 无法将某些组件移动到 {DEVICE}: {e}")
-                    logger.info("🔄 为确保稳定性回退到 CPU 模式")
+                    logger.warning(f"⚠️ Unable to move some components to {DEVICE}: {e}")
+                    logger.info("🔄 Falling back to CPU mode for stability")
                     DEVICE = "cpu"
                     MODEL.device = "cpu"
             
-            logger.info(f"✅ 模型在 {DEVICE} 上加载成功")
-            return MODEL, "模型加载成功"
+            logger.info(f"✅ Model loaded on {DEVICE}")
+            return MODEL, "Model loaded successfully"
             
         except Exception as e:
-            logger.error(f"❌ 加载模型失败: {e}")
-            return None, f"模型加载失败: {str(e)}"
-    return MODEL, "模型已加载"
+            logger.error(f"❌ Failed to load model: {e}")
+            return None, f"Model loading failed: {str(e)}"
+    return MODEL, "Model already loaded"
 
 def parse_role_mappings(mapping_text):
-    """解析角色映射文本，返回 {角色代号: {'display_name': 显示名, 'voice_file': 'xxx.wav', 'seed_id': seed_id}} 字典"""
+    """Parse role mapping text and return {role_code: {'display_name': display_name, 'voice_file': 'xxx.wav', 'seed_id': seed_id}} dict"""
     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*$')
+    pattern = re.compile(r'Role Code:\s*(\w+)\s*→\s*Display Name:\s*([^→]+?)(?:\s+voice:\s*([\w_-]+))?(?:\s+seed_id:\s*(\w+))?\s*$')
     
     for line in lines:
         match = pattern.match(line.strip())
@@ -291,7 +291,7 @@ def parse_role_mappings(mapping_text):
     return role_map
 
 def filter_lines(lines, filter_text):
-    """根据筛选条件过滤对话行"""
+    """Filter dialogue lines according to filter conditions"""
     if not filter_text:
         return lines
     filtered = []
@@ -308,13 +308,13 @@ def filter_lines(lines, filter_text):
                     if len(re.sub(r'[^A-Za-z0-9]', '', line)) < min_len:
                         include = False
                 except ValueError:
-                    print(f"警告: 无效的 min_len 条件: {condition}")
+                    print(f"Warning: invalid min_len condition: {condition}")
             elif condition.startswith('keyword='):
                 keyword = condition.split('=')[1].lower()
                 if keyword not in line.lower():
                     include = False
             else:
-                print(f"警告: 未知筛选条件: {condition}")
+                print(f"Warning: unknown filter condition: {condition}")
         if include:
             filtered.append(line)
     return filtered
@@ -348,7 +348,7 @@ def parse_roles_from_rpy_file(file_bytes, filter_text=""):
 
         return role_dict, lines
     except Exception as e:
-        raise ValueError(f"解析 .rpy 文件失败: {str(e)}")
+        raise ValueError(f"Failed to parse .rpy file: {str(e)}")
 
 def save_wav(audio_data, sample_rate, output_path):
     try:
@@ -358,30 +358,11 @@ def save_wav(audio_data, sample_rate, output_path):
             audio_int16 = audio_data
         write(output_path, sample_rate, audio_int16)
     except Exception as e:
-        raise RuntimeError(f"保存音频文件失败: {str(e)}")
+        raise RuntimeError(f"Failed to save audio file: {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):
-    """为每行文本分析情感，返回参数字典列表"""
+    """Analyze sentiment for each text line and return a list of parameter dicts"""
     context_window = 2
     params_list = []
     for idx, line in enumerate(texts):
@@ -403,7 +384,7 @@ def pre_analyze_lines(texts):
     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"""
+    """Get .pt data from CSV file by seed_id and load as PyTorch tensor"""
     try:
         if seed_id and not seed_id.startswith("seed_"):
             seed_id = f"seed_{seed_id}"
@@ -411,16 +392,16 @@ def get_pt_file(seed_id, csv_path=os.path.join(os.path.dirname(__file__), "evalu
         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}"
+            return None, f"seed_id not found: {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 数据"
+        return spk_emb, f"Successfully loaded spk_emb data for seed_id: {seed_id}"
     except Exception as e:
-        return None, f"加载 spk_emb 数据失败: {str(e)}"
+        return None, f"Failed to load spk_emb data: {str(e)}"
 
 def zip_outputs_folder():
     try:
@@ -435,18 +416,18 @@ def zip_outputs_folder():
                         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"
+            return zip_path, "Outputs folder successfully zipped as outputs.zip"
         else:
-            return None, "Outputs 文件夹不存在或为空"
+            return None, "Outputs folder does not exist or is empty"
     except Exception as e:
-        return None, f"打包 Outputs 文件夹失败: {str(e)}"
+        return None, f"Failed to zip Outputs folder: {str(e)}"
 
 def compress_wav_to_mp3():
-    """将 Outputs 文件夹及其子目录中的 .wav 文件转换为 80kbps 的 .mp3 文件，并替换原文件"""
+    """Convert .wav files in Outputs folder and subfolders to 80kbps .mp3 files, replacing the originals"""
     try:
         outputs_dir = "Outputs"
         if not os.path.exists(outputs_dir) or not os.path.isdir(outputs_dir):
-            return "Outputs 文件夹不存在或为空"
+            return "Outputs folder does not exist or is empty"
         
         converted_files = 0
         for root, _, files in os.walk(outputs_dir):
@@ -455,42 +436,42 @@ def compress_wav_to_mp3():
                     wav_path = os.path.join(root, file)
                     mp3_path = os.path.join(root, file[:-4] + ".mp3")
                     try:
-                        # 读取 WAV 文件
+                        # Read WAV file
                         audio = AudioSegment.from_wav(wav_path)
-                        # 转换为 MP3，设置比特率为 80kbps
+                        # Convert to MP3, set bitrate to 80kbps
                         audio.export(mp3_path, format="mp3", bitrate="80k")
-                        # 删除原 WAV 文件
+                        # Delete original WAV file
                         os.remove(wav_path)
-                        print(f"\033[92m✅ 转换并替换: {wav_path} -> {mp3_path}\033[0m")
+                        print(f"\033[92m✅ Converted and replaced: {wav_path} -> {mp3_path}\033[0m")
                         converted_files += 1
                     except Exception as e:
-                        print(f"\033[91m❌ 转换 {wav_path} 失败: {str(e)}\033[0m")
+                        print(f"\033[91m❌ Failed to convert {wav_path}: {str(e)}\033[0m")
                         continue
         
         if converted_files == 0:
-            return "未找到 .wav 文件进行转换"
-        return f"成功将 {converted_files} 个 .wav 文件转换为 .mp3 并替换"
+            return "No .wav files found to convert"
+        return f"Successfully converted and replaced {converted_files} .wav files to .mp3"
     except Exception as e:
-        print(f"\033[91m❌ 压缩 WAV 到 MP3 失败: {str(e)}\033[0m")
-        return f"压缩 WAV 到 MP3 失败: {str(e)}"
+        print(f"\033[91m❌ Failed to compress WAV to MP3: {str(e)}\033[0m")
+        return f"Failed to compress WAV to 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 参数"""
+    """Batch generate role audio, dynamically adjust IndexTTS parameters based on sentiment analysis"""
     try:
         display_name = role_map.get(role, {'display_name': role})['display_name']
         
         if cancel_generation.is_set():
-            return None, f"{display_name}：生成已取消", button
+            return None, f"{display_name}: Generation cancelled", button
 
-        # 检查是否提供 spk_emb_seed_id 或 ref_wav
+        # Check if spk_emb_seed_id or ref_wav is provided
         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)
+            print(f"\033[93m⚠️ Role {display_name} did not provide spk_emb_seed_id or reference audio, skipping generation\033[0m")
+            return None, f"{display_name}: No spk_emb_seed_id or reference audio provided, skipping generation", gr.Button(interactive=True)
 
         current_model = get_or_load_model()
         if current_model[0] is None:
-            raise RuntimeError(f"ChatterboxTTS 模型未加载：{current_model[1]}")
+            raise RuntimeError(f"ChatterboxTTS model not loaded: {current_model[1]}")
 
         params_list = pre_analyze_lines(texts[start_index-1:])
         saved_paths = []
@@ -499,7 +480,7 @@ def generate_all_lines_audio(role, texts, lines, start_index, role_map, spk_emb_
         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")
+        print(f"\033[94m🚀 Start generating audio for role {display_name}, from line {start_index}, total {len(texts[start_index-1:])} lines\033[0m")
 
         def generate_single_line(idx, line, params):
             if cancel_generation.is_set():
@@ -527,16 +508,16 @@ def generate_all_lines_audio(role, texts, lines, start_index, role_map, spk_emb_
                             identifier = translate_match.group(1)
                             break
             if identifier is None:
-                print(f"\033[93m跳过: 未找到 translate id for {line} [角色: {display_name}, 索引: {idx+1}]\033[0m")
+                print(f"\033[93mSkip: No translate id found for {line} [Role: {display_name}, Index: {idx+1}]\033[0m")
                 return None
 
             processed_line = line
-            # print(f"\033[92m📢 生成 {display_name} 第 {idx+1}/{len(texts)} 条语音：{processed_line[:30]}...\033[0m")
+            # print(f"\033[92m📢 Generate {display_name} line {idx+1}/{len(texts)}: {processed_line[:30]}...\033[0m")
 
             filename = f"{identifier}.wav"
             output_path = os.path.join("Outputs", filename)
 
-            # 默认参数
+            # Default parameters
             kwargs = {
                 "do_sample": True,
                 "top_p": 0.8,
@@ -548,39 +529,39 @@ def generate_all_lines_audio(role, texts, lines, start_index, role_map, spk_emb_
                 "max_mel_tokens": 600
             }
 
-            # 如果启用情感分析，覆盖参数
+            # If sentiment analysis enabled, override parameters
             if use_sentiment:
                 kwargs.update(params)
 
-            # 调用 TTS 推理
+            # Call TTS inference
             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']}, "
+            print(f"\033[91m-------\nTemperature: {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")
+                  f"Num_beams: {kwargs['num_beams']} {line}\n[Role: {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
+                print(f"\033[93m⚠️ {display_name}: Generation cancelled, stopped at line {idx+1}\033[0m")
+                return None, f"{display_name}: Generation cancelled", 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)
+        print(f"\033[94m✅ {display_name}: Generation finished, {len(saved_paths)} audio lines generated\033[0m")
+        return None, f"{display_name}: From line {start_index}, {len(saved_paths)} audio lines generated", 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)
+        print(f"\033[91m❌ {display_name}: Batch generation failed: {str(e)}\033[0m")
+        return None, f"{display_name}: Batch generation failed: {str(e)}", gr.Button(interactive=True)
     finally:
         queued_roles.discard(role_index)
         is_generating.clear()
         process_queue()
 
 def process_queue():
-    """处理队列中的下一个角色"""
+    """Process the next role in the 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)
@@ -588,36 +569,36 @@ def process_queue():
         role_data = role_texts[role_index]
         if not role_data:
             continue
-        role = role_data.get("role", f"角色{role_index+1}")
+        role = role_data.get("role", f"Role{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
+        # Check if spk_emb_seed_id or ref_wav is provided
         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 或参考音频，跳过生成"
+            print(f"\033[93m⚠️ Role {display_name} did not provide spk_emb_seed_id or reference audio, skipping generation\033[0m")
+            role_components[role_index][4].value = f"{display_name}: No spk_emb_seed_id or reference audio provided, skipping generation"
             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}：开始生成"
+        print(f"\033[94m🚀 Starting generation for role {display_name} from queue\033[0m")
+        # Set UI state
+        role_components[role_index][4].value = f"{display_name}: Generation started"
         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
+        # Use cached config to call 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][4].value = f"File parsing failed: {str(e)}"
                 role_components[role_index][-1].value = gr.Button(interactive=True)
                 queued_roles.discard(role_index)
                 is_generating.clear()
@@ -628,23 +609,23 @@ def process_queue():
             spk_emb_seed_id, ref_wav, role_index=role_index, 
             button=role_components[role_index][-1], status_output=role_components[role_index][4]
         )
-        # 更新 UI 组件
+        # Update UI components
         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
+role_components = []  # Global storage for role components
+role_mapping_input = None  # Global storage for 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 + ["请上传文件"]
+        return ["", 1, "", None, "", f"### Role {i+1}", False, True] * 40 + ["Please upload a file"]
 
     try:
-        mapping_file_path = os.path.join(os.path.dirname(__file__), "角色映射.txt")
+        mapping_file_path = os.path.join(os.path.dirname(__file__), "role_mapping.txt")
         with open(mapping_file_path, "w", encoding="utf-8") as f:
             f.write(mapping_text.strip() if mapping_text else "")
 
@@ -652,70 +633,70 @@ def process_file(file, mapping_text, filter_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
+        for role, lines_ in role_dict.items():
+            if len(lines_) >= 100:
+                filtered_role_dict[role] = lines_
             else:
-                print(f"角色 {role} 的对话条数 ({len(lines)}) 小于100，已被过滤")
+                print(f"Role {role} dialogue count ({len(lines_)}) is less than 100, filtered out")
         
-        # 按 display_name 字母顺序排序
-        role_items = [(role, lines) for role, lines in filtered_role_dict.items()]
+        # Sort by display_name alphabetically
+        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")
+        # print(f"\033[94m📋 Roles sorted alphabetically: {[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 ["", 1, "", None, "", f"### Role {i+1}", False, True] * 40 + [f"File parsing failed: {str(e)}"]
 
     return_values = []
     for i in range(40):
         if i < len(role_items):
-            role, lines = role_items[i]
+            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 voice_file not specified or does not exist, try 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):
-                # 缓存到临时目录
+                # Cache to temp directory
                 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")
+                print(f"\033[92m✅ Loaded and cached reference audio 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])
+                # print(f"\033[93m⚠️ Reference audio not found 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_)} lines in total", f"### {display_name}", True, True])
         else:
             role_texts[i] = {}
-            return_values.extend(["", 1, "", None, "", f"### 角色{i+1}", False, True])
+            return_values.extend(["", 1, "", None, "", f"### Role {i+1}", False, True])
 
-    return_values.append("文件处理成功，请为每个角色点击批量生成")
+    return_values.append("File processed successfully, please click batch generate for each role")
     return return_values
 
 def stop_all_generation():
-    """停止所有正在进行的生成任务，并释放所有按钮"""
+    """Stop all ongoing generation tasks and release all buttons"""
     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")
+    print(f"\033[93m🛑 Stopped all generation tasks\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)]
-    # 确保所有按钮恢复为可交互状态
+    status_outputs = [f"{role_texts[i].get('display_name', f'Role {i+1}')} : Generation cancelled" if role_texts[i] else "" for i in range(40)]
+    # Ensure all buttons are restored to interactive state
     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
+    return "Stopping all generation tasks...", status_outputs, button_states
 
 def get_pt_file_for_download(seed_id):
-    """为下载按钮生成 .pt 文件并返回路径和状态"""
+    """Generate .pt file for download button and return path and status"""
     spk_emb, message = get_pt_file(seed_id)
     if spk_emb is not None:
         os.makedirs("tmp", exist_ok=True)
@@ -725,66 +706,70 @@ def get_pt_file_for_download(seed_id):
     return gr.DownloadButton(value=None, label="Download .pt File", visible=False), message
 
 def get_download_zip_state():
-    """检查 zip 文件状态并返回下载按钮状态"""
+    """Check zip file state and return download button state"""
     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"
+        return gr.DownloadButton(value=os.path.join("tmp", "outputs.zip"), label="Download Outputs.zip", visible=True), "Ready to download outputs.zip"
+    return gr.DownloadButton(value=None, label="Download Outputs.zip", visible=False), "outputs.zip not found"
 
 def main():
-    # 在脚本启动时清空缓存文件夹
+    # Clear cache folder at script start
     # 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")
+    mapping_file_path = os.path.join(os.path.dirname(__file__), "role_mapping.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 → 显示名: 无名角色"
+        role_mapping_placeholder = (
+            "Role Code: jud → Display Name: Judge voice:jud seed_id:1403\n"
+            "Role Code: jury → Display Name: Members of The Jury voice:jury seed_id:1404\n"
+            "Role Code: noname → Display Name: Anonymous Role"
+        )
 
     with gr.Blocks() as demo:
         gr.Markdown("https://huggingface.co/spaces/ResembleAI/Chatterbox")
         
-        model_status = gr.Textbox(label="模型加载状态", interactive=False, value="正在加载模型...")
+        model_status = gr.Textbox(label="Model loading status", interactive=False, value="Loading model...")
 
         with gr.Row():
             default_rpy_path = os.path.join(os.path.dirname(__file__), "dialogue.rpy")
             file_input = gr.File(
-                label="上传 .rpy 文件",
+                label="Upload .rpy file",
                 type="binary",
                 value=default_rpy_path if os.path.exists(default_rpy_path) else None
             )
             with gr.Column():
                 role_mapping_input = gr.Textbox(
-                    label="角色映射（格式：角色代号: xxx → 显示名: xxx voice:xxx seed_id:xxx）",
+                    label="Role Mapping (Format: Role Code: xxx → Display Name: xxx voice:xxx seed_id:xxx)",
                     lines=5,
                     placeholder=role_mapping_placeholder,
                     value=role_mapping_placeholder
                 )
                 filter_input = gr.Textbox(
-                    label="对话筛选（格式：min_len=X;keyword=Y，留空显示全部）",
+                    label="Dialogue Filter (Format: min_len=X;keyword=Y, leave empty to show all)",
                     lines=2,
-                    placeholder="示例：min_len=20;keyword=hello\n（最小长度20字符，包含'hello'的对话）",
+                    placeholder="Example: min_len=20;keyword=hello\n(Minimum length 20 characters, contains 'hello' dialogues)",
                     value="min_len=3"
                 )
         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)
+            process_button = gr.Button("Process File")
+            stop_button = gr.Button("Stop All Generation")
+            zip_button = gr.Button("Zip Outputs Folder")
+            compress_button = gr.Button("Compress WAV to MP3")
+        all_status = gr.Textbox(label="Overall Status", interactive=False, visible=False)
         download_zip_button = gr.DownloadButton(label="Download Outputs.zip", visible=False)
-        zip_status = gr.Textbox(label="打包状态", interactive=False)
+        zip_status = gr.Textbox(label="Zip Status", interactive=False)
 
         with gr.Row():
             seed_id_input = gr.Textbox(
-                label="输入 seed_id 获取 .pt 文件",
-                placeholder="例如: 1403 或 seed_1403",
+                label="Enter seed_id to get .pt file",
+                placeholder="e.g.: 1403 or seed_1403",
                 visible=False
             )
             pt_download_button = gr.DownloadButton(label="Download .pt File", visible=False)
-            pt_status = gr.Textbox(label="生成 .pt 文件状态", interactive=False)
+            pt_status = gr.Textbox(label="Generate .pt file status", interactive=False)
 
         def load_model_on_start():
             model, status = get_or_load_model()
@@ -829,9 +814,9 @@ def main():
             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")
+                        role_display = gr.Markdown(f"### Role {i+1}", elem_classes="compact-header")
                         text_input = gr.Textbox(
-                            label="文本",
+                            label="Text",
                             lines=2,
                             max_lines=4,
                             elem_classes="compact-textbox",
@@ -839,36 +824,36 @@ def main():
                         )
                         start_index = gr.Number(
                             value=1,
-                            label="从第几条开始",
+                            label="Start from line",
                             minimum=1,
                             step=1,
                             elem_classes="compact-number"
                         )
                         spk_emb_seed_id = gr.Textbox(
-                            label="输入 spk_emb 的 seed_id",
-                            placeholder="例如: 1403 或 seed_1403",
+                            label="Enter spk_emb seed_id",
+                            placeholder="e.g.: 1403 or seed_1403",
                             elem_classes="compact-textbox",
                             visible=False
                         )
                         ref_wav = gr.Audio(
                             type="filepath",
-                            label="参考音频文件（可选，建议 6 秒以上）",
+                            label="Reference audio file (optional, recommended >6s)",
                             sources=["upload", "microphone"],
                             elem_classes="compact-audio"
                         )
                         audio_output = gr.Audio(
-                            label="输出音频",
+                            label="Output audio",
                             elem_classes="compact-audio",
                             visible=False
                         )
                         status = gr.Textbox(
-                            label="状态",
+                            label="Status",
                             interactive=False,
                             elem_classes="compact-textbox",
                             container=False
                         )
                         bulk_btn = gr.Button(
-                            f"生成角色{i+1}",
+                            f"Generate Role {i+1}",
                             size="sm",
                             elem_classes="compact-button",
                             interactive=True
@@ -881,32 +866,32 @@ def main():
                                 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}")
+                                    return None, f"Role {i+1} has no data", gr.Button(interactive=True)
+                                role = role_data.get("role", f"Role{i+1}")
                                 display_name = role_data.get("display_name", role)
                                 
-                                # 优先使用 UI 提供的 ref_wav，但检查是否需要缓存
+                                # Prefer UI provided ref_wav, but check if needs caching
                                 ref_wav_path = ref_wav
                                 if ref_wav and os.path.exists(ref_wav):
-                                    # 检查 ref_wav 是否已经是缓存目录中的文件
+                                    # Check if ref_wav is already in cache dir
                                     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")
+                                        print(f"\033[92m✅ Cached UI provided reference audio for {display_name}: {ref_wav} -> {cached_path}\033[0m")
                                     else:
-                                        # 已经是缓存文件，直接使用
+                                        # Already cached, use directly
                                         role_texts[i]["ref_wav"] = ref_wav
-                                        print(f"\033[92m✅ 使用已缓存的参考音频 for {display_name}: {ref_wav}\033[0m")
+                                        print(f"\033[92m✅ Using already cached reference audio for {display_name}: {ref_wav}\033[0m")
                                 else:
                                     ref_wav_path = role_texts[i].get("ref_wav")
                                 
-                                # 检查是否提供 spk_emb_seed_id 或 ref_wav
+                                # Check if spk_emb_seed_id or ref_wav provided
                                 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)
+                                    print(f"\033[93m⚠️ Role {display_name} did not provide spk_emb_seed_id or reference audio, skipping generation\033[0m")
+                                    return None, f"{display_name}: No spk_emb_seed_id or reference audio provided, skipping generation", gr.Button(interactive=True)
                                 
-                                # 缓存角色配置到队列
+                                # Cache role config to queue
                                 role_config = {
                                     'role_index': i,
                                     'txt': txt,
@@ -920,19 +905,19 @@ def main():
                                         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)
+                                        print(f"\033[94m⏳ Role {display_name} added to queue, position {pos}/{pos}\033[0m")
+                                        return None, f"{display_name}: Waiting in queue, position {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")
+                                    print(f"\033[94m🚀 Single role generation: {display_name}, from line {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)
+                                            return None, f"File parsing failed: {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, 
@@ -941,7 +926,7 @@ def main():
                                     return result
                             return inner
 
-                        # 存储 make_bulk 函数，传递 bulk_btn
+                        # Store make_bulk function, pass bulk_btn
                         make_bulk_functions[i] = make_bulk(i, bulk_btn)
 
                         bulk_btn.click(