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

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", [])