Update voice_processing.py

voice_processing.py

@@ -111,6 +111,7 @@ def get_model_names():
     model_root = "weights"  # Assuming this is where your models are stored
     return [d for d in os.listdir(model_root) if os.path.isdir(f"{model_root}/{d}")]
 
+# Add this helper function to ensure a new event loop is created if none exists
 def run_async_in_thread(fn, *args):
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
@@ -118,6 +119,12 @@ def run_async_in_thread(fn, *args):
     loop.close()
     return result
 
+def parallel_tts(tasks):
+    with ThreadPoolExecutor() as executor:
+        futures = [executor.submit(run_async_in_thread, tts, *task) for task in tasks]
+        results = [future.result() for future in futures]
+    return results
+
 async def tts(
     model_name,
     tts_text,
@@ -240,11 +247,12 @@ hubert_model = load_hubert()
 
 rmvpe_model = RMVPE("rmvpe.pt", config.is_half, config.device)
 
+# Add the optimized TTSProcessor
 class TTSProcessor:
     def __init__(self, config):
         self.config = config
         self.executor = ThreadPoolExecutor(max_workers=config.n_cpu)
-        self.semaphore = asyncio.Semaphore(10)  # Limit to 10 concurrent tasks
+        self.semaphore = asyncio.Semaphore(config.max_concurrent_tts)
         self.queue = asyncio.Queue()
         self.is_processing = False
 
@@ -265,20 +273,24 @@ class TTSProcessor:
         self.is_processing = True
         while not self.queue.empty():
             task = await self.queue.get()
-            try:
-                await task
-            except Exception as e:
-                print(f"Error processing TTS task: {str(e)}")
-            finally:
-                self.queue.task_done()
+            await task
+            self.queue.task_done()
         self.is_processing = False
 
 # Initialize the TTSProcessor
 tts_processor = TTSProcessor(config)
 
-async def parallel_tts(tasks):
+# Update parallel_tts to use TTSProcessor
+async def parallel_tts_processor(tasks):
     return await asyncio.gather(*(tts_processor.tts(*task) for task in tasks))
 
 def parallel_tts_wrapper(tasks):
     loop = asyncio.get_event_loop()
-    return loop.run_until_complete(parallel_tts(tasks))
+    return loop.run_until_complete(parallel_tts_processor(tasks))
+
+# Keep the original parallel_tts function
+# def parallel_tts(tasks):
+#     with ThreadPoolExecutor() as executor:
+#         futures = [executor.submit(run_async_in_thread, tts, *task) for task in tasks]
+#         results = [future.result() for future in futures]
+#     return results