lollms-client 0.15.2__py3-none-any.whl → 0.16.0__py3-none-any.whl

examples/generate_and_speak/generate_and_speak.py

@@ -0,0 +1,251 @@
+# lollms_client/examples/text_and_speech_demo/generate_and_speak.py
+from pathlib import Path
+import time
+import argparse
+
+# Ensure pygame is installed for this example
+try:
+    import pipmaster as pm
+    pm.ensure_packages(["pygame"])
+    import pygame
+    PYGAME_AVAILABLE = True
+except ImportError:
+    print("Pygame not found or pipmaster failed. Please install it manually: pip install pygame")
+    PYGAME_AVAILABLE = False
+except Exception as e:
+    print(f"Could not ensure pygame: {e}")
+    PYGAME_AVAILABLE = False
+
+from lollms_client import LollmsClient, MSG_TYPE
+from ascii_colors import ASCIIColors, trace_exception
+
+# --- Configuration ---
+SPEECH_OUTPUT_DIR = Path(__file__).parent / "speech_output"
+SPEECH_OUTPUT_DIR.mkdir(exist_ok=True)
+
+# Default path for Piper voices relative to this example script for convenience
+DEFAULT_PIPER_VOICES_SUBDIR = Path(__file__).parent / "piper_voices_for_demo"
+DEFAULT_PIPER_VOICE_FILENAME = "en_US-lessac-medium.onnx" # A common, good quality English voice
+
+def text_stream_callback(chunk: str, message_type: MSG_TYPE, params: dict = None, metadata: list = None) -> bool:
+    if message_type == MSG_TYPE.MSG_TYPE_CHUNK:
+        print(chunk, end="", flush=True)
+    elif message_type == MSG_TYPE.MSG_TYPE_STEP_START:
+        ASCIIColors.yellow(f"\n>> Starting step: {chunk}")
+    elif message_type == MSG_TYPE.MSG_TYPE_STEP_END:
+        ASCIIColors.green(f"\n<< Finished step: {chunk}")
+    return True
+
+def ensure_default_piper_voice_for_demo(voices_dir: Path, voice_filename: str):
+    """Helper to download a default Piper voice if not present for the demo."""
+    voices_dir.mkdir(exist_ok=True)
+    onnx_path = voices_dir / voice_filename
+    json_path = voices_dir / f"{voice_filename}.json"
+
+    if not onnx_path.exists() or not json_path.exists():
+        ASCIIColors.info(f"Default Piper test voice '{voice_filename}' not found in {voices_dir}. Attempting to download...")
+        try:
+            import requests
+            # Construct URLs (assuming en_US/lessac/medium structure)
+            voice_parts = voice_filename.split('-') # e.g., ['en_US', 'lessac', 'medium.onnx']
+            lang_code = voice_parts[0].split('_')[0] # en
+            voice_name_path = "/".join(voice_parts[0:2]) # en_US/lessac
+            quality_path = voice_parts[2].split('.')[0] # medium
+
+            # Base URL for Piper voices on Hugging Face
+            PIPER_VOICES_HF_BASE_URL = "https://huggingface.co/rhasspy/piper-voices/resolve/main/"
+
+            onnx_url = f"{PIPER_VOICES_HF_BASE_URL}{lang_code}/{voice_name_path}/{quality_path}/{voice_filename}"
+            json_url = f"{PIPER_VOICES_HF_BASE_URL}{lang_code}/{voice_name_path}/{quality_path}/{voice_filename}.json"
+
+
+            if not onnx_path.exists():
+                ASCIIColors.info(f"Downloading {onnx_url} to {onnx_path}")
+                r_onnx = requests.get(onnx_url, stream=True)
+                r_onnx.raise_for_status()
+                with open(onnx_path, 'wb') as f:
+                    for chunk in r_onnx.iter_content(chunk_size=8192): f.write(chunk)
+            
+            if not json_path.exists():
+                ASCIIColors.info(f"Downloading {json_url} to {json_path}")
+                r_json = requests.get(json_url)
+                r_json.raise_for_status()
+                with open(json_path, 'w', encoding='utf-8') as f: f.write(r_json.text)
+            ASCIIColors.green(f"Default Piper test voice '{voice_filename}' downloaded successfully to {voices_dir}.")
+            return True
+        except Exception as e_download:
+            ASCIIColors.error(f"Failed to download default Piper test voice '{voice_filename}': {e_download}")
+            ASCIIColors.warning(f"Please manually download '{voice_filename}' and '{voice_filename}.json' "
+                                f"from rhasspy.github.io/piper-voices/ or Hugging Face "
+                                f"and place them in {voices_dir.resolve()}")
+            return False
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate text with an LLM and synthesize it to speech using LOLLMS.")
+    # LLM Arguments
+    parser.add_argument(
+        "--llm_binding", type=str, default="ollama", choices=["ollama", "openai", "lollms", "llamacpp", "pythonllamacpp", "transformers", "vllm"],
+        help="The LLM binding to use for text generation."
+    )
+    parser.add_argument(
+        "--llm_model", type=str, default="mistral",
+        help="Model name or path for the LLM binding."
+    )
+    parser.add_argument("--llm_host", type=str, default=None, help="Host address for server-based LLM bindings.")
+    parser.add_argument("--models_path", type=str, default=None, help="Path to models directory for local LLM bindings.")
+    parser.add_argument("--openai_key", type=str, default=None, help="OpenAI API key.")
+
+    # TTS Arguments
+    parser.add_argument(
+        "--tts_binding", type=str, default="bark", choices=["bark", "lollms", "xtts", "piper"],
+        help="The TTS binding to use for speech synthesis."
+    )
+    # Bark specific
+    parser.add_argument("--bark_model", type=str, default="suno/bark-small", help="Bark model ID for TTS.")
+    parser.add_argument("--bark_voice_preset", type=str, default="v2/en_speaker_6", help="Bark voice preset.")
+    # XTTS specific
+    parser.add_argument("--xtts_model", type=str, default="tts_models/multilingual/multi-dataset/xtts_v2", help="XTTS model identifier for Coqui TTS.")
+    parser.add_argument("--xtts_speaker_wav", type=str, default=None, help="Path to speaker WAV for XTTS voice cloning.")
+    parser.add_argument("--xtts_language", type=str, default="en", help="Language for XTTS.")
+    # Piper specific
+    parser.add_argument("--piper_default_voice_model_path", type=str, default=None, help="Path to the default .onnx Piper voice model.")
+    parser.add_argument("--piper_voices_dir", type=str, default=str(DEFAULT_PIPER_VOICES_SUBDIR), help="Directory containing Piper voice models.")
+    parser.add_argument("--piper_voice_file", type=str, default=DEFAULT_PIPER_VOICE_FILENAME, help="Filename of the Piper voice to use from piper_voices_dir (e.g., en_US-ryan-medium.onnx).")
+
+    # Common TTS/LLM args
+    parser.add_argument("--tts_host", type=str, default=None, help="Host address for server-based TTS bindings (e.g., lollms TTS).")
+    parser.add_argument("--device", type=str, default=None, choices=["cpu", "cuda", "mps", None], help="Device for local TTS/LLM models.")
+    args = parser.parse_args()
+
+    ASCIIColors.red("--- LOLLMS Text Generation and Speech Synthesis Demo ---")
+    ASCIIColors.info(f"Using LLM Binding: {args.llm_binding} (Model: {args.llm_model})")
+    ASCIIColors.info(f"Using TTS Binding: {args.tts_binding}")
+    if args.tts_binding == "bark":
+        ASCIIColors.info(f"  Bark Model: {args.bark_model}, Voice Preset: {args.bark_voice_preset}")
+    elif args.tts_binding == "xtts":
+        ASCIIColors.info(f"  XTTS Model: {args.xtts_model}, Speaker WAV: {args.xtts_speaker_wav or 'Default in binding'}, Lang: {args.xtts_language}")
+    elif args.tts_binding == "piper":
+        ASCIIColors.info(f"  Piper Voices Dir: {args.piper_voices_dir}, Voice File: {args.piper_voice_file}")
+        # Ensure default Piper voice for demo if Piper is selected and no specific default path is given
+        if not args.piper_default_voice_model_path:
+            ensure_default_piper_voice_for_demo(Path(args.piper_voices_dir), args.piper_voice_file)
+            args.piper_default_voice_model_path = str(Path(args.piper_voices_dir) / args.piper_voice_file)
+
+
+    llm_binding_config = {}
+    if args.llm_binding == "openai" and args.openai_key: llm_binding_config["service_key"] = args.openai_key
+    elif args.llm_binding in ["llamacpp", "pythonllamacpp", "transformers", "vllm"]:
+        if args.device: llm_binding_config["device"] = args.device
+        if args.llm_binding == "pythonllamacpp": llm_binding_config["n_gpu_layers"] = -1 if args.device == "cuda" else 0
+
+    tts_binding_config = {"device": args.device}
+    if args.tts_binding == "bark":
+        tts_binding_config["model_name"] = args.bark_model
+        tts_binding_config["default_voice"] = args.bark_voice_preset
+    elif args.tts_binding == "xtts":
+        tts_binding_config["model_name"] = args.xtts_model
+        tts_binding_config["default_speaker_wav"] = args.xtts_speaker_wav
+        tts_binding_config["default_language"] = args.xtts_language
+    elif args.tts_binding == "piper":
+        tts_binding_config["default_voice_model_path"] = args.piper_default_voice_model_path
+        tts_binding_config["piper_voices_dir"] = args.piper_voices_dir
+    elif args.tts_binding == "lollms":
+        tts_binding_config["model_name"] = "default_lollms_voice" # Placeholder, server handles actual voice
+
+    lollms_client = None
+    try:
+        ASCIIColors.magenta("Initializing LollmsClient...")
+        lollms_client = LollmsClient(
+            binding_name=args.llm_binding, model_name=args.llm_model,
+            host_address=args.llm_host, models_path=args.models_path,
+            llm_binding_config=llm_binding_config,
+            tts_binding_name=args.tts_binding, tts_host_address=args.tts_host,
+            tts_binding_config=tts_binding_config,
+            verify_ssl_certificate=False
+        )
+        ASCIIColors.green("LollmsClient initialized.")
+    except Exception as e:
+        ASCIIColors.error(f"Failed to initialize LollmsClient: {e}"); trace_exception(e)
+        return
+
+    generated_text = ""
+    text_prompt = "Craft a very short, cheerful message about the joy of discovery."
+    ASCIIColors.cyan(f"\n--- Generating Text (Prompt: '{text_prompt[:50]}...') ---")
+    if not lollms_client.binding:
+        ASCIIColors.error("LLM binding not available."); return
+    try:
+        print(f"{ASCIIColors.YELLOW}AI is thinking: {ASCIIColors.RESET}", end="")
+        generated_text = lollms_client.generate_text(
+            prompt=text_prompt, n_predict=100, stream=True,
+            streaming_callback=text_stream_callback, temperature=0.7
+        )
+        print("\n"); ASCIIColors.green("Text generation complete.")
+        ASCIIColors.magenta("Generated Text:\n"); ASCIIColors.yellow(generated_text)
+    except Exception as e:
+        ASCIIColors.error(f"Text generation failed: {e}"); trace_exception(e); return
+    if not generated_text:
+        ASCIIColors.warning("LLM did not generate any text."); return
+
+    speech_file_path = None
+    ASCIIColors.cyan(f"\n--- Synthesizing Speech (using {args.tts_binding}) ---")
+    if not lollms_client.tts:
+        ASCIIColors.error("TTS binding not available."); return
+    try:
+        tts_call_kwargs = {}
+        if args.tts_binding == "bark":
+            # For Bark, 'voice' in generate_audio is the voice_preset.
+            # If not using the default from init, pass it here.
+            # tts_call_kwargs['voice'] = args.bark_voice_preset 
+            pass # Uses default_voice from init if args.bark_voice_preset not specified to override
+        elif args.tts_binding == "xtts":
+            tts_call_kwargs['language'] = args.xtts_language
+            # 'voice' for XTTS is the speaker_wav path. If not using default from init, pass here.
+            # tts_call_kwargs['voice'] = args.xtts_speaker_wav 
+        elif args.tts_binding == "piper":
+            # 'voice' for Piper is the .onnx filename.
+            tts_call_kwargs['voice'] = args.piper_voice_file
+            # Example Piper specific param:
+            # tts_call_kwargs['length_scale'] = 1.0 
+
+        audio_bytes = lollms_client.tts.generate_audio(text=generated_text, **tts_call_kwargs)
+
+        if audio_bytes:
+            filename_stem = f"speech_output_{args.llm_binding}_{args.tts_binding}"
+            speech_file_path = SPEECH_OUTPUT_DIR / f"{filename_stem.replace('/', '_')}.wav"
+            with open(speech_file_path, "wb") as f: f.write(audio_bytes)
+            ASCIIColors.green(f"Speech synthesized and saved to: {speech_file_path}")
+        elif args.tts_binding == "lollms":
+            ASCIIColors.warning("LOLLMS TTS binding returned empty bytes. Server might have saved file if 'fn' was used.")
+            speech_file_path = None
+        else:
+            ASCIIColors.warning("Speech synthesis returned empty bytes."); speech_file_path = None
+    except Exception as e:
+        ASCIIColors.error(f"Speech synthesis failed: {e}"); trace_exception(e); return
+
+    if speech_file_path and PYGAME_AVAILABLE:
+        ASCIIColors.magenta("\n--- Playing Synthesized Speech ---")
+        try:
+            pygame.mixer.init()
+            speech_sound = pygame.mixer.Sound(str(speech_file_path))
+            ASCIIColors.cyan("Playing audio... Press Ctrl+C in console to stop playback early.")
+            speech_sound.play()
+            while pygame.mixer.get_busy():
+                pygame.time.Clock().tick(10)
+                for event in pygame.event.get():
+                    if event.type == pygame.QUIT: pygame.mixer.stop(); break
+            ASCIIColors.green("Playback finished.")
+        except pygame.error as e: ASCIIColors.warning(f"Could not play audio with pygame: {e}")
+        except KeyboardInterrupt: pygame.mixer.stop(); ASCIIColors.yellow("\nPlayback interrupted.")
+        finally: pygame.quit()
+    elif not PYGAME_AVAILABLE:
+        ASCIIColors.warning("Pygame is not available for playback.")
+        if speech_file_path: ASCIIColors.info(f"Generated speech: {speech_file_path.resolve()}")
+    elif not speech_file_path:
+         ASCIIColors.warning("No speech file generated/path unknown. Skipping playback.")
+
+    ASCIIColors.red("\n--- Demo Finished ---")
+
+if __name__ == "__main__":
+    main()

