The open-source AI voice studio. Clone, dictate, create.
fix take-label race in regeneration, add accessible focus to select
James Pine473bb3e9fbcf
diff --git a/app/src/components/ui/select.tsx b/app/src/components/ui/select.tsxindex 7bdfe2b0..22e981d3 100644--- a/app/src/components/ui/select.tsx+++ b/app/src/components/ui/select.tsx@@ -16,7 +16,7 @@ const SelectTrigger = React.forwardRef<<SelectPrimitive.Triggerref={ref}className={cn(- 'flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1',+ 'flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:bg-muted disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1',className,)}{...props}diff --git a/backend/app.py b/backend/app.pyindex 69cee59b..4e29163e 100644--- a/backend/app.py+++ b/backend/app.py@@ -1,9 +1,12 @@"""FastAPI application factory, middleware, and lifecycle events."""import asyncio+import loggingimport osfrom pathlib import Path+logger = logging.getLogger(__name__)+# AMD GPU environment variables must be set before torch importif not os.environ.get("HSA_OVERRIDE_GFX_VERSION"):os.environ["HSA_OVERRIDE_GFX_VERSION"] = "10.3.0"@@ -30,11 +33,9 @@ def safe_content_disposition(disposition_type: str, filename: str) -> str:Uses RFC 5987 ``filename*`` parameter so browsers can decode UTF-8filenames while the ``filename`` fallback stays ASCII-only."""- ascii_name = (- "".join(c for c in filename if c.isascii() and (c.isalnum() or c in " -_.")).strip() or "download"- )+ ascii_name = "".join(c for c in filename if c.isascii() and (c.isalnum() or c in " -_.")).strip() or "download"utf8_name = quote(filename, safe="")- return f'{disposition_type}; filename="{ascii_name}"; filename*=UTF-8\'\'{utf8_name}'+ return f"{disposition_type}; filename=\"{ascii_name}\"; filename*=UTF-8''{utf8_name}"def create_app() -> FastAPI:@@ -55,13 +56,13 @@ def create_app() -> FastAPI:def _configure_cors(application: FastAPI) -> None:"""Set up CORS middleware with local-first defaults."""default_origins = [- "http://localhost:5173", # Vite dev server+ "http://localhost:5173", # Vite dev server"http://127.0.0.1:5173","http://localhost:17493","http://127.0.0.1:17493",- "tauri://localhost", # Tauri webview (macOS)- "https://tauri.localhost", # Tauri webview (Windows/Linux)- "http://tauri.localhost", # Tauri webview (Windows, some builds)+ "tauri://localhost", # Tauri webview (macOS)+ "https://tauri.localhost", # Tauri webview (Windows/Linux)+ "http://tauri.localhost", # Tauri webview (Windows, some builds)]env_origins = os.environ.get("VOICEBOX_CORS_ORIGINS", "")all_origins = default_origins + [o.strip() for o in env_origins.split(",") if o.strip()]@@ -96,9 +97,9 @@ def _register_lifecycle(application: FastAPI) -> None:@application.on_event("startup")async def startup_event():- print("voicebox API starting up...")+ logger.info("Voicebox server starting up...")database.init_db()- print(f"Database initialized at {database._db_path}")+ logger.info("Database initialized at %s", database._db_path)init_queue()@@ -115,15 +116,15 @@ def _register_lifecycle(application: FastAPI) -> None:))if result.rowcount > 0:- print(f"Marked {result.rowcount} stale generation(s) as failed")+ logger.info("Marked %d stale generation(s) as failed", result.rowcount)db.commit()db.close()except Exception as e:- print(f"Warning: Could not clean up stale generations: {e}")+ logger.warning("Could not clean up stale generations: %s", e)backend_type = get_backend_type()- print(f"Backend: {backend_type.upper()}")- print(f"GPU available: {_get_gpu_status()}")+ logger.info("Backend: %s", backend_type.upper())+ logger.info("GPU available: %s", _get_gpu_status())from .services.cuda import check_and_update_cuda_binary@@ -132,23 +133,23 @@ def _register_lifecycle(application: FastAPI) -> None:try:progress_manager = get_progress_manager()progress_manager._set_main_loop(asyncio.get_running_loop())- print("Progress manager initialized with event loop")+ logger.info("Progress manager initialized with event loop")except Exception as e:- print(f"Warning: Could not initialize progress manager event loop: {e}")+ logger.warning("Could not initialize progress manager event loop: %s", e)try:from huggingface_hub import constants as hf_constantscache_dir = Path(hf_constants.HF_HUB_CACHE)cache_dir.mkdir(parents=True, exist_ok=True)- print(f"HuggingFace cache directory: {cache_dir}")+ logger.info("HuggingFace cache directory: %s", cache_dir)except Exception as e:- print(f"Warning: Could not create HuggingFace cache directory: {e}")- print("Model downloads may fail. Please ensure the directory exists and has write permissions.")+ logger.warning("Could not create HuggingFace cache directory: %s", e)+ logger.warning("Model downloads may fail. Please ensure the directory exists and has write permissions.")@application.on_event("shutdown")async def shutdown_event():- print("voicebox API shutting down...")+ logger.info("Voicebox server shutting down...")tts.unload_tts_model()transcribe.unload_whisper_model()diff --git a/backend/backends/mlx_backend.py b/backend/backends/mlx_backend.pyindex 1ea7746f..e4a1ea97 100644--- a/backend/backends/mlx_backend.py+++ b/backend/backends/mlx_backend.py@@ -4,13 +4,17 @@ MLX backend implementation for TTS and STT using mlx-audio.from typing import Optional, List, Tupleimport asyncio+import loggingimport numpy as npimport osfrom pathlib import Path+logger = logging.getLogger(__name__)+# PATCH: Import and apply offline patch BEFORE any huggingface_hub usage# This prevents mlx_audio from making network requests when models are cachedfrom ..utils.hf_offline_patch import patch_huggingface_hub_offline, ensure_original_qwen_config_cached+patch_huggingface_hub_offline()ensure_original_qwen_config_cached()@@ -21,23 +25,23 @@ from ..utils.cache import get_cache_key, get_cached_voice_prompt, cache_voice_prclass MLXTTSBackend:"""MLX-based TTS backend using mlx-audio."""-+def __init__(self, model_size: str = "1.7B"):self.model = Noneself.model_size = model_sizeself._current_model_size = None-+def is_loaded(self) -> bool:"""Check if model is loaded."""return self.model is not None-+def _get_model_path(self, model_size: str) -> str:"""Get the MLX model path.-+Args:model_size: Model size (1.7B or 0.6B)-+Returns:HuggingFace Hub model ID for MLX"""@@ -47,67 +51,68 @@ class MLXTTSBackend:# 0.6B not yet converted to MLX format"0.6B": "mlx-community/Qwen3-TTS-12Hz-1.7B-Base-bf16", # Fallback to 1.7B}-+if model_size not in mlx_model_map:raise ValueError(f"Unknown model size: {model_size}")-+hf_model_id = mlx_model_map[model_size]- print(f"Will download MLX model from HuggingFace Hub: {hf_model_id}")-+ logger.info("Will download MLX model from HuggingFace Hub: %s", hf_model_id)+return hf_model_id-+def _is_model_cached(self, model_size: str) -> bool:return is_model_cached(self._get_model_path(model_size),weight_extensions=(".safetensors", ".bin", ".npz"),)-+async def load_model_async(self, model_size: Optional[str] = None):"""Lazy load the MLX TTS model.-+Args:model_size: Model size to load (1.7B or 0.6B)"""if model_size is None:model_size = self.model_size-+# If already loaded with correct size, returnif self.model is not None and self._current_model_size == model_size:return-+# Unload existing model if different size requestedif self.model is not None and self._current_model_size != model_size:self.unload_model()-+# Run blocking load in thread poolawait asyncio.to_thread(self._load_model_sync, model_size)-+# Alias for compatibilityload_model = load_model_async-+def _load_model_sync(self, model_size: str):"""Synchronous model loading."""model_path = self._get_model_path(model_size)model_name = f"qwen-tts-{model_size}"is_cached = self._is_model_cached(model_size)-+# Force offline mode when cached to avoid network requestsoriginal_hf_hub_offline = os.environ.get("HF_HUB_OFFLINE")if is_cached:os.environ["HF_HUB_OFFLINE"] = "1"- print(f"[PATCH] Model {model_size} is cached, forcing HF_HUB_OFFLINE=1 to avoid network requests")-+ logger.info("[PATCH] Model %s is cached, forcing HF_HUB_OFFLINE=1 to avoid network requests", model_size)+try:with model_load_progress(model_name, is_cached):from mlx_audio.tts import load- print(f"Loading MLX TTS model {model_size}...")-++ logger.info("Loading MLX TTS model %s...", model_size)+try:self.model = load(model_path)except Exception as load_error:if is_cached and "offline" in str(load_error).lower():- print(f"[PATCH] Offline load failed, trying with network: {load_error}")+ logger.warning("[PATCH] Offline load failed, trying with network: %s", load_error)os.environ.pop("HF_HUB_OFFLINE", None)self.model = load(model_path)else:@@ -117,19 +122,19 @@ class MLXTTSBackend:os.environ["HF_HUB_OFFLINE"] = original_hf_hub_offlineelse:os.environ.pop("HF_HUB_OFFLINE", None)-+self._current_model_size = model_sizeself.model_size = model_size- print(f"MLX TTS model {model_size} loaded successfully")-+ logger.info("MLX TTS model %s loaded successfully", model_size)+def unload_model(self):"""Unload the model to free memory."""if self.model is not None:del self.modelself.model = Noneself._current_model_size = None- print("MLX TTS model unloaded")-+ logger.info("MLX TTS model unloaded")+async def create_voice_prompt(self,audio_path: str,@@ -138,20 +143,20 @@ class MLXTTSBackend:) -> Tuple[dict, bool]:"""Create voice prompt from reference audio.-+MLX backend stores voice prompt as a dict with audio path and text.The actual voice prompt processing happens during generation.-+Args:audio_path: Path to reference audio filereference_text: Transcript of reference audiouse_cache: Whether to use cached prompt if available-+Returns:Tuple of (voice_prompt_dict, was_cached)"""await self.load_model_async(None)-+# Check cache if enabledif use_cache:cache_key = get_cache_key(audio_path, reference_text)@@ -165,25 +170,25 @@ class MLXTTSBackend:return cached_prompt, Trueelse:# Cached file no longer exists, invalidate cache- print(f"Cached audio file not found: {cached_audio_path}, regenerating prompt")-+ logger.warning("Cached audio file not found: %s, regenerating prompt", cached_audio_path)+# MLX voice prompt format - store audio path and text# The model will process this during generationvoice_prompt_items = {"ref_audio": str(audio_path),"ref_text": reference_text,}-+# Cache if enabledif use_cache:cache_key = get_cache_key(audio_path, reference_text)cache_voice_prompt(cache_key, voice_prompt_items)-+return voice_prompt_items, False-+async def combine_voice_prompts(self, audio_paths, reference_texts):return await _combine_voice_prompts(audio_paths, reference_texts)-+async def generate(self,text: str,@@ -207,7 +212,7 @@ class MLXTTSBackend:"""await self.load_model_async(None)- print(f"Generating audio for text: {text}")+ logger.info("Generating audio for text: %s", text)def _generate_sync():"""Run synchronous generation in thread pool."""@@ -219,20 +224,21 @@ class MLXTTSBackend:# Set seed if provided (MLX uses numpy random)if seed is not None:import mlx.core as mx+np.random.seed(seed)mx.random.seed(seed)-+# Extract voice prompt inforef_audio = voice_prompt.get("ref_audio") or voice_prompt.get("ref_audio_path")ref_text = voice_prompt.get("ref_text", "")-+# Validate that the audio file existsif ref_audio and not Path(ref_audio).exists():- print(f"Warning: Audio file not found: {ref_audio}")- print("This may be due to a cached voice prompt referencing a deleted temp file.")- print("Regenerating without voice prompt.")+ logger.warning("Audio file not found: %s", ref_audio)+ logger.warning("This may be due to a cached voice prompt referencing a deleted temp file.")+ logger.warning("Regenerating without voice prompt.")ref_audio = None-+# Check if model supports voice cloning via generate method# MLX API may support ref_audio parameter directlytry:@@ -240,6 +246,7 @@ class MLXTTSBackend:if ref_audio:# Check if generate accepts ref_audio parameterimport inspect+sig = inspect.signature(self.model.generate)if "ref_audio" in sig.parameters:# Generate with voice cloning@@ -258,18 +265,18 @@ class MLXTTSBackend:sample_rate = result.sample_rateexcept Exception as e:# If voice cloning fails, try without it- print(f"Warning: Voice cloning failed, generating without voice prompt: {e}")+ logger.warning("Voice cloning failed, generating without voice prompt: %s", e)for result in self.model.generate(text, lang_code=lang):audio_chunks.append(np.array(result.audio))sample_rate = result.sample_rate-+# Concatenate all chunksif audio_chunks:audio = np.concatenate([np.asarray(chunk, dtype=np.float32) for chunk in audio_chunks])else:# Fallback: empty audioaudio = np.array([], dtype=np.float32)-+return audio, sample_rate# Run blocking inference in thread pool@@ -284,55 +291,56 @@ class MLXSTTBackend:def __init__(self, model_size: str = "base"):self.model = Noneself.model_size = model_size-+def is_loaded(self) -> bool:"""Check if model is loaded."""return self.model is not None-+def _is_model_cached(self, model_size: str) -> bool:hf_repo = WHISPER_HF_REPOS.get(model_size, f"openai/whisper-{model_size}")return is_model_cached(hf_repo, weight_extensions=(".safetensors", ".bin", ".npz"))-+async def load_model_async(self, model_size: Optional[str] = None):"""Lazy load the MLX Whisper model.-+Args:model_size: Model size (tiny, base, small, medium, large)"""if model_size is None:model_size = self.model_size-+if self.model is not None and self.model_size == model_size:return-+# Run blocking load in thread poolawait asyncio.to_thread(self._load_model_sync, model_size)-+# Alias for compatibilityload_model = load_model_async-+def _load_model_sync(self, model_size: str):"""Synchronous model loading."""progress_model_name = f"whisper-{model_size}"is_cached = self._is_model_cached(model_size)-+with model_load_progress(progress_model_name, is_cached):from mlx_audio.stt import load+model_name = WHISPER_HF_REPOS.get(model_size, f"openai/whisper-{model_size}")- print(f"Loading MLX Whisper model {model_size}...")+ logger.info("Loading MLX Whisper model %s...", model_size)self.model = load(model_name)-+self.model_size = model_size- print(f"MLX Whisper model {model_size} loaded successfully")-+ logger.info("MLX Whisper model %s loaded successfully", model_size)+def unload_model(self):"""Unload the model to free memory."""if self.model is not None:del self.modelself.model = None- print("MLX Whisper model unloaded")-+ logger.info("MLX Whisper model unloaded")+async def transcribe(self,audio_path: str,diff --git a/backend/backends/pytorch_backend.py b/backend/backends/pytorch_backend.pyindex 809f6984..8f4a7a58 100644--- a/backend/backends/pytorch_backend.py+++ b/backend/backends/pytorch_backend.py@@ -4,39 +4,47 @@ PyTorch backend implementation for TTS and STT.from typing import Optional, List, Tupleimport asyncio+import loggingimport torchimport numpy as np+logger = logging.getLogger(__name__)+from . import TTSBackend, STTBackend, LANGUAGE_CODE_TO_NAME, WHISPER_HF_REPOS-from .base import is_model_cached, get_torch_device, combine_voice_prompts as _combine_voice_prompts, model_load_progress+from .base import (+ is_model_cached,+ get_torch_device,+ combine_voice_prompts as _combine_voice_prompts,+ model_load_progress,+)from ..utils.cache import get_cache_key, get_cached_voice_prompt, cache_voice_promptfrom ..utils.audio import load_audioclass PyTorchTTSBackend:"""PyTorch-based TTS backend using Qwen3-TTS."""-+def __init__(self, model_size: str = "1.7B"):self.model = Noneself.model_size = model_sizeself.device = self._get_device()self._current_model_size = None-+def _get_device(self) -> str:"""Get the best available device."""return get_torch_device(allow_xpu=True, allow_directml=True)-+def is_loaded(self) -> bool:"""Check if model is loaded."""return self.model is not None-+def _get_model_path(self, model_size: str) -> str:"""Get the HuggingFace Hub model ID.-+Args:model_size: Model size (1.7B or 0.6B)-+Returns:HuggingFace Hub model ID"""@@ -44,39 +52,39 @@ class PyTorchTTSBackend:"1.7B": "Qwen/Qwen3-TTS-12Hz-1.7B-Base","0.6B": "Qwen/Qwen3-TTS-12Hz-0.6B-Base",}-+if model_size not in hf_model_map:raise ValueError(f"Unknown model size: {model_size}")-+return hf_model_map[model_size]-+def _is_model_cached(self, model_size: str) -> bool:return is_model_cached(self._get_model_path(model_size))-+async def load_model_async(self, model_size: Optional[str] = None):"""Lazy load the TTS model with automatic downloading from HuggingFace Hub.-+Args:model_size: Model size to load (1.7B or 0.6B)"""if model_size is None:model_size = self.model_size-+# If already loaded with correct size, returnif self.model is not None and self._current_model_size == model_size:return-+# Unload existing model if different size requestedif self.model is not None and self._current_model_size != model_size:self.unload_model()-+# Run blocking load in thread poolawait asyncio.to_thread(self._load_model_sync, model_size)-+# Alias for compatibilityload_model = load_model_async-+def _load_model_sync(self, model_size: str):"""Synchronous model loading."""model_name = f"qwen-tts-{model_size}"@@ -84,8 +92,9 @@ class PyTorchTTSBackend:with model_load_progress(model_name, is_cached):from qwen_tts import Qwen3TTSModel+model_path = self._get_model_path(model_size)- print(f"Loading TTS model {model_size} on {self.device}...")+ logger.info("Loading TTS model %s on %s...", model_size, self.device)if self.device == "cpu":self.model = Qwen3TTSModel.from_pretrained(@@ -102,20 +111,20 @@ class PyTorchTTSBackend:self._current_model_size = model_sizeself.model_size = model_size- print(f"TTS model {model_size} loaded successfully")-+ logger.info("TTS model %s loaded successfully", model_size)+def unload_model(self):"""Unload the model to free memory."""if self.model is not None:del self.modelself.model = Noneself._current_model_size = None-+if torch.cuda.is_available():torch.cuda.empty_cache()-- print("TTS model unloaded")-++ logger.info("TTS model unloaded")+async def create_voice_prompt(self,audio_path: str,@@ -124,17 +133,17 @@ class PyTorchTTSBackend:) -> Tuple[dict, bool]:"""Create voice prompt from reference audio.-+Args:audio_path: Path to reference audio filereference_text: Transcript of reference audiouse_cache: Whether to use cached prompt if available-+Returns:Tuple of (voice_prompt_dict, was_cached)"""await self.load_model_async(None)-+# Check cache if enabledif use_cache:cache_key = get_cache_key(audio_path, reference_text)@@ -150,7 +159,7 @@ class PyTorchTTSBackend:# Legacy cache format - convert to dict# This shouldn't happen in practice, but handle itreturn {"prompt": cached_prompt}, True-+def _create_prompt_sync():"""Run synchronous voice prompt creation in thread pool."""return self.model.create_voice_clone_prompt(@@ -158,24 +167,24 @@ class PyTorchTTSBackend:ref_text=reference_text,x_vector_only_mode=False,)-+# Run blocking operation in thread poolvoice_prompt_items = await asyncio.to_thread(_create_prompt_sync)-+# Cache if enabledif use_cache:cache_key = get_cache_key(audio_path, reference_text)cache_voice_prompt(cache_key, voice_prompt_items)-+return voice_prompt_items, False-+async def combine_voice_prompts(self,audio_paths: List[str],reference_texts: List[str],) -> Tuple[np.ndarray, str]:return await _combine_voice_prompts(audio_paths, reference_texts)-+async def generate(self,text: str,@@ -231,15 +240,15 @@ class PyTorchSTTBackend:self.processor = Noneself.model_size = model_sizeself.device = self._get_device()-+def _get_device(self) -> str:"""Get the best available device."""return get_torch_device(allow_xpu=True, allow_directml=True)-+def is_loaded(self) -> bool:"""Check if model is loaded."""return self.model is not None-+def _is_model_cached(self, model_size: str) -> bool:hf_repo = WHISPER_HF_REPOS.get(model_size, f"openai/whisper-{model_size}")return is_model_cached(hf_repo)@@ -258,10 +267,10 @@ class PyTorchSTTBackend:returnawait asyncio.to_thread(self._load_model_sync, model_size)-+# Alias for compatibilityload_model = load_model_async-+def _load_model_sync(self, model_size: str):"""Synchronous model loading."""progress_model_name = f"whisper-{model_size}"@@ -269,16 +278,17 @@ class PyTorchSTTBackend:with model_load_progress(progress_model_name, is_cached):from transformers import WhisperProcessor, WhisperForConditionalGeneration+model_name = WHISPER_HF_REPOS.get(model_size, f"openai/whisper-{model_size}")- print(f"Loading Whisper model {model_size} on {self.device}...")+ logger.info("Loading Whisper model %s on %s...", model_size, self.device)self.processor = WhisperProcessor.from_pretrained(model_name)self.model = WhisperForConditionalGeneration.from_pretrained(model_name)self.model.to(self.device)self.model_size = model_size- print(f"Whisper model {model_size} loaded successfully")-+ logger.info("Whisper model %s loaded successfully", model_size)+def unload_model(self):"""Unload the model to free memory."""if self.model is not None:@@ -286,12 +296,12 @@ class PyTorchSTTBackend:del self.processorself.model = Noneself.processor = None-+if torch.cuda.is_available():torch.cuda.empty_cache()-- print("Whisper model unloaded")-++ logger.info("Whisper model unloaded")+async def transcribe(self,audio_path: str,@@ -299,21 +309,21 @@ class PyTorchSTTBackend:) -> str:"""Transcribe audio to text.-+Args:audio_path: Path to audio filelanguage: Optional language hint (en or zh)-+Returns:Transcribed text"""await self.load_model_async(None)-+def _transcribe_sync():"""Run synchronous transcription in thread pool."""# Load audioaudio, sr = load_audio(audio_path, sample_rate=16000)-+# Process audioinputs = self.processor(audio,@@ -321,7 +331,7 @@ class PyTorchSTTBackend:return_tensors="pt",)inputs = inputs.to(self.device)-+# Generate transcription# If language is provided, force it; otherwise let Whisper auto-detectgenerate_kwargs = {}@@ -331,20 +341,20 @@ class PyTorchSTTBackend:task="transcribe",)generate_kwargs["forced_decoder_ids"] = forced_decoder_ids-+with torch.no_grad():predicted_ids = self.model.generate(inputs["input_features"],**generate_kwargs,)-+# Decodetranscription = self.processor.batch_decode(predicted_ids,skip_special_tokens=True,)[0]-+return transcription.strip()-+# Run blocking transcription in thread poolreturn await asyncio.to_thread(_transcribe_sync)diff --git a/backend/build_binary.py b/backend/build_binary.pyindex 005bbe25..b4b1bb7c 100644--- a/backend/build_binary.py+++ b/backend/build_binary.py@@ -8,11 +8,14 @@ Usage:import PyInstaller.__main__import argparse+import loggingimport osimport platformimport sysfrom pathlib import Path+logger = logging.getLogger(__name__)+def is_apple_silicon():"""Check if running on Apple Silicon."""@@ -28,155 +31,246 @@ def build_server(cuda=False):"""backend_dir = Path(__file__).parent- binary_name = 'voicebox-server-cuda' if cuda else 'voicebox-server'+ binary_name = "voicebox-server-cuda" if cuda else "voicebox-server"# PyInstaller argumentsargs = [- 'server.py', # Use server.py as entry point instead of main.py- '--onefile',- '--name', binary_name,+ "server.py", # Use server.py as entry point instead of main.py+ "--onefile",+ "--name",+ binary_name,]# Hide console window on Windows only. On macOS/Linux the sidecar needs# stdout/stderr for Tauri to capture logs.if platform.system() == "Windows":- args.append('--noconsole')+ args.append("--noconsole")# Add local qwen_tts path if specified (for editable installs)- qwen_tts_path = os.getenv('QWEN_TTS_PATH')+ qwen_tts_path = os.getenv("QWEN_TTS_PATH")if qwen_tts_path and Path(qwen_tts_path).exists():- args.extend(['--paths', str(qwen_tts_path)])+ args.extend(["--paths", str(qwen_tts_path)])print(f"Using local qwen_tts source from: {qwen_tts_path}")# Add common hidden imports- args.extend([- '--hidden-import', 'backend',- '--hidden-import', 'backend.main',- '--hidden-import', 'backend.config',- '--hidden-import', 'backend.database',- '--hidden-import', 'backend.models',- '--hidden-import', 'backend.services.profiles',- '--hidden-import', 'backend.services.history',- '--hidden-import', 'backend.services.tts',- '--hidden-import', 'backend.services.transcribe',- '--hidden-import', 'backend.utils.platform_detect',- '--hidden-import', 'backend.backends',- '--hidden-import', 'backend.backends.pytorch_backend',- '--hidden-import', 'backend.utils.audio',- '--hidden-import', 'backend.utils.cache',- '--hidden-import', 'backend.utils.progress',- '--hidden-import', 'backend.utils.hf_progress',-- '--hidden-import', 'backend.services.cuda',- '--hidden-import', 'backend.services.effects',- '--hidden-import', 'backend.utils.effects',- '--hidden-import', 'backend.services.versions',- '--hidden-import', 'pedalboard',- '--hidden-import', 'chatterbox',- '--hidden-import', 'chatterbox.tts_turbo',- '--hidden-import', 'chatterbox.mtl_tts',- '--hidden-import', 'backend.backends.chatterbox_backend',- '--hidden-import', 'backend.backends.chatterbox_turbo_backend',- '--hidden-import', 'backend.backends.luxtts_backend',- '--hidden-import', 'zipvoice',- '--hidden-import', 'zipvoice.luxvoice',- '--collect-all', 'zipvoice',- '--collect-all', 'linacodec',- '--hidden-import', 'torch',- '--hidden-import', 'transformers',- '--hidden-import', 'fastapi',- '--hidden-import', 'uvicorn',- '--hidden-import', 'sqlalchemy',- '--hidden-import', 'librosa',- '--hidden-import', 'soundfile',- '--hidden-import', 'qwen_tts',- '--hidden-import', 'qwen_tts.inference',- '--hidden-import', 'qwen_tts.inference.qwen3_tts_model',- '--hidden-import', 'qwen_tts.inference.qwen3_tts_tokenizer',- '--hidden-import', 'qwen_tts.core',- '--hidden-import', 'qwen_tts.cli',- '--copy-metadata', 'qwen-tts',- '--copy-metadata', 'requests',- '--copy-metadata', 'transformers',- '--copy-metadata', 'huggingface-hub',- '--copy-metadata', 'tokenizers',- '--copy-metadata', 'safetensors',- '--copy-metadata', 'tqdm',- '--hidden-import', 'requests',- '--collect-submodules', 'qwen_tts',- '--collect-data', 'qwen_tts',- # Fix for pkg_resources and jaraco namespace packages- '--hidden-import', 'pkg_resources.extern',- '--collect-submodules', 'jaraco',- # inflect uses typeguard @typechecked which calls inspect.getsource()- # at import time — needs .py source files, not just .pyc bytecode- '--collect-all', 'inflect',- # perth ships pretrained watermark model files (hparams.yaml, .pth.tar)- # in perth/perth_net/pretrained/ — needed by chatterbox at runtime- '--collect-all', 'perth',- # piper_phonemize ships espeak-ng-data/ (phoneme tables, language dicts)- # needed by LuxTTS for text-to-phoneme conversion- '--collect-all', 'piper_phonemize',- ])+ args.extend(+ [+ "--hidden-import",+ "backend",+ "--hidden-import",+ "backend.main",+ "--hidden-import",+ "backend.config",+ "--hidden-import",+ "backend.database",+ "--hidden-import",+ "backend.models",+ "--hidden-import",+ "backend.services.profiles",+ "--hidden-import",+ "backend.services.history",+ "--hidden-import",+ "backend.services.tts",+ "--hidden-import",+ "backend.services.transcribe",+ "--hidden-import",+ "backend.utils.platform_detect",+ "--hidden-import",+ "backend.backends",+ "--hidden-import",+ "backend.backends.pytorch_backend",+ "--hidden-import",+ "backend.utils.audio",+ "--hidden-import",+ "backend.utils.cache",+ "--hidden-import",+ "backend.utils.progress",+ "--hidden-import",+ "backend.utils.hf_progress",+ "--hidden-import",+ "backend.services.cuda",+ "--hidden-import",+ "backend.services.effects",+ "--hidden-import",+ "backend.utils.effects",+ "--hidden-import",+ "backend.services.versions",+ "--hidden-import",+ "pedalboard",+ "--hidden-import",+ "chatterbox",+ "--hidden-import",+ "chatterbox.tts_turbo",+ "--hidden-import",+ "chatterbox.mtl_tts",+ "--hidden-import",+ "backend.backends.chatterbox_backend",+ "--hidden-import",+ "backend.backends.chatterbox_turbo_backend",+ "--hidden-import",+ "backend.backends.luxtts_backend",+ "--hidden-import",+ "zipvoice",+ "--hidden-import",+ "zipvoice.luxvoice",+ "--collect-all",+ "zipvoice",+ "--collect-all",+ "linacodec",+ "--hidden-import",+ "torch",+ "--hidden-import",+ "transformers",+ "--hidden-import",+ "fastapi",+ "--hidden-import",+ "uvicorn",+ "--hidden-import",+ "sqlalchemy",+ "--hidden-import",+ "librosa",+ "--hidden-import",+ "soundfile",+ "--hidden-import",+ "qwen_tts",+ "--hidden-import",+ "qwen_tts.inference",+ "--hidden-import",+ "qwen_tts.inference.qwen3_tts_model",+ "--hidden-import",+ "qwen_tts.inference.qwen3_tts_tokenizer",+ "--hidden-import",+ "qwen_tts.core",+ "--hidden-import",+ "qwen_tts.cli",+ "--copy-metadata",+ "qwen-tts",+ "--copy-metadata",+ "requests",+ "--copy-metadata",+ "transformers",+ "--copy-metadata",+ "huggingface-hub",+ "--copy-metadata",+ "tokenizers",+ "--copy-metadata",+ "safetensors",+ "--copy-metadata",+ "tqdm",+ "--hidden-import",+ "requests",+ "--collect-submodules",+ "qwen_tts",+ "--collect-data",+ "qwen_tts",+ # Fix for pkg_resources and jaraco namespace packages+ "--hidden-import",+ "pkg_resources.extern",+ "--collect-submodules",+ "jaraco",+ # inflect uses typeguard @typechecked which calls inspect.getsource()+ # at import time — needs .py source files, not just .pyc bytecode+ "--collect-all",+ "inflect",+ # perth ships pretrained watermark model files (hparams.yaml, .pth.tar)+ # in perth/perth_net/pretrained/ — needed by chatterbox at runtime+ "--collect-all",+ "perth",+ # piper_phonemize ships espeak-ng-data/ (phoneme tables, language dicts)+ # needed by LuxTTS for text-to-phoneme conversion+ "--collect-all",+ "piper_phonemize",+ ]+ )# Add CUDA-specific hidden importsif cuda:print("Building with CUDA support")- args.extend([- '--hidden-import', 'torch.cuda',- '--hidden-import', 'torch.backends.cudnn',- ])+ args.extend(+ [+ "--hidden-import",+ "torch.cuda",+ "--hidden-import",+ "torch.backends.cudnn",+ ]+ )else:# Exclude NVIDIA CUDA packages from CPU-only builds to keep binary small.# When building from a venv with CUDA torch installed, PyInstaller would# bundle ~3GB of NVIDIA shared libraries. We exclude both the Python# modules and the binary DLLs.nvidia_packages = [- 'nvidia', 'nvidia.cublas', 'nvidia.cuda_cupti', 'nvidia.cuda_nvrtc',- 'nvidia.cuda_runtime', 'nvidia.cudnn', 'nvidia.cufft', 'nvidia.curand',- 'nvidia.cusolver', 'nvidia.cusparse', 'nvidia.nccl', 'nvidia.nvjitlink',- 'nvidia.nvtx',+ "nvidia",+ "nvidia.cublas",+ "nvidia.cuda_cupti",+ "nvidia.cuda_nvrtc",+ "nvidia.cuda_runtime",+ "nvidia.cudnn",+ "nvidia.cufft",+ "nvidia.curand",+ "nvidia.cusolver",+ "nvidia.cusparse",+ "nvidia.nccl",+ "nvidia.nvjitlink",+ "nvidia.nvtx",]for pkg in nvidia_packages:- args.extend(['--exclude-module', pkg])+ args.extend(["--exclude-module", pkg])# Add MLX-specific imports if building on Apple Silicon (never for CUDA builds)if is_apple_silicon() and not cuda:print("Building for Apple Silicon - including MLX dependencies")- args.extend([- '--hidden-import', 'backend.backends.mlx_backend',- '--hidden-import', 'mlx',- '--hidden-import', 'mlx.core',- '--hidden-import', 'mlx.nn',- '--hidden-import', 'mlx_audio',- '--hidden-import', 'mlx_audio.tts',- '--hidden-import', 'mlx_audio.stt',- '--collect-submodules', 'mlx',- '--collect-submodules', 'mlx_audio',- # Use --collect-all so PyInstaller bundles both data files AND- # native shared libraries (.dylib, .metallib) for MLX.- # Previously only --collect-data was used, which caused MLX to- # raise OSError at runtime inside the bundled binary because- # the Metal shader libraries were missing.- '--collect-all', 'mlx',- '--collect-all', 'mlx_audio',- ])+ args.extend(+ [+ "--hidden-import",+ "backend.backends.mlx_backend",+ "--hidden-import",+ "mlx",+ "--hidden-import",+ "mlx.core",+ "--hidden-import",+ "mlx.nn",+ "--hidden-import",+ "mlx_audio",+ "--hidden-import",+ "mlx_audio.tts",+ "--hidden-import",+ "mlx_audio.stt",+ "--collect-submodules",+ "mlx",+ "--collect-submodules",+ "mlx_audio",+ # Use --collect-all so PyInstaller bundles both data files AND+ # native shared libraries (.dylib, .metallib) for MLX.+ # Previously only --collect-data was used, which caused MLX to+ # raise OSError at runtime inside the bundled binary because+ # the Metal shader libraries were missing.+ "--collect-all",+ "mlx",+ "--collect-all",+ "mlx_audio",+ ]+ )elif not cuda:print("Building for non-Apple Silicon platform - PyTorch only")- dist_dir = str(backend_dir / 'dist')- build_dir = str(backend_dir / 'build')+ dist_dir = str(backend_dir / "dist")+ build_dir = str(backend_dir / "build")- args.extend([- '--distpath', dist_dir,- '--workpath', build_dir,- '--noconfirm',- '--clean',- ])+ args.extend(+ [+ "--distpath",+ dist_dir,+ "--workpath",+ build_dir,+ "--noconfirm",+ "--clean",+ ]+ )# Change to backend directoryos.chdir(backend_dir)-+# For CPU builds on Windows, ensure we're using CPU-only torch.# If CUDA torch is installed (local dev), swap to CPU torch before building,# then restore CUDA torch after. This prevents PyInstaller from bundling@@ -184,17 +278,28 @@ def build_server(cuda=False):restore_cuda = Falseif not cuda and platform.system() == "Windows":import subprocess+result = subprocess.run(- [sys.executable, "-c", "import torch; print(torch.version.cuda or '')"],- capture_output=True, text=True+ [sys.executable, "-c", "import torch; print(torch.version.cuda or '')"], capture_output=True, text=True)has_cuda_torch = bool(result.stdout.strip())if has_cuda_torch:print("CUDA torch detected — installing CPU torch for CPU build...")subprocess.run(- [sys.executable, "-m", "pip", "install", "torch", "torchvision", "torchaudio",- "--index-url", "https://download.pytorch.org/whl/cpu", "--force-reinstall", "-q"],- check=True+ [+ sys.executable,+ "-m",+ "pip",+ "install",+ "torch",+ "torchvision",+ "torchaudio",+ "--index-url",+ "https://download.pytorch.org/whl/cpu",+ "--force-reinstall",+ "-q",+ ],+ check=True,)restore_cuda = True@@ -206,55 +311,77 @@ def build_server(cuda=False):if restore_cuda:print("Restoring CUDA torch...")import subprocess+subprocess.run(- [sys.executable, "-m", "pip", "install", "torch", "torchvision", "torchaudio",- "--index-url", "https://download.pytorch.org/whl/cu126", "--force-reinstall", "-q"],- check=True+ [+ sys.executable,+ "-m",+ "pip",+ "install",+ "torch",+ "torchvision",+ "torchaudio",+ "--index-url",+ "https://download.pytorch.org/whl/cu126",+ "--force-reinstall",+ "-q",+ ],+ check=True,)-+print(f"Binary built in {backend_dir / 'dist' / binary_name}")def _get_cuda_dll_excludes():"""Get list of CUDA DLL filenames to exclude from CPU builds.-+When building locally with CUDA torch installed, PyInstaller bundles ~3GB ofCUDA DLLs from torch/lib/. Returns a list of DLL filenames to exclude."""try:import torch- torch_lib = Path(torch.__file__).parent / 'lib'++ torch_lib = Path(torch.__file__).parent / "lib"except ImportError:return []-+cuda_prefixes = (- 'torch_cuda', 'cublas', 'cublasLt', 'cudnn', 'cusparse', 'cufft',- 'cusolver', 'cusolverMg', 'curand', 'nvrtc', 'nvJitLink', 'nccl',- 'nvperf', 'nvrtc-builtins',+ "torch_cuda",+ "cublas",+ "cublasLt",+ "cudnn",+ "cusparse",+ "cufft",+ "cusolver",+ "cusolverMg",+ "curand",+ "nvrtc",+ "nvJitLink",+ "nccl",+ "nvperf",+ "nvrtc-builtins",)-+exclude_dlls = []if torch_lib.exists():for f in torch_lib.iterdir():- if f.suffix == '.dll' and any(f.name.startswith(p) for p in cuda_prefixes):+ if f.suffix == ".dll" and any(f.name.startswith(p) for p in cuda_prefixes):exclude_dlls.append(f.name)-+if exclude_dlls:- total_mb = sum(- (torch_lib / dll).stat().st_size- for dll in exclude_dlls- if (torch_lib / dll).exists()- ) / 1024 / 1024+ total_mb = (+ sum((torch_lib / dll).stat().st_size for dll in exclude_dlls if (torch_lib / dll).exists()) / 1024 / 1024+ )print(f"CPU build: will exclude {len(exclude_dlls)} CUDA DLLs ({total_mb:.0f} MB)")-+return exclude_dlls-if __name__ == '__main__':+if __name__ == "__main__":parser = argparse.ArgumentParser(description="Build voicebox-server binary")parser.add_argument(- '--cuda',- action='store_true',+ "--cuda",+ action="store_true",help="Build CUDA-enabled binary (voicebox-server-cuda)",)cli_args = parser.parse_args()diff --git a/backend/services/generation.py b/backend/services/generation.pyindex ff86a0de..d8d5214d 100644--- a/backend/services/generation.py+++ b/backend/services/generation.py@@ -235,8 +235,11 @@ def _save_regenerate(audio_path = config.get_generations_dir() / f"{generation_id}_{suffix}.wav"save_audio(audio, str(audio_path), sample_rate)- existing = versions_mod.list_versions(generation_id, db)- label = f"take-{len(existing) + 1}"+ # Count via DB query rather than list length to avoid TOCTOU race+ from ..database import GenerationVersion as DBGenerationVersion++ count = db.query(DBGenerationVersion).filter_by(generation_id=generation_id).count()+ label = f"take-{count + 1}"versions_mod.create_version(generation_id=generation_id,