Update app.py

app.py

@@ -26,7 +26,7 @@ import queue
 import sys
 sys.path.append(os.path.join(os.getcwd(), 'neutts-air'))
 from neuttsair.neutts import NeuTTSAir
-
+from threading import Thread
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("NeuTTS-API")
@@ -358,62 +358,49 @@ async def stream_text_to_speech_cloning(
         raise HTTPException(status_code=503, detail="Service unavailable: Model not loaded")
     
     try:
-        # Initial audio conversion is still done once, in memory.
         converted_wav_buffer = await convert_to_wav_in_memory(reference_audio)
         ref_audio_bytes = converted_wav_buffer.getvalue()
         
         def stream_generator():
-            # 1. Create a queue to communicate between the producer and consumer.
-            # A small maxsize acts as a "look-ahead" buffer.
             q = queue.Queue(maxsize=2)
 
-            # 2. Define the PRODUCER (The "Grill Chef")
-            # This function runs in a background thread to generate audio continuously.
             def producer():
                 try:
-                    # Get reference encoding once for the whole stream
                     audio_hash = hashlib.sha256(ref_audio_bytes).hexdigest()
                     ref_s = app.state.tts_wrapper._get_or_create_reference_encoding(audio_hash, ref_audio_bytes)
                     
                     sentences = app.state.tts_wrapper._split_text_into_chunks(text)
                     
                     for sentence in sentences:
-                        # Generate the raw audio (CPU-heavy part)
                         with torch.no_grad():
                             audio_chunk = app.state.tts_wrapper.tts_model.infer(sentence, ref_s, reference_text)
-                        # Put the finished audio (a numpy array) into the queue
                         q.put(audio_chunk)
 
                 except Exception as e:
                     logger.error(f"Error in producer thread: {e}")
-                    # If an error occurs, put the exception in the queue to notify the consumer
                     q.put(e)
                 finally:
-                    # 3. Signal that production is finished by putting None in the queue
                     q.put(None)
 
-            # 4. Start the producer in the background ThreadPoolExecutor
-            loop = asyncio.get_event_loop()
-            loop.run_in_executor(tts_executor, producer)
+            # === THIS IS THE FIX ===
+            # Start the producer in a standard, separate thread.
+            # This avoids the asyncio loop error.
+            producer_thread = Thread(target=producer)
+            producer_thread.start()
+            # =======================
 
-            # 5. The main thread becomes the CONSUMER (The "Finisher")
             while True:
-                # Get the next audio chunk from the queue (this will wait if the queue is empty)
                 result = q.get()
 
-                # Check for the "end of stream" signal
                 if result is None:
                     break
                 
-                # Check if the producer sent an error
                 if isinstance(result, Exception):
                     logger.error(f"Terminating stream due to producer error: {result}")
                     raise result
 
-                # Convert the raw audio to the desired format and yield it to the user
                 yield app.state.tts_wrapper._convert_to_streamable_format(result, output_format)
 
-        # Return the StreamingResponse with our new high-performance generator
         return StreamingResponse(
             stream_generator(),
             media_type=f"audio/{'mpeg' if output_format == 'mp3' else output_format}"