lollms-client 1.6.5__py3-none-any.whl → 1.6.6__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.5" # Updated version
+__version__ = "1.6.6" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/tti_bindings/diffusers/__init__.py

@@ -53,6 +53,7 @@ class DiffusersBinding(LollmsTTIBinding):
         self.server_dir = self.binding_root / "server"
         self.venv_dir = Path("./venv/tti_diffusers_venv")
         self.models_path = Path(kwargs.get("models_path", "./data/models/diffusers_models")).resolve()
+        self.extra_models_path = kwargs.get("extra_models_path")
         self.models_path.mkdir(exist_ok=True, parents=True)
         if self.auto_start_server:
             self.ensure_server_is_running()
@@ -68,36 +69,47 @@ class DiffusersBinding(LollmsTTIBinding):
         return False
 
 
-    def ensure_server_is_running(self, continue_if_locked: bool = True):
+    def ensure_server_is_running(self):
         """
         Ensures the Diffusers server is running. If not, it attempts to start it
-        in a process-safe manner using a file lock.
-
-        Args:
-            continue_if_locked (bool): If True, return immediately if another process
-                                    already holds the lock.
+        in a process-safe manner using a file lock. This method is designed to
+        prevent race conditions in multi-worker environments.
         """
         self.server_dir.mkdir(exist_ok=True)
-        lock_path = self.models_path / "diffusers_server.lock"
+        # Use a lock file in the binding's server directory for consistency across instances
+        lock_path = self.server_dir / "diffusers_server.lock"
         lock = FileLock(lock_path)
 
         ASCIIColors.info("Attempting to start or connect to the Diffusers server...")
+
+        # First, perform a quick check without the lock to avoid unnecessary waiting.
+        if self.is_server_running():
+            ASCIIColors.green("Diffusers Server is already running and responsive.")
+            return
+
         try:
-            # Try to acquire lock immediately if continue_if_locked=True
-            with lock.acquire(timeout=0 if continue_if_locked else 60):
+            # Try to acquire the lock with a timeout. If another process is starting
+            # the server, this will wait until it's finished.
+            with lock.acquire(timeout=60):
+                # After acquiring the lock, we MUST re-check if the server is running.
+                # Another process might have started it and released the lock while we were waiting.
                 if not self.is_server_running():
                     ASCIIColors.yellow("Lock acquired. Starting dedicated Diffusers server...")
                     self.start_server()
+                    # The process that starts the server is responsible for waiting for it to be ready
+                    # BEFORE releasing the lock. This is the key to preventing race conditions.
+                    self._wait_for_server()
                 else:
-                    ASCIIColors.green("Server was started by another process. Connected successfully.")
+                    ASCIIColors.green("Server was started by another process while we waited. Connected successfully.")
         except Timeout:
-            if continue_if_locked:
-                ASCIIColors.yellow("Lock held by another process. Skipping server startup and continuing execution.")
-                return
-            else:
-                ASCIIColors.yellow("Could not acquire lock within timeout. Waiting for server to become available...")
+            # This happens if the process holding the lock takes more than 60 seconds to start the server.
+            # We don't try to start another one. We just wait for the existing one to be ready.
+            ASCIIColors.yellow("Could not acquire lock, another process is taking a long time to start the server. Waiting...")
+            self._wait_for_server(timeout=300) # Give it a longer timeout here just in case.
 
