lollms-client 1.6.1__py3-none-any.whl → 1.6.2__py3-none-any.whl

lollms_client/__init__.py

@@ -8,7 +8,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 
-__version__ = "1.6.1" # Updated version
+__version__ = "1.6.2" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/lollms_core.py

@@ -143,16 +143,21 @@ class LollmsClient():
                 ASCIIColors.warning(f"Failed to create LLM binding: {llm_binding_name}. Available: {available}")
 
         if tts_binding_name:
-            self.tts = self.tts_binding_manager.create_binding(
-                binding_name=tts_binding_name,
-                **{
-                    k: v
-                    for k, v in (tts_binding_config or {}).items()
-                    if k != "binding_name"
-                }
-            )
-            if self.tts is None:
-                ASCIIColors.warning(f"Failed to create TTS binding: {tts_binding_name}. Available: {self.tts_binding_manager.get_available_bindings()}")
+            try:
+                params = {
+                        k: v
+                        for k, v in (tts_binding_config or {}).items()
+                        if k != "binding_name"
+                    }
+                self.tts = self.tts_binding_manager.create_binding(
+                    binding_name=tts_binding_name,
+                    **params
+                )
+                if self.tts is None:
+                    ASCIIColors.warning(f"Failed to create TTS binding: {tts_binding_name}. Available: {self.tts_binding_manager.get_available_bindings()}")
+            except Exception as e:
+                trace_exception(e)
+                ASCIIColors.warning(f"Exception occurred while creating TTS binding: {str(e)}")
 
         if tti_binding_name:
             if tti_binding_config:

lollms_client/lollms_tts_binding.py

@@ -49,26 +49,28 @@ class LollmsTTSBindingManager:
             except Exception as e:
                 trace_exception(e)
                 print(f"Failed to load TTS binding {binding_name}: {str(e)}")
-
-    def create_binding(self,
+    def create_binding(self, 
                       binding_name: str,
-                      config: Dict[str, Any] = None) -> Optional[LollmsTTSBinding]:
-        if config is None:
-            config = {}
-            
+                      **kwargs) -> Optional[LollmsTTSBinding]:
+        """
+        Create an instance of a specific binding.
+
+        Args:
+            binding_name (str): Name of the binding to create.
+            kwargs: binding specific arguments
+
+        Returns:
+            Optional[LollmsLLMBinding]: Binding instance or None if creation failed.
+        """
         if binding_name not in self.available_bindings:
             self._load_binding(binding_name)
-
+        
         binding_class = self.available_bindings.get(binding_name)
         if binding_class:
-            try:
-                return binding_class(**config)
-            except Exception as e:
-                trace_exception(e)
-                print(f"Failed to instantiate TTS binding {binding_name}: {str(e)}")
-                return None
+            return binding_class(**kwargs)
         return None
 