examples/generate_game_sfx/generate_game_fx.py

@@ -0,0 +1,240 @@
+# lollms_client/examples/game_sfx_generation/generate_game_sfx.py
+from pathlib import Path
+import time
+import argparse # For command-line arguments
+
+# Ensure pygame is installed for this example
+try:
+    import pipmaster as pm
+    pm.ensure_packages(["pygame"])
+    import pygame
+    PYGAME_AVAILABLE = True
+except ImportError:
+    print("Pygame not found or pipmaster failed. Please install it manually: pip install pygame")
+    PYGAME_AVAILABLE = False
+except Exception as e:
+    print(f"Could not ensure pygame: {e}")
+    PYGAME_AVAILABLE = False
+
+
+from lollms_client import LollmsClient # Removed LollmsDiscussion, LollmsMessage as not used
+from ascii_colors import ASCIIColors, trace_exception
+
+# --- Configuration ---
+# Output directory for generated sound effects
+SFX_OUTPUT_DIR = Path(__file__).parent / "sfx_output"
+SFX_OUTPUT_DIR.mkdir(exist_ok=True)
+
+# Sound effect descriptions. Note: 'duration' is more relevant for audiocraft.
+# Bark's duration is more implicit based on prompt content.
+SOUND_EFFECTS_TO_GENERATE = [
+    {
+        "filename": "sfx_crunch",
+        "prompt": "Sound effect of a single, sharp, dry crunch, like stepping on a crisp autumn leaf or a piece of dry wood breaking.",
+        "duration": 1, # audiocraft specific
+        "bark_params": {"fine_temperature": 0.4, "coarse_temperature": 0.6} # Example bark specific
+    },
+    {
+        "filename": "sfx_death_electronic",
+        "prompt": "Short, impactful electronic death sound effect for a video game character, like a quick digital zap or a brief power-down sound.",
+        "duration": 1.5,
+        "bark_params": {"voice_preset": None} # Try without preset for more raw SFX
+    },
+    {
+        "filename": "sfx_powerup_positive",
+        "prompt": "Bright, positive, short power-up collection sound effect, like a magical chime, a sparkling shimmer, or an uplifting notification. [SFX]",
+        "duration": 1.5
+    },
+    {
+        "filename": "sfx_laser_shot",
+        "prompt": "Sound effect of a futuristic laser gun firing a single shot, a quick 'pew' sound. [SFX: laser pew]",
+        "duration": 0.5
+    },
+    {
+        "filename": "sfx_coin_collect",
+        "prompt": "Classic video game coin collection sound effect, a short, metallic, cheerful 'ding' or 'jingle'. [SFX: coin]",
+        "duration": 0.7
+    }
+]
+
+def generate_sfx(lollms_client: LollmsClient, sfx_info: dict) -> Path | None:
+    """Generates a single sound effect using the LollmsClient's TTM binding."""
+    filename_stem = sfx_info["filename"]
+    prompt = sfx_info["prompt"]
+
+    # Default output format
+    output_format = "wav" # WAV is generally best for SFX in pygame
+    output_path = SFX_OUTPUT_DIR / f"{filename_stem}_{lollms_client.ttm.binding_name}.{output_format}" # Add binding name to filename
+
+    ASCIIColors.cyan(f"\nGenerating SFX using '{lollms_client.ttm.binding_name}': '{filename_stem}'")
+    ASCIIColors.info(f"Prompt: '{prompt[:60]}...'")
+
+
+    if not lollms_client.ttm:
+        ASCIIColors.error("TTM (Text-to-Music/Sound) binding is not available in LollmsClient.")
+        return None
+
+    ttm_params = {"progress": True} # Common param for both
+
+    if lollms_client.ttm.binding_name == "audiocraft":
+        ttm_params["duration"] = sfx_info.get("duration", 1.0)
+        ttm_params["temperature"] = sfx_info.get("audiocraft_temperature", 1.0)
+        ttm_params["cfg_coef"] = sfx_info.get("audiocraft_cfg_coef", 3.0)
+        ASCIIColors.info(f"AudioCraft Params: duration={ttm_params['duration']}, temp={ttm_params['temperature']}, cfg={ttm_params['cfg_coef']}")
+    elif lollms_client.ttm.binding_name == "bark":
+        # Bark duration is implicit. Parameters are different.
+        bark_specific_params = sfx_info.get("bark_params", {})
+        ttm_params["voice_preset"] = bark_specific_params.get("voice_preset", None) # None might be good for SFX
+        ttm_params["fine_temperature"] = bark_specific_params.get("fine_temperature", 0.5)
+        ttm_params["coarse_temperature"] = bark_specific_params.get("coarse_temperature", 0.7)
+        ASCIIColors.info(f"Bark Params: preset={ttm_params['voice_preset']}, fine_temp={ttm_params['fine_temperature']}, coarse_temp={ttm_params['coarse_temperature']}")
+    else:
+        ASCIIColors.warning(f"Unknown TTM binding '{lollms_client.ttm.binding_name}'. Using generic parameters.")
+
+
+    try:
+        music_bytes = lollms_client.ttm.generate_music(prompt=prompt, **ttm_params)
+
+        if music_bytes:
+            with open(output_path, "wb") as f:
+                f.write(music_bytes)
+            ASCIIColors.green(f"SFX '{filename_stem}' ({lollms_client.ttm.binding_name}) saved to: {output_path}")
+            return output_path
+        else:
+            ASCIIColors.warning(f"SFX generation for '{filename_stem}' ({lollms_client.ttm.binding_name}) returned empty bytes.")
+            return None
+    except Exception as e:
+        ASCIIColors.error(f"Error generating SFX '{filename_stem}' ({lollms_client.ttm.binding_name}): {e}")
+        trace_exception(e)
+        return None
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate game sound effects using LOLLMS TTM bindings.")
+    parser.add_argument(
+        "--ttm_binding",
+        type=str,
+        choices=["audiocraft", "bark"],
+        default="bark", # Default to audiocraft
+        help="The TTM binding to use for generation."
+    )
+    parser.add_argument(
+        "--audiocraft_model",
+        type=str,
+        default="facebook/musicgen-small",
+        help="Hugging Face model ID for AudioCraft (e.g., facebook/musicgen-small, facebook/musicgen-melody)."
+    )
+    parser.add_argument(
+        "--bark_model",
+        type=str,
+        default="suno/bark-small",
+        help="Hugging Face model ID for Bark (e.g., suno/bark-small, suno/bark)."
+    )
+    parser.add_argument(
+        "--device",
+        type=str,
+        default=None, # Auto-detect
+        choices=["cpu", "cuda", "mps", None],
+        help="Device to run the TTM model on (cpu, cuda, mps, or auto-detect)."
+    )
+    args = parser.parse_args()
+
+    ASCIIColors.red(f"--- LOLLMS Game SFX Generation Example (Using: {args.ttm_binding}) ---")
+
+    ttm_binding_config = {"device": args.device} # Common device config
+    if args.ttm_binding == "audiocraft":
+        ttm_binding_config["model_name"] = args.audiocraft_model
+        ttm_binding_config["output_format"] = "wav" # Audiocraft binding defaults to wav for bytes
+    elif args.ttm_binding == "bark":
+        ttm_binding_config["model_name"] = args.bark_model
+        # Bark binding currently outputs WAV by default for bytes
+    else:
+        ASCIIColors.error(f"Unsupported TTM binding: {args.ttm_binding}")
+        return
+
+    try:
+        ASCIIColors.magenta(f"Initializing LollmsClient with {args.ttm_binding} for TTM...")
+        lollms_client = LollmsClient(
+            binding_name="lollms", # Can be a dummy if only using TTM
+            ttm_binding_name=args.ttm_binding,
+            ttm_binding_config=ttm_binding_config
+        )
+        ASCIIColors.green("LollmsClient initialized.")
+    except Exception as e:
+        ASCIIColors.error(f"Failed to initialize LollmsClient: {e}")
+        trace_exception(e)
+        return
+
+    if not lollms_client.ttm:
+        ASCIIColors.error(f"{args.ttm_binding.capitalize()} TTM binding could not be loaded. Exiting.")
+        return
+
+    generated_sfx_paths = {}
+    for sfx_info_item in SOUND_EFFECTS_TO_GENERATE:
+        sfx_path = generate_sfx(lollms_client, sfx_info_item)
+        if sfx_path:
+            generated_sfx_paths[sfx_info_item["filename"]] = {
+                "path": sfx_path,
+                "binding": args.ttm_binding # Store which binding generated it
+            }
+        time.sleep(0.5) # Small delay
+
+    ASCIIColors.red("\n--- SFX Generation Complete ---")
+    if not generated_sfx_paths:
+        ASCIIColors.warning("No sound effects were successfully generated.")
+        return
+
+    if not PYGAME_AVAILABLE:
+        ASCIIColors.warning("Pygame is not available. Skipping sound playback demo.")
+        ASCIIColors.info(f"Generated SFX can be found in: {SFX_OUTPUT_DIR.resolve()}")
+        return
+
+    ASCIIColors.magenta("\n--- Pygame SFX Playback Demo ---")
+    pygame.mixer.init()
+    game_sounds = {}
+    sfx_playback_order = [] # To map number keys to sounds
+
+    for filename_stem, sfx_data in generated_sfx_paths.items():
+        path = sfx_data["path"]
+        binding_used = sfx_data["binding"]
+        playback_name = f"{filename_stem} ({binding_used})"
+        try:
+            sound = pygame.mixer.Sound(str(path))
+            game_sounds[playback_name] = sound
+            sfx_playback_order.append(playback_name)
+            ASCIIColors.green(f"Loaded '{path.name}' into pygame as '{playback_name}'.")
+        except pygame.error as e:
+            ASCIIColors.warning(f"Could not load sound '{path.name}' into pygame: {e}")
+
+    if not game_sounds:
+        ASCIIColors.warning("No sounds loaded into pygame. Exiting demo.")
+        return
+
+    print("\nInstructions:")
+    for i, sfx_name_to_play in enumerate(sfx_playback_order):
+        print(f"  Press key '{i+1}' to play: {sfx_name_to_play}")
+    print("  Press 'Q' to quit the demo.")
+
+    pygame.display.set_mode((400, 200))
+    pygame.display.set_caption(f"SFX Player ({args.ttm_binding.capitalize()})")
+
+    running = True
+    while running:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT: running = False
+            if event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_q: running = False
+                for i in range(len(sfx_playback_order)):
+                    if event.key == getattr(pygame, f"K_{i+1}", None): # Check if K_i+1 exists
+                        sfx_name_to_play = sfx_playback_order[i]
+                        if sfx_name_to_play in game_sounds:
+                            ASCIIColors.cyan(f"Playing: {sfx_name_to_play}")
+                            game_sounds[sfx_name_to_play].play()
+                        break
+        pygame.time.Clock().tick(30)
+
+    pygame.quit()
+    ASCIIColors.red("--- Demo Finished ---")
+    ASCIIColors.info(f"Generated SFX are in: {SFX_OUTPUT_DIR.resolve()}")
+
+if __name__ == "__main__":
+    main()

