lollms-client 1.3.4__py3-none-any.whl → 1.3.7__py3-none-any.whl

lollms_client/tts_bindings/xtts/server/main.py

@@ -0,0 +1,314 @@
+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)

lollms_client/tts_bindings/xtts/server/setup_voices.py

@@ -0,0 +1,67 @@
+# File: lollms_client/tts_bindings/xtts/server/setup_voices.py
+#!/usr/bin/env python3
+"""
+Helper script to set up XTTS voices directory with sample speaker files
+"""
+
+import os
+import urllib.request
+from pathlib import Path
+
+def download_sample_voices():
+    """Download some sample voice files for XTTS"""
+    
+    voices_dir = Path(__file__).parent / "voices"
+    voices_dir.mkdir(exist_ok=True)
+    
+    print(f"Setting up voices in: {voices_dir}")
+    
+    # You can add URLs to sample speaker voice files here
+    # For now, let's create instructions for users
+    
+    readme_content = """
+# XTTS Voices Directory
+
+Place your speaker reference WAV files in this directory.
+
+## How to add voices:
+
+1. Record or find WAV files of speakers you want to clone (5-30 seconds recommended)
+2. Name them descriptively (e.g., "john.wav", "sarah.wav", "narrator.wav")
+3. Place them in this directory
+4. The voice name will be the filename without extension
+
+## Requirements for voice files:
+- WAV format
+- 22050 Hz sample rate (recommended)
+- Mono or stereo
+- Good quality, clear speech
+- 5-30 seconds duration
+- Single speaker
+
+## Example usage:
+```python
+# Use a custom voice file named "john.wav"
+audio = tts.generate_audio("Hello world", voice="john")
+```
+
+## Getting sample voices:
+You can:
+1. Record your own voice
+2. Use text-to-speech to create reference voices
+3. Extract audio clips from videos/podcasts (respect copyright)
+4. Use royalty-free voice samples
+
+Note: XTTS works by cloning the voice characteristics from the reference file.
+"""
+    
+    readme_path = voices_dir / "README.md"
+    with open(readme_path, 'w') as f:
+        f.write(readme_content)
+    
+    print("✓ Created voices directory and README")
+    print(f"📁 Add your WAV voice files to: {voices_dir}")
+    print("📖 See README.md for detailed instructions")
+
+if __name__ == "__main__":
+    download_sample_voices()

{lollms_client-1.3.4.dist-info → lollms_client-1.3.7.dist-info}/METADATA

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

{lollms_client-1.3.4.dist-info → lollms_client-1.3.7.dist-info}/RECORD

@@ -1,10 +1,10 @@
-lollms_client/__init__.py,sha256=bgTFpgnMg3q6-llOTdgn0sDJ33axbhZ5dhUez4Ka-ho,1146
+lollms_client/__init__.py,sha256=DfF1ngnJNGLJVePtxUV6K5l0g7eh8fdHrnDokKuvJCw,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=h-rU9L0flqM5pYcVay5VJs7QSos6FrLqQ7rGB1By4Hg,176514
-lollms_client/lollms_discussion.py,sha256=4vOnXJp4nLDtL2gRmnkTB4-mjYyIHsgp35pRSJPeT9U,117527
+lollms_client/lollms_core.py,sha256=LS28j1Kh24NB80vJ4CI6HUsMjRp9I-8XCW7X8n8sNeQ,180837
+lollms_client/lollms_discussion.py,sha256=87BHKOqCslm8W1CKq_xwnoyvH6K3im5U8WFeiLTWseE,117600
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
-lollms_client/lollms_llm_binding.py,sha256=5-Vknm0YILPd6ZiwZynsXMfns__Yd_1tDDc2fciRiiA,25020
+lollms_client/lollms_llm_binding.py,sha256=Dj1PI2bQBYv_JgPxCIaIC7DMUvWdFJGwXFdsP5hdGBg,25014
 lollms_client/lollms_mcp_binding.py,sha256=psb27A23VFWDfZsR2WUbQXQxiZDW5yfOak6ZtbMfszI,10222
 lollms_client/lollms_mcp_security.py,sha256=FhVTDhSBjksGEZnopVnjFmEF5dv7D8bBTqoaj4BiF0E,3562
 lollms_client/lollms_personality.py,sha256=O-9nqZhazcITOkxjT24ENTxTmIoZLgqIsQ9WtWs0Id0,8719
@@ -12,7 +12,7 @@ lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_Ko
 lollms_client/lollms_stt_binding.py,sha256=jAUhLouEhh2hmm1bK76ianfw_6B59EHfY3FmLv6DU-g,5111
 lollms_client/lollms_tti_binding.py,sha256=B38nzBCSPV9jVRZa-x8W7l9nJEW0RyS1MMJoueb8kt0,8519
 lollms_client/lollms_ttm_binding.py,sha256=FjVVSNXOZXK1qvcKEfxdiX6l2b4XdGOSNnZ0utAsbDg,4167
-lollms_client/lollms_tts_binding.py,sha256=5cJYECj8PYLJAyB6SEH7_fhHYK3Om-Y3arkygCnZ24o,4342
+lollms_client/lollms_tts_binding.py,sha256=4qw94lc9M8lsh2q1u3FF0RuxTY__kukYg266ai3or-Y,5126
 lollms_client/lollms_ttv_binding.py,sha256=KkTaHLBhEEdt4sSVBlbwr5i_g_TlhcrwrT-7DjOsjWQ,4131
 lollms_client/lollms_types.py,sha256=0iSH1QHRRD-ddBqoL9EEKJ8wWCuwDUlN_FrfbCdg7Lw,3522
 lollms_client/lollms_utilities.py,sha256=3DAsII2X9uhRzRL-D0QlALcEdRg82y7OIL4yHVF32gY,19446
