Update app.py

app.py

@@ -391,54 +391,49 @@ async def text_to_speech(
 async def stream_text_to_speech_cloning(
     text: str = Form(..., min_length=1, max_length=5000),
     reference_text: str = Form(...),
-    speed: float = Form(1.0, ge=0.5, le=2.0),
+    speed: float = Form(1.0, ge=0.5, le=2.0), # Kept for API compatibility, not used in this logic
     output_format: str = Form("mp3", pattern="^(wav|mp3|flac)$"),
-    reference_audio: UploadFile = File(...)):
+    reference_audio: UploadFile = File(...)
+):
     """
-    Sentence-by-Sentence Streaming Endpoint.
-    Fixes race condition by moving cleanup into the streaming generator.
+    High-performance parallel streaming endpoint using the local wrapper.
     """
     if not hasattr(app.state, 'tts_wrapper'):
         raise HTTPException(status_code=503, detail="Service unavailable: Model not loaded")
-    
-    # 1. Asynchronously save reference audio (non-blocking)
+
     temp_ref_path = await save_upload_file_async(reference_audio)
-    converted_wav_path = None # Initialize for cleanup
-    
+    converted_wav_path = None
+
     try:
-        # 2. Convert the uploaded file (WebM, etc.) to a 24kHz WAV file
         converted_wav_path = await run_blocking_task_async(
-            convert_to_wav_blocking,
-            temp_ref_path
+            convert_to_wav_blocking, temp_ref_path
         )
-        
-        # 2.5. CLEANUP ORIGINAL FILE IMMEDIATELY: It is no longer needed after conversion
+
         if os.path.exists(temp_ref_path):
             os.unlink(temp_ref_path)
-            
-        # 3. Define the generator function, which will run in the thread pool
-        def stream_generator(path_to_delete: str):
+
+        async def stream_generator(path_to_delete: str):
             try:
-                # This logic uses the path_to_delete parameter, which is guaranteed to exist
-                for chunk_bytes in app.state.tts_wrapper.stream_speech_blocking(
-                    text, 
-                    path_to_delete, # Pass the CONVERTED WAV path
-                    reference_text,
-                    speed,
-                    output_format
+                # This now calls our new wrapper's parallel streaming method
+                async for audio_chunk in app.state.tts_wrapper.stream_speech_parallel(
+                    text=text,
+                    ref_audio_path=path_to_delete,
+                    ref_text=reference_text,
+                    executor=tts_executor
                 ):
-                    yield chunk_bytes
+                    audio_buffer = io.BytesIO()
+                    sf.write(audio_buffer, audio_chunk, SAMPLE_RATE, format=output_format)
+                    audio_buffer.seek(0)
+                    yield audio_buffer.read()
+
             except Exception as e:
-                # Log the error and raise it to stop the stream
                 logger.error(f"Streaming generator error: {e}")
-                raise # Re-raise to ensure the stream terminates
+                raise
             finally:
-                # 4. **CRUCIAL FIX:** Clean up the converted file ONLY AFTER GENERATION IS DONE
                 if os.path.exists(path_to_delete):
                     os.unlink(path_to_delete)
                     logger.info(f"Cleaned up converted file: {path_to_delete}")
 
-        # Return StreamingResponse, passing the path to the generator
         return StreamingResponse(
             stream_generator(converted_wav_path),
             media_type=f"audio/{'mpeg' if output_format == 'mp3' else output_format}",
@@ -449,20 +444,17 @@ async def stream_text_to_speech_cloning(
                 "X-Accel-Buffering": "no"
             }
         )
-        
+
     except Exception as e:
         logger.error(f"Streaming setup error: {e}")
-        # Clean up files only if the setup failed *before* starting the generator
         if os.path.exists(temp_ref_path):
             os.unlink(temp_ref_path)
         if converted_wav_path and os.path.exists(converted_wav_path):
             os.unlink(converted_wav_path)
-            
-        # Reraise HTTPExceptions that may have come from the conversion step
+
         if isinstance(e, HTTPException):
              raise
         raise HTTPException(status_code=500, detail=f"Streaming synthesis failed: {e}")
-    # Note: The outer 'finally' block is now removed as its logic is handled in 2.5 and 4.
 
 @app.get("/audio/{filename}")
 async def get_audio(filename: str):