examples/text_2_image.py

@@ -15,7 +15,6 @@ LOLLMS_CLIENT_ID = "my_lollms_client_id" # Replace with your actual client ID or
 # Initialize LollmsClient, enabling the TTI 'lollms' binding
 # The service_key here is used as client_id by the TTI binding for lollms
 lc = LollmsClient(
-    host_address="http://localhost:9600",
     tti_binding_name="lollms"
 )
 

lollms_client/__init__.py

@@ -6,7 +6,7 @@ from lollms_client.lollms_discussion import LollmsDiscussion, LollmsMessage
 from lollms_client.lollms_utilities import PromptReshaper # Keep general utilities
 from lollms_client.lollms_functions import FunctionCalling_Library
 
-__version__ = "0.15.2"
+__version__ = "0.16.0"
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/lollms_core.py

@@ -48,6 +48,13 @@ class LollmsClient():
                  ttv_bindings_dir: Path = Path(__file__).parent / "ttv_bindings",
                  ttm_bindings_dir: Path = Path(__file__).parent / "ttm_bindings",
 
+                 # Configurations
+                 tts_binding_config: Optional[Dict[str, any]] = None, # Renamed for clarity
+                 tti_binding_config: Optional[Dict[str, any]] = None, # Renamed for clarity
+                 stt_binding_config: Optional[Dict[str, any]] = None, # Renamed for clarity
+                 ttv_binding_config: Optional[Dict[str, any]] = None, # Renamed for clarity
+                 ttm_binding_config: Optional[Dict[str, any]] = None, # Renamed for clarity
+
                  # General Parameters (mostly defaults for LLM generation)
                  service_key: Optional[str] = None, # Shared service key/client_id
                  verify_ssl_certificate: bool = True,
