Update app.py

app.py

@@ -1,160 +1,121 @@
 import os
-import random
-import re
-import tempfile
-import torch
-import torchaudio
-import numpy as np
 import gradio as gr
-from chatterbox.tts import ChatterboxTTS
+from engine import VoiceCloningEngine
 
-# Constants
-MAX_CHUNK_CHARS = 250
-DEFAULT_DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+# Initialize the Voice Cloning Engine
+engine = VoiceCloningEngine()
 
-class VoiceCloningEngine:
+def process_tts(text, ref_audio, exaggeration, cfg_weight, temperature, seed, progress=gr.Progress()):
     """
-    A dedicated engine to handle Chatterbox TTS operations including
-    model management, text chunking, and audio generation.
+    Main TTS processing function connecting the UI with the VoiceCloningEngine.
     """
-    def __init__(self, device=DEFAULT_DEVICE):
-        self.device = device
-        self.model = None
-        self.sr = 24000 # Default Chatterbox SR
-
-    def load_model(self):
-        """Loads the model into memory if not already present."""
-        if self.model is None:
-            print(f"Loading Chatterbox TTS on {self.device}...")
-            self.model = ChatterboxTTS.from_pretrained(self.device)
-            self.sr = self.model.sr
-        return self.model
-
-    def set_seed(self, seed: int):
-        """Sets deterministic seeds for reproducibility."""
-        if seed == 0:
-            seed = random.randint(1, 1000000)
-        torch.manual_seed(seed)
-        torch.cuda.manual_seed(seed)
-        torch.cuda.manual_seed_all(seed)
-        random.seed(seed)
-        np.random.seed(seed)
-        return seed
-
-    def chunk_text(self, text):
-        """
-        Splits text into chunks at sentence boundaries for long script handling.
-        """
-        # Split by punctuation followed by space
-        sentences = re.split(r'(?<=[.!?])\s+', text.strip())
-        chunks = []
-        current_chunk = ""
-        
-        for sentence in sentences:
-            if len(current_chunk) + len(sentence) <= MAX_CHUNK_CHARS:
-                current_chunk += (sentence + " ")
-            else:
-                if current_chunk:
-                    chunks.append(current_chunk.strip())
-                
-                # Handle single sentences longer than MAX_CHUNK_CHARS
-                if len(sentence) > MAX_CHUNK_CHARS:
-                    sub_parts = re.split(r'(?<=,)\s+|\s+', sentence)
-                    temp = ""
-                    for part in sub_parts:
-                        if len(temp) + len(part) <= MAX_CHUNK_CHARS:
-                            temp += (part + " ")
-                        else:
-                            if temp: chunks.append(temp.strip())
-                            temp = part + " "
-                    current_chunk = temp
-                else:
-                    current_chunk = sentence + " "
-                    
-        if current_chunk:
-            chunks.append(current_chunk.strip())
-        return chunks
-
-    def generate(self, text, ref_audio, exaggeration, cfg_weight, temperature, seed, progress=None):
-        """
-        Processes the full script by chunking and concatenating results.
-        """
-        self.load_model()
-        actual_seed = self.set_seed(int(seed))
-        chunks = self.chunk_text(text)
-        
-        if not chunks:
-            raise ValueError("No valid text provided.")
-        if ref_audio is None:
-            raise ValueError("Reference audio is required for cloning.")
-
-        all_wavs = []
-        for i, chunk in enumerate(chunks):
-            if progress:
-                progress((i / len(chunks)), desc=f"Processing chunk {i+1}/{len(chunks)}")
-            
-            wav = self.model.generate(
-                chunk,
-                audio_prompt_path=ref_audio,
-                exaggeration=exaggeration,
-                temperature=temperature,
-                cfg_weight=cfg_weight
-            )
-            
-            if wav.dim() == 1:
-                wav = wav.unsqueeze(0)
-            all_wavs.append(wav.cpu())
-
-        final_wav = torch.cat(all_wavs, dim=-1)
-        
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
-            output_path = tmp.name
-            torchaudio.save(output_path, final_wav, self.sr)
-            
-        return output_path, actual_seed
+    if not text.strip():
+        return None, "Error: Please enter a script."
+    if ref_audio is None:
+        return None, "Error: Please upload a reference audio clip."
 
-# Initialize the engine
-engine = VoiceCloningEngine()
-
-def process_tts(text, ref_audio, exaggeration, cfg_weight, temperature, seed, progress=gr.Progress()):
     try:
-        path, used_seed = engine.generate(text, ref_audio, exaggeration, cfg_weight, temperature, seed, progress)
-        return path, f"Success! Seed used: {used_seed}"
+        # Call the engine with the Gradio Progress callback
+        output_path, used_seed = engine.generate(
+            text=text,
+            ref_audio=ref_audio,
+            exaggeration=exaggeration,
+            cfg_weight=cfg_weight,
+            temperature=temperature,
+            seed=seed,
+            progress_callback=progress
+        )
+        return output_path, f"Successfully generated audio with seed {used_seed}."
     except Exception as e:
+        import traceback
+        traceback.print_exc()
         return None, f"Error: {str(e)}"
 
-# UI Construction
-with gr.Blocks(theme=gr.themes.Soft(), title="Chatterbox Voice Clone") as demo:
-    gr.Markdown("# 🗣️ Voice Cloning TTS Engine")
-    gr.Markdown("Optimized for long scripts with intelligent chunking and smooth concatenation.")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            text_input = gr.Textbox(label="Script", lines=8, placeholder="Enter long text here...")
-            ref_audio = gr.Audio(label="Reference Voice", type="filepath")
-            
-            with gr.Row():
-                exag = gr.Slider(0.1, 1.0, value=0.5, label="Exaggeration", info="Warning: >0.8 can be unstable")
-                cfg = gr.Slider(0.0, 1.0, value=0.5, label="CFG/Pace")
-            
-            with gr.Accordion("Advanced Options", open=False):
-                seed_val = gr.Number(label="Seed", value=0, precision=0, info="0 for random")
-                temp_val = gr.Slider(0.1, 2.0, value=1.0, label="Temperature")
-            
-            btn = gr.Button("Generate", variant="primary")
-            
-        with gr.Column(scale=1):
-            audio_out = gr.Audio(label="Generated Audio", type="filepath")
-            status = gr.Textbox(label="Status", interactive=False)
-            
-            gr.Markdown("### 📖 Quick Guide")
-            gr.Markdown("""
-            - **Chunking**: Sentences are automatically split at ~250 chars.
-            - **Secrets**: Use HF Secrets for API keys if needed.
-            - **Pacing**: Lower CFG for slower, more deliberate speech.
-            """)
+# UI Layout and Configuration
+def create_ui():
+    with gr.Blocks(theme=gr.themes.Soft(), title="Voice Cloning TTS Chatterbox") as demo:
+        gr.Markdown("# 🗣️ Voice Cloning TTS Engine")
+        gr.Markdown("""
+        **A high-performance voice cloning application powered by Chatterbox TTS.** 
+        Optimized for long scripts with intelligent chunking, context preservation, and smooth concatenation.
+        """)
+        
+        with gr.Row():
+            # Configuration Column
+            with gr.Column(scale=1):
+                text_input = gr.Textbox(
+                    label="Script", 
+                    placeholder="Paste your long script here. The engine automatically splits it at sentence boundaries for smooth narration...", 
+                    lines=10,
+                    value="Welcome to the modular voice cloning application. By separating the core processing engine into its own file, we ensure cleaner code and better scalability. This tool automatically handles long texts, ensuring that your narration is smooth and continuous across multiple sentences."
+                )
+                ref_audio = gr.Audio(
+                    label="Reference Voice (Voice to Clone)", 
+                    type="filepath",
+                    sources=["upload", "microphone"]
+                )
+                
+                with gr.Row():
+                    exaggeration = gr.Slider(
+                        0.1, 1.0, value=0.5, step=0.05, 
+                        label="Exaggeration", 
+                        info="Intensity of cloned voice traits. Default 0.5. Warning: >0.8 can be unstable."
+                    )
+                    cfg_weight = gr.Slider(
+                        0.0, 1.0, value=0.5, step=0.05, 
+                        label="CFG/Pace", 
+                        info="Balance between text adherence and reference voice speed."
+                    )
+                
+                with gr.Accordion("Advanced Options", open=False):
+                    seed = gr.Number(
+                        label="Seed", 
+                        value=0, 
+                        precision=0, 
+                        info="Set to 0 for a random seed each time."
+                    )
+                    temperature = gr.Slider(
+                        0.1, 2.0, value=1.0, step=0.05, 
+                        label="Temperature", 
+                        info="Higher values increase expressiveness and randomness."
+                    )
+                
+                generate_btn = gr.Button("Generate Speech", variant="primary")
+                
+            # Result Column
+            with gr.Column(scale=1):
+                audio_output = gr.Audio(label="Generated Speech", type="filepath")
+                status_msg = gr.Textbox(label="Status", interactive=False)
+                
+                gr.Markdown("### 📖 Documentation")
+                gr.Markdown("""
+                ### Features
+                - **Modular Engine**: The `VoiceCloningEngine` in `engine.py` handles all core processing, making the app easier to maintain.
+                - **Intelligent Chunking**: Scripts are automatically split at sentence boundaries (~250 chars) for stability.
+                - **Context Preservation**: Audio segments are concatenated smoothly for long-form narration.
+                
+                ### Deployment & Secrets
+                - **Secrets Management**: If your app requires API keys, set them in the **Hugging Face Space Secrets** and access them via `os.getenv()`.
+                - **GPU Recommended**: This app runs best on a T4 or L4 GPU Space.
+                """)
 
-    btn.click(process_tts, [text_input, ref_audio, exag, cfg, temp_val, seed_val], [audio_out, status])
+        # Connect UI events
+        generate_btn.click(
+            fn=process_tts,
+            inputs=[
+                text_input, 
+                ref_audio, 
+                exaggeration, 
+                cfg_weight, 
+                temperature, 
+                seed
+            ],
+            outputs=[audio_output, status_msg]
+        )
+        
+    return demo
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0")
+    ui = create_ui()
+    # Ensure server_name is set for Hugging Face compatibility
+    ui.launch(server_name="0.0.0.0")