@@ -25,8 +25,8 @@ lollms_client/llm_bindings/grok/__init__.py,sha256=tVIIl2uXpBYD7ia3k8JqYM8uvAVYl
 lollms_client/llm_bindings/groq/__init__.py,sha256=EGrMh9vuCoM4pskDw8ydfsAWYgEb423e9HBwqdO2JQc,12120
 lollms_client/llm_bindings/hugging_face_inference_api/__init__.py,sha256=SFcj5XQTDmN9eR4of82IgQa9iRYZaGlF6rMlF5S5wWg,13938
 lollms_client/llm_bindings/litellm/__init__.py,sha256=lRH4VfZMUG5JCCj6a7hk2PTfSyDowAu-ujLOM-XPl-8,12756
-lollms_client/llm_bindings/llamacpp/__init__.py,sha256=4CbNYpfquVEgfsxuLsxQta_dZRSpbSBL-VWhyDMdBAc,59379
-lollms_client/llm_bindings/lollms/__init__.py,sha256=7DgTGHtrFjhRnjx0YYlNTip2p5TSV-_4GN00ekEUd3g,24855
+lollms_client/llm_bindings/llamacpp/__init__.py,sha256=llPF85AzYgMp7Cpo_4OvEHKlxIAgI6F95NB3SqskD9E,62480
+lollms_client/llm_bindings/lollms/__init__.py,sha256=XFQKtTJnkW8OwF1IoyzHqAZ8JAJ0PnAUKDdeOLGcbrE,24310
 lollms_client/llm_bindings/lollms_webui/__init__.py,sha256=iuDfhZZoLC-PDEPLHrcjk5-962S5c7OeCI7PMdJxI_A,17753
 lollms_client/llm_bindings/mistral/__init__.py,sha256=cddz9xIj8NRFLKHe2JMxzstpUrNIu5s9juci3mhiHfo,14133
 lollms_client/llm_bindings/ollama/__init__.py,sha256=a6cgzXPuo8ZLhIZHJFy8QF0n5ZTk0X4OC1JSyXG1enk,46013
@@ -58,14 +58,21 @@ lollms_client/ttm_bindings/audiocraft/__init__.py,sha256=a0k6wTrHth6GaVOiNnVboeF
 lollms_client/ttm_bindings/bark/__init__.py,sha256=Pr3ou2a-7hNYDqbkxrAbghZpO5HvGUhz7e-7VGXIHHA,18976
 lollms_client/ttm_bindings/lollms/__init__.py,sha256=DU3WLmJaWNM1NAMtJsnaFo4Y9wlfc675M8aUiaLnojA,3143
 lollms_client/tts_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client/tts_bindings/bark/__init__.py,sha256=cpnmr6rmXcNdy4ib_5UHAbUP5oGoMJwB931_vU6VI14,19480
+lollms_client/tts_bindings/bark/__init__.py,sha256=Fqjz5r1aYwggbEfBSHyHB26V8OmbfUlxqH9a9i6HzfQ,4634
+lollms_client/tts_bindings/bark/server/install_bark.py,sha256=y9VhplwOqPwCVx_ex2MzkkBKMaUtzwPiUKg93_1LJzo,2221
+lollms_client/tts_bindings/bark/server/main.py,sha256=jUpjFzbndq4kl8KPykRHG0DdVhUjrAn2GOt6iMt-lIY,12922
 lollms_client/tts_bindings/lollms/__init__.py,sha256=8x2_T9XscvISw2TiaLoFxvrS7TIsVLdqbwSc04cX-wc,7164
-lollms_client/tts_bindings/piper_tts/__init__.py,sha256=0IEWG4zH3_sOkSb9WbZzkeV5Lvhgp5Gs2-2GN51MTjA,18930
-lollms_client/tts_bindings/xtts/__init__.py,sha256=FgcdUH06X6ZR806WQe5ixaYx0QoxtAcOgYo87a2qxYc,18266
+lollms_client/tts_bindings/piper_tts/__init__.py,sha256=FbMw_m2QOn2ny7r5El_s6jByS1dpiuUp7MADudl4VLQ,4855
+lollms_client/tts_bindings/piper_tts/server/install_piper.py,sha256=g71Ne2T18wAytOPipfQ9DNeTAOD9PrII5qC-vr9DtLA,3256
+lollms_client/tts_bindings/piper_tts/server/main.py,sha256=DMozfSR1aCbrlmOXltRFjtXhYhXajsGcNKQjsWgRwZk,17402
+lollms_client/tts_bindings/piper_tts/server/setup_voices.py,sha256=UdHaPa5aNcw8dR-aRGkZr2OfSFFejH79lXgfwT0P3ss,1964
+lollms_client/tts_bindings/xtts/__init__.py,sha256=i1bU6D7wDnWOSf7TRrw_bqeAF6Y8eFp-JIW8z_lWuQM,4211
+lollms_client/tts_bindings/xtts/server/main.py,sha256=T-Kn5NM-u1FJMygeV8rOoZKlqnYHZM30TsnbyZNDzxo,12794
+lollms_client/tts_bindings/xtts/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.3.4.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-1.3.4.dist-info/METADATA,sha256=-kvBYsZuAAUsVlNnSg8NtzR5yOXiL5xiZRATEQvgMGg,58549
-lollms_client-1.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-1.3.4.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-1.3.4.dist-info/RECORD,,
+lollms_client-1.3.7.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-1.3.7.dist-info/METADATA,sha256=8jA3bx0wtTJgA2bPxOviSDoY7MTl_aYnEwhzEgvD_7w,58549
+lollms_client-1.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-1.3.7.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-1.3.7.dist-info/RECORD,,