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

lollms_client/lollms_discussion.py

@@ -1,3 +1,6 @@
+#lollms_client/lollms_discussion.py
+#author : ParisNeo
+
 import base64
 import json
 import re
@@ -1000,6 +1003,13 @@ class LollmsDiscussion:
         self._rebuild_message_index() # Ensure index is fresh
         return [LollmsMessage(self, msg_obj) for msg_obj in self._message_index.values()]
 
+    def setMemory(self, memory:str):
+        """sets memory content
+
+        Args:
+            memory (str): _description_
+        """
+        self.memory = memory
 
     def get_full_data_zone(self):
         """Assembles all data zones into a single, formatted string for the prompt."""
@@ -2585,4 +2595,4 @@ class LollmsDiscussion:
         if db_manager:
             new_discussion.commit()
 
-        return new_discussion
+        return new_discussion

lollms_client/ttm_bindings/beatoven_ai/__init__.py

@@ -0,0 +1,125 @@
+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 = "BeatovenAITTMBinding"
+
+class BeatovenAITTMBinding(LollmsTTMBinding):
+    """A Text-to-Music binding for the Beatoven.ai API."""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName, **kwargs)
+        self.api_key = self.settings.get("api_key") or os.environ.get("BEATOVEN_API_KEY")
+        if not self.api_key:
+            raise ValueError("Beatoven.ai API key is required. Please set it in config or as BEATOVEN_API_KEY env var.")
+        self.base_url = "https://api.beatoven.ai/api/v1"
+        self.headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+    def list_models(self, **kwargs) -> List[str]:
+        # Beatoven.ai does not expose different models via the API.
+        # Customization is done via genre, mood, and tempo.
+        return ["default"]
+
+    def _poll_for_completion(self, task_id: str) -> Dict[str, Any]:
+        """Polls the tasks endpoint until the composition is complete."""
+        poll_url = f"{self.base_url}/tasks/{task_id}"
+        while True:
+            try:
+                response = requests.get(poll_url, headers=self.headers)
+                response.raise_for_status()
+                data = response.json()
+                status = data.get("status")
+
+                if status == "success":
+                    ASCIIColors.green("Composition task successful.")
+                    return data
+                elif status == "failed":
+                    error_info = data.get("error", "Unknown error.")
+                    raise Exception(f"Beatoven.ai task failed: {error_info}")
+                else:
+                    ASCIIColors.info(f"Task status is '{status}'. Waiting...")
+                    time.sleep(5)
+            except requests.exceptions.HTTPError as e:
+                raise Exception(f"Failed to poll task status: {e.response.text}")
+
+    def generate_music(self, prompt: str, **kwargs) -> bytes:
+        """
+        Generates music by creating a track, waiting for composition, and downloading the result.
+        """
+        # Step 1: Create a track
+        create_track_url = f"{self.base_url}/tracks"
+        payload = {
+            "title": prompt[:100], # Use prompt as title, truncated
+            "duration_in_seconds": kwargs.get("duration", 30),
+            "genre": kwargs.get("genre", "Cinematic"),
+            "tempo": kwargs.get("tempo", "medium"),
+            "prompt": prompt
+        }
+
+        try:
+            ASCIIColors.info("Submitting music track request to Beatoven.ai...")
+            create_response = requests.post(create_track_url, json=payload, headers=self.headers)
+            create_response.raise_for_status()
+            task_id = create_response.json().get("task_id")
+            ASCIIColors.info(f"Track creation submitted. Task ID: {task_id}")
+            
+            # Step 2: Poll for task completion
+            task_result = self._poll_for_completion(task_id)
+            track_id = task_result.get("track_id")
+            if not track_id:
+                raise Exception("Task completed but did not return a track_id.")
+
+            # Step 3: Get track details to find the audio URL
+            track_url = f"{self.base_url}/tracks/{track_id}"
+            track_response = requests.get(track_url, headers=self.headers)
+            track_response.raise_for_status()
+            
+            audio_url = track_response.json().get("renders", {}).get("wav")
+            if not audio_url:
+                raise Exception("Could not find WAV render URL in the completed track details.")
+
+            # Step 4: Download the audio file
+            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:
+            error_details = e.response.json()
+            raise Exception(f"Beatoven.ai API HTTP Error: {error_details}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Beatoven.ai TTM Binding Test ---")
+    if "BEATOVEN_API_KEY" not in os.environ:
+        ASCIIColors.error("BEATOVEN_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = BeatovenAITTMBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Music Generation ---")
+        prompt = "A mysterious and suspenseful cinematic track with soft piano and eerie strings, building tension."
+        music_bytes = binding.generate_music(prompt, duration=45, genre="Cinematic", tempo="slow")
+        
+        assert len(music_bytes) > 1000, "Generated music bytes are too small."
+        output_path = Path(__file__).parent / "tmp_beatoven_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"Beatoven.ai TTM binding test failed: {e}")

lollms_client/ttm_bindings/replicate/__init__.py

@@ -0,0 +1,112 @@
+import os
+import requests
+import base64
+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 = "StabilityAITTMBinding"
+
+# Models available via the Stability AI Audio API
+# Sourced from: https://platform.stability.ai/docs/api-reference#tag/Generate/paths/~1v1~1generation~1stable-audio-2.0~1text-to-audio/post
+STABILITY_AI_MODELS = [
+    {"model_name": "stable-audio-2.0", "display_name": "Stable Audio 2.0", "description": "High-quality, full-track music generation up to 3 minutes."},
+    {"model_name": "stable-audio-1.0", "display_name": "Stable Audio 1.0", "description": "Original model, best for short clips and sound effects."},
+]
+
+class StabilityAITTMBinding(LollmsTTMBinding):
+    """A Text-to-Music binding for Stability AI's Stable Audio API."""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName, **kwargs)
+        self.api_key = self.settings.get("api_key") or os.environ.get("STABILITY_API_KEY")
+        if not self.api_key:
+            raise ValueError("Stability AI API key is required. Please set it in the configuration or as STABILITY_API_KEY environment variable.")
+        self.model_name = self.settings.get("model_name", "stable-audio-2.0")
+
+    def list_models(self, **kwargs) -> List[Dict[str, str]]:
+        return STABILITY_AI_MODELS
+
+    def generate_music(self, prompt: str, **kwargs) -> bytes:
+        """
+        Generates music using the Stable Audio API.
+
+        Args:
+            prompt (str): The text prompt describing the desired music.
+            duration (int): The duration of the audio in seconds. Defaults to 29.
+            **kwargs: Additional parameters for the API.
+        
+        Returns:
+            bytes: The generated audio data in WAV format.
+        """
+        url = f"https://api.stability.ai/v1/generation/{self.model_name}/text-to-audio"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "audio/wav",
+        }
+        
+        # Get duration, with a default of 29 seconds as it's a common value
+        duration = kwargs.get("duration", 29)
+        
+        payload = {
+            "text_prompts[0][text]": prompt,
+            "text_prompts[0][weight]": 1.0,
+            "seed": kwargs.get("seed", 0), # 0 for random in API
+            "steps": kwargs.get("steps", 100),
+            "cfg_scale": kwargs.get("cfg_scale", 7.0),
+        }
+
+        # Handle different parameter names for duration
+        if self.model_name == "stable-audio-2.0":
+            payload["duration"] = duration
+        else: # stable-audio-1.0
+            payload["sample_length"] = duration * 44100 # v1 uses sample length
+
+        try:
+            ASCIIColors.info(f"Requesting music from Stability AI ({self.model_name})...")
+            response = requests.post(url, headers=headers, data=payload)
+            response.raise_for_status()
+            
+            ASCIIColors.green("Successfully generated music from Stability AI.")
+            return response.content
+        except requests.exceptions.HTTPError as e:
+            try:
+                error_details = e.response.json()
+                error_message = error_details.get("message", e.response.text)
+            except:
+                error_message = e.response.text
+            ASCIIColors.error(f"HTTP Error from Stability AI: {e.response.status_code} - {error_message}")
+            raise Exception(f"Stability AI API Error: {error_message}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise Exception(f"An unexpected error occurred: {e}")
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Stability AI TTM Binding Test ---")
+    if "STABILITY_API_KEY" not in os.environ:
+        ASCIIColors.error("STABILITY_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        # Test with default settings
+        binding = StabilityAITTMBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Music Generation ---")
+        prompt = "80s synthwave, retro futuristic, driving beat, cinematic"
+        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_stability_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"Stability AI TTM binding test failed: {e}")

lollms_client/ttm_bindings/stability_ai/__init__.py

@@ -0,0 +1,114 @@
+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):
+        super().__init__(binding_name=BindingName, **kwargs)
+        self.api_key = self.settings.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.settings.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,93 @@
+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):
+        super().__init__(binding_name=BindingName, **kwargs)
+        self.api_key = self.settings.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-1.4.5.dist-info → lollms_client-1.4.6.dist-info}/METADATA

@@ -1,9 +1,210 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.4.5
+Version: 1.4.6
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
-License: Apache Software License
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright [yyyy] [name of copyright owner]
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+        
 Project-URL: Homepage, https://github.com/ParisNeo/lollms_client
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
@@ -18,6 +219,7 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: httpx
 Requires-Dist: requests
 Requires-Dist: ascii-colors
 Requires-Dist: pipmaster

{lollms_client-1.4.5.dist-info → lollms_client-1.4.6.dist-info}/RECORD

@@ -1,8 +1,8 @@
-lollms_client/__init__.py,sha256=1ATuXFW5bb2NSxUu0nl6c3tXgX30-GS0pYWv6hkA8Vg,1146
+lollms_client/__init__.py,sha256=UIi_5xF39cMR7ahFo4W9e0Wf5PzbHghi6IdtlV6E0fA,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=aCEoxmEF6ZmkBgJgZd74lKkM4A3PVVyt2IwMvLfScWw,315053
-lollms_client/lollms_discussion.py,sha256=jWw1lSq0Oz_X5pnkECf1XwdDP2Lf84im00VpwuvsXXk,123041
+lollms_client/lollms_discussion.py,sha256=W4VYFcpPwQX0Qot1NlK6THhFJFRtBVVaSE6j70tkq-Q,123273
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
 lollms_client/lollms_llm_binding.py,sha256=Dj1PI2bQBYv_JgPxCIaIC7DMUvWdFJGwXFdsP5hdGBg,25014
 lollms_client/lollms_mcp_binding.py,sha256=psb27A23VFWDfZsR2WUbQXQxiZDW5yfOak6ZtbMfszI,10222
@@ -60,8 +60,11 @@ lollms_client/tti_bindings/openai/__init__.py,sha256=YWJolJSQfIzTJvrLQVe8rQewP7r
 lollms_client/tti_bindings/stability_ai/__init__.py,sha256=GJxE0joQ0UZbheozysbN96AvQq60pjY2UjnSLFmRh4g,8025
 lollms_client/ttm_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/ttm_bindings/audiocraft/__init__.py,sha256=a0k6wTrHth6GaVOiNnVboeFY3oKVvCQPbQlqO38XEyc,14328
-lollms_client/ttm_bindings/bark/__init__.py,sha256=Pr3ou2a-7hNYDqbkxrAbghZpO5HvGUhz7e-7VGXIHHA,18976
+lollms_client/ttm_bindings/beatoven_ai/__init__.py,sha256=cQDpk0x0LfLZFaFs51_QQru_XkS-0nKRdVsrT36gdYw,5589
 lollms_client/ttm_bindings/lollms/__init__.py,sha256=DU3WLmJaWNM1NAMtJsnaFo4Y9wlfc675M8aUiaLnojA,3143