@@ -84,6 +91,11 @@ class LollmsClient():
             stt_bindings_dir (Path): Directory for STT bindings.
             ttv_bindings_dir (Path): Directory for TTV bindings.
             ttm_bindings_dir (Path): Directory for TTM bindings.
+            tts_binding_config (Optional[Dict]): Additional config for the TTS binding.
+            tti_binding_config (Optional[Dict]): Additional config for the TTI binding.
+            stt_binding_config (Optional[Dict]): Additional config for the STT binding.
+            ttv_binding_config (Optional[Dict]): Additional config for the TTV binding.
+            ttm_binding_config (Optional[Dict]): Additional config for the TTM binding.
             service_key (Optional[str]): Shared authentication key or client_id.
             verify_ssl_certificate (bool): Whether to verify SSL certificates.
             ctx_size (Optional[int]): Default context size for LLM.
@@ -144,54 +156,62 @@ class LollmsClient():
         if tts_binding_name:
             self.tts = self.tts_binding_manager.create_binding(
                 binding_name=tts_binding_name,
-                host_address=effective_host_address,
-                service_key=self.service_key,
-                verify_ssl_certificate=self.verify_ssl_certificate
+                **tts_binding_config
             )
             if self.tts is None:
                 ASCIIColors.warning(f"Failed to create TTS binding: {tts_binding_name}. Available: {self.tts_binding_manager.get_available_bindings()}")
 
         if tti_binding_name:
