from __future__ import annotations import argparse import atexit import itertools import json import logging import math import multiprocessing as mp import os import random import shutil import sys import threading import time import gc from dataclasses import dataclass from pathlib import Path from typing import Any, Dict, List, Optional import warnings import numpy as np import torch warnings.filterwarnings("ignore", category=FutureWarning) warnings.filterwarnings("ignore", category=UserWarning) import gradio as gr import pandas as pd from omegaconf import OmegaConf current_dir = os.path.dirname(os.path.abspath(__file__)) sys.path.append(current_dir) sys.path.append(os.path.join(current_dir, "indextts")) from tools.i18n.i18n import I18nAuto parser = argparse.ArgumentParser(description="IndexTTS Parallel WebUI") parser.add_argument("--verbose", action="store_true", default=False, help="Enable verbose logging") parser.add_argument("--port", type=int, default=7862, help="Port for the web UI") parser.add_argument("--host", type=str, default="0.0.0.0", help="Host for the web UI") parser.add_argument("--model_dir", type=str, default="checkpoints", help="Model checkpoints directory") parser.add_argument("--is_fp16", action="store_true", default=False, help="Enable fp16 inference") cmd_args = parser.parse_args() 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) required_files = [ "config.yaml", "s2mel.pth", "wav2vec2bert_stats.pt", ] for file_name in required_files: file_path = os.path.join(cmd_args.model_dir, file_name) if not os.path.exists(file_path): print(f"Required file {file_path} does not exist. Please download it.") sys.exit(1) try: BASE_CFG = OmegaConf.load(os.path.join(cmd_args.model_dir, "config.yaml")) except Exception as exc: # pragma: no cover - config must load print(f"Failed to load config.yaml: {exc}") sys.exit(1) # Configure cache locations and disable DeepSpeed before importing heavy modules hf_cache_dir = os.path.join(cmd_args.model_dir, "hf_cache") torch_cache_dir = os.path.join(cmd_args.model_dir, "torch_cache") os.environ.setdefault("INDEXTTS_USE_DEEPSPEED", "0") os.environ.setdefault("HF_HOME", hf_cache_dir) os.environ.setdefault("HF_HUB_CACHE", hf_cache_dir) os.environ.setdefault("TRANSFORMERS_CACHE", hf_cache_dir) os.environ.setdefault("TORCH_HOME", torch_cache_dir) os.makedirs(hf_cache_dir, exist_ok=True) os.makedirs(torch_cache_dir, exist_ok=True) from indextts.infer_v2_modded import IndexTTS2 i18n = I18nAuto(language="Auto") logger = logging.getLogger("webui_parallel") os.makedirs(os.path.join(current_dir, "outputs", "tasks"), exist_ok=True) os.makedirs(os.path.join(current_dir, "prompts"), exist_ok=True) # Avoid DeepSpeed initialization on platforms where it stalls by default os.environ.setdefault("INDEXTTS_USE_DEEPSPEED", "0") example_cases: List[List[Any]] = [] examples_path = Path(current_dir) / "examples" / "cases.jsonl" if examples_path.exists(): with examples_path.open("r", encoding="utf-8") as f: for line in f: line = line.strip() if not line: continue example = json.loads(line) emo_audio = example.get("emo_audio") emo_audio_path = os.path.join("examples", emo_audio) if emo_audio else None example_cases.append([ os.path.join("examples", example.get("prompt_audio", "sample_prompt.wav")), example.get("emo_mode", 0), example.get("text"), emo_audio_path, example.get("emo_weight", 1.0), example.get("emo_text", ""), example.get("emo_vec_1", 0), example.get("emo_vec_2", 0), example.get("emo_vec_3", 0), example.get("emo_vec_4", 0), example.get("emo_vec_5", 0), example.get("emo_vec_6", 0), example.get("emo_vec_7", 0), example.get("emo_vec_8", 0), ]) EMO_CHOICES = [ "Match prompt audio", "Use emotion reference audio", "Use emotion vector", "Use emotion text description", ] parallel_worker_config = { "model_dir": cmd_args.model_dir, "is_fp16": cmd_args.is_fp16, "verbose": cmd_args.verbose, "hf_cache": hf_cache_dir, "torch_cache": torch_cache_dir, "gpt_path": None, "bpe_path": None, } class WorkerPool: def __init__(self, config: Dict[str, Any]): self.config = config self.ctx = mp.get_context("spawn") self.job_queue: Optional[mp.Queue] = None self.result_queue: Optional[mp.Queue] = None self.processes: List[mp.Process] = [] self.worker_count = 0 self.lock = threading.Lock() self.batch_counter = itertools.count() def _all_alive(self) -> bool: return all(p.is_alive() for p in self.processes) def ensure(self, count: int): count = max(1, int(count)) with self.lock: if self.worker_count == count and self.processes and self._all_alive(): return self.stop_locked() self.start_locked(count) def start_locked(self, count: int): self.job_queue = self.ctx.Queue() self.result_queue = self.ctx.Queue() self.processes = [] self.worker_count = count for _ in range(count): p = self.ctx.Process( target=_worker_loop, args=(self.job_queue, self.result_queue, self.config), daemon=True, ) p.start() self.processes.append(p) def stop_locked(self): if not self.processes: return if self.job_queue is not None: for _ in self.processes: self.job_queue.put({"type": "stop"}) for p in self.processes: p.join(timeout=5) self.processes = [] if self.job_queue is not None: self.job_queue.close() self.job_queue = None if self.result_queue is not None: self.result_queue.close() self.result_queue = None self.worker_count = 0 def stop(self): with self.lock: self.stop_locked() def run_jobs(self, jobs: List[GenerationJob], progress: Optional[gr.Progress]): if not jobs: return {} with self.lock: if not self.processes or self.job_queue is None or self.result_queue is None: raise RuntimeError("Worker pool not initialized") batch_id = next(self.batch_counter) total = len(jobs) for job in jobs: payload = job.__dict__.copy() payload["batch_id"] = batch_id self.job_queue.put(payload) row_results: Dict[int, Dict[str, Any]] = {} processed = 0 total = len(jobs) while processed < total: message = self.result_queue.get() # type: ignore[arg-type] if message.get("type") == "init_error": raise RuntimeError(f"Worker failed to start: {message['error']}") if message.get("batch_id") != batch_id: continue row_results[message["row_id"]] = message processed += 1 _update_progress(progress, min(processed / total, 0.999), desc=f"Processed {processed}/{total}") _update_progress(progress, 1.0, desc="Parallel generation complete") return row_results worker_pool = WorkerPool(parallel_worker_config) def _shutdown_worker_pool(): worker_pool.stop() atexit.register(_shutdown_worker_pool) _PRIMARY_TTS: Optional[IndexTTS2] = None _MODEL_SELECTION: Dict[str, Optional[str]] = {"gpt": None, "bpe": None} def _candidate_paths(base_dirs: List[Path], suffixes: List[str]) -> List[str]: results: List[str] = [] seen: set[str] = set() for base in base_dirs: if not base or not base.exists(): continue for suffix in suffixes: for path in base.glob(f"*{suffix}"): resolved = str(path.resolve()) if resolved not in seen: seen.add(resolved) results.append(resolved) results.sort() return results def _is_gpt_checkpoint(path: Path) -> bool: name = path.name.lower() if not name.endswith(".pth"): return False excluded = ("s2mel", "campplus", "bigvgan", "wav2vec", "emo", "spk", "cfm") return not any(token in name for token in excluded) def _discover_gpt_checkpoints() -> List[str]: bases = [ Path(cmd_args.model_dir), Path(current_dir) / "models", ] candidates = _candidate_paths(bases, [".pth"]) return [path for path in candidates if _is_gpt_checkpoint(Path(path))] def _discover_bpe_models() -> List[str]: bases = [ Path(cmd_args.model_dir), Path(current_dir) / "tokenizers", ] return _candidate_paths(bases, [".model"]) def dispose_primary_tts(): global _PRIMARY_TTS if _PRIMARY_TTS is not None: try: if hasattr(_PRIMARY_TTS, "gr_progress"): _PRIMARY_TTS.gr_progress = None finally: _PRIMARY_TTS = None gc.collect() if torch.cuda.is_available(): torch.cuda.empty_cache() def build_primary_tts() -> IndexTTS2: if _MODEL_SELECTION["gpt"] is None or _MODEL_SELECTION["bpe"] is None: raise RuntimeError("Model selection is not set. Provide GPT and BPE paths before loading.") return IndexTTS2( model_dir=cmd_args.model_dir, cfg_path=os.path.join(cmd_args.model_dir, "config.yaml"), is_fp16=cmd_args.is_fp16, use_cuda_kernel=False, use_accel=True, gpt_checkpoint_path=_MODEL_SELECTION["gpt"], bpe_model_path=_MODEL_SELECTION["bpe"], ) def load_primary_tts(gpt_path: str, bpe_path: str) -> IndexTTS2: dispose_primary_tts() resolved_gpt = os.path.abspath(gpt_path) resolved_bpe = os.path.abspath(bpe_path) previous_selection = _MODEL_SELECTION.copy() _MODEL_SELECTION["gpt"] = resolved_gpt _MODEL_SELECTION["bpe"] = resolved_bpe try: tts = build_primary_tts() except Exception: _MODEL_SELECTION.update(previous_selection) dispose_primary_tts() raise global _PRIMARY_TTS _PRIMARY_TTS = tts parallel_worker_config["gpt_path"] = resolved_gpt parallel_worker_config["bpe_path"] = resolved_bpe worker_pool.stop() return tts def ensure_primary_tts() -> IndexTTS2: if _PRIMARY_TTS is None: raise RuntimeError("No GPT checkpoint loaded. Use the Load button in the UI.") return _PRIMARY_TTS def _model_status_text() -> str: if _PRIMARY_TTS is None: return "⚠️ No model loaded. Select a GPT checkpoint and BPE tokenizer, then click Load." gpt_path = _MODEL_SELECTION.get("gpt") bpe_path = _MODEL_SELECTION.get("bpe") gpt_name = Path(gpt_path).name if gpt_path else "?" bpe_name = Path(bpe_path).name if bpe_path else "?" return f"✅ Loaded GPT: **{gpt_name}** | BPE: **{bpe_name}**" def _format_label(path: str) -> str: path_obj = Path(path) candidates: List[str] = [] try: rel_model = os.path.relpath(path, cmd_args.model_dir) if not rel_model.startswith(".."): prefix = Path(cmd_args.model_dir).name or "checkpoints" candidates.append(f"{prefix}/{rel_model}".replace("\\", "/")) except ValueError: pass try: rel_repo = os.path.relpath(path, current_dir) if not rel_repo.startswith(".."): candidates.append(rel_repo.replace("\\", "/")) except ValueError: pass candidates.append(path_obj.name) for label in candidates: if label: return label return str(path_obj) def _format_dropdown_choices( paths: List[str], current_selection: Optional[str], ) -> Tuple[List[str], Dict[str, str], Optional[str]]: labels: List[str] = [] mapping: Dict[str, str] = {} selected_label: Optional[str] = None for path in paths: label = _format_label(path) base_label = label suffix = 1 while label in mapping: label = f"{base_label} ({suffix})" suffix += 1 mapping[label] = path labels.append(label) if current_selection and os.path.abspath(path) == os.path.abspath(current_selection): selected_label = label if labels and selected_label is None: selected_label = labels[0] return labels, mapping, selected_label @dataclass class GenerationJob: row_id: int prompt_path: str text: str output_path: str emo_mode: int emo_weight: float emo_vector: Optional[List[float]] emo_text: str emo_random: bool emo_ref_path: Optional[str] max_tokens: int generation_kwargs: Dict[str, Any] verbose: bool duration_seconds: Optional[float] = None def _normalize_seed(seed_value: Any) -> Optional[int]: if seed_value is None: return None if isinstance(seed_value, str): value = seed_value.strip() if not value: return None try: seed = int(value) except ValueError: try: seed = int(float(value)) except ValueError: return None elif isinstance(seed_value, bool): seed = int(seed_value) elif isinstance(seed_value, float): if math.isnan(seed_value): return None seed = int(seed_value) else: try: seed = int(seed_value) except (TypeError, ValueError): return None if seed < 0: seed = abs(seed) return seed def _normalize_duration_seconds(value: Any) -> Optional[float]: if value is None: return None if isinstance(value, str): value = value.strip() if not value: return None try: seconds = float(value) except (TypeError, ValueError): return None if seconds <= 0: return None return seconds def _apply_seed(seed: Optional[int]) -> None: if seed is None: return py_seed = int(seed % (2**32)) random.seed(py_seed) np.random.seed(py_seed) torch_seed = int(seed % (2**63 - 1)) torch.manual_seed(torch_seed) if torch.cuda.is_available(): torch.cuda.manual_seed_all(torch_seed) def _prepare_generation_kwargs(raw_kwargs: Dict[str, Any]) -> Dict[str, Any]: kwargs = dict(raw_kwargs or {}) seed = _normalize_seed(kwargs.pop("seed", None)) _apply_seed(seed) return kwargs def _worker_loop(job_queue: mp.Queue, result_queue: mp.Queue, config: Dict[str, Any]): hf_cache = config.get("hf_cache") torch_cache = config.get("torch_cache") if hf_cache: os.environ.setdefault("HF_HOME", hf_cache) os.environ.setdefault("HF_HUB_CACHE", hf_cache) os.environ.setdefault("TRANSFORMERS_CACHE", hf_cache) os.makedirs(hf_cache, exist_ok=True) if torch_cache: os.environ.setdefault("TORCH_HOME", torch_cache) os.makedirs(torch_cache, exist_ok=True) os.environ.setdefault("INDEXTTS_USE_DEEPSPEED", "0") gpt_override = config.get("gpt_path") bpe_override = config.get("bpe_path") if not gpt_override or not bpe_override: result_queue.put({"type": "init_error", "error": "No GPT/BPE model loaded. Use the Load button."}) return try: worker_tts = IndexTTS2( model_dir=config["model_dir"], cfg_path=os.path.join(config["model_dir"], "config.yaml"), is_fp16=config.get("is_fp16", False), use_cuda_kernel=False, use_accel=True, gpt_checkpoint_path=gpt_override, bpe_model_path=bpe_override, ) except Exception as exc: # pragma: no cover - worker init path logger.exception("Worker failed to initialize") result_queue.put({"type": "init_error", "error": str(exc)}) return while True: job = job_queue.get() if isinstance(job, dict) and job.get("type") == "stop": break try: emo_mode = job["emo_mode"] emo_audio_prompt = job["emo_ref_path"] if emo_mode == 1 else None emo_alpha = job["emo_weight"] if emo_mode == 1 else 1.0 emo_vector = job["emo_vector"] if emo_mode == 2 else None use_emo_text = emo_mode == 3 generation_kwargs = _prepare_generation_kwargs(job.get("generation_kwargs", {})) worker_tts.infer( spk_audio_prompt=job["prompt_path"], text=job["text"], output_path=job["output_path"], emo_audio_prompt=emo_audio_prompt, emo_alpha=emo_alpha, emo_vector=emo_vector, use_emo_text=use_emo_text, emo_text=job["emo_text"], use_random=job["emo_random"], verbose=job.get("verbose", False), max_text_tokens_per_sentence=job["max_tokens"], duration_seconds=job.get("duration_seconds"), **generation_kwargs, ) result_queue.put( { "type": "result", "row_id": job["row_id"], "status": "Completed", "output_path": job["output_path"], "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"), "error": None, "batch_id": job.get("batch_id"), } ) except Exception as exc: # pragma: no cover - worker runtime path logger.exception("Worker generation error") result_queue.put( { "type": "result", "row_id": job["row_id"], "status": f"Error: {exc}", "output_path": None, "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"), "error": str(exc), "batch_id": job.get("batch_id"), } ) try: worker_tts.unload() # type: ignore[attr-defined] except Exception: # pragma: no cover - optional cleanup pass def _update_progress(progress: Optional[gr.Progress], value: float, desc: str = "") -> None: if progress is None: return try: progress(value, desc=desc) except Exception: pass MAX_LENGTH_TO_USE_SPEED = 70 def create_demo() -> gr.Blocks: gpt_choices = _discover_gpt_checkpoints() bpe_choices = _discover_bpe_models() gpt_labels, gpt_map, initial_gpt_label = _format_dropdown_choices(gpt_choices, _MODEL_SELECTION["gpt"]) bpe_labels, bpe_map, initial_bpe_label = _format_dropdown_choices(bpe_choices, _MODEL_SELECTION["bpe"]) gpt_cfg = getattr(BASE_CFG, "gpt", {}) max_mel_tokens_limit = int(getattr(gpt_cfg, "max_mel_tokens", 2048)) if max_mel_tokens_limit < 100: max_mel_tokens_limit = 100 default_mel_value = min(1500, max_mel_tokens_limit) max_text_tokens_limit = int(getattr(gpt_cfg, "max_text_tokens", 256)) if max_text_tokens_limit < 40: max_text_tokens_limit = 40 default_text_tokens = min(120, max_text_tokens_limit) cfg_version = getattr(BASE_CFG, "version", "1.0") with gr.Blocks(title="IndexTTS Parallel Demo") as demo: model_status = gr.Markdown(value=_model_status_text()) gpt_map_state = gr.State(gpt_map) bpe_map_state = gr.State(bpe_map) with gr.Row(): gpt_dropdown = gr.Dropdown( choices=gpt_labels, value=initial_gpt_label, label="GPT Checkpoint (.pth)", interactive=True, ) bpe_dropdown = gr.Dropdown( choices=bpe_labels, value=initial_bpe_label, label="BPE Tokenizer (.model)", interactive=True, ) refresh_models_button = gr.Button("Refresh Models", variant="secondary") load_models_button = gr.Button("Load Models", variant="primary") def refresh_model_lists(): gpt_files = _discover_gpt_checkpoints() bpe_files = _discover_bpe_models() gpt_labels_new, gpt_map_new, gpt_value = _format_dropdown_choices(gpt_files, _MODEL_SELECTION["gpt"]) bpe_labels_new, bpe_map_new, bpe_value = _format_dropdown_choices(bpe_files, _MODEL_SELECTION["bpe"]) return ( gr.update(choices=gpt_labels_new, value=gpt_value), gr.update(choices=bpe_labels_new, value=bpe_value), gpt_map_new, bpe_map_new, _model_status_text(), ) def handle_model_load( gpt_label: Optional[str], bpe_label: Optional[str], gpt_map_value: Optional[Dict[str, str]], bpe_map_value: Optional[Dict[str, str]], progress: gr.Progress = gr.Progress(track_tqdm=False), ) -> str: gpt_map_local = gpt_map_value or {} bpe_map_local = bpe_map_value or {} gpt_path = gpt_map_local.get(gpt_label or "", gpt_label) bpe_path = bpe_map_local.get(bpe_label or "", bpe_label) if not gpt_path or not bpe_path: gr.Warning("Select both a GPT checkpoint and a BPE tokenizer before loading.") return _model_status_text() progress(0.1, "Loading models...") try: load_primary_tts(gpt_path, bpe_path) except Exception as exc: logger.exception("Failed to load models") gr.Warning(f"Failed to load models: {exc}") return f"❌ Failed to load models: {exc}" gr.Info("Models loaded successfully.") return _model_status_text() refresh_models_button.click( refresh_model_lists, inputs=[], outputs=[gpt_dropdown, bpe_dropdown, gpt_map_state, bpe_map_state, model_status], ) load_models_button.click( handle_model_load, inputs=[gpt_dropdown, bpe_dropdown, gpt_map_state, bpe_map_state], outputs=model_status, ) batch_rows_state = gr.State([]) next_batch_id_state = gr.State(1) gr.HTML( """

