lollms-client 1.6.1__tar.gz → 1.6.2__tar.gz

{lollms_client-1.6.1/src/lollms_client.egg-info → lollms_client-1.6.2}/PKG-INFO

@@ -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 → lollms_client-1.6.2}/README.md

@@ -1069,6 +1069,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.")```
+```
 
 ---
 
@@ -1170,7 +1171,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
 
@@ -1282,4 +1285,4 @@ This project is licensed under the **Apache 2.0 License**. See the [LICENSE](LIC
 
 ## Changelog
 
-For a list of changes and updates, please refer to the [CHANGELOG.md](CHANGELOG.md) file.
+For a list of changes and updates, please refer to the [CHANGELOG.md](CHANGELOG.md) file.

{lollms_client-1.6.1 → lollms_client-1.6.2}/src/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-1.6.1 → lollms_client-1.6.2}/src/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-1.6.1 → lollms_client-1.6.2}/src/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-1.6.2/src/lollms_client/tts_bindings/xtts/__init__.py

@@ -0,0 +1,164 @@
+from lollms_client.lollms_tts_binding import LollmsTTSBinding
+from typing import Optional, List
+from pathlib import Path
+import requests
+import subprocess
+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):
+    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.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.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):
+        """
+        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 = 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":
+            python_executable = venv_path / "Scripts" / "python.exe"
+        else:
+            python_executable = venv_path / "bin" / "python"
+
+        # 3. Launch the server as a detached subprocess
+        command = [
+            str(python_executable),
+            str(server_script),
+            "--host", self.host,
+            "--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.")
+
+
+    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:
+            if self.is_server_running():
+                print("XTTS Server is up and running.")
+                return
+            time.sleep(1)
+        
+        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.
+        """
+        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
+
+    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", [])
+
+    def list_models(self, **kwargs) -> List[str]:
+        """Get available models from the server"""
+        response = requests.get(f"{self.base_url}/list_models")
+        response.raise_for_status()
+        return response.json().get("models", [])

lollms_client-1.6.2/src/lollms_client/tts_bindings/xtts/server/main.py

@@ -0,0 +1,317 @@
+try:
+    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
+
+    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"]
+            
+            # 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()}")
+                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 = []
+                
+                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"]
+        
+        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 not self.model_loaded or self.model is None:
+                raise RuntimeError("XTTS model failed to load")
+            
+            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}")
+                
+                # 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=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)
+                
+            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 = []
+            
+            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
+        
+        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
+
+    # --- 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))
+
+    @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("/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}
+
+    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()
+
+        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 → lollms_client-1.6.2/src/lollms_client.egg-info}/PKG-INFO

@@ -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