-            self.tti = self.tti_binding_manager.create_binding(
-                binding_name=tti_binding_name,
-                host_address=effective_host_address,
-                service_key=self.service_key, # Passed as service_key, used as client_id by lollms TTI binding
-                verify_ssl_certificate=self.verify_ssl_certificate
-            )
+            if tti_binding_config:
+                self.tti = self.tti_binding_manager.create_binding(
+                    binding_name=tti_binding_name,
+                    **tti_binding_config
+                )
+            else:
+                self.tti = self.tti_binding_manager.create_binding(
+                    binding_name=tti_binding_name
+                )
             if self.tti is None:
                 ASCIIColors.warning(f"Failed to create TTI binding: {tti_binding_name}. Available: {self.tti_binding_manager.get_available_bindings()}")
 
         if stt_binding_name:
-            self.stt = self.stt_binding_manager.create_binding(
-                binding_name=stt_binding_name,
-                host_address=effective_host_address,
-                service_key=self.service_key,
-                verify_ssl_certificate=self.verify_ssl_certificate
-            )
+            if stt_binding_config:
+                self.stt = self.stt_binding_manager.create_binding(
+                    binding_name=stt_binding_name,
+                    **stt_binding_config
+                )
+            else:
+                self.stt = self.stt_binding_manager.create_binding(
+                    binding_name=stt_binding_name,
+                )
             if self.stt is None:
                 ASCIIColors.warning(f"Failed to create STT binding: {stt_binding_name}. Available: {self.stt_binding_manager.get_available_bindings()}")
