lollms-client 1.4.1__py3-none-any.whl → 1.7.10__py3-none-any.whl

lollms_client/ttm_bindings/stability_ai/__init__.py

@@ -0,0 +1,117 @@
+import os
+import requests
+import time
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from lollms_client.lollms_ttm_binding import LollmsTTMBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+# Ensure required packages are installed
+pm.ensure_packages(["requests"])
+
+BindingName = "ReplicateTTMBinding"
+
+# Popular music models available on Replicate
+# Sourced from: https://replicate.com/collections/text-to-music
+REPLICATE_MODELS = [
+    {"model_name": "meta/musicgen:b05b1dff1d8c6ac63d42422dd565e23b63869bf2d51acda751e04b5dd304535d", "display_name": "Meta - MusicGen", "description": "State-of-the-art controllable text-to-music model from Meta."},
+    {"model_name": "suno-ai/bark:b76242b40d67c76ab6742e987628a2a9ac019e11d56ab96c4e91ce03b79b2787", "display_name": "Suno - Bark", "description": "Text-to-audio model capable of music, voice, and sound effects."},
+    {"model_name": "joehoover/musicgen-melody:7a76a8258b23fae65c5a24debbe88414f9bed22c2422a63465731103f6990803", "display_name": "MusicGen Melody", "description": "MusicGen fine-tuned for generating melodies."},
+]
+
+class ReplicateTTMBinding(LollmsTTMBinding):
+    """A Text-to-Music binding for models hosted on Replicate."""
+
+    def __init__(self,
+                 **kwargs):
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+        self.api_key = self.config.get("api_key") or os.environ.get("REPLICATE_API_TOKEN")
+        if not self.api_key:
+            raise ValueError("Replicate API token is required. Please set it in config or as REPLICATE_API_TOKEN env var.")
+        self.model_version = self.config.get("model_name", "meta/musicgen:b05b1dff1d8c6ac63d42422dd565e23b63869bf2d51acda751e04b5dd304535d")
+        self.base_url = "https://api.replicate.com/v1"
+        self.headers = {"Authorization": f"Token {self.api_key}", "Content-Type": "application/json"}
+
+    def list_models(self, **kwargs) -> List[Dict[str, str]]:
+        return REPLICATE_MODELS
+
+    def generate_music(self, prompt: str, **kwargs) -> bytes:
+        """
+        Generates music via Replicate by starting a prediction and polling for the result.
+        """
+        model_id, version_id = self.model_version.split(":")
+        
+        payload = {
+            "version": version_id,
+            "input": {
+                "prompt": prompt,
+                "duration": kwargs.get("duration", 8),
+                "temperature": kwargs.get("temperature", 1.0),
+                "top_p": kwargs.get("top_p", 0.9),
+                # Add other model-specific parameters here
+            }
+        }
+        
+        try:
+            # 1. Start the prediction
+            ASCIIColors.info(f"Submitting music generation job to Replicate ({model_id})...")
+            start_response = requests.post(f"{self.base_url}/predictions", json=payload, headers=self.headers)
+            start_response.raise_for_status()
+            job_data = start_response.json()
+            get_url = job_data["urls"]["get"]
+            ASCIIColors.info(f"Job submitted. Polling for results at: {get_url}")
+
+            # 2. Poll for the result
+            while True:
+                poll_response = requests.get(get_url, headers=self.headers)
+                poll_response.raise_for_status()
+                poll_data = poll_response.json()
+                status = poll_data["status"]
+
+                if status == "succeeded":
+                    ASCIIColors.green("Generation successful!")
+                    output_url = poll_data["output"]
+                    # Download the resulting audio file
+                    audio_response = requests.get(output_url)
+                    audio_response.raise_for_status()
+                    return audio_response.content
+                elif status in ["starting", "processing"]:
+                    ASCIIColors.info(f"Job status: {status}. Waiting...")
+                    time.sleep(3)
+                else: # failed, canceled
+                    error_log = poll_data.get("logs", "No logs available.")
+                    raise Exception(f"Replicate job failed with status '{status}'. Log: {error_log}")
+                    
+        except requests.exceptions.HTTPError as e:
+            error_details = e.response.json().get("detail", e.response.text)
+            raise Exception(f"Replicate API HTTP Error: {error_details}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Replicate TTM Binding Test ---")
+    if "REPLICATE_API_TOKEN" not in os.environ:
+        ASCIIColors.error("REPLICATE_API_TOKEN environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = ReplicateTTMBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Music Generation with MusicGen ---")
+        prompt = "An epic cinematic orchestral piece, with soaring strings and dramatic percussion, fit for a movie trailer"
+        music_bytes = binding.generate_music(prompt, duration=10)
+        
+        assert len(music_bytes) > 1000, "Generated music bytes are too small."
+        output_path = Path(__file__).parent / "tmp_replicate_music.wav"
+        with open(output_path, "wb") as f:
+            f.write(music_bytes)
+        ASCIIColors.green(f"Music generation OK. Audio saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Replicate TTM binding test failed: {e}")

lollms_client/ttm_bindings/topmediai/__init__.py

@@ -0,0 +1,96 @@
+import os
+import requests
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from lollms_client.lollms_ttm_binding import LollmsTTMBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+# Ensure required packages are installed
+pm.ensure_packages(["requests"])
+
+BindingName = "TopMediaiTTMBinding"
+
+class TopMediaiTTMBinding(LollmsTTMBinding):
+    """A Text-to-Music binding for the TopMediai API."""
+
+    def __init__(self,
+                 **kwargs):
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+        self.api_key = self.config.get("api_key") or os.environ.get("TOPMEDIAI_API_KEY")
+        if not self.api_key:
+            raise ValueError("TopMediai API key is required. Please set it in config or as TOPMEDIAI_API_KEY env var.")
+        self.base_url = "https://api.topmediai.com/v1"
+        self.headers = {"x-api-key": self.api_key, "Content-Type": "application/json"}
+
+    def list_models(self, **kwargs) -> List[str]:
+        # The API does not provide a list of selectable models.
+        # It's a single, prompt-based system.
+        return ["default"]
+
+    def generate_music(self, prompt: str, **kwargs) -> bytes:
+        """
+        Generates music using the TopMediai synchronous API.
+        """
+        url = f"{self.base_url}/music"
+        duration = kwargs.get("duration", 30)
+
+        payload = {
+            "text": prompt,
+            "duration": f"{duration}", # API expects duration as a string
+        }
+
+        try:
+            ASCIIColors.info("Requesting music from TopMediai...")
+            response = requests.post(url, json=payload, headers=self.headers)
+            response.raise_for_status()
+            data = response.json()
+
+            if data.get("code") != 0:
+                raise Exception(f"TopMediai API returned an error: {data.get('message', 'Unknown error')}")
+
+            audio_url = data.get("data", {}).get("music_url")
+            if not audio_url:
+                raise Exception("API response did not contain a music URL.")
+
+            ASCIIColors.info(f"Downloading generated audio from {audio_url}")
+            audio_response = requests.get(audio_url)
+            audio_response.raise_for_status()
+            
+            return audio_response.content
+
+        except requests.exceptions.HTTPError as e:
+            try:
+                error_details = e.response.json()
+                raise Exception(f"TopMediai API HTTP Error: {error_details}") from e
+            except:
+                raise Exception(f"TopMediai API HTTP Error: {e.response.text}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- TopMediai TTM Binding Test ---")
+    if "TOPMEDIAI_API_KEY" not in os.environ:
+        ASCIIColors.error("TOPMEDIAI_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = TopMediaiTTMBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Music Generation ---")
+        prompt = "lo-fi hip hop beat, chill, relaxing, perfect for studying"
+        music_bytes = binding.generate_music(prompt, duration=30)
+        
+        assert len(music_bytes) > 1000, "Generated music bytes are too small."
+        output_path = Path(__file__).parent / "tmp_topmediai_music.mp3"
+        with open(output_path, "wb") as f:
+            f.write(music_bytes)
+        ASCIIColors.green(f"Music generation OK. Audio saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"TopMediai TTM binding test failed: {e}")

lollms_client/tts_bindings/bark/__init__.py

@@ -11,17 +11,14 @@ import pipmaster as pm
 BindingName = "BarkClientBinding"
 
 class BarkClientBinding(LollmsTTSBinding):
-    def __init__(self, 
-                 host: str = "localhost", 
-                 port: int = 8082, 
-                 auto_start_server: bool = True,
+    def __init__(self,
                  **kwargs):
-        
-        binding_name = "bark"
-        super().__init__(binding_name=binding_name, **kwargs)
-        self.host = host
-        self.port = port
-        self.auto_start_server = auto_start_server
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+        self.host = self.config.get("host", "http://localhost")
+        self.port = self.config.get("port", 9632)
+        self.auto_start_server = self.config.get("auto_start_server", True)
         self.server_process = None
         self.base_url = f"http://{self.host}:{self.port}"
 

lollms_client/tts_bindings/lollms/__init__.py

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

lollms_client/tts_bindings/piper_tts/__init__.py

@@ -11,17 +11,14 @@ import pipmaster as pm
 BindingName = "PiperClientBinding"
 
 class PiperClientBinding(LollmsTTSBinding):
-    def __init__(self, 
-                 host: str = "localhost", 
-                 port: int = 8083, 
-                 auto_start_server: bool = True,
+    def __init__(self,
                  **kwargs):
-        
-        binding_name = "piper"
-        super().__init__(binding_name=binding_name, **kwargs)
-        self.host = host
-        self.port = port
-        self.auto_start_server = auto_start_server
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+        self.host = self.config.get("host", "http://localhost")
+        self.port = self.config.get("port", 9632)
+        self.auto_start_server = self.config.get("auto_start_server", True)
         self.server_process = None
         self.base_url = f"http://{self.host}:{self.port}"
 
@@ -104,7 +101,7 @@ class PiperClientBinding(LollmsTTSBinding):
         response.raise_for_status()
         return response.json().get("voices", [])
 
-    def list_models(self, **kwargs) -> List[str]:
+    def list_models(self) -> List[str]:
         """Get available models from the server"""
         response = requests.get(f"{self.base_url}/list_models")
         response.raise_for_status()

lollms_client/tts_bindings/xtts/__init__.py

@@ -1,52 +1,132 @@
-# File: lollms_client/tts_bindings/xtts/__init__.py
-from lollms_client.lollms_tts_binding import LollmsTTSBinding
-from typing import Optional, List
-from pathlib import Path
+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
+
+# 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):
-    def __init__(self, 
-                 host: str = "localhost", 
-                 port: int = 8081, 
-                 auto_start_server: bool = True,
+    """
+    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,
                  **kwargs):
-        
-        binding_name = "xtts"
-        super().__init__(binding_name=binding_name, **kwargs)
-        self.host = host
-        self.port = port
-        self.auto_start_server = auto_start_server
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+
+        self.config = kwargs
+        self.host = kwargs.get("host", "localhost")
+        self.port = kwargs.get("port", 9633)
+        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.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=2)
+            if response.status_code == 200 and response.json().get("status") == "running":
+                return True
+        except requests.exceptions.RequestException:
+            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.
+        """
+        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():
+            ASCIIColors.green("XTTS Server is already running and responsive.")
+            return
+
+        try:
+            with lock.acquire(timeout=10):
+                if not self.is_server_running():
+                    ASCIIColors.yellow("Lock acquired. Starting dedicated XTTS server...")
+                    self.start_server()
+                    self._wait_for_server()
+                else:
+                    ASCIIColors.green("Server was started by another process while we waited. Connected successfully.")
+        except Timeout:
+            ASCIIColors.yellow("Could not acquire lock, another process is starting the server. Waiting...")
+            self._wait_for_server(timeout=60)
+
+        if not self.is_server_running():
+            raise RuntimeError("Failed to start or connect to the XTTS server after all attempts.")
+
+
+    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}")
+        # Ensure pipmaster is available.
+        try:
+            import pipmaster as pm
+        except ImportError:
+            print("FATAL: pipmaster is not installed. Please install it using: pip install pipmaster")
+            raise Exception("pipmaster not found")
+        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:
+            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.")
+
 
     def start_server(self):
-        print("XTTS Client: Starting dedicated server...")
-        binding_root = Path(__file__).parent
-        server_dir = binding_root / "server"
-        requirements_file = server_dir / "requirements.txt"
-        server_script = server_dir / "main.py"
-
-        # 1. Ensure a virtual environment and dependencies
-        venv_path = server_dir / "venv"
-        pm_v = pm.PackageManager(venv_path=venv_path)
-        pm_v.ensure_requirements(str(requirements_file))
-
-        # 2. Get the python executable from the venv
+        """
+        Installs dependencies and launches the FastAPI server as a background subprocess.
+        This method should only be called from within a file lock.
+        """
+        server_script = self.server_dir / "main.py"
+        if not server_script.exists():
+            raise FileNotFoundError(f"Server script not found at {server_script}.")
+
+        if not self.venv_dir.exists():
+            self.install_server_dependencies()
+
         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 subprocess with stdout/stderr forwarded to console
         command = [
             str(python_executable),
             str(server_script),
@@ -54,58 +134,61 @@ class XTTSClientBinding(LollmsTTSBinding):
             "--port", str(self.port)
         ]
         
-        # Forward stdout and stderr to the parent process console
-        self.server_process = subprocess.Popen(
-            command,
-            stdout=None,  # Inherit parent's stdout (shows in console)
-            stderr=None,  # Inherit parent's stderr (shows in console)
-        )
+        # Use DETACHED_PROCESS on Windows to allow the server to run independently.
+        creationflags = subprocess.DETACHED_PROCESS if sys.platform == "win32" else 0
         
-        # 4. Wait for the server to be ready
-        self._wait_for_server()
+        self.server_process = subprocess.Popen(command, creationflags=creationflags)
+        ASCIIColors.info("XTTS server process launched in the background.")
 
-    def _wait_for_server(self, timeout=60):
+    def _wait_for_server(self, timeout=10):
+        """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:
-            try:
-                response = requests.get(f"{self.base_url}/status")
-                if response.status_code == 200 and response.json().get("status") == "running":
-                    print("XTTS Server is up and running.")
-                    return
-            except requests.ConnectionError:
-                time.sleep(1)
-        
-        self.stop_server()
-        raise RuntimeError("Failed to start the XTTS server in the specified timeout.")
-
-    def stop_server(self):
-        if self.server_process:
-            print("XTTS Client: Stopping dedicated server...")
-            self.server_process.terminate()
-            self.server_process.wait()
-            self.server_process = None
-            print("Server stopped.")
-    
+            if self.is_server_running():
+                ASCIIColors.green("XTTS Server is up and running.")
+                return
+            time.sleep(2)
+        raise RuntimeError("Failed to connect to the XTTS server within the specified timeout.")
+
     def __del__(self):
-        # Ensure the server is stopped when the object is destroyed
-        self.stop_server()
+        # 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, **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", [])
 
+    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 []