Update app.py

app.py

@@ -1,6 +1,5 @@
 import gradio as gr
 from g4f.client import Client
-import re
 import json
 import torch
 import soundfile as sf
@@ -8,6 +7,14 @@ from openvoice_cli.__main__ import tune_one
 import os
 import uuid
 import zipfile
+import logging
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor
+import threading
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # Initialize G4F client
 client = Client()
@@ -19,12 +26,13 @@ speaker = 'baya'  # Russian voice
 sample_rate = 48000  # Sample rate for Russian model
 device = torch.device('cpu')
 
-# Load Silero TTS model
+# Load Silero TTS model with thread safety
 model, _ = torch.hub.load(repo_or_dir='snakers4/silero-models',
                           model='silero_tts',
                           language=language,
                           speaker=model_id)
 model.to(device)
+tts_lock = threading.Lock()  # Lock for TTS model thread safety
 
 def get_task(prompt):
     return f'''Ты генерируешь скрипт продолжения прямой линии с Владимиром Владимировичем Путиным. Вопросы телезрителей передаёт Киселёв - он максимально подобострастен, поддерживает Путина и Россию. Пиши в духе пропаганды пророссийской. Каждая реплика - не менее 150-200 символов. Английские названия при необходимости всегда транскрибируй кириллицей. Числительные также записывай кириллицей. Пиши в стиле кремлёвской пропаганды. Пиши в стереотипном стиле. Киселёв задаёт вопросы, обрашается к Путину как "Владимир Владимирович" или "Господин Президент". Путин отвечает. Всё максимально аутентично. Фразы Киселёва: {{"Киселёв":"фраза"}} Фразы Путина: {{"Путин":"фраза"}} Ответ дай в формате JSON без дополнительных символов: [{{"Киселёв":"фраза"}}, {{"Путин":"фраза"}} . . . ].
@@ -32,9 +40,7 @@ def get_task(prompt):
 
 def validate_response(response):
     try:
-        # Attempt to parse the response as JSON
         data = json.loads(response)
-        # Check if the response is a list and follows the required pattern
         if isinstance(data, list) and all(isinstance(item, dict) and len(item) == 1 for item in data):
             return True
     except json.JSONDecodeError:
@@ -44,75 +50,116 @@ def validate_response(response):
 def generate_text(prompt):
     max_retries = 4
     for attempt in range(max_retries):
+        logger.info(f"Generating response for prompt: {prompt} (attempt {attempt+1})")
         response = client.chat.completions.create(
             model="llama-3.3-70b",
             messages=[{"role": "user", "content": get_task(prompt)}],
             web_search=False
         )
         response_text = response.choices[0].message.content
+        logger.info(f"Generated response: {response_text}")
+        
         if validate_response(response_text):
             return response_text
-    # If all retries fail, return a placeholder
+        logger.warning("Invalid response format, retrying...")
+    
+    logger.error("Failed to generate valid response after 4 attempts")
     return '[{"Киселёв":"К сожалению, не удалось расслышать вопрос. Пожалуйста, попробуйте еще раз."}, {"Путин":"Мы работаем над улучшением системы. Спасибо за понимание."}]'
 
+def split_text(text, max_length=800):
+    """Split text into chunks of maximum length, trying to preserve word boundaries"""
+    chunks = []
+    while len(text) > max_length:
+        split_at = text.rfind(' ', 0, max_length)
+        if split_at == -1:
+            split_at = max_length
+        chunks.append(text[:split_at])
+        text = text[split_at:].lstrip()
+    chunks.append(text)
+    return chunks
+
 def generate_audio(text, speaker_name):
-    # Generate speech using Silero TTS
-    audio = model.apply_tts(ssml_text=f"<speak>{text}</speak>",
-                            speaker=speaker,
-                            sample_rate=sample_rate,
-                            put_accent=True,
-                            put_yo=True)
+    """Generate audio with thread-safe splitting and synthesis"""
+    logger.info(f"Generating audio for {speaker_name} ({len(text)} chars)")
     
-    # Save to a temporary file
-    temp_filename = f"temp_{speaker_name}.wav"
-    sf.write(temp_filename, audio, sample_rate)
-    return temp_filename
-
-def generate_cover(base_audio, ref_audio):
-    # Create unique output filename
-    output_filename = f"output_{uuid.uuid4().hex[:6]}.wav"
+    chunks = split_text(text)
+    audio_arrays = []
     
-    # Process the audio with OpenVoice
-    tune_one(
-        input_file=base_audio,
-        ref_file=ref_audio,
-        output_file=output_filename,
-        device='cpu'
-    )
+    for chunk in chunks:
+        with tts_lock:  # Ensure thread-safe TTS operations
+            audio = model.apply_tts(
+                ssml_text=f"<speak>{chunk}</speak>",
+                speaker=speaker,
+                sample_rate=sample_rate,
+                put_accent=True,
+                put_yo=True
+            )
+        audio_arrays.append(audio)
     
-    return output_filename
+    full_audio = np.concatenate(audio_arrays)
+    temp_filename = f"temp_{uuid.uuid4().hex}.wav"
+    sf.write(temp_filename, full_audio, sample_rate)
+    return temp_filename
+
+def process_line(args):
+    """Process single dialogue line with parallel execution support"""
+    idx, speaker, text = args
+    try:
+        logger.info(f"Processing line {idx+1} for {speaker}")
+        
+        # Generate base audio
+        base_audio = generate_audio(text, speaker)
+        
+        # Generate voice cover
+        ref_audio = "kisel.mp3" if speaker == "Киселёв" else "putin.mp3"
+        covered_audio = tune_one(
+            input_file=base_audio,
+            ref_file=ref_audio,
+            output_file=f"output_{uuid.uuid4().hex[:6]}.wav",
+            device='cpu'
+        )
+        
+        # Cleanup and rename
+        final_filename = f"t{idx+1}-{speaker}.wav"
+        os.rename(covered_audio, final_filename)
+        os.remove(base_audio)  # Clean up temporary file
+        
+        return final_filename
+    except Exception as e:
+        logger.error(f"Error processing line {idx+1}: {str(e)}")
+        return None
 
 def process_prompt(prompt):
-    # Generate the script
+    """Main processing pipeline with parallel execution"""
+    logger.info(f"Starting processing for prompt: {prompt}")
+    
+    # Generate script
     script = generate_text(prompt)
     script_data = json.loads(script)
     
-    # Prepare a list to store the generated audio files
-    audio_files = []
+    # Prepare tasks for parallel processing
+    tasks = [(idx, speaker, text) 
+             for idx, item in enumerate(script_data) 
+             for speaker, text in item.items()]
     
-    for i, item in enumerate(script_data):
-        for speaker, text in item.items():
-            # Generate the base audio using Silero TTS
-            base_audio_file = generate_audio(text, speaker)
-            
-            # Determine the reference audio file based on the speaker
-            ref_audio_file = "kisel.mp3" if speaker == "Киселёв" else "putin.mp3"
-            
-            # Generate the covered audio using OpenVoice
-            covered_audio_file = generate_cover(base_audio_file, ref_audio_file)
-            
-            # Rename the file to include the speaker and sequence number
-            final_filename = f"t{i+1}-{speaker}.wav"
-            os.rename(covered_audio_file, final_filename)
-            
-            # Add the final file to the list
-            audio_files.append(final_filename)
+    # Process lines in parallel
+    audio_files = []
+    with ThreadPoolExecutor(max_workers=4) as executor:  # Optimal for CPU-bound tasks
+        futures = [executor.submit(process_line, task) for task in tasks]
+        for future in futures:
+            result = future.result()
+            if result:
+                audio_files.append(result)
     
-    # Create a zip file containing all the audio files
+    # Package results
     zip_filename = "output_audio_files.zip"
     with zipfile.ZipFile(zip_filename, 'w') as zipf:
-        for audio_file in audio_files:
-            zipf.write(audio_file)
+        for file in audio_files:
+            zipf.write(file)
+    
+    # Cleanup working files
+    for file in audio_files:
+        os.remove(file)
     
     return zip_filename