-        self._wait_for_server()
+        # A final verification to ensure we are connected.
+        if not self.is_server_running():
+            raise RuntimeError("Failed to start or connect to the Diffusers server after all attempts.")
 
     def install_server_dependencies(self):
         """
@@ -191,6 +203,10 @@ class DiffusersBinding(LollmsTTIBinding):
             "--models-path", str(self.models_path.resolve()) # Pass models_path to server
         ]
 
+        if self.extra_models_path:
+            resolved_extra_path = Path(self.extra_models_path).resolve()
+            command.extend(["--extra-models-path", str(resolved_extra_path)])
+
         # Use DETACHED_PROCESS on Windows to allow the server to run independently of the parent process.
         # On Linux/macOS, the process will be daemonized enough to not be killed with the worker.
         creationflags = subprocess.DETACHED_PROCESS if sys.platform == "win32" else 0
@@ -273,11 +289,14 @@ class DiffusersBinding(LollmsTTIBinding):
         pass
 
     def generate_image(self, prompt: str, negative_prompt: str = "", **kwargs) -> bytes:
-        # This is a pure JSON request
+        params = kwargs.copy()
+        if "model_name" not in params and self.config.get("model_name"):
+            params["model_name"] = self.config["model_name"]
+            
         response = self._post_json_request("/generate_image", data={
             "prompt": prompt,
             "negative_prompt": negative_prompt,
-            "params": kwargs
+            "params": params
         })
         return response.content
 
@@ -307,15 +326,19 @@ class DiffusersBinding(LollmsTTIBinding):
                 raise ValueError(f"Unsupported image type in edit_image: {type(img)}")
         if not images_b64:
             raise ValueError("No valid images were provided to the edit_image function.")
+        
+        params = kwargs.copy()
+        if "model_name" not in params and self.config.get("model_name"):
+            params["model_name"] = self.config["model_name"]
 
         # Translate "mask" to "mask_image" for server compatibility
-        if "mask" in kwargs and kwargs["mask"]:
-            kwargs["mask_image"] = kwargs.pop("mask")
+        if "mask" in params and params["mask"]:
+            params["mask_image"] = params.pop("mask")
 
         json_payload = {
             "prompt": prompt,
             "images_b64": images_b64,
-            "params": kwargs
+            "params": params
         }
         response = self._post_json_request("/edit_image", data=json_payload)
         return response.content
@@ -351,4 +374,4 @@ class DiffusersBinding(LollmsTTIBinding):
     def __del__(self):
         # The client destructor does not stop the server,
         # as it is a shared resource for all worker processes.
-        pass
+        pass

lollms_client/tti_bindings/diffusers/server/main.py

@@ -62,7 +62,7 @@ MODELS_PATH = Path("./models")
 CIVITAI_MODELS = {
     "realistic-vision-v6": {
         "display_name": "Realistic Vision V6.0", "url": "https://civitai.com/api/download/models/501240?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "realisticVisionV60_v60B1.safetensors", "description": "Photorealistic SD1.5 checkpoint.", "owned_by": "civitai"
+        "filename": "realisticVisionV60_v60B1.safensors", "description": "Photorealistic SD1.5 checkpoint.", "owned_by": "civitai"
     },
     "absolute-reality": {
         "display_name": "Absolute Reality", "url": "https://civitai.com/api/download/models/132760?type=Model&format=SafeTensor&size=pruned&fp=fp16",
@@ -122,19 +122,45 @@ CIVITAI_MODELS = {
     },
 }
 
-HF_DEFAULT_MODELS = [
-    {"family": "FLUX", "model_name": "black-forest-labs/FLUX.1-schnell", "display_name": "FLUX.1 Schnell", "desc": "A fast and powerful next-gen T2I model."},
-    {"family": "FLUX", "model_name": "black-forest-labs/FLUX.1-dev", "display_name": "FLUX.1 Dev", "desc": "The larger, developer version of the FLUX.1 model."},
-    {"family": "SDXL", "model_name": "stabilityai/stable-diffusion-xl-base-1.0", "display_name": "SDXL Base 1.0", "desc": "Text2Image 1024 native."},
-    {"family": "SDXL", "model_name": "stabilityai/stable-diffusion-xl-refiner-1.0", "display_name": "SDXL Refiner 1.0", "desc": "Refiner for SDXL."},
-    {"family": "SD 1.x", "model_name": "runwayml/stable-diffusion-v1-5", "display_name": "Stable Diffusion 1.5", "desc": "Classic SD1.5."},
-    {"family": "SD 2.x", "model_name": "stabilityai/stable-diffusion-2-1", "display_name": "Stable Diffusion 2.1", "desc": "SD2.1 base."},
-    {"family": "SD3", "model_name": "stabilityai/stable-diffusion-3-medium-diffusers", "display_name": "Stable Diffusion 3 Medium", "desc": "SD3 medium."},
-    {"family": "Qwen", "model_name": "Qwen/Qwen-Image", "display_name": "Qwen Image", "desc": "Dedicated image generation."},
-    {"family": "Specialized", "model_name": "playgroundai/playground-v2.5-1024px-aesthetic", "display_name": "Playground v2.5", "desc": "High aesthetic 1024."},
-    {"family": "Editors", "model_name": "Qwen/Qwen-Image-Edit", "display_name": "Qwen Image Edit", "desc": "Dedicated image editing."},
-    {"family": "Editors", "model_name": "Qwen/Qwen-Image-Edit-2509", "display_name": "Qwen Image Edit Plus (Multi-Image)", "desc": "Advanced multi-image editing, fusion, and pose transfer."}
-]
+HF_PUBLIC_MODELS = {
+    "General Purpose & SDXL": [
+        {"model_name": "stabilityai/stable-diffusion-xl-base-1.0", "display_name": "Stable Diffusion XL 1.0", "desc": "Official 1024x1024 text-to-image model from Stability AI."},
+        {"model_name": "stabilityai/sdxl-turbo", "display_name": "SDXL Turbo", "desc": "A fast, real-time text-to-image model based on SDXL."},
+        {"model_name": "kandinsky-community/kandinsky-3", "display_name": "Kandinsky 3", "desc": "A powerful multilingual model with strong prompt understanding and aesthetic quality."},
+        {"model_name": "playgroundai/playground-v2.5-1024px-aesthetic", "display_name": "Playground v2.5", "desc": "A high-quality model focused on aesthetic outputs."},
+    ],
+    "Photorealistic": [
+        {"model_name": "emilianJR/epiCRealism", "display_name": "epiCRealism", "desc": "A popular community model for generating photorealistic images."},
+        {"model_name": "SG161222/Realistic_Vision_V5.1_noVAE", "display_name": "Realistic Vision 5.1", "desc": "One of the most popular realistic models, great for portraits and scenes."},
+        {"model_name": "Photon-v1", "display_name": "Photon", "desc": "A model known for high-quality, realistic images with good lighting and detail."},
+    ],
+    "Anime & Illustration": [
+        {"model_name": "hakurei/waifu-diffusion", "display_name": "Waifu Diffusion 1.4", "desc": "A widely-used model for generating high-quality anime-style images."},
+        {"model_name": "gsdf/Counterfeit-V3.0", "display_name": "Counterfeit V3.0", "desc": "A strong model for illustrative and 2.5D anime styles."},
+        {"model_name": "cagliostrolab/animagine-xl-3.0", "display_name": "Animagine XL 3.0", "desc": "A state-of-the-art anime model on the SDXL architecture."},
+    ],
+    "Artistic & Stylized": [
+        {"model_name": "wavymulder/Analog-Diffusion", "display_name": "Analog Diffusion", "desc": "Creates images with a vintage, analog film aesthetic."},
+        {"model_name": "dreamlike-art/dreamlike-photoreal-2.0", "display_name": "Dreamlike Photoreal 2.0", "desc": "Produces stunning, artistic, and photorealistic images."},
+    ],
+    "Image Editing Tools": [
+        {"model_name": "stabilityai/stable-diffusion-xl-refiner-1.0", "display_name": "SDXL Refiner 1.0", "desc": "A dedicated refiner model to improve details in SDXL generations."},
+        {"model_name": "Qwen/Qwen-Image-Edit", "display_name": "Qwen Image Edit", "desc": "An instruction-based model for various image editing tasks."},
+        {"model_name": "Qwen/Qwen-Image-Edit-2509", "display_name": "Qwen Image Edit Plus", "desc": "Advanced multi-image editing, fusion, and pose transfer."},
+    ],
+    "Legacy & Base Models": [
+        {"model_name": "runwayml/stable-diffusion-v1-5", "display_name": "Stable Diffusion 1.5", "desc": "The classic and versatile SD1.5 base model."},
+        {"model_name": "stabilityai/stable-diffusion-2-1", "display_name": "Stable Diffusion 2.1", "desc": "The 768x768 base model from the SD2.x series."},
+    ]
+}
+
+HF_GATED_MODELS = {
+    "Next-Generation (Gated Access Required)": [
+        {"model_name": "stabilityai/stable-diffusion-3-medium-diffusers", "display_name": "Stable Diffusion 3 Medium", "desc": "State-of-the-art model with advanced prompt understanding. Requires free registration."},
+        {"model_name": "black-forest-labs/FLUX.1-schnell", "display_name": "FLUX.1 Schnell", "desc": "A powerful and extremely fast next-generation model. Requires access request."},
+        {"model_name": "black-forest-labs/FLUX.1-dev", "display_name": "FLUX.1 Dev", "desc": "The larger developer version of the FLUX.1 model. Requires access request."},
+    ]
+}
 
 
 TORCH_DTYPE_MAP_STR_TO_OBJ = {
@@ -228,9 +254,25 @@ class ModelManager:
             if not local_path.exists():
                 self._download_civitai_model(model_name)
             return local_path
+
+        # Search in extra models path
+        if state.extra_models_path and state.extra_models_path.exists():
+            found_paths = list(state.extra_models_path.rglob(model_name))
+            if found_paths:
+                ASCIIColors.info(f"Found model in extra path: {found_paths[0]}")
+                return found_paths[0]
+
+        # Search in primary models path
+        found_paths = list(self.models_path.rglob(model_name))
+        if found_paths:
+            ASCIIColors.info(f"Found model in primary path: {found_paths[0]}")
+            return found_paths[0]
+
+        # Fallback for HF hub models that are folders, not single files.
         local_path = self.models_path / model_name
         if local_path.exists():
             return local_path
+
         return model_name
 
     def _download_civitai_model(self, model_key: str):
@@ -535,9 +577,12 @@ class PipelineRegistry:
             return list(self._managers.values())
 
 class ServerState:
-    def __init__(self, models_path: Path):
+    def __init__(self, models_path: Path, extra_models_path: Optional[Path] = None):
         self.models_path = models_path
+        self.extra_models_path = extra_models_path
         self.models_path.mkdir(parents=True, exist_ok=True)
+        if self.extra_models_path:
+            self.extra_models_path.mkdir(parents=True, exist_ok=True)
         self.config_path = self.models_path.parent / "diffusers_server_config.json"
         self.registry = PipelineRegistry()
         self.manager: Optional[ModelManager] = None
@@ -802,14 +847,49 @@ async def edit_image(request: EditRequestJSON):
 
 @router.get("/list_models")
 def list_models_endpoint():
-    civitai = [{'model_name': key, 'display_name': info['display_name'], 'description': info['description'], 'owned_by': info['owned_by']} for key, info in CIVITAI_MODELS.items()]
-    local = [{'model_name': f.name, 'display_name': f.stem, 'description': 'Local safetensors file.', 'owned_by': 'local_user'} for f in state.models_path.glob("*.safetensors")]
-    huggingface = [{'model_name': m['model_name'], 'display_name': m['display_name'], 'description': m['desc'], 'owned_by': 'huggingface'} for m in HF_DEFAULT_MODELS]
-    return huggingface + civitai + local
+    huggingface_models = []
+    # Add public models, organized by category
+    for category, models in HF_PUBLIC_MODELS.items():
+        for model_info in models:
+            huggingface_models.append({
+                'model_name': model_info['model_name'], 
+                'display_name': model_info['display_name'], 
+                'description': f"({category}) {model_info['desc']}", 
+                'owned_by': 'huggingface'
+            })
+
+    # Conditionally add gated models if an HF token is provided in the server config
+    if state.config.get("hf_token"):
+        ASCIIColors.info("HF token detected, including gated models in the list.")
+        for category, models in HF_GATED_MODELS.items():
+            for model_info in models:
+                huggingface_models.append({
+                    'model_name': model_info['model_name'], 
+                    'display_name': model_info['display_name'], 
+                    'description': f"({category}) {model_info['desc']}", 
+                    'owned_by': 'huggingface'
+                })
+    else:
+        ASCIIColors.info("No HF token found, showing public models only.")
+
+    civitai_models = [{'model_name': key, 'display_name': info['display_name'], 'description': f"(Civitai) {info['description']}", 'owned_by': info['owned_by']} for key, info in CIVITAI_MODELS.items()]
+    
+    local_files = list_local_models_endpoint()
+    local_models = [{'model_name': filename, 'display_name': Path(filename).stem, 'description': '(Local) Local safetensors file.', 'owned_by': 'local_user'} for filename in local_files]
+
+    return huggingface_models + civitai_models + local_models
 
 @router.get("/list_local_models")
 def list_local_models_endpoint():
-    return sorted([f.name for f in state.models_path.glob("*.safetensors")])
+    local_models = set()
+    # Main models path
+    for f in state.models_path.glob("**/*.safetensors"):
+        local_models.add(f.name)
+    # Extra models path
+    if state.extra_models_path and state.extra_models_path.exists():
+        for f in state.extra_models_path.glob("**/*.safetensors"):
+            local_models.add(f.name)
+    return sorted(list(local_models))
 
 @router.get("/list_available_models")
 def list_available_models_endpoint():
@@ -866,14 +946,18 @@ if __name__ == "__main__":
     parser.add_argument("--host", type=str, default="localhost", help="Host to bind to.")
     parser.add_argument("--port", type=int, default=9630, help="Port to bind to.")
     parser.add_argument("--models-path", type=str, required=True, help="Path to the models directory.")
+    parser.add_argument("--extra-models-path", type=str, default=None, help="Path to an extra models directory.")
     args = parser.parse_args()
 
     MODELS_PATH = Path(args.models_path)
-    state = ServerState(MODELS_PATH)
+    EXTRA_MODELS_PATH = Path(args.extra_models_path) if args.extra_models_path else None
+    state = ServerState(MODELS_PATH, EXTRA_MODELS_PATH)
     
     ASCIIColors.cyan(f"--- Diffusers TTI Server ---")
     ASCIIColors.green(f"Starting server on http://{args.host}:{args.port}")
     ASCIIColors.green(f"Serving models from: {MODELS_PATH.resolve()}")
+    if EXTRA_MODELS_PATH:
+        ASCIIColors.green(f"Serving extra models from: {EXTRA_MODELS_PATH.resolve()}")
     if not DIFFUSERS_AVAILABLE:
         ASCIIColors.error("Diffusers or its dependencies are not installed correctly in the server's environment!")
     else:

lollms_client/tts_bindings/xtts/__init__.py

@@ -1,38 +1,51 @@
-from lollms_client.lollms_tts_binding import LollmsTTSBinding
-from typing import Optional, List
-from pathlib import Path
+import os
+import sys
 import requests
 import subprocess
-import sys
 import time
-import pipmaster as pm
+from pathlib import Path
+from typing import Optional, List
 
-# New import for process-safe file locking
+# Ensure pipmaster is available.
+try:
+    import pipmaster as pm
+except ImportError:
+    print("FATAL: pipmaster is not installed. Please install it using: pip install pipmaster")
+    sys.exit(1)
+
+# Ensure filelock is available for process-safe server startup.
 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)
 
+from lollms_client.lollms_tts_binding import LollmsTTSBinding
+from ascii_colors import ASCIIColors
 
 BindingName = "XTTSClientBinding"
 
 class XTTSClientBinding(LollmsTTSBinding):
+    """
+    Client binding for a dedicated, managed XTTS server.
+    This architecture prevents the heavy XTTS model from being loaded into memory
+    by multiple worker processes, solving potential OOM errors and speeding up TTS generation.
+    """
     def __init__(self, 
-                 host: str = "localhost", 
-                 port: int = 8081, 
-                 auto_start_server: bool = True,
                  **kwargs):
         
         binding_name = "xtts"
         super().__init__(binding_name=binding_name, **kwargs)
-        self.host = host
-        self.port = port
-        self.auto_start_server = auto_start_server
+
+        self.config = kwargs
+        self.host = kwargs.get("host", "localhost")
+        self.port = kwargs.get("port", 8081)
+        self.auto_start_server = kwargs.get("auto_start_server", True)
         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"
+        self.venv_dir = Path("./venv/tts_xtts_venv")
 
         if self.auto_start_server:
             self.ensure_server_is_running()
@@ -40,10 +53,10 @@ class XTTSClientBinding(LollmsTTSBinding):
     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)
+            response = requests.get(f"{self.base_url}/status", timeout=2)
             if response.status_code == 200 and response.json().get("status") == "running":
                 return True
-        except requests.ConnectionError:
+        except requests.exceptions.RequestException:
             return False
         return False
 
@@ -52,64 +65,69 @@ class XTTSClientBinding(LollmsTTSBinding):
         Ensures the XTTS server is running. If not, it attempts to start it
         in a process-safe manner using a file lock.
         """
