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

lollms_client/tti_bindings/gemini/__init__.py

@@ -307,7 +307,7 @@ class GeminiTTIBinding_Impl(LollmsTTIBinding):
         
         return applied_some_settings
 
-    def listModels(self) -> list:
+    def list_models(self) -> list:
         """Lists available Imagen models in a standardized format."""
         models = IMAGEN_VERTEX_MODELS if self.auth_method == "vertex_ai" else IMAGEN_GEMINI_API_MODELS
         return [

lollms_client/tti_bindings/leonardo_ai/__init__.py

@@ -38,7 +38,7 @@ class LeonardoAITTIBinding(LollmsTTIBinding):
         self.base_url = "https://cloud.leonardo.ai/api/rest/v1"
         self.headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
 
-    def listModels(self) -> list:
+    def list_models(self) -> list:
         # You could also fetch this dynamically from /models endpoint
         return LEONARDO_AI_MODELS
     

lollms_client/tti_bindings/novita_ai/__init__.py

@@ -36,7 +36,7 @@ class NovitaAITTIBinding(LollmsTTIBinding):
         self.base_url = "https://api.novita.ai/v3"
         self.headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
 
-    def listModels(self) -> list:
+    def list_models(self) -> list:
         return NOVITA_AI_MODELS
     
     def generate_image(self, prompt: str, negative_prompt: str = "", width: int = 1024, height: int = 1024, **kwargs) -> bytes:

lollms_client/tti_bindings/stability_ai/__init__.py

@@ -40,7 +40,7 @@ class StabilityAITTIBinding(LollmsTTIBinding):
             raise ValueError("Stability AI API key is required. Please set it in the configuration or as STABILITY_API_KEY environment variable.")
         self.model_name = self.config.get("model_name", "stable-diffusion-3-medium")
 
-    def listModels(self) -> list:
+    def list_models(self) -> list:
         return STABILITY_AI_MODELS
 
     def _get_api_url(self, task: str) -> str:

lollms_client/tts_bindings/lollms/__init__.py

@@ -29,6 +29,7 @@ class LollmsTTSBinding_Impl(LollmsTTSBinding):
                          model_name=model_name,
                          service_key=service_key, # Stored in the parent class
                          verify_ssl_certificate=verify_ssl_certificate)
+        self.host_address = host_address
         # self.client_id = service_key # Can access via self.service_key from parent
 
     def generate_audio(self, text: str, voice: Optional[str] = None, **kwargs) -> bytes:
@@ -142,4 +143,8 @@ class LollmsTTSBinding_Impl(LollmsTTSBinding):
         except Exception as e:
             ASCIIColors.error(f"An unexpected error occurred while listing voices: {e}")
             trace_exception(e)
-            return ["main_voice"]
+            return ["main_voice"]
+
+    def list_models(self) -> list:
+        """Lists models"""
+        return  ["lollms"]

lollms_client/tts_bindings/piper_tts/__init__.py

@@ -104,7 +104,7 @@ class PiperClientBinding(LollmsTTSBinding):
         response.raise_for_status()
         return response.json().get("voices", [])
 
-    def list_models(self, **kwargs) -> List[str]:
+    def list_models(self) -> List[str]:
         """Get available models from the server"""
         response = requests.get(f"{self.base_url}/list_models")
         response.raise_for_status()

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,29 +31,85 @@ 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 install(self, venv_path, requirements_file):
+        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...")
 
     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 = Path("./venv/xtts_venv")
 
+        if not venv_path.exists():
+            self.install(venv_path, requirements_file)
+            
         # 2. Get the python executable from the venv
         if sys.platform == "win32":
             python_executable = venv_path / "Scripts" / "python.exe"
         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 +117,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"""
@@ -103,9 +161,10 @@ class XTTSClientBinding(LollmsTTSBinding):
         response.raise_for_status()
         return response.json().get("voices", [])
 
-    def list_models(self, **kwargs) -> List[str]:
-        """Get available models from the server"""
+
+    def list_models(self) -> list:
+        """Lists models"""
         response = requests.get(f"{self.base_url}/list_models")
         response.raise_for_status()
         return response.json().get("models", [])
-
+