IndexTTS2 Parallel Batch Demo

""" ) with gr.Accordion("Emotion Settings", open=True): with gr.Row(): emo_control_method = gr.Radio( choices=EMO_CHOICES, type="index", value=0, label="Emotion Control Mode", ) with gr.Group(visible=False) as emotion_reference_group: with gr.Row(): emo_upload = gr.Audio(label="Emotion Reference Audio", type="filepath") with gr.Row(): emo_weight = gr.Slider(label="Emotion Weight", minimum=0.0, maximum=1.6, value=0.8, step=0.01) with gr.Row(): emo_random = gr.Checkbox(label="Random Emotion Sampling", value=False, visible=False) with gr.Group(visible=False) as emotion_vector_group: with gr.Row(): with gr.Column(): vec1 = gr.Slider(label="Joy", minimum=0.0, maximum=1.4, value=0.0, step=0.05) vec2 = gr.Slider(label="Anger", minimum=0.0, maximum=1.4, value=0.0, step=0.05) vec3 = gr.Slider(label="Sadness", minimum=0.0, maximum=1.4, value=0.0, step=0.05) vec4 = gr.Slider(label="Fear", minimum=0.0, maximum=1.4, value=0.0, step=0.05) with gr.Column(): vec5 = gr.Slider(label="Disgust", minimum=0.0, maximum=1.4, value=0.0, step=0.05) vec6 = gr.Slider(label="Low Mood", minimum=0.0, maximum=1.4, value=0.0, step=0.05) vec7 = gr.Slider(label="Surprise", minimum=0.0, maximum=1.4, value=0.0, step=0.05) vec8 = gr.Slider(label="Calm", minimum=0.0, maximum=1.4, value=0.0, step=0.05) with gr.Group(visible=False) as emo_text_group: emo_text = gr.Textbox(label="Emotion Description", placeholder="Describe the target emotion", value="") with gr.Accordion("Advanced Generation Settings", open=False): with gr.Row(): with gr.Column(scale=1): gr.Markdown("**GPT2 Sampling Settings**") with gr.Row(): do_sample = gr.Checkbox(label="do_sample", value=True, info="Enable sampling") temperature = gr.Slider(label="temperature", minimum=0.1, maximum=2.0, value=0.8, 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=default_mel_value, minimum=50, maximum=max_mel_tokens_limit, step=10, info="Maximum generated mel tokens", ) seed_value = gr.Number( label="Seed", value=None, precision=0, minimum=0, step=1, info="Leave blank for random sampling; set a value for reproducible outputs.", ) with gr.Column(scale=2): gr.Markdown("**Sentence Settings**") max_text_tokens_per_sentence = gr.Slider( label="Max tokens per sentence", value=default_text_tokens, minimum=20, maximum=max_text_tokens_limit, step=2, key="max_text_tokens_per_sentence", ) duration_seconds_input = gr.Number( label="Target duration (seconds)", value=None, precision=2, minimum=0, step=0.1, info="Optional: approximate overall audio length. Leave blank for free duration.", ) with gr.Accordion("Preview sentences", open=True): sentences_preview = gr.Dataframe( headers=["Index", "Sentence", "Token Count"], key="sentences_preview", wrap=True, ) advanced_params = [ do_sample, top_p, top_k, temperature, length_penalty, num_beams, repetition_penalty, max_mel_tokens, seed_value, ] with gr.Tab("Single Generation"): with gr.Row(): prompt_audio = gr.Audio(label="Prompt Audio", key="prompt_audio", sources=["upload", "microphone"], type="filepath") with gr.Column(): input_text_single = gr.TextArea( label="Text", key="input_text_single", placeholder="Enter text to synthesize", info=f"Model version {cfg_version}", ) gen_button = gr.Button("Generate", key="gen_button", interactive=True) output_audio = gr.Audio(label="Generated Result", visible=True, key="output_audio") if example_cases: gr.Examples( examples=example_cases, inputs=[ prompt_audio, emo_control_method, input_text_single, emo_upload, emo_weight, emo_text, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, ], ) with gr.Tab("Batch Generation"): gr.Markdown("Manage multiple prompt audios, give each its own text, generate in bulk, and retry specific entries as needed.") with gr.Row(): with gr.Column(scale=2): with gr.Row(): dataset_path_input = gr.Textbox( label="Dataset train.txt path", value="vivy_va_dataset/train.txt", scale=3, placeholder="Path to train.txt", ) load_dataset_button = gr.Button("Load Dataset", scale=1) batch_file_input = gr.Files( label="Add prompt audio files", file_types=["audio"], file_count="multiple", type="filepath", ) worker_count = gr.Slider( label="Parallel workers", minimum=1, maximum=8, value=2, step=1, info="Number of parallel TTS workers", ) batch_table = gr.Dataframe( headers=["ID", "Prompt", "Text", "Output", "Status", "Last Generated"], datatype=["number", "str", "str", "str", "str", "str"], row_count=(0, "dynamic"), col_count=6, interactive=False, value=[], ) with gr.Column(): selected_entry = gr.Dropdown(label="Select entry", choices=[], value=None, interactive=True) batch_prompt_player = gr.Audio(label="Prompt Audio", type="filepath", interactive=False) batch_output_player = gr.Audio(label="Generated Audio", type="filepath", interactive=False) batch_text_input = gr.TextArea(label="Text", placeholder="Enter text for this entry", interactive=True) apply_text_button = gr.Button("Save Text", variant="secondary") batch_status = gr.Markdown(value="No entry selected.") with gr.Row(): generate_all_button = gr.Button("Generate All") regenerate_button = gr.Button("Regenerate Selected") with gr.Row(): delete_entry_button = gr.Button("Delete Selected") clear_entries_button = gr.Button("Clear All") def gen_single( emo_control_method_value, prompt, text, emo_ref_path, emo_weight_value, vec1_value, vec2_value, vec3_value, vec4_value, vec5_value, vec6_value, vec7_value, vec8_value, emo_text_value, emo_random_value, max_text_tokens_per_sentence_value, duration_seconds_value, *args, progress: gr.Progress = gr.Progress(), ): if not prompt: gr.Warning("Upload a prompt audio file first.") return gr.update() output_path = os.path.join(current_dir, "outputs", f"spk_{int(time.time())}.wav") try: tts = ensure_primary_tts() except RuntimeError as exc: gr.Warning(str(exc)) return gr.update() tts.gr_progress = progress advanced_values = list(args) expected_len = len(advanced_params) if len(advanced_values) < expected_len: advanced_values.extend([None] * (expected_len - len(advanced_values))) raw_generation_kwargs = build_generation_kwargs(*advanced_values[:expected_len]) generation_kwargs = _prepare_generation_kwargs(raw_generation_kwargs) emo_mode = emo_control_method_value if isinstance(emo_control_method_value, int) else getattr(emo_control_method_value, "value", 0) if emo_mode == 2: vec_sum = vec1_value + vec2_value + vec3_value + vec4_value + vec5_value + vec6_value + vec7_value + vec8_value if vec_sum > 1.5: gr.Warning("Emotion vector sum cannot exceed 1.5. Adjust the sliders and retry.") return gr.update() emo_vector = [vec1_value, vec2_value, vec3_value, vec4_value, vec5_value, vec6_value, vec7_value, vec8_value] else: emo_vector = None duration_seconds = _normalize_duration_seconds(duration_seconds_value) tts.infer( spk_audio_prompt=prompt, text=text, output_path=output_path, emo_audio_prompt=emo_ref_path if emo_mode == 1 else None, emo_alpha=float(emo_weight_value) if emo_mode == 1 else 1.0, emo_vector=emo_vector if emo_mode == 2 else None, use_emo_text=(emo_mode == 3), emo_text=emo_text_value, use_random=emo_random_value, verbose=cmd_args.verbose, max_text_tokens_per_sentence=int(max_text_tokens_per_sentence_value), duration_seconds=duration_seconds, **generation_kwargs, ) return gr.update(value=output_path, visible=True) def on_input_text_change(text_value, max_tokens_value): if not text_value: return {sentences_preview: gr.update(value=[], visible=True, type="array")} try: tts = ensure_primary_tts() except RuntimeError as exc: gr.Warning(str(exc)) return {sentences_preview: gr.update(value=[], visible=True, type="array")} tokenized = tts.tokenizer.tokenize(text_value) sentences = tts.tokenizer.split_segments( tokenized, max_text_tokens_per_segment=int(max_tokens_value) ) data = [] for idx, sentence_tokens in enumerate(sentences): sentence_str = "".join(sentence_tokens) data.append([idx, sentence_str, len(sentence_tokens)]) return {sentences_preview: gr.update(value=data, visible=True, type="array")} def on_method_select(emo_control_value): if emo_control_value == 1: return ( gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), ) if emo_control_value == 2: return ( gr.update(visible=False), gr.update(visible=True), gr.update(visible=True), gr.update(visible=False), ) if emo_control_value == 3: return ( gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), gr.update(visible=True), ) return ( gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), ) def build_batch_table_data(rows: List[Dict[str, Any]]): table_data = [] for row in rows: text_preview = (row.get("text") or "")[:57] if row.get("text") and len(row["text"]) > 60: text_preview += "..." table_data.append( [ row.get("id"), os.path.basename(row.get("prompt_path", "")) if row.get("prompt_path") else "", text_preview, os.path.basename(row.get("output_path", "")) if row.get("output_path") else "", row.get("status", "Pending"), row.get("last_generated", ""), ] ) return table_data def find_batch_row(rows, row_id): for row in rows or []: if row.get("id") == row_id: return row return None def resolve_batch_selection(rows, selected_value): choices = [str(row.get("id")) for row in rows or []] if not choices: return gr.update(choices=[], value=None), None if selected_value is not None: selected_str = str(selected_value) if selected_str in choices: return gr.update(choices=choices, value=selected_str), int(selected_str) return gr.update(choices=choices, value=choices[-1]), int(choices[-1]) def prepare_batch_selection(rows, selected_value): dropdown_update, resolved_id = resolve_batch_selection(rows, selected_value) row = find_batch_row(rows, resolved_id) prompt_update = gr.update(value=row.get("prompt_path") if row else None) output_update = gr.update(value=row.get("output_path") if row else None) text_update = gr.update(value=row.get("text", "") if row else "") return dropdown_update, resolved_id, prompt_update, output_update, text_update, row def format_batch_status(row, message=None): if not row: base = "No entry selected." else: details = [f"Row {row.get('id')}: {row.get('status', 'Pending')}"] if row.get("text"): preview = row["text"][:117] + ("..." if len(row["text"]) > 120 else "") details.append(f"Text: {preview}") if row.get("output_path"): details.append(f"Output: {row['output_path']}") if row.get("last_generated"): details.append(f"Last generated: {row['last_generated']}") base = "\n".join(details) if message: base = f"{base}\n{message}" if base else message return gr.update(value=base) def add_batch_prompts(files, rows, next_id, selected_value): rows = rows or [] next_id = next_id or 1 files = files or [] updated_rows = [dict(row) for row in rows] prompts_dir = os.path.join(current_dir, "prompts") os.makedirs(prompts_dir, exist_ok=True) added = 0 last_added_id = None for file_path in files: if not file_path: continue safe_name = os.path.basename(file_path) timestamp = int(time.time() * 1000) target_name = f"batch_prompt_{next_id}_{timestamp}_{safe_name}" target_path = os.path.join(prompts_dir, target_name) try: shutil.copy(file_path, target_path) except Exception as exc: logger.exception("Failed to store prompt %s", file_path) gr.Warning(f"Failed to add {safe_name}: {exc}") continue entry = { "id": next_id, "prompt_path": target_path, "output_path": None, "status": "Pending", "last_generated": "", "text": "", } updated_rows.append(entry) added += 1 last_added_id = entry["id"] next_id += 1 selected_seed = last_added_id if added else selected_value dropdown_update, resolved_id, prompt_update, output_update, text_update, selected_row = prepare_batch_selection( updated_rows, selected_seed ) table_update = gr.update(value=build_batch_table_data(updated_rows)) status_message = f"Added {added} prompt{'s' if added != 1 else ''}." if added else "No new prompts were added." status_update = format_batch_status(selected_row, status_message) return updated_rows, next_id, gr.update(value=None), table_update, dropdown_update, prompt_update, output_update, text_update, status_update def validate_emotion_settings(emo_control_method_value, vec_values): mode = emo_control_method_value if isinstance(emo_control_method_value, int) else getattr( emo_control_method_value, "value", 0 ) try: mode = int(mode) except (TypeError, ValueError): mode = 0 vec = None if mode == 2: if sum(vec_values) > 1.5: gr.Warning("Emotion vector sum cannot exceed 1.5. Adjust the sliders and retry.") return mode, None vec = vec_values return mode, vec def build_generation_kwargs( do_sample_value, top_p_value, top_k_value, temperature_value, length_penalty_value, num_beams_value, repetition_penalty_value, max_mel_tokens_value, seed_value, ): try: top_k_int = int(top_k_value) except (TypeError, ValueError): top_k_int = 0 try: num_beams_int = int(num_beams_value) except (TypeError, ValueError): num_beams_int = 1 kwargs = { "do_sample": bool(do_sample_value), "top_p": float(top_p_value), "top_k": top_k_int if top_k_int > 0 else None, "temperature": float(temperature_value), "length_penalty": float(length_penalty_value), "num_beams": num_beams_int, "repetition_penalty": float(repetition_penalty_value), "max_mel_tokens": int(max_mel_tokens_value), } seed_int = _normalize_seed(seed_value) if seed_int is not None: kwargs["seed"] = seed_int return kwargs def load_dataset_entries(dataset_path, rows, next_id, selected_value, *, progress: Optional[gr.Progress] = None): rows = rows or [] next_id = next_id or 1 dataset_path = (dataset_path or "").strip() if not dataset_path: gr.Warning("Provide a dataset train.txt path before loading.") dropdown_update, _, prompt_update, output_update, text_update, row = prepare_batch_selection(rows, selected_value) table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(row) return rows, next_id, gr.update(value=""), table_update, dropdown_update, prompt_update, output_update, text_update, status_update dataset_path_abs = dataset_path if os.path.isabs(dataset_path) else os.path.abspath(os.path.join(current_dir, dataset_path)) if not os.path.exists(dataset_path_abs): gr.Warning(f"Dataset file not found: {dataset_path_abs}") dropdown_update, _, prompt_update, output_update, text_update, row = prepare_batch_selection(rows, selected_value) table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(row) return rows, next_id, gr.update(value=dataset_path), table_update, dropdown_update, prompt_update, output_update, text_update, status_update dataset_dir = os.path.dirname(dataset_path_abs) candidate_dirs = [dataset_dir, os.path.join(dataset_dir, "wavs"), os.path.join(dataset_dir, "audio")] try: lines = Path(dataset_path_abs).read_text(encoding="utf-8").splitlines() except Exception as exc: gr.Warning(f"Failed to read dataset file: {exc}") dropdown_update, _, prompt_update, output_update, text_update, row = prepare_batch_selection(rows, selected_value) table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(row) return rows, next_id, gr.update(value=dataset_path), table_update, dropdown_update, prompt_update, output_update, text_update, status_update updated_rows = [dict(row) for row in rows] prompts_dir = os.path.join(current_dir, "prompts") os.makedirs(prompts_dir, exist_ok=True) existing_prompts = {os.path.basename(r.get("prompt_path", "")) for r in updated_rows if r.get("prompt_path")} added = 0 missing_audio = 0 invalid_lines = 0 total_lines = len(lines) _update_progress(progress, 0.0, desc="Parsing dataset") for idx, raw_line in enumerate(lines): _update_progress(progress, min((idx + 1) / max(total_lines, 1), 0.95), desc=f"Processing line {idx + 1}/{total_lines}") stripped = raw_line.strip() if not stripped or stripped.startswith("#"): continue parts = stripped.split("|", 1) if len(parts) != 2: invalid_lines += 1 continue audio_name = parts[0].strip() text_value = parts[1].strip() if not audio_name or not text_value: invalid_lines += 1 continue source_path = None for base_dir in candidate_dirs: candidate = os.path.join(base_dir, audio_name) if os.path.exists(candidate): source_path = candidate break if not source_path: missing_audio += 1 continue unique_prefix = f"dataset_{next_id}_{int(time.time() * 1000)}" target_name = f"{unique_prefix}_{os.path.basename(audio_name)}" if target_name in existing_prompts: target_name = f"{unique_prefix}_{next_id}_{os.path.basename(audio_name)}" target_path = os.path.join(prompts_dir, target_name) try: shutil.copy(source_path, target_path) except Exception as exc: logger.exception("Failed to copy dataset prompt %s", source_path) gr.Warning(f"Failed to copy {audio_name}: {exc}") missing_audio += 1 continue entry = { "id": next_id, "prompt_path": target_path, "output_path": None, "status": "Pending", "last_generated": "", "text": text_value, } updated_rows.append(entry) existing_prompts.add(target_name) added += 1 next_id += 1 selected_seed = updated_rows[-1]["id"] if added else selected_value dropdown_update, resolved_id, prompt_update, output_update, text_update, selected_row = prepare_batch_selection( updated_rows, selected_seed ) table_update = gr.update(value=build_batch_table_data(updated_rows)) messages = [] if added: messages.append(f"Loaded {added} entries") if missing_audio: messages.append(f"{missing_audio} missing audio") if invalid_lines: messages.append(f"{invalid_lines} invalid lines") status_message = ", ".join(messages) if messages else "No new entries loaded." status_update = format_batch_status(selected_row, status_message) _update_progress(progress, 1.0, desc="Dataset load complete") return updated_rows, next_id, gr.update(value=dataset_path), table_update, dropdown_update, prompt_update, output_update, text_update, status_update def generate_all_batch(rows, selected_value, worker_count_value, emo_control_method_value, emo_ref_path, emo_weight_value, vec1_value, vec2_value, vec3_value, vec4_value, vec5_value, vec6_value, vec7_value, vec8_value, emo_text_value, emo_random_value, max_text_tokens_per_sentence_value, duration_seconds_value, *advanced_param_values, progress: Optional[gr.Progress] = None): rows = rows or [] if not rows: gr.Warning("Add prompt audio files before generating.") dropdown_update, _, prompt_update, output_update, text_update, row = prepare_batch_selection(rows, selected_value) table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(row) return rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update if parallel_worker_config.get("gpt_path") is None or parallel_worker_config.get("bpe_path") is None: gr.Warning("Load a GPT checkpoint and BPE tokenizer before generating.") dropdown_update, _, prompt_update, output_update, text_update, row = prepare_batch_selection(rows, selected_value) table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(row, "Model not loaded.") return rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update vec_values = [vec1_value, vec2_value, vec3_value, vec4_value, vec5_value, vec6_value, vec7_value, vec8_value] emo_mode, emo_vector = validate_emotion_settings(emo_control_method_value, vec_values) if emo_mode == 2 and emo_vector is None: dropdown_update, _, prompt_update, output_update, text_update, row = prepare_batch_selection(rows, selected_value) table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(row, "Emotion vector sum exceeded limit.") return rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update try: max_tokens = int(max_text_tokens_per_sentence_value) except (TypeError, ValueError): max_tokens = 120 duration_seconds = _normalize_duration_seconds(duration_seconds_value) duration_seconds = _normalize_duration_seconds(duration_seconds_value) adv_values = list(advanced_param_values) expected_len = len(advanced_params) if len(adv_values) < expected_len: adv_values.extend([None] * (expected_len - len(adv_values))) base_generation_kwargs = build_generation_kwargs(*adv_values[:expected_len]) outputs_dir = os.path.join(current_dir, "outputs", "tasks") os.makedirs(outputs_dir, exist_ok=True) jobs: List[GenerationJob] = [] row_map: Dict[int, Dict[str, Any]] = {} for row in rows: new_row = dict(row) prompt_path = new_row.get("prompt_path") if not prompt_path or not os.path.exists(prompt_path): new_row["status"] = "Error: Prompt missing" row_map[new_row["id"]] = new_row continue text_value = (new_row.get("text") or "").strip() if not text_value: new_row["status"] = "Error: Text missing" row_map[new_row["id"]] = new_row continue output_path = os.path.join(outputs_dir, f"batch_row_{new_row['id']}_{int(time.time() * 1000)}.wav") new_row["status"] = "Running" new_row["output_path"] = output_path row_map[new_row["id"]] = new_row jobs.append( GenerationJob( row_id=new_row["id"], prompt_path=prompt_path, text=text_value, output_path=output_path, emo_mode=emo_mode, emo_weight=float(emo_weight_value) if emo_mode == 1 else 1.0, emo_vector=emo_vector if emo_mode == 2 else None, emo_text=emo_text_value, emo_random=bool(emo_random_value), emo_ref_path=emo_ref_path if emo_mode == 1 else None, max_tokens=max_tokens, generation_kwargs=dict(base_generation_kwargs), verbose=cmd_args.verbose, duration_seconds=duration_seconds, ) ) running_rows = list(row_map.values()) table_running = gr.update(value=build_batch_table_data(running_rows)) dropdown_update, resolved_id, prompt_update, output_update, text_update, selected_row = prepare_batch_selection( running_rows, selected_value ) if not jobs: status_update = format_batch_status(selected_row, "No rows ready for generation.") return running_rows, table_running, dropdown_update, prompt_update, output_update, text_update, status_update _update_progress(progress, 0.0, desc="Starting parallel generation") worker_pool.ensure(worker_count_value) results = worker_pool.run_jobs(jobs, progress) for row_id, result in results.items(): row_entry = row_map.get(row_id) if not row_entry: continue row_entry["status"] = result["status"] row_entry["last_generated"] = result.get("timestamp", "") if result["output_path"]: row_entry["output_path"] = result["output_path"] final_rows = list(row_map.values()) table_update = gr.update(value=build_batch_table_data(final_rows)) dropdown_update, resolved_id, prompt_update, output_update, text_update, selected_row = prepare_batch_selection( final_rows, resolved_id ) status_update = format_batch_status(selected_row, "Parallel generation finished.") return final_rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update def regenerate_batch_entry(rows, selected_value, worker_count_value, emo_control_method_value, emo_ref_path, emo_weight_value, vec1_value, vec2_value, vec3_value, vec4_value, vec5_value, vec6_value, vec7_value, vec8_value, emo_text_value, emo_random_value, max_text_tokens_per_sentence_value, duration_seconds_value, *advanced_param_values, progress: Optional[gr.Progress] = None): rows = rows or [] dropdown_update, resolved_id, prompt_update, output_update, text_update, selected_row = prepare_batch_selection(rows, selected_value) if not selected_row: gr.Warning("Select an entry to regenerate.") table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(None) return rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update if parallel_worker_config.get("gpt_path") is None or parallel_worker_config.get("bpe_path") is None: gr.Warning("Load a GPT checkpoint and BPE tokenizer before generating.") table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(selected_row, "Model not loaded.") return rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update vec_values = [vec1_value, vec2_value, vec3_value, vec4_value, vec5_value, vec6_value, vec7_value, vec8_value] emo_mode, emo_vector = validate_emotion_settings(emo_control_method_value, vec_values) if emo_mode == 2 and emo_vector is None: table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(selected_row, "Emotion vector sum exceeded limit.") return rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update prompt_path = selected_row.get("prompt_path") if not prompt_path or not os.path.exists(prompt_path): gr.Warning("Prompt audio file is missing.") table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(selected_row, "Prompt audio file missing.") return rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update text_value = (selected_row.get("text") or "").strip() if not text_value: gr.Warning("Enter text for this entry before regenerating.") table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(selected_row, "Text is missing.") return rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update try: max_tokens = int(max_text_tokens_per_sentence_value) except (TypeError, ValueError): max_tokens = 120 adv_values = list(advanced_param_values) expected_len = len(advanced_params) if len(adv_values) < expected_len: adv_values.extend([None] * (expected_len - len(adv_values))) generation_kwargs = build_generation_kwargs(*adv_values[:expected_len]) outputs_dir = os.path.join(current_dir, "outputs", "tasks") os.makedirs(outputs_dir, exist_ok=True) output_path = os.path.join(outputs_dir, f"batch_row_{selected_row['id']}_{int(time.time() * 1000)}.wav") job = GenerationJob( row_id=selected_row["id"], prompt_path=prompt_path, text=text_value, output_path=output_path, emo_mode=emo_mode, emo_weight=float(emo_weight_value) if emo_mode == 1 else 1.0, emo_vector=emo_vector if emo_mode == 2 else None, emo_text=emo_text_value, emo_random=bool(emo_random_value), emo_ref_path=emo_ref_path if emo_mode == 1 else None, max_tokens=max_tokens, generation_kwargs=dict(generation_kwargs), verbose=cmd_args.verbose, duration_seconds=duration_seconds, ) _update_progress(progress, 0.0, desc="Regenerating entry") worker_pool.ensure(worker_count_value) results = worker_pool.run_jobs([job], progress) result = results.get(job.row_id) updated_rows = [] for row in rows: if row.get("id") != job.row_id: updated_rows.append(dict(row)) continue new_row = dict(row) if result: new_row["status"] = result["status"] new_row["output_path"] = result.get("output_path", new_row.get("output_path")) new_row["last_generated"] = result.get("timestamp", "") else: new_row["status"] = "Error: Unknown" updated_rows.append(new_row) table_update = gr.update(value=build_batch_table_data(updated_rows)) dropdown_update, resolved_id, prompt_update, output_update, text_update, selected_row = prepare_batch_selection( updated_rows, job.row_id ) status_update = format_batch_status(selected_row, "Regeneration finished.") return updated_rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update def delete_batch_entry(rows, selected_value): rows = rows or [] dropdown_update, resolved_id, prompt_update, output_update, text_update, selected_row = prepare_batch_selection(rows, selected_value) if not selected_row: gr.Warning("Select an entry to delete.") table_update = gr.update(value=build_batch_table_data(rows)) status_update = format_batch_status(None) return rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update remaining_rows = [dict(row) for row in rows if row.get("id") != selected_row.get("id")] dropdown_update, resolved_id, prompt_update, output_update, text_update, row = prepare_batch_selection(remaining_rows, None) table_update = gr.update(value=build_batch_table_data(remaining_rows)) status_update = format_batch_status(row, "Entry deleted.") return remaining_rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update def clear_batch_rows(rows, next_id): dropdown_update = gr.update(choices=[], value=None) prompt_update = gr.update(value=None) output_update = gr.update(value=None) text_update = gr.update(value="") status_update = format_batch_status(None, "Batch list cleared.") return [], 1, gr.update(value=[]), dropdown_update, prompt_update, output_update, text_update, status_update def on_select_batch_entry(selected_value, rows): dropdown_update, resolved_id, prompt_update, output_update, text_update, row = prepare_batch_selection(rows, selected_value) status_update = format_batch_status(row) return dropdown_update, prompt_update, output_update, text_update, status_update def update_batch_text(new_text, rows, selected_value): rows = rows or [] try: selected_id = int(selected_value) if selected_value is not None else None except (TypeError, ValueError): selected_id = None if selected_id is None: gr.Warning("Select an entry before editing text.") table_update = gr.update(value=build_batch_table_data(rows)) dropdown_update, resolved_id, prompt_update, output_update, text_update, row = prepare_batch_selection(rows, selected_value) status_update = format_batch_status(row) return rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update updated_rows = [] target_row = None for row in rows: new_row = dict(row) if row.get("id") == selected_id: new_row["text"] = new_text if new_row.get("output_path"): new_row["status"] = "Pending" target_row = new_row updated_rows.append(new_row) dropdown_update, resolved_id, prompt_update, output_update, text_update, row = prepare_batch_selection(updated_rows, selected_id) table_update = gr.update(value=build_batch_table_data(updated_rows)) status_update = format_batch_status(row, "Text updated. Regenerate to apply." if target_row else None) return updated_rows, table_update, dropdown_update, prompt_update, output_update, text_update, status_update def update_prompt_audio(): return gr.update(interactive=True) emo_control_method.select( on_method_select, inputs=[emo_control_method], outputs=[emotion_reference_group, emo_random, emotion_vector_group, emo_text_group], ) input_text_single.change( on_input_text_change, inputs=[input_text_single, max_text_tokens_per_sentence], outputs=[sentences_preview], ) max_text_tokens_per_sentence.change( on_input_text_change, inputs=[input_text_single, max_text_tokens_per_sentence], outputs=[sentences_preview], ) prompt_audio.upload(update_prompt_audio, inputs=[], outputs=[gen_button]) gen_button.click( gen_single, inputs=[ emo_control_method, prompt_audio, input_text_single, emo_upload, emo_weight, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, emo_text, emo_random, max_text_tokens_per_sentence, duration_seconds_input, *advanced_params, ], outputs=[output_audio], show_progress=True, ) batch_file_input.upload( add_batch_prompts, inputs=[batch_file_input, batch_rows_state, next_batch_id_state, selected_entry], outputs=[batch_rows_state, next_batch_id_state, batch_file_input, batch_table, selected_entry, batch_prompt_player, batch_output_player, batch_text_input, batch_status], ) load_dataset_button.click( load_dataset_entries, inputs=[dataset_path_input, batch_rows_state, next_batch_id_state, selected_entry], outputs=[batch_rows_state, next_batch_id_state, dataset_path_input, batch_table, selected_entry, batch_prompt_player, batch_output_player, batch_text_input, batch_status], ) selected_entry.change( on_select_batch_entry, inputs=[selected_entry, batch_rows_state], outputs=[selected_entry, batch_prompt_player, batch_output_player, batch_text_input, batch_status], ) apply_text_button.click( update_batch_text, inputs=[batch_text_input, batch_rows_state, selected_entry], outputs=[batch_rows_state, batch_table, selected_entry, batch_prompt_player, batch_output_player, batch_text_input, batch_status], ) generate_all_button.click( generate_all_batch, inputs=[ batch_rows_state, selected_entry, worker_count, emo_control_method, emo_upload, emo_weight, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, emo_text, emo_random, max_text_tokens_per_sentence, duration_seconds_input, *advanced_params, ], outputs=[batch_rows_state, batch_table, selected_entry, batch_prompt_player, batch_output_player, batch_text_input, batch_status], ) regenerate_button.click( regenerate_batch_entry, inputs=[ batch_rows_state, selected_entry, worker_count, emo_control_method, emo_upload, emo_weight, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, emo_text, emo_random, max_text_tokens_per_sentence, duration_seconds_input, *advanced_params, ], outputs=[batch_rows_state, batch_table, selected_entry, batch_prompt_player, batch_output_player, batch_text_input, batch_status], ) delete_entry_button.click( delete_batch_entry, inputs=[batch_rows_state, selected_entry], outputs=[batch_rows_state, batch_table, selected_entry, batch_prompt_player, batch_output_player, batch_text_input, batch_status], ) clear_entries_button.click( clear_batch_rows, inputs=[batch_rows_state, next_batch_id_state], outputs=[batch_rows_state, next_batch_id_state, batch_table, selected_entry, batch_prompt_player, batch_output_player, batch_text_input, batch_status], ) return demo def main(): demo = create_demo() demo.queue(20) demo.launch(server_name=cmd_args.host, server_port=cmd_args.port) if __name__ == "__main__": mp.set_start_method("spawn", force=True) main()