+        self.server_dir.mkdir(exist_ok=True)
+        lock_path = self.server_dir / "xtts_server.lock"
+        lock = FileLock(lock_path)
+
+        ASCIIColors.info("Attempting to start or connect to the XTTS server...")
+        
         if self.is_server_running():
-            print("XTTS Server is already running.")
+            ASCIIColors.green("XTTS Server is already running and responsive.")
             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
+            with lock.acquire(timeout=60):
                 if not self.is_server_running():
-                    print("Lock acquired. Starting dedicated XTTS server...")
+                    ASCIIColors.yellow("Lock acquired. Starting dedicated XTTS server...")
                     self.start_server()
+                    self._wait_for_server()
                 else:
-                    print("Server was started by another process while waiting for the lock.")
+                    ASCIIColors.green("Server was started by another process while we waited. Connected successfully.")
         except Timeout:
-            print("Could not acquire lock. Another process is likely starting the server. Waiting...")
+            ASCIIColors.yellow("Could not acquire lock, another process is starting the server. Waiting...")
+            self._wait_for_server(timeout=180)
 
-        # All workers (the one that started the server and those that waited) will verify the server is ready
-        self._wait_for_server()
+        if not self.is_server_running():
+            raise RuntimeError("Failed to start or connect to the XTTS server after all attempts.")
 
-    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
-        )
+    def install_server_dependencies(self):
+        """
+        Installs the server's dependencies into a dedicated virtual environment
+        using pipmaster, which handles complex packages like PyTorch.
+        """
+        ASCIIColors.info(f"Setting up virtual environment in: {self.venv_dir}")
+        pm_v = pm.PackageManager(venv_path=str(self.venv_dir))
+        
+        requirements_file = self.server_dir / "requirements.txt"
+        
+        ASCIIColors.info("Installing server dependencies from requirements.txt...")
+        success = pm_v.ensure_requirements(str(requirements_file), verbose=True)
 
         if not success:
-            print("FATAL: Failed to install server dependencies. Aborting launch.")
-            return
+            ASCIIColors.error("Failed to install server dependencies. Please check the console output for errors.")
+            raise RuntimeError("XTTS server dependency installation failed.")
+
+        ASCIIColors.green("Server dependencies are satisfied.")
 
-        print("Dependencies are satisfied. Proceeding to launch server...")
 
     def start_server(self):
         """
-        Installs dependencies and launches the server as a background subprocess.
+        Installs dependencies and launches the FastAPI 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"
+        if not server_script.exists():
+            raise FileNotFoundError(f"Server script not found at {server_script}.")
 
-        # 1. Ensure a virtual environment and dependencies
-        venv_path = Path("./venv/xtts_venv")
+        if not self.venv_dir.exists():
+            self.install_server_dependencies()
 
-        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"
+            python_executable = self.venv_dir / "Scripts" / "python.exe"
         else:
-            python_executable = venv_path / "bin" / "python"
+            python_executable = self.venv_dir / "bin" / "python"
 
-        # 3. Launch the server as a detached subprocess
         command = [
             str(python_executable),
             str(server_script),
@@ -117,54 +135,61 @@ class XTTSClientBinding(LollmsTTSBinding):
             "--port", str(self.port)
         ]
         
-        # 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.")
-
+        # Use DETACHED_PROCESS on Windows to allow the server to run independently.
+        creationflags = subprocess.DETACHED_PROCESS if sys.platform == "win32" else 0
+        
+        self.server_process = subprocess.Popen(command, creationflags=creationflags)
+        ASCIIColors.info("XTTS server process launched in the background.")
 
-    def _wait_for_server(self, timeout=60):
-        print("Waiting for XTTS server to become available...")
+    def _wait_for_server(self, timeout=120):
+        """Waits for the server to become responsive."""
+        ASCIIColors.info("Waiting for XTTS server to become available...")
         start_time = time.time()
         while time.time() - start_time < timeout:
             if self.is_server_running():
-                print("XTTS Server is up and running.")
+                ASCIIColors.green("XTTS Server is up and running.")
                 return
-            time.sleep(1)
-        
+            time.sleep(2)
         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: An instance is shutting down, but the shared server will remain active for other workers.")
-            self.server_process = None
-    
     def __del__(self):
-        """
-        The destructor does not stop the server to prevent disrupting other workers.
-        """
+        # The client destructor does not stop the server,
+        # as it is a shared resource for other processes.
         pass
 
     def generate_audio(self, text: str, voice: Optional[str] = None, **kwargs) -> bytes:
         """Generate audio by calling the server's API"""
-        payload = {"text": text, "voice": voice, **kwargs}
-        response = requests.post(f"{self.base_url}/generate_audio", json=payload)
-        response.raise_for_status()
-        return response.content
+        payload = {"text": text, "voice": voice}
+        # Pass other kwargs from the description file (language, split_sentences)
+        payload.update(kwargs)
+        
+        try:
+            response = requests.post(f"{self.base_url}/generate_audio", json=payload, timeout=300)
+            response.raise_for_status()
+            return response.content
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"Failed to communicate with XTTS server at {self.base_url}.")
+            ASCIIColors.error(f"Error details: {e}")
+            raise RuntimeError("Communication with the XTTS server failed.") from e
+
 
     def list_voices(self, **kwargs) -> List[str]:
         """Get available voices from the server"""
-        response = requests.get(f"{self.base_url}/list_voices")
-        response.raise_for_status()
-        return response.json().get("voices", [])
+        try:
+            response = requests.get(f"{self.base_url}/list_voices")
+            response.raise_for_status()
+            return response.json().get("voices", [])
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"Failed to get voices from XTTS server: {e}")
+            return []
 
 
-    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", [])
-        
+    def list_models(self, **kwargs) -> list:
+        """Lists models supported by the server"""
+        try:
+            response = requests.get(f"{self.base_url}/list_models")
+            response.raise_for_status()
+            return response.json().get("models", [])
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"Failed to get models from XTTS server: {e}")
+            return []