+
     @staticmethod
     def _get_fallback_description(binding_name: str) -> Dict:
         return {

lollms_client/tts_bindings/xtts/__init__.py

@@ -1,4 +1,3 @@
-# File: lollms_client/tts_bindings/xtts/__init__.py
 from lollms_client.lollms_tts_binding import LollmsTTSBinding
 from typing import Optional, List
 from pathlib import Path
@@ -8,6 +7,14 @@ import sys
 import time
 import pipmaster as pm
 
+# New import for process-safe file locking
+try:
+    from filelock import FileLock, Timeout
+except ImportError:
+    print("FATAL: The 'filelock' library is required. Please install it by running: pip install filelock")
+    sys.exit(1)
+
+
 BindingName = "XTTSClientBinding"
 
 class XTTSClientBinding(LollmsTTSBinding):
@@ -24,21 +31,73 @@ class XTTSClientBinding(LollmsTTSBinding):
         self.auto_start_server = auto_start_server
         self.server_process = None
         self.base_url = f"http://{self.host}:{self.port}"
+        self.binding_root = Path(__file__).parent
+        self.server_dir = self.binding_root / "server"
 
         if self.auto_start_server:
-            self.start_server()
+            self.ensure_server_is_running()
+
+    def is_server_running(self) -> bool:
+        """Checks if the server is already running and responsive."""
+        try:
+            response = requests.get(f"{self.base_url}/status", timeout=1)
+            if response.status_code == 200 and response.json().get("status") == "running":
+                return True
+        except requests.ConnectionError:
+            return False
+        return False
+
+    def ensure_server_is_running(self):
+        """
+        Ensures the XTTS server is running. If not, it attempts to start it
+        in a process-safe manner using a file lock.
+        """
+        if self.is_server_running():
+            print("XTTS Server is already running.")
+            return
+
+        lock_path = self.server_dir / "xtts_server.lock"
+        lock = FileLock(lock_path, timeout=10) # Wait a maximum of 10 seconds for the lock
+
+        print("Attempting to start or wait for the XTTS server...")
+        try:
+            with lock:
+                # Double-check after acquiring the lock to handle race conditions
+                if not self.is_server_running():
+                    print("Lock acquired. Starting dedicated XTTS server...")
+                    self.start_server()
+                else:
+                    print("Server was started by another process while waiting for the lock.")
+        except Timeout:
+            print("Could not acquire lock. Another process is likely starting the server. Waiting...")
+
+        # All workers (the one that started the server and those that waited) will verify the server is ready
+        self._wait_for_server()
+
 
     def start_server(self):
-        print("XTTS Client: Starting dedicated server...")
-        binding_root = Path(__file__).parent
-        server_dir = binding_root / "server"
-        requirements_file = server_dir / "requirements.txt"
-        server_script = server_dir / "main.py"
+        """
+        Installs dependencies and launches the server as a background subprocess.
+        This method should only be called from within a file lock.
+        """
+        requirements_file = self.server_dir / "requirements.txt"
+        server_script = self.server_dir / "main.py"
 
         # 1. Ensure a virtual environment and dependencies
-        venv_path = server_dir / "venv"
-        pm_v = pm.PackageManager(venv_path=venv_path)
-        pm_v.ensure_requirements(str(requirements_file))
+        venv_path = self.server_dir / "venv"
+        print(f"Ensuring virtual environment and dependencies in: {venv_path}")
+        pm_v = pm.PackageManager(venv_path=str(venv_path))
+
+        success = pm_v.ensure_requirements(
+            str(requirements_file),
+            verbose=True
+        )
+
+        if not success:
+            print("FATAL: Failed to install server dependencies. Aborting launch.")
+            return
+
+        print("Dependencies are satisfied. Proceeding to launch server...")
 
         # 2. Get the python executable from the venv
         if sys.platform == "win32":
@@ -46,7 +105,7 @@ class XTTSClientBinding(LollmsTTSBinding):
         else:
             python_executable = venv_path / "bin" / "python"
 
-        # 3. Launch the server as a subprocess with stdout/stderr forwarded to console
+        # 3. Launch the server as a detached subprocess
         command = [
             str(python_executable),
             str(server_script),
@@ -54,41 +113,36 @@ class XTTSClientBinding(LollmsTTSBinding):
             "--port", str(self.port)
         ]
         
-        # Forward stdout and stderr to the parent process console
-        self.server_process = subprocess.Popen(
-            command,
-            stdout=None,  # Inherit parent's stdout (shows in console)
-            stderr=None,  # Inherit parent's stderr (shows in console)
-        )
-        
-        # 4. Wait for the server to be ready
-        self._wait_for_server()
+        # The server is started as a background process and is not tied to this specific worker's lifecycle
+        subprocess.Popen(command)
+        print("XTTS Server process launched in the background.")
+
 
     def _wait_for_server(self, timeout=60):
+        print("Waiting for XTTS server to become available...")
         start_time = time.time()
         while time.time() - start_time < timeout:
-            try:
-                response = requests.get(f"{self.base_url}/status")
-                if response.status_code == 200 and response.json().get("status") == "running":
-                    print("XTTS Server is up and running.")
-                    return
-            except requests.ConnectionError:
-                time.sleep(1)
+            if self.is_server_running():
+                print("XTTS Server is up and running.")
+                return
+            time.sleep(1)
         
-        self.stop_server()
-        raise RuntimeError("Failed to start the XTTS server in the specified timeout.")
+        raise RuntimeError("Failed to connect to the XTTS server within the specified timeout.")
 
     def stop_server(self):
+        """
+        In a multi-worker setup, a single client instance should not stop the shared server.
+        The server will continue running until the main application is terminated.
+        """
         if self.server_process:
-            print("XTTS Client: Stopping dedicated server...")
-            self.server_process.terminate()
-            self.server_process.wait()
+            print("XTTS Client: An instance is shutting down, but the shared server will remain active for other workers.")
             self.server_process = None
-            print("Server stopped.")
     
     def __del__(self):
-        # Ensure the server is stopped when the object is destroyed
-        self.stop_server()
+        """
+        The destructor does not stop the server to prevent disrupting other workers.
+        """
+        pass
 
     def generate_audio(self, text: str, voice: Optional[str] = None, **kwargs) -> bytes:
         """Generate audio by calling the server's API"""
@@ -107,5 +161,4 @@ class XTTSClientBinding(LollmsTTSBinding):
         """Get available models from the server"""
         response = requests.get(f"{self.base_url}/list_models")
         response.raise_for_status()
-        return response.json().get("models", [])
-
+        return response.json().get("models", [])

lollms_client/tts_bindings/xtts/server/main.py

@@ -1,314 +1,317 @@
-import uvicorn
-from fastapi import FastAPI, APIRouter, HTTPException
-from pydantic import BaseModel
-import argparse
-import sys
-from pathlib import Path
-import asyncio
-import traceback
-import os
-from typing import Optional, List
-import io
-import wave
-import numpy as np
-import tempfile
-
-# --- XTTS Implementation ---
 try:
-    print("Server: Loading XTTS dependencies...")
-    import torch
-    import torchaudio
-    from TTS.api import TTS
-    print("Server: XTTS dependencies loaded successfully")
-    
-    # Check for CUDA availability
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    print(f"Server: Using device: {device}")
-    
-    xtts_available = True
-    
-except Exception as e:
-    print(f"Server: Failed to load XTTS dependencies: {e}")
-    print(f"Server: Traceback:\n{traceback.format_exc()}")
-    xtts_available = False
-
-# --- API Models ---
-class GenerationRequest(BaseModel):
-    text: str
-    voice: Optional[str] = None
-    language: Optional[str] = "en"
-    speaker_wav: Optional[str] = None
+    import uvicorn
+    from fastapi import FastAPI, APIRouter, HTTPException
+    from pydantic import BaseModel
+    import argparse
+    import sys
+    from pathlib import Path
+    import asyncio
+    import traceback
+    import os
+    from typing import Optional, List
+    import io
+    import wave
+    import numpy as np
+    import tempfile
 
-class XTTSServer:
-    def __init__(self):
-        self.model = None
-        self.model_loaded = False
-        self.model_loading = False  # Flag to prevent concurrent loading
-        self.available_voices = self._load_available_voices()
-        self.available_models = ["xtts_v2"]
+    # --- XTTS Implementation ---
+    try:
+        print("Server: Loading XTTS dependencies...")
+        import torch
+        import torchaudio
+        from TTS.api import TTS
+        print("Server: XTTS dependencies loaded successfully")
         
-        # Don't initialize model here - do it lazily on first request
-        print("Server: XTTS server initialized (model will be loaded on first request)")
-    
-    async def _ensure_model_loaded(self):
-        """Ensure the XTTS model is loaded (lazy loading)"""
-        if self.model_loaded:
-            return
-            
-        if self.model_loading:
-            # Another request is already loading the model, wait for it
-            while self.model_loading and not self.model_loaded:
-                await asyncio.sleep(0.1)
-            return
-            
-        if not xtts_available:
-            raise RuntimeError("XTTS library not available")
-            
-        try:
-            self.model_loading = True
-            print("Server: Loading XTTS model for the first time (this may take a few minutes)...")
-            
-            # Initialize XTTS model
-            self.model = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)
-            
-            self.model_loaded = True
-            print("Server: XTTS model loaded successfully")
-            
-        except Exception as e:
-            print(f"Server: Error loading XTTS model: {e}")
-            print(f"Server: Traceback:\n{traceback.format_exc()}")
+        # Check for CUDA availability
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Server: Using device: {device}")
+        
+        xtts_available = True
+        
+    except Exception as e:
+        print(f"Server: Failed to load XTTS dependencies: {e}")
+        print(f"Server: Traceback:\n{traceback.format_exc()}")
+        xtts_available = False
+
+    # --- API Models ---
+    class GenerationRequest(BaseModel):
+        text: str
+        voice: Optional[str] = None
+        language: Optional[str] = "en"
+        speaker_wav: Optional[str] = None
+
+    class XTTSServer:
+        def __init__(self):
+            self.model = None
             self.model_loaded = False