-
         if ttv_binding_name:
-            self.ttv = self.ttv_binding_manager.create_binding(
-                binding_name=ttv_binding_name,
-                host_address=effective_host_address,
-                service_key=self.service_key,
-                verify_ssl_certificate=self.verify_ssl_certificate
-            )
+            if ttv_binding_config:
+                self.ttv = self.ttv_binding_manager.create_binding(
+                    binding_name=ttv_binding_name,
+                    **ttv_binding_config
+                )
+            else:
+                self.ttv = self.ttv_binding_manager.create_binding(
+                    binding_name=ttv_binding_name
+                )
             if self.ttv is None:
                 ASCIIColors.warning(f"Failed to create TTV binding: {ttv_binding_name}. Available: {self.ttv_binding_manager.get_available_bindings()}")
 
         if ttm_binding_name:
-            self.ttm = self.ttm_binding_manager.create_binding(
-                binding_name=ttm_binding_name,
-                host_address=effective_host_address,
-                service_key=self.service_key,
-                verify_ssl_certificate=self.verify_ssl_certificate
-            )
+            if ttm_binding_config:
+                self.ttm = self.ttm_binding_manager.create_binding(
+                    binding_name=ttm_binding_name,
+                    **ttm_binding_config
+                )
+            else:
+                self.ttm = self.ttm_binding_manager.create_binding(
+                    binding_name=ttm_binding_name
+                )
             if self.ttm is None:
                 ASCIIColors.warning(f"Failed to create TTM binding: {ttm_binding_name}. Available: {self.ttm_binding_manager.get_available_bindings()}")
 