+lollms_client/ttm_bindings/replicate/__init__.py,sha256=OG-xDsElyt14T3nWIQPBdV_SH1RL25xYCphb7hKWz1Y,4924
+lollms_client/ttm_bindings/stability_ai/__init__.py,sha256=djI0dKaJziVmz8AUDfqEXAyzBws-9jl1joeqcPWy1xo,5574
+lollms_client/ttm_bindings/topmediai/__init__.py,sha256=KvY8rpP5Cx6e08u28-vHy7cEtwrxS0a6v4fiNfGWw4k,3706
 lollms_client/tts_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/tts_bindings/bark/__init__.py,sha256=Fqjz5r1aYwggbEfBSHyHB26V8OmbfUlxqH9a9i6HzfQ,4634
 lollms_client/tts_bindings/bark/server/install_bark.py,sha256=y9VhplwOqPwCVx_ex2MzkkBKMaUtzwPiUKg93_1LJzo,2221
@@ -76,8 +79,8 @@ lollms_client/tts_bindings/xtts/server/main.py,sha256=T-Kn5NM-u1FJMygeV8rOoZKlqn
 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.4.5.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-1.4.5.dist-info/METADATA,sha256=IJc5k53zOajOIIvuq-dhLQQ67bHpLwzNyTqxlQZNCz8,58689
-lollms_client-1.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-1.4.5.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-1.4.5.dist-info/RECORD,,
+lollms_client-1.4.6.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-1.4.6.dist-info/METADATA,sha256=rY8D_NB8PXElSNWcACeIr1Ud0N6f8aTe9EKCPOPxSKU,71854
+lollms_client-1.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-1.4.6.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-1.4.6.dist-info/RECORD,,

lollms_client/ttm_bindings/bark/__init__.py