-            raise
-        finally:
-            self.model_loading = False
-    
-    def _load_available_voices(self) -> List[str]:
-        """Load and return available voices"""
-        try:
-            # Look for voice files in voices directory
-            voices_dir = Path(__file__).parent / "voices"
-            voices = []
+            self.model_loading = False  # Flag to prevent concurrent loading
+            self.available_voices = self._load_available_voices()
+            self.available_models = ["xtts_v2"]
             
-            if voices_dir.exists():
-                # Look for WAV files in voices directory
-                for voice_file in voices_dir.glob("*.wav"):
-                    voices.append(voice_file.stem)
-            
-            # If no custom voices found, provide some default names
-            if not voices:
-                voices = ["default", "female", "male"]
+            # Don't initialize model here - do it lazily on first request
+            print("Server: XTTS server initialized (model will be loaded on first request)")
+        
+        async def _ensure_model_loaded(self):
+            """Ensure the XTTS model is loaded (lazy loading)"""
+            if self.model_loaded:
+                return
                 
-            return voices
-            
-        except Exception as e:
-            print(f"Server: Error loading voices: {e}")
-            return ["default"]
-    
-    async def generate_audio(self, text: str, voice: Optional[str] = None, 
-                      language: str = "en", speaker_wav: Optional[str] = None) -> bytes:
-        """Generate audio from text using XTTS"""
-        # Ensure model is loaded before proceeding
-        await self._ensure_model_loaded()
+            if self.model_loading:
+                # Another request is already loading the model, wait for it
+                while self.model_loading and not self.model_loaded:
+                    await asyncio.sleep(0.1)
+                return
+                
+            if not xtts_available:
+                raise RuntimeError("XTTS library not available")
+                
+            try:
+                self.model_loading = True
+                print("Server: Loading XTTS model for the first time (this may take a few minutes)...")
+                
+                # Initialize XTTS model
+                self.model = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)
+                
+                self.model_loaded = True
+                print("Server: XTTS model loaded successfully")
+                
+            except Exception as e:
+                print(f"Server: Error loading XTTS model: {e}")
+                print(f"Server: Traceback:\n{traceback.format_exc()}")
+                self.model_loaded = False
+                raise
+            finally:
+                self.model_loading = False
         