lollms_client/tts_bindings/xtts/server/main.py

@@ -13,24 +13,26 @@ try:
     import wave
     import numpy as np
     import tempfile
+    
+    # Use ascii_colors for logging
+    from ascii_colors import ASCIIColors
 
     # --- XTTS Implementation ---
     try:
-        print("Server: Loading XTTS dependencies...")
+        ASCIIColors.info("Server: Loading XTTS dependencies...")
         import torch
-        import torchaudio
         from TTS.api import TTS
-        print("Server: XTTS dependencies loaded successfully")
+        ASCIIColors.green("Server: XTTS dependencies loaded successfully")
         
         # Check for CUDA availability
         device = "cuda" if torch.cuda.is_available() else "cpu"
-        print(f"Server: Using device: {device}")
+        ASCIIColors.info(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()}")
+        ASCIIColors.error(f"Server: Failed to load XTTS dependencies: {e}")
+        ASCIIColors.error(f"Server: Traceback:\n{traceback.format_exc()}")
         xtts_available = False
 
     # --- API Models ---
@@ -38,18 +40,21 @@ try:
         text: str
         voice: Optional[str] = None
         language: Optional[str] = "en"
-        speaker_wav: Optional[str] = None
+        # speaker_wav is kept for backward compatibility but voice is preferred
+        speaker_wav: Optional[str] = None 
+        split_sentences: Optional[bool] = True
 
     class XTTSServer:
         def __init__(self):
             self.model = None
             self.model_loaded = False
             self.model_loading = False  # Flag to prevent concurrent loading
+            self.available_models = ["tts_models/multilingual/multi-dataset/xtts_v2"]
+            self.voices_dir = Path(__file__).parent / "voices"
+            self.voices_dir.mkdir(exist_ok=True)
             self.available_voices = self._load_available_voices()
-            self.available_models = ["xtts_v2"]
             
-            # Don't initialize model here - do it lazily on first request
-            print("Server: XTTS server initialized (model will be loaded on first request)")
+            ASCIIColors.info("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)"""
@@ -63,171 +68,130 @@ try:
                 return
                 
             if not xtts_available:
-                raise RuntimeError("XTTS library not available")
+                raise RuntimeError("XTTS library not available. Please ensure all dependencies are installed correctly in the venv.")
                 
             try:
                 self.model_loading = True
-                print("Server: Loading XTTS model for the first time (this may take a few minutes)...")
+                ASCIIColors.yellow("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 = TTS(self.available_models[0]).to(device)
                 
                 self.model_loaded = True
-                print("Server: XTTS model loaded successfully")
+                ASCIIColors.green("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()}")
+                ASCIIColors.error(f"Server: Error loading XTTS model: {e}")
+                ASCIIColors.error(f"Server: Traceback:\n{traceback.format_exc()}")
                 self.model_loaded = False
                 raise
             finally:
                 self.model_loading = False
         
         def _load_available_voices(self) -> List[str]:
-            """Load and return available voices"""
+            """Load and return available voices, ensuring 'default_voice' is always present."""
             try:
-                # Look for voice files in voices directory
-                voices_dir = Path(__file__).parent / "voices"
-                voices = []
+                self.voices_dir.mkdir(exist_ok=True)
                 
-                if voices_dir.exists():
-                    # Look for WAV files in voices directory
-                    for voice_file in voices_dir.glob("*.wav"):
-                        voices.append(voice_file.stem)
+                # Scan for case-insensitive .wav and .mp3 files and get their stems
+                found_voices = {p.stem for p in self.voices_dir.glob("*.[wW][aA][vV]")}
+                found_voices.update({p.stem for p in self.voices_dir.glob("*.[mM][pP]3")})
                 
-                # If no custom voices found, provide some default names
-                if not voices:
-                    voices = ["default", "female", "male"]
-                    
-                return voices
+                # GUARANTEE 'default_voice' is in the list for UI consistency.
+                all_voices = {"default_voice"}.union(found_voices)
+                
+                sorted_voices = sorted(list(all_voices))
+                ASCIIColors.info(f"Discovered voices: {sorted_voices}")
+                return sorted_voices
                 
             except Exception as e:
-                print(f"Server: Error loading voices: {e}")
-                return ["default"]
+                ASCIIColors.error(f"Server: Error scanning voices directory: {e}")
+                # If scanning fails, it's crucial to still return the default.
+                return ["default_voice"]
         
-        async def generate_audio(self, text: str, voice: Optional[str] = None, 
-                        language: str = "en", speaker_wav: Optional[str] = None) -> bytes:
+        def _get_speaker_wav_path(self, voice_name: str) -> Optional[str]:
+            """Find the path to a speaker wav/mp3 file from its name."""
+            if not voice_name:
+                return None
+            
+            # Case 1: voice_name is an absolute path that exists
+            if os.path.isabs(voice_name) and os.path.exists(voice_name):
+                return voice_name
+            
+            # Case 2: voice_name is a name in the voices directory (check for .mp3 then .wav)
+            mp3_path = self.voices_dir / f"{voice_name}.mp3"
+            if mp3_path.exists():
+                return str(mp3_path)
+
+            wav_path = self.voices_dir / f"{voice_name}.wav"
+            if wav_path.exists():
+                return str(wav_path)
+            
+            return None
+
+        async def generate_audio(self, req: GenerationRequest) -> bytes:
             """Generate audio from text using XTTS"""
-            # Ensure model is loaded before proceeding
             await self._ensure_model_loaded()
             
             if not self.model_loaded or self.model is None:
-                raise RuntimeError("XTTS model failed to load")
+                raise RuntimeError("XTTS model failed to load or is not available.")
             
             try:
-                print(f"Server: Generating audio for: '{text[:50]}{'...' if len(text) > 50 else ''}'")
-                print(f"Server: Using voice: {voice}, language: {language}")
+                text_to_generate = req.text
+                ASCIIColors.info(f"Server: Generating audio for: '{text_to_generate[:50]}{'...' if len(text_to_generate) > 50 else ''}'")
+                ASCIIColors.info(f"Server: Language: {req.language}, Requested Voice: {req.voice}")
+
+                # Determine which voice name to use. Priority: speaker_wav > voice > 'default_voice'
+                voice_to_find = req.speaker_wav or req.voice or "default_voice"
+                speaker_wav_path = self._get_speaker_wav_path(voice_to_find)
+
+                # If the chosen voice wasn't found and it wasn't the default, try the default as a fallback.
+                if not speaker_wav_path and voice_to_find != "default_voice":
+                    ASCIIColors.warning(f"Voice '{voice_to_find}' not found. Falling back to 'default_voice'.")
+                    speaker_wav_path = self._get_speaker_wav_path("default_voice")
+
+                # If still no path, it's a critical error because even the default is missing.
+                if not speaker_wav_path:
+                    available = self._get_all_available_voice_files()
+                    raise RuntimeError(
+                        f"XTTS requires a speaker reference file, but none could be found.\n"
+                        f"Attempted to use '{voice_to_find}' but it was not found, and the fallback 'default_voice.mp3' is also missing from the voices folder.\n"
+                        f"Please add audio files to the '{self.voices_dir.resolve()}' directory. Available files: {available or 'None'}"
+                    )
                 
-                # Handle voice/speaker selection
-                speaker_wav_path = None
+                ASCIIColors.info(f"Server: Using speaker reference: {speaker_wav_path}")
+
+                # Generate audio using XTTS
+                wav_chunks = self.model.tts(
+                    text=text_to_generate,
+                    speaker_wav=speaker_wav_path,
+                    language=req.language,
+                    split_sentences=req.split_sentences
+                )
                 
-                # 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}")
+                # Combine chunks into a single audio stream
+                audio_data = np.array(wav_chunks, dtype=np.float32)
                 
-                # 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")
-                else:
-                    voice = "default_voice"
-                    # Look for voice file in voices directory
-                    voices_dir = Path(__file__).parent / "voices"
-                    potential_voice_path = voices_dir / f"{voice}.mp3"
-                    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
+                buffer = io.BytesIO()
+                with wave.open(buffer, 'wb') as wf:
+                    wf.setnchannels(1)
+                    wf.setsampwidth(2) # 16-bit
+                    wf.setframerate(self.model.synthesizer.output_sample_rate)
+                    wf.writeframes((audio_data * 32767).astype(np.int16).tobytes())
                 
-                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}")
-                            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)
+                audio_bytes = buffer.getvalue()
+
+                ASCIIColors.green(f"Server: Generated {len(audio_bytes)} bytes of audio.")
+                return audio_bytes
                 
             except Exception as e:
-                print(f"Server: Error generating audio: {e}")
-                print(f"Server: Traceback:\n{traceback.format_exc()}")
+                ASCIIColors.error(f"Server: Error generating audio: {e}")
+                ASCIIColors.error(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 = []
-            
-            if voices_dir.exists():
-                voice_files = [str(f) for f in voices_dir.glob("*.wav")]
-                
-            return voice_files
-        
-        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
+            return [f.name for f in self.voices_dir.glob("*.*")]
         
         def list_voices(self) -> List[str]:
             """Return list of available voices"""
@@ -241,47 +205,36 @@ try:
     app = FastAPI(title="XTTS Server")
     router = APIRouter()
     xtts_server = XTTSServer()
-    model_lock = asyncio.Lock()  # Ensure thread-safe access
+    model_lock = asyncio.Lock()  # Ensure only one generation happens at a time on the model
 
     # --- API Endpoints ---
     @router.post("/generate_audio")
-    async def generate_audio(request: GenerationRequest):
+    async def api_generate_audio(request: GenerationRequest):
         async with model_lock:
             try:
-                print(f"request.language:{request.language}")
-                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
+                audio_bytes = await xtts_server.generate_audio(request)
                 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()}")
+                ASCIIColors.error(f"Server: ERROR in generate_audio endpoint: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
 
     @router.get("/list_voices")
-    async def list_voices():
+    async def api_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()}")
+            ASCIIColors.error(f"Server: ERROR in list_voices endpoint: {e}")
             raise HTTPException(status_code=500, detail=str(e))
 
     @router.get("/list_models")
-    async def list_models():
+    async def api_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()}")
+            ASCIIColors.error(f"Server: ERROR in list_models endpoint: {e}")
             raise HTTPException(status_code=500, detail=str(e))
 
     @router.get("/status")
@@ -290,41 +243,33 @@ try:
             "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"
+            "device": device if xtts_available else "N/A"
         }
 
-    # Add a health check endpoint that responds immediately
-    @router.get("/health")
-    async def health_check():
-        return {"status": "healthy", "ready": True}
-
     app.include_router(router)
 
     # --- Server Startup ---
     if __name__ == '__main__':
-        parser = argparse.ArgumentParser(description="XTTS TTS Server")
+        parser = argparse.ArgumentParser(description="LoLLMs XTTS Server")
         parser.add_argument("--host", type=str, default="localhost", help="Host to bind the server to.")
-        parser.add_argument("--port", type=int, default="96", help="Port 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'}")
+        ASCIIColors.cyan("--- LoLLMs XTTS Server ---")
+        ASCIIColors.green(f"Starting server on http://{args.host}:{args.port}")
+        ASCIIColors.info(f"Voices directory: {xtts_server.voices_dir.resolve()}")
         
-        # 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}")
-        try:
-            uvicorn.run(app, host=args.host, port=args.port)
-        except Exception as e:
-            print(f"Server: CRITICAL ERROR running server: {e}")
-            print(f"Server: Traceback:\n{traceback.format_exc()}")  
+        if not xtts_available:
+            ASCIIColors.red("Warning: XTTS dependencies not found. Server will run but generation will fail.")
+        else:
+            ASCIIColors.info(f"Detected device: {device}")
+        
+        uvicorn.run(app, host=args.host, port=args.port)
+
 except Exception as e:
-    print(f"Server: CRITICAL ERROR during startup: {e}")
+    # This will catch errors during initial imports
+    from ascii_colors import ASCIIColors
+    ASCIIColors.red(f"Server: CRITICAL ERROR during startup: {e}")
+    import traceback
+    ASCIIColors.red(f"Server: Traceback:\n{traceback.format_exc()}")```

{lollms_client-1.6.5.dist-info → lollms_client-1.6.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.6.5
+Version: 1.6.6
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License:                                  Apache License

{lollms_client-1.6.5.dist-info → lollms_client-1.6.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lollms_client/__init__.py,sha256=Hd_YPYSwQbM4DCXGuw-PcSQ3Ks1aF51UqF_-Y3af6mI,1146
+lollms_client/__init__.py,sha256=51YtCHNJCmroyA9htiIgjui1ZSFfkn_zhhe0USpE8nc,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=Un74iLbnnn2yZYH6HBNRz1mTZ454NEMBEndS4nvh3ZI,244887
@@ -52,8 +52,8 @@ lollms_client/stt_bindings/lollms/__init__.py,sha256=9Vmn1sQQZKLGLe7nZnc-0LnNeSY
 lollms_client/stt_bindings/whisper/__init__.py,sha256=1Ej67GdRKBy1bba14jMaYDYHiZkxJASkWm5eF07ztDQ,15363
 lollms_client/stt_bindings/whispercpp/__init__.py,sha256=xSAQRjAhljak3vWCpkP0Vmdb6WmwTzPjXyaIB85KLGU,21439
 lollms_client/tti_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client/tti_bindings/diffusers/__init__.py,sha256=w061Iurhc_0wygy5neDLZdP_elhJpjhfTys8POq9jsE,16127
-lollms_client/tti_bindings/diffusers/server/main.py,sha256=LG33B0UIxETDNjI-2SH9hEFO9dCmpNpoxAPJguTig48,44955
+lollms_client/tti_bindings/diffusers/__init__.py,sha256=esrcyy_z_6HVCFKMVXl1h_qY_pX3kMHwO81M2C8hSIg,17706
+lollms_client/tti_bindings/diffusers/server/main.py,sha256=PQ3WXhkQzEzyT100k7nu1ZHQtkGphvpWNGl7Bcg26eY,49593
 lollms_client/tti_bindings/gemini/__init__.py,sha256=eYGz6gnOxWGdJu2O0H-EwGG-Hg7Yo3Hzsgn4neqx29Q,12963
 lollms_client/tti_bindings/leonardo_ai/__init__.py,sha256=pUbF1rKPZib1x0Kn2Bk1A7sTFWmZzNG02kmW6Iu1j2w,5885
 lollms_client/tti_bindings/lollms/__init__.py,sha256=5Tnsn4b17djvieQkcjtIDBm3qf0pg5ZWWov-4_2wmo0,8762
@@ -76,13 +76,13 @@ lollms_client/tts_bindings/piper_tts/__init__.py,sha256=7LQUuWV8I3IEdacc65NRHmDf
 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=ktIZawgvNTX9mICmbA2paOH9T76bupLPuDqW4zzOBMk,6504
-lollms_client/tts_bindings/xtts/server/main.py,sha256=zIGYd-1HQWjNMJ97LVIge6wU8fF5mA0LFK06nV-3mwQ,14905
+lollms_client/tts_bindings/xtts/__init__.py,sha256=lTlExBPZ97FPaf9DoqxE4ilwwO5y88dPOHeRaR5BCnc,8002
+lollms_client/tts_bindings/xtts/server/main.py,sha256=JYKUzg4qFOGW8O_QDb9ChEdhcPRSccdwOlR3q-kJX7I,12306
 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.5.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-1.6.5.dist-info/METADATA,sha256=z4bzGNlcBvmktssJam9ANM83Yu8d0ULV_0d5RXP1A6Y,76835
-lollms_client-1.6.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-1.6.5.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-1.6.5.dist-info/RECORD,,
+lollms_client-1.6.6.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-1.6.6.dist-info/METADATA,sha256=i6Gb5wKrXNF6OPUCz41s5YbpBY5HEvLdAD5a6ONZV84,76835
+lollms_client-1.6.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-1.6.6.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-1.6.6.dist-info/RECORD,,