@@ -1,339 +0,0 @@
-# lollms_client/ttm_bindings/bark/__init__.py
-import io
-import os
-from pathlib import Path
-from typing import Optional, List, Union, Dict, Any
-
-from ascii_colors import trace_exception, ASCIIColors
-
-# --- Package Management and Conditional Imports ---
-_bark_deps_installed_with_correct_torch = False
-_bark_installation_error = ""
-try:
-    import pipmaster as pm
-    import platform
-
-    preferred_torch_device_for_install = "cpu"
-    if platform.system() == "Linux" or platform.system() == "Windows":
-        preferred_torch_device_for_install = "cuda"
-    elif platform.system() == "Darwin":
-        preferred_torch_device_for_install = "mps"
-
-    torch_pkgs = ["torch"]
-    bark_core_pkgs = ["transformers", "accelerate", "sentencepiece"]
-    other_deps = ["scipy", "numpy"]
-
-    torch_index_url = None
-    if preferred_torch_device_for_install == "cuda":
-        torch_index_url = "https://download.pytorch.org/whl/cu126"
-        ASCIIColors.info(f"Attempting to ensure PyTorch with CUDA support (target index: {torch_index_url}) for Bark binding.")
-        pm.ensure_packages(torch_pkgs, index_url=torch_index_url)
-        pm.ensure_packages(bark_core_pkgs + other_deps)
-    else:
-        ASCIIColors.info("Ensuring PyTorch, Bark dependencies, and others using default PyPI index for Bark binding.")
-        pm.ensure_packages(torch_pkgs + bark_core_pkgs + other_deps)
-
-    import torch
-    from transformers import AutoProcessor, BarkModel, GenerationConfig 
-    import scipy.io.wavfile
-    import numpy as np
-
-    _bark_deps_installed_with_correct_torch = True
-except Exception as e:
-    _bark_installation_error = str(e)
-    AutoProcessor, BarkModel, GenerationConfig, torch, scipy, np = None, None, None, None, None, None
-# --- End Package Management ---
-
-from lollms_client.lollms_ttm_binding import LollmsTTMBinding
-
-BindingName = "BarkTTMBinding"
-
-DEFAULT_BARK_MODELS = [
-    "suno/bark",
-    "suno/bark-small",
-]
-
-BARK_VOICE_PRESETS_EXAMPLES = [
-    "v2/en_speaker_0", "v2/en_speaker_1", "v2/en_speaker_2", "v2/en_speaker_3",
-    "v2/en_speaker_4", "v2/en_speaker_5", "v2/en_speaker_6", "v2/en_speaker_7",
-    "v2/en_speaker_8", "v2/en_speaker_9",
-    "v2/de_speaker_0", "v2/es_speaker_0", "v2/fr_speaker_0",
-]
-
-
-class BarkTTMBinding(LollmsTTMBinding):
-    def __init__(self,
-                 model_name: str = "suno/bark-small",
-                 device: Optional[str] = None,
-                 default_voice_preset: Optional[str] = "v2/en_speaker_6",
-                 enable_better_transformer: bool = True,
-                 **kwargs): 
-
-        super().__init__(binding_name="bark")
-
-        if not _bark_deps_installed_with_correct_torch:
-            raise ImportError(f"Bark TTM binding dependencies not met. Error: {_bark_installation_error}")
-
-        self.device = device
-        if self.device is None:
-            if torch.cuda.is_available(): self.device = "cuda"; ASCIIColors.info("CUDA device detected by PyTorch for Bark.")
-            elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): self.device = "mps"; ASCIIColors.info("MPS device detected for Bark.")
-            else: self.device = "cpu"; ASCIIColors.info("No GPU (CUDA/MPS) by PyTorch, using CPU for Bark.")
-        elif self.device == "cuda" and not torch.cuda.is_available(): self.device = "cpu"; ASCIIColors.warning("CUDA req, not avail. CPU for Bark.")
-        elif self.device == "mps" and not (hasattr(torch.backends, 'mps') and torch.backends.mps.is_available()): self.device = "cpu"; ASCIIColors.warning("MPS req, not avail. CPU for Bark.")
-
-        ASCIIColors.info(f"BarkTTMBinding: Using device '{self.device}'.")
-
-        self.loaded_model_name = None
-        self.model: Optional[BarkModel] = None
-        self.processor: Optional[AutoProcessor] = None
-        self.default_voice_preset = default_voice_preset
-        self.enable_better_transformer = enable_better_transformer
-        
-        self.default_generation_params = {}
-        temp_gen_config = GenerationConfig() 
-        for key, value in kwargs.items():
-            if hasattr(temp_gen_config, key):
-                self.default_generation_params[key] = value
-
-        self._load_bark_model(model_name)
-
-    def _load_bark_model(self, model_name_to_load: str):
-        if self.model is not None and self.loaded_model_name == model_name_to_load:
-            ASCIIColors.info(f"Bark model '{model_name_to_load}' already loaded.")
-            return
-
-        ASCIIColors.info(f"Loading Bark model: '{model_name_to_load}' on device '{self.device}'...")
-        try:
-            dtype_for_bark = torch.float16 if self.device == "cuda" else None 
-
-            self.processor = AutoProcessor.from_pretrained(model_name_to_load)
-            self.model = BarkModel.from_pretrained(
-                model_name_to_load,
-                torch_dtype=dtype_for_bark,
-                low_cpu_mem_usage=True if self.device != "cpu" else False
-            ).to(self.device)
-
-            if self.enable_better_transformer and self.device == "cuda":
-                try:
-                    self.model = self.model.to_bettertransformer()
-                    ASCIIColors.info("Applied BetterTransformer optimization to Bark model.")
-                except Exception as e_bt:
-                    ASCIIColors.warning(f"Failed to apply BetterTransformer: {e_bt}. Proceeding without it.")
-            
-            if "small" not in model_name_to_load and self.device=="cpu":
-                ASCIIColors.warning("Using full Bark model on CPU. Generation might be slow.")
-            elif self.device != "cpu" and "small" not in model_name_to_load:
-                if hasattr(self.model, "enable_model_cpu_offload"):
-                    try: self.model.enable_model_cpu_offload(); ASCIIColors.info("Enabled model_cpu_offload for Bark.")
-                    except Exception as e: ASCIIColors.warning(f"Could not enable model_cpu_offload: {e}")
-                elif hasattr(self.model, "enable_cpu_offload"):
-                    try: self.model.enable_cpu_offload(); ASCIIColors.info("Enabled cpu_offload for Bark (older API).")
-                    except Exception as e: ASCIIColors.warning(f"Could not enable cpu_offload (older API): {e}")
-                else: ASCIIColors.info("CPU offload not explicitly enabled.")
-
-            self.loaded_model_name = model_name_to_load
-            ASCIIColors.green(f"Bark model '{model_name_to_load}' loaded successfully.")
-        except Exception as e:
-            self.model, self.processor, self.loaded_model_name = None, None, None
-            ASCIIColors.error(f"Failed to load Bark model '{model_name_to_load}': {e}"); trace_exception(e)
-            raise RuntimeError(f"Failed to load Bark model '{model_name_to_load}'") from e
-
-    def generate_music(self,
-                       prompt: str,
-                       voice_preset: Optional[str] = None,
-                       do_sample: Optional[bool] = None, 
-                       temperature: Optional[float] = None,
-                       **kwargs) -> bytes:
-        if self.model is None or self.processor is None:
-            raise RuntimeError("Bark model or processor not loaded.")
-
-        effective_voice_preset = voice_preset if voice_preset is not None else self.default_voice_preset
-        
-        ASCIIColors.info(f"Generating SFX/audio with Bark: '{prompt[:60]}...' (Preset: {effective_voice_preset})")
-        try:
-            # The processor correctly returns 'input_ids' and 'attention_mask'
-            inputs = self.processor(
-                text=[prompt], # Processor expects a list of texts
-                voice_preset=effective_voice_preset,
-                return_tensors="pt",
-                # Explicitly ask for padding if tokenizer supports it,
-                # though Bark's processor might handle this internally.
-                # padding=True, # Let processor decide best padding strategy
-                # truncation=True # Ensure inputs fit model context
-            )
-            inputs = {k: v.to(self.device) for k, v in inputs.items()}
-            
-            # Ensure attention_mask is present
-            if 'attention_mask' not in inputs:
-                ASCIIColors.warning("Processor did not return attention_mask. Creating a default one (all ones). This might lead to suboptimal results if padding was intended.")
-                inputs['attention_mask'] = torch.ones_like(inputs['input_ids'])
-
-
-            if hasattr(self.model, 'generation_config') and self.model.generation_config is not None:
-                gen_config = GenerationConfig.from_dict(self.model.generation_config.to_dict())
-            else:
-                gen_config = GenerationConfig()
-
-            for key, value in self.default_generation_params.items():
-                if hasattr(gen_config, key): setattr(gen_config, key, value)
-
-            if do_sample is not None: gen_config.do_sample = do_sample
-            
-            if temperature is not None:
-                if 'semantic_temperature' not in kwargs and hasattr(gen_config, 'semantic_temperature'): gen_config.semantic_temperature = temperature 
-                if 'coarse_temperature' not in kwargs and hasattr(gen_config, 'coarse_temperature'): gen_config.coarse_temperature = temperature
-                if 'fine_temperature' not in kwargs and hasattr(gen_config, 'fine_temperature'): gen_config.fine_temperature = temperature
-            
-            for key, value in kwargs.items():
-                if hasattr(gen_config, key): setattr(gen_config, key, value)
-
-            # Critical: Set pad_token_id in GenerationConfig.
-            # Bark uses specific token IDs for its different codebooks.
-            # The processor's tokenizer should have the correct pad_token_id if it's used for text inputs.
-            # For Bark, the semantic vocabulary has its own pad_token_id, often same as EOS.
-            # Let's try to get it from the model's semantic config or text config.
-            pad_token_id_to_set = None
-            if hasattr(self.model.config, 'semantic_config') and hasattr(self.model.config.semantic_config, 'pad_token_id'):
-                pad_token_id_to_set = self.model.config.semantic_config.pad_token_id
-            elif hasattr(self.model.config, 'text_config') and hasattr(self.model.config.text_config, 'pad_token_id'):
-                 pad_token_id_to_set = self.model.config.text_config.pad_token_id
-            elif hasattr(self.processor, 'tokenizer') and self.processor.tokenizer and self.processor.tokenizer.pad_token_id is not None:
-                pad_token_id_to_set = self.processor.tokenizer.pad_token_id
-            
-            if pad_token_id_to_set is not None:
-                gen_config.pad_token_id = pad_token_id_to_set
-                # Also set EOS token if it's distinct and meaningful for generation stopping
-                if hasattr(gen_config, 'eos_token_id') and gen_config.eos_token_id is None:
-                    eos_id = None
-                    if hasattr(self.model.config, 'semantic_config') and hasattr(self.model.config.semantic_config, 'eos_token_id'):
-                         eos_id = self.model.config.semantic_config.eos_token_id
-                    if eos_id is not None:
-                         gen_config.eos_token_id = eos_id
-
-            else:
-                # This state is problematic for Bark if pad_token_id is truly needed and distinct from EOS
-                ASCIIColors.warning("Could not determine a specific pad_token_id from Bark's config for GenerationConfig. This might lead to issues.")
-                # If eos_token_id is also not set, generation might not stop correctly.
-                # Defaulting pad_token_id to eos_token_id if eos_token_id exists.
-                if gen_config.eos_token_id is not None:
-                    gen_config.pad_token_id = gen_config.eos_token_id
-                    ASCIIColors.info(f"Setting pad_token_id to eos_token_id ({gen_config.eos_token_id}) as a fallback.")
-                else:
-                    # This is a last resort and might not be correct for Bark specifically
-                    gen_config.pad_token_id = 0 
-                    ASCIIColors.warning("pad_token_id defaulted to 0 as a last resort.")
-
-
-            ASCIIColors.debug(f"Bark final generation_config: {gen_config.to_json_string()}")
-
-            with torch.no_grad():
-                output = self.model.generate(
-                    input_ids=inputs['input_ids'], # Explicitly pass input_ids
-                    attention_mask=inputs.get('attention_mask'), # Pass attention_mask if available
-                    generation_config=gen_config
-                )
-
-            if isinstance(output, torch.Tensor): speech_output_tensor = output
-            elif isinstance(output, dict) and "audio_features" in output: speech_output_tensor = output["audio_features"]
-            elif isinstance(output, dict) and "waveform" in output: speech_output_tensor = output["waveform"] # Bark might return this key
-            else: raise TypeError(f"Unexpected output type from BarkModel.generate: {type(output)}. Content: {output}")
-
-            audio_array_np = speech_output_tensor.cpu().numpy().squeeze()
-            if audio_array_np.ndim == 0 or audio_array_np.size == 0:
-                raise RuntimeError("Bark model returned empty audio data.")
-
-            audio_int16 = (audio_array_np * 32767).astype(np.int16)
-
-            buffer = io.BytesIO()
-            sample_rate_to_use = int(self.model.generation_config.sample_rate if hasattr(self.model.generation_config, 'sample_rate') and self.model.generation_config.sample_rate else 24_000)
-            scipy.io.wavfile.write(buffer, rate=sample_rate_to_use, data=audio_int16)
-            audio_bytes = buffer.getvalue()
-            buffer.close()
-
-            ASCIIColors.green("Bark audio generation successful.")
-            return audio_bytes
-        except Exception as e:
-            ASCIIColors.error(f"Bark audio generation failed: {e}"); trace_exception(e)
-            if "out of memory" in str(e).lower() and self.device == "cuda":
-                 ASCIIColors.yellow("CUDA out of memory. Consider using suno/bark-small or ensure GPU has sufficient VRAM.")
-            raise RuntimeError(f"Bark audio generation error: {e}") from e
-
-    def list_models(self, **kwargs) -> List[str]:
-        return DEFAULT_BARK_MODELS.copy()
-
-    def list_voice_presets(self) -> List[str]:
-        return BARK_VOICE_PRESETS_EXAMPLES.copy()
-
-    def __del__(self):
-        if hasattr(self, 'model') and self.model is not None:
-            del self.model; self.model = None
-            if hasattr(self, 'processor') and self.processor is not None:
-                del self.processor; self.processor = None
-            if torch and hasattr(torch, 'cuda') and torch.cuda.is_available():
-                torch.cuda.empty_cache()
-            loaded_name = getattr(self, 'loaded_model_name', None)
-            msg = f"BarkTTMBinding for model '{loaded_name}' destroyed." if loaded_name else "BarkTTMBinding destroyed."
-            ASCIIColors.info(msg)
-
-# --- Main Test Block ---
-if __name__ == '__main__':
-    if not _bark_deps_installed_with_correct_torch:
-        print(f"{ASCIIColors.RED}Bark TTM binding dependencies not met. Skipping tests. Error: {_bark_installation_error}{ASCIIColors.RESET}")
-        exit()
-
-    ASCIIColors.yellow("--- BarkTTMBinding Test ---")
-    test_model_id = "suno/bark-small"
-    test_output_dir = Path("./test_bark_sfx_output")
-    test_output_dir.mkdir(exist_ok=True)
-    ttm_binding = None
-
-    try:
-        ASCIIColors.cyan(f"\n--- Initializing BarkTTMBinding (model: '{test_model_id}') ---")
-        ttm_binding = BarkTTMBinding(model_name=test_model_id)
-
-        ASCIIColors.cyan("\n--- Listing common Bark models ---")
-        models = ttm_binding.list_models(); print(f"Common Bark models: {models}")
-        ASCIIColors.cyan("\n--- Listing example Bark voice presets ---")
-        presets = ttm_binding.list_voice_presets(); print(f"Example presets: {presets[:5]}...")
-
-        sfx_prompts_to_test = [
-            ("laser_blast", "A short, sharp laser blast sound effect [SFX]"),
-            ("footsteps_gravel", "Footsteps walking on gravel [footsteps]."),
-            ("explosion_distant", "A distant explosion [boom] with a slight echo."),
-            ("interface_click", "A clean, quick digital interface click sound. [click]"),
-            ("creature_roar_short", "[roar] A short, guttural creature roar."),
-            ("ambient_wind", "[wind] Gentle wind blowing through trees."),
-            ("speech_hello", "Hello, this is a test of Bark's speech capabilities."),
-        ]
-
-        for name, prompt in sfx_prompts_to_test:
-            ASCIIColors.cyan(f"\n--- Generating SFX/Audio for: '{name}' ---"); print(f"Prompt: {prompt}")
-            try:
-                call_kwargs = {}
-                if "speech" in name:
-                    call_kwargs = {"semantic_temperature": 0.6, "coarse_temperature": 0.8, "fine_temperature": 0.5, "do_sample": True}
-                elif name == "laser_blast":
-                    call_kwargs = {"semantic_temperature": 0.5, "coarse_temperature": 0.6, "fine_temperature": 0.4, "do_sample": True}
-                else: # For SFX, sometimes more deterministic sampling helps for consistency
-                    call_kwargs = {"do_sample": True, "semantic_temperature": 0.7, "coarse_temperature": 0.7, "fine_temperature": 0.7}
-
-
-                sfx_bytes = ttm_binding.generate_music(prompt, voice_preset=None, **call_kwargs)
-                if sfx_bytes:
-                    output_filename = f"sfx_{name}_{test_model_id.split('/')[-1]}.wav"
-                    output_path = test_output_dir / output_filename
-                    with open(output_path, "wb") as f: f.write(sfx_bytes)
-                    ASCIIColors.green(f"SFX for '{name}' saved to: {output_path} ({len(sfx_bytes) / 1024:.2f} KB)")
-                else: ASCIIColors.error(f"SFX generation for '{name}' returned empty bytes.")
-            except Exception as e_gen: ASCIIColors.error(f"Failed to generate SFX for '{name}': {e_gen}")
-
-    except ImportError as e_imp: ASCIIColors.error(f"Import error: {e_imp}")
-    except RuntimeError as e_rt: ASCIIColors.error(f"Runtime error: {e_rt}")
-    except Exception as e: ASCIIColors.error(f"Unexpected error: {e}"); trace_exception(e)
-    finally:
-        if ttm_binding: del ttm_binding
-        ASCIIColors.info(f"Test SFX (if any) are in: {test_output_dir.resolve()}")
-        print(f"{ASCIIColors.YELLOW}Check the audio files in '{test_output_dir.resolve()}'!{ASCIIColors.RESET}")
-
-    ASCIIColors.yellow("\n--- BarkTTMBinding Test Finished ---")