-        if not self.model_loaded or self.model is None:
-            raise RuntimeError("XTTS model failed to load")
+        def _load_available_voices(self) -> List[str]:
+            """Load and return available voices"""
+            try:
+                # Look for voice files in voices directory
+                voices_dir = Path(__file__).parent / "voices"
+                voices = []
+                
+                if voices_dir.exists():
+                    # Look for WAV files in voices directory
+                    for voice_file in voices_dir.glob("*.wav"):
+                        voices.append(voice_file.stem)
+                
+                # If no custom voices found, provide some default names
+                if not voices:
+                    voices = ["default", "female", "male"]
+                    
+                return voices
+                
+            except Exception as e:
+                print(f"Server: Error loading voices: {e}")
+                return ["default"]
         
-        try:
-            print(f"Server: Generating audio for: '{text[:50]}{'...' if len(text) > 50 else ''}'")
-            print(f"Server: Using voice: {voice}, language: {language}")
-            
-            # Handle voice/speaker selection
-            speaker_wav_path = None
-            
-            # First priority: use provided speaker_wav parameter
-            if speaker_wav:
-                speaker_wav_path = speaker_wav
-                print(f"Server: Using provided speaker_wav: {speaker_wav_path}")
+        async def generate_audio(self, text: str, voice: Optional[str] = None, 
+                        language: str = "en", speaker_wav: Optional[str] = None) -> bytes:
+            """Generate audio from text using XTTS"""
+            # Ensure model is loaded before proceeding
+            await self._ensure_model_loaded()
             
-            # Second priority: check if voice parameter is a file path
-            elif voice and voice != "default":
-                if os.path.exists(voice):
-                    # Voice parameter is a full file path
-                    speaker_wav_path = voice
-                    print(f"Server: Using voice as file path: {speaker_wav_path}")
-                else:
-                    # Look for voice file in voices directory
-                    voices_dir = Path(__file__).parent / "voices"
-                    potential_voice_path = voices_dir / f"{voice}.wav"
-                    if potential_voice_path.exists():
-                        speaker_wav_path = str(potential_voice_path)
-                        print(f"Server: Using custom voice file: {speaker_wav_path}")
-                    else:
-                        print(f"Server: Voice '{voice}' not found in voices directory")
-            
-            # Create a temporary file for output
-            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
-                temp_output_path = temp_file.name
+            if not self.model_loaded or self.model is None:
+                raise RuntimeError("XTTS model failed to load")
             
             try:
-                # Generate audio using XTTS
-                if speaker_wav_path and os.path.exists(speaker_wav_path):
-                    print(f"Server: Generating with speaker reference: {speaker_wav_path}")
-                    self.model.tts_to_file(
-                        text=text,
-                        speaker_wav=speaker_wav_path,
-                        language=language,
-                        file_path=temp_output_path
-                    )
-                else:
-                    print("Server: No valid speaker reference found, trying default")
-                    # For XTTS without speaker reference, try to find a default
-                    default_speaker = self._get_default_speaker_file()
-                    if default_speaker and os.path.exists(default_speaker):
-                        print(f"Server: Using default speaker: {default_speaker}")
+                print(f"Server: Generating audio for: '{text[:50]}{'...' if len(text) > 50 else ''}'")
+                print(f"Server: Using voice: {voice}, language: {language}")
+                
+                # Handle voice/speaker selection
+                speaker_wav_path = None
+                
+                # First priority: use provided speaker_wav parameter
+                if speaker_wav:
+                    speaker_wav_path = speaker_wav
+                    print(f"Server: Using provided speaker_wav: {speaker_wav_path}")
+                
+                # Second priority: check if voice parameter is a file path
+                elif voice and voice != "default":
+                    if os.path.exists(voice):
+                        # Voice parameter is a full file path
+                        speaker_wav_path = voice
+                        print(f"Server: Using voice as file path: {speaker_wav_path}")
+                    else:
+                        # Look for voice file in voices directory
+                        voices_dir = Path(__file__).parent / "voices"
+                        potential_voice_path = voices_dir / f"{voice}.wav"
+                        if potential_voice_path.exists():
+                            speaker_wav_path = str(potential_voice_path)
+                            print(f"Server: Using custom voice file: {speaker_wav_path}")
+                        else:
+                            print(f"Server: Voice '{voice}' not found in voices directory")
+                
+                # Create a temporary file for output
+                with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
+                    temp_output_path = temp_file.name
+                
+                try:
+                    # Generate audio using XTTS
+                    if speaker_wav_path and os.path.exists(speaker_wav_path):
+                        print(f"Server: Generating with speaker reference: {speaker_wav_path}")
                         self.model.tts_to_file(
                             text=text,
-                            speaker_wav=default_speaker,
+                            speaker_wav=speaker_wav_path,
                             language=language,
                             file_path=temp_output_path
                         )
                     else:
-                        # Create a more helpful error message
-                        available_voices = self._get_all_available_voice_files()
-                        error_msg = f"No speaker reference available. XTTS requires a speaker reference file.\n"
-                        error_msg += f"Attempted to use: {speaker_wav_path if speaker_wav_path else 'None'}\n"
-                        error_msg += f"Available voice files: {available_voices}"
-                        raise RuntimeError(error_msg)
-                
-                # Read the generated audio file
-                with open(temp_output_path, 'rb') as f:
-                    audio_bytes = f.read()
-                
-                print(f"Server: Generated {len(audio_bytes)} bytes of audio")
-                return audio_bytes
+                        print("Server: No valid speaker reference found, trying default")
+                        # For XTTS without speaker reference, try to find a default
+                        default_speaker = self._get_default_speaker_file()
+                        if default_speaker and os.path.exists(default_speaker):
+                            print(f"Server: Using default speaker: {default_speaker}")
+                            self.model.tts_to_file(
+                                text=text,
+                                speaker_wav=default_speaker,
+                                language=language,
+                                file_path=temp_output_path
+                            )
+                        else:
+                            # Create a more helpful error message
+                            available_voices = self._get_all_available_voice_files()
+                            error_msg = f"No speaker reference available. XTTS requires a speaker reference file.\n"
+                            error_msg += f"Attempted to use: {speaker_wav_path if speaker_wav_path else 'None'}\n"
+                            error_msg += f"Available voice files: {available_voices}"
+                            raise RuntimeError(error_msg)
+                    
+                    # Read the generated audio file
+                    with open(temp_output_path, 'rb') as f:
+                        audio_bytes = f.read()
+                    
+                    print(f"Server: Generated {len(audio_bytes)} bytes of audio")
+                    return audio_bytes
+                    
+                finally:
+                    # Clean up temporary file
+                    if os.path.exists(temp_output_path):
+                        os.unlink(temp_output_path)
                 
-            finally:
-                # Clean up temporary file
-                if os.path.exists(temp_output_path):
-                    os.unlink(temp_output_path)
-            
-        except Exception as e:
-            print(f"Server: Error generating audio: {e}")
-            print(f"Server: Traceback:\n{traceback.format_exc()}")
-            raise
-    
-    def _get_all_available_voice_files(self) -> List[str]:
-        """Get list of all available voice files for debugging"""
-        voices_dir = Path(__file__).parent / "voices"
-        voice_files = []
+            except Exception as e:
+                print(f"Server: Error generating audio: {e}")
+                print(f"Server: Traceback:\n{traceback.format_exc()}")
+                raise
         
-        if voices_dir.exists():
-            voice_files = [str(f) for f in voices_dir.glob("*.wav")]
+        def _get_all_available_voice_files(self) -> List[str]:
+            """Get list of all available voice files for debugging"""
+            voices_dir = Path(__file__).parent / "voices"
+            voice_files = []
             
-        return voice_files
-    
-    def _get_default_speaker_file(self) -> Optional[str]:
-        """Get path to default speaker file"""
-        voices_dir = Path(__file__).parent / "voices"
+            if voices_dir.exists():
+                voice_files = [str(f) for f in voices_dir.glob("*.wav")]
+                
+            return voice_files
         
-        # Look for a default speaker file
-        for filename in ["default.wav", "speaker.wav", "reference.wav"]:
-            potential_path = voices_dir / filename
-            if potential_path.exists():
-                return str(potential_path)
+        def _get_default_speaker_file(self) -> Optional[str]:
+            """Get path to default speaker file"""
+            voices_dir = Path(__file__).parent / "voices"
+            
+            # Look for a default speaker file
+            for filename in ["default.wav", "speaker.wav", "reference.wav"]:
+                potential_path = voices_dir / filename
+                if potential_path.exists():
+                    return str(potential_path)
+            
+            # If no default found, look for any wav file
+            wav_files = list(voices_dir.glob("*.wav"))
+            if wav_files:
+                return str(wav_files[0])
+            
+            return None
         
-        # If no default found, look for any wav file
-        wav_files = list(voices_dir.glob("*.wav"))
-        if wav_files:
-            return str(wav_files[0])
+        def list_voices(self) -> List[str]:
+            """Return list of available voices"""
+            return self.available_voices
         
-        return None
-    
-    def list_voices(self) -> List[str]:
-        """Return list of available voices"""
-        return self.available_voices
-    
-    def list_models(self) -> List[str]:
-        """Return list of available models"""
-        return self.available_models
+        def list_models(self) -> List[str]:
+            """Return list of available models"""
+            return self.available_models
 
-# --- Globals ---
-app = FastAPI(title="XTTS Server")
-router = APIRouter()
-xtts_server = XTTSServer()
-model_lock = asyncio.Lock()  # Ensure thread-safe access
+    # --- Globals ---
+    app = FastAPI(title="XTTS Server")
+    router = APIRouter()
+    xtts_server = XTTSServer()
+    model_lock = asyncio.Lock()  # Ensure thread-safe access
+
+    # --- API Endpoints ---
+    @router.post("/generate_audio")
+    async def generate_audio(request: GenerationRequest):
+        async with model_lock:
+            try:
+                audio_bytes = await xtts_server.generate_audio(
+                    text=request.text,
+                    voice=request.voice,
+                    language=request.language,
+                    speaker_wav=request.speaker_wav
+                )
+                from fastapi.responses import Response
+                return Response(content=audio_bytes, media_type="audio/wav")
+            except Exception as e:
+                print(f"Server: ERROR in generate_audio endpoint: {e}")
+                print(f"Server: ERROR traceback:\n{traceback.format_exc()}")
+                raise HTTPException(status_code=500, detail=str(e))
 
-# --- API Endpoints ---
-@router.post("/generate_audio")
-async def generate_audio(request: GenerationRequest):
-    async with model_lock:
+    @router.get("/list_voices")
+    async def list_voices():
         try:
-            audio_bytes = await xtts_server.generate_audio(
-                text=request.text,
-                voice=request.voice,
-                language=request.language,
-                speaker_wav=request.speaker_wav
-            )
-            from fastapi.responses import Response
-            return Response(content=audio_bytes, media_type="audio/wav")
+            voices = xtts_server.list_voices()
+            print(f"Server: Returning {len(voices)} voices: {voices}")
+            return {"voices": voices}
         except Exception as e:
-            print(f"Server: ERROR in generate_audio endpoint: {e}")
+            print(f"Server: ERROR in list_voices endpoint: {e}")
             print(f"Server: ERROR traceback:\n{traceback.format_exc()}")
             raise HTTPException(status_code=500, detail=str(e))
 
-@router.get("/list_voices")
-async def list_voices():
-    try:
-        voices = xtts_server.list_voices()
-        print(f"Server: Returning {len(voices)} voices: {voices}")
-        return {"voices": voices}
-    except Exception as e:
-        print(f"Server: ERROR in list_voices endpoint: {e}")
-        print(f"Server: ERROR traceback:\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.get("/list_models")
-async def list_models():
-    try:
-        models = xtts_server.list_models()
-        print(f"Server: Returning {len(models)} models: {models}")
-        return {"models": models}
-    except Exception as e:
-        print(f"Server: ERROR in list_models endpoint: {e}")
-        print(f"Server: ERROR traceback:\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=str(e))
+    @router.get("/list_models")
+    async def list_models():
+        try:
+            models = xtts_server.list_models()
+            print(f"Server: Returning {len(models)} models: {models}")
+            return {"models": models}
+        except Exception as e:
+            print(f"Server: ERROR in list_models endpoint: {e}")
+            print(f"Server: ERROR traceback:\n{traceback.format_exc()}")
+            raise HTTPException(status_code=500, detail=str(e))
 
-@router.get("/status")
-async def status():
-    return {
-        "status": "running",
-        "xtts_available": xtts_available,
-        "model_loaded": xtts_server.model_loaded,
-        "model_loading": xtts_server.model_loading,
-        "voices_count": len(xtts_server.available_voices),
-        "device": torch.cuda.get_device_name(0) if torch.cuda.is_available() else "CPU"
-    }
+    @router.get("/status")
+    async def status():
+        return {
+            "status": "running",
+            "xtts_available": xtts_available,
+            "model_loaded": xtts_server.model_loaded,
+            "model_loading": xtts_server.model_loading,
+            "voices_count": len(xtts_server.available_voices),
+            "device": torch.cuda.get_device_name(0) if torch.cuda.is_available() else "CPU"
+        }
 
-# Add a health check endpoint that responds immediately
-@router.get("/health")
-async def health_check():
-    return {"status": "healthy", "ready": True}
+    # Add a health check endpoint that responds immediately
+    @router.get("/health")
+    async def health_check():
+        return {"status": "healthy", "ready": True}
 
-app.include_router(router)
+    app.include_router(router)
 
-# --- Server Startup ---
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description="XTTS TTS Server")
-    parser.add_argument("--host", type=str, default="localhost", help="Host to bind the server to.")
-    parser.add_argument("--port", type=int, default="8081", help="Port to bind the server to.")
-    
-    args = parser.parse_args()
+    # --- Server Startup ---
+    if __name__ == '__main__':
+        parser = argparse.ArgumentParser(description="XTTS TTS Server")
+        parser.add_argument("--host", type=str, default="localhost", help="Host to bind the server to.")
+        parser.add_argument("--port", type=int, default="8081", help="Port to bind the server to.")
+        
+        args = parser.parse_args()
 
-    print(f"Server: Starting XTTS server on {args.host}:{args.port}")
-    print(f"Server: XTTS available: {xtts_available}")
-    print(f"Server: Model will be loaded on first audio generation request")
-    print(f"Server: Available voices: {len(xtts_server.available_voices)}")
-    if xtts_available:
-        print(f"Server: Device: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU'}")
-    
-    # Create voices directory if it doesn't exist
-    voices_dir = Path(__file__).parent / "voices"
-    voices_dir.mkdir(exist_ok=True)
-    print(f"Server: Voices directory: {voices_dir}")
-    
-    uvicorn.run(app, host=args.host, port=args.port)
+        print(f"Server: Starting XTTS server on {args.host}:{args.port}")
+        print(f"Server: XTTS available: {xtts_available}")
+        print(f"Server: Model will be loaded on first audio generation request")
+        print(f"Server: Available voices: {len(xtts_server.available_voices)}")
+        if xtts_available:
+            print(f"Server: Device: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU'}")
+        
+        # Create voices directory if it doesn't exist
+        voices_dir = Path(__file__).parent / "voices"
+        voices_dir.mkdir(exist_ok=True)
+        print(f"Server: Voices directory: {voices_dir}")
+        
+        uvicorn.run(app, host=args.host, port=args.port)
+except Exception as e:
+    print(f"Server: CRITICAL ERROR during startup: {e}")

{lollms_client-1.6.1.dist-info → lollms_client-1.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.6.1
+Version: 1.6.2
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License:                                  Apache License
@@ -1302,6 +1302,7 @@ try:
 except Exception as e:
     ASCIIColors.error(f"Error initializing Hugging Face Inference API binding: {e}")
     ASCIIColors.info("Please ensure your Hugging Face API token is correctly set and you have access to the specified model.")```
+```
 
 ---
 
@@ -1403,7 +1404,9 @@ else:
 
     except Exception as e:
         ASCIIColors.error(f"An error occurred during multi-image fusion: {e}")
-```This powerful feature allows for complex creative tasks like character swapping, background replacement, and style transfer directly through the `lollms_client` library.
+```
+
+This powerful feature allows for complex creative tasks like character swapping, background replacement, and style transfer directly through the `lollms_client` library.
 
 ### Listing Available Models
 

{lollms_client-1.6.1.dist-info → lollms_client-1.6.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
-lollms_client/__init__.py,sha256=lRGg7_mob01b8ZxJtc7S4djDcL7d8kA6nJfKHSIuOWY,1146
+lollms_client/__init__.py,sha256=zZKNRiai-0QTZCCLS1KlMYvwRdcIEla7HeypZZBJUTs,1146
 lollms_client/lollms_agentic.py,sha256=pQiMEuB_XkG29-SW6u4KTaMFPr6eKqacInggcCuCW3k,13914
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=lYsDsVr_SWhFhMiFxNzzY_ZTvNvFZAUdvbxQRpO9EcI,321464
+lollms_client/lollms_core.py,sha256=TsyOvjtZtC-C2cy3-6Zag7QW-UfUN3jzfStgMsqfte4,321724
 lollms_client/lollms_discussion.py,sha256=LZc9jYbUMRTovehiFJKEp-NXuCl_WnrqUtT3t4Nzayk,123922
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
 lollms_client/lollms_llm_binding.py,sha256=tXuc3gxe6UrP36OBGsR-ESvQ9LpsB_nqtqL-GsEj6Uc,25019
@@ -12,7 +12,7 @@ lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_Ko
 lollms_client/lollms_stt_binding.py,sha256=jAUhLouEhh2hmm1bK76ianfw_6B59EHfY3FmLv6DU-g,5111
 lollms_client/lollms_tti_binding.py,sha256=B38nzBCSPV9jVRZa-x8W7l9nJEW0RyS1MMJoueb8kt0,8519
 lollms_client/lollms_ttm_binding.py,sha256=FjVVSNXOZXK1qvcKEfxdiX6l2b4XdGOSNnZ0utAsbDg,4167
-lollms_client/lollms_tts_binding.py,sha256=4qw94lc9M8lsh2q1u3FF0RuxTY__kukYg266ai3or-Y,5126
+lollms_client/lollms_tts_binding.py,sha256=k13rNq4YmuR50kkAEacwADW7COoDUOMLGAcnm27xjO4,5150
 lollms_client/lollms_ttv_binding.py,sha256=KkTaHLBhEEdt4sSVBlbwr5i_g_TlhcrwrT-7DjOsjWQ,4131
 lollms_client/lollms_types.py,sha256=0iSH1QHRRD-ddBqoL9EEKJ8wWCuwDUlN_FrfbCdg7Lw,3522
 lollms_client/lollms_utilities.py,sha256=3DAsII2X9uhRzRL-D0QlALcEdRg82y7OIL4yHVF32gY,19446
@@ -75,13 +75,13 @@ lollms_client/tts_bindings/piper_tts/__init__.py,sha256=FbMw_m2QOn2ny7r5El_s6jBy
 lollms_client/tts_bindings/piper_tts/server/install_piper.py,sha256=g71Ne2T18wAytOPipfQ9DNeTAOD9PrII5qC-vr9DtLA,3256
 lollms_client/tts_bindings/piper_tts/server/main.py,sha256=DMozfSR1aCbrlmOXltRFjtXhYhXajsGcNKQjsWgRwZk,17402
 lollms_client/tts_bindings/piper_tts/server/setup_voices.py,sha256=UdHaPa5aNcw8dR-aRGkZr2OfSFFejH79lXgfwT0P3ss,1964
-lollms_client/tts_bindings/xtts/__init__.py,sha256=i1bU6D7wDnWOSf7TRrw_bqeAF6Y8eFp-JIW8z_lWuQM,4211
-lollms_client/tts_bindings/xtts/server/main.py,sha256=T-Kn5NM-u1FJMygeV8rOoZKlqnYHZM30TsnbyZNDzxo,12794
+lollms_client/tts_bindings/xtts/__init__.py,sha256=2a1qzF8iDbr1bt0KQhcNbZqy0B06gjsWVAMJF-YATrE,6371
+lollms_client/tts_bindings/xtts/server/main.py,sha256=27l5FlclhqiXSBf-_qg4QR7Q7mUly72kaBtG8kBXASE,14088
 lollms_client/tts_bindings/xtts/server/setup_voices.py,sha256=UdHaPa5aNcw8dR-aRGkZr2OfSFFejH79lXgfwT0P3ss,1964
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-1.6.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-1.6.1.dist-info/METADATA,sha256=wRlmSzWMv4IsGALozvPDg6CIiEzqeQb9qrgj99hMvyo,76825
-lollms_client-1.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-1.6.1.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-1.6.1.dist-info/RECORD,,
+lollms_client-1.6.2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-1.6.2.dist-info/METADATA,sha256=g8ACOGQCyj4dIDIfa3fJmyqJzoLB-aN2U_qkOKs7CVw,76834
+lollms_client-1.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-1.6.2.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-1.6.2.dist-info/RECORD,,