-
         # --- Store Default Generation Parameters ---
         self.default_ctx_size = ctx_size
         self.default_n_predict = n_predict

lollms_client/lollms_stt_binding.py

@@ -9,26 +9,14 @@ class LollmsSTTBinding(ABC):
     """Abstract base class for all LOLLMS Speech-to-Text bindings."""
 
     def __init__(self,
-                 host_address: Optional[str] = None,
-                 model_name: Optional[str] = None, # Can represent a default model
-                 service_key: Optional[str] = None,
-                 verify_ssl_certificate: bool = True):
+                 binding_name:str="unknown"):
         """
         Initialize the LollmsSTTBinding base class.
 
         Args:
-            host_address (Optional[str]): The host address for the STT service.
-            model_name (Optional[str]): A default identifier for the STT model.
-            service_key (Optional[str]): Authentication key for the service.
-            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+            binding_name (Optional[str]): The binding name
         """
-        if host_address is not None:
-            self.host_address = host_address.rstrip('/')
-        else:
-            self.host_address = None
-        self.model_name = model_name
-        self.service_key = service_key
-        self.verify_ssl_certificate = verify_ssl_certificate
+        self.binding_name = binding_name
 
     @abstractmethod
     def transcribe_audio(self, audio_path: Union[str, Path], model: Optional[str] = None, **kwargs) -> str: