lollms-client 0.15.2__py3-none-any.whl → 0.17.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/simple_text_gen_with_image_test.py

@@ -10,14 +10,14 @@ from ascii_colors import ASCIIColors, trace_exception
 # MODEL_NAME = None # Server will use its default or last loaded model
 
 # Option 2: Ollama binding
-# BINDING_NAME = "ollama"
-# HOST_ADDRESS = "http://localhost:11434" # Default Ollama host
-# MODEL_NAME = "llava:latest" # Or "llama3:latest", "phi3:latest", etc. - ensure it's pulled in Ollama
-
-# Option 2: llamacpp binding
-BINDING_NAME = "llamacpp"
-MODELS_PATH = r"E:\drumber" # Change to your own models folder
-MODEL_NAME = "llava-v1.6-mistral-7b.Q3_K_XS.gguf" # Change to your vision capable model (make sure you have a mmprj file with the gguf model with the same name but without the quantization name and with mmproj- prefix (mmproj-llava-v1.6-mistral-7b.gguf))
+BINDING_NAME = "ollama"
+HOST_ADDRESS = "http://localhost:11434" # Default Ollama host
+MODEL_NAME = "llava:latest" # Or "llama3:latest", "phi3:latest", etc. - ensure it's pulled in Ollama
+
+# Option 3: llamacpp binding
+# BINDING_NAME = "llamacpp"
+# MODELS_PATH = r"E:\drumber" # Change to your own models folder
+# MODEL_NAME = "llava-v1.6-mistral-7b.Q3_K_XS.gguf" # Change to your vision capable model (make sure you have a mmprj file with the gguf model with the same name but without the quantization name and with mmproj- prefix (mmproj-llava-v1.6-mistral-7b.gguf))
 # You can also add a clip_model_path parameter to your lc_params
 img = "E:\\drumber\\1711741182996.jpg"
 # Option 3: OpenAI binding (requires OPENAI_API_KEY environment variable or service_key)

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"
 )
 

examples/text_gen.py

@@ -15,7 +15,7 @@ lc = LollmsClient("llamacpp", models_path=r"E:\drumber", model_name="llava-v1.6-
 def cb(chunk, type):
     print(chunk,end="",flush=True)
     
-response = lc.generate_text(prompt="One plus one equals ", stream=False, temperature=0.5, streaming_callback=cb)
+response = lc.generate_text(prompt="!@>user: Hi there\n!@>assistant: Hi there, how can I help you?!@>user: what is 1+1?\n!@>assistant: ", stream=False, temperature=0.5, streaming_callback=cb, split=True)
 print()
 print(response)
 print()

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.17.0"
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/llm_bindings/llamacpp/__init__.py

@@ -475,7 +475,12 @@ class LlamaCppServerBinding(LollmsLLMBinding):
                                    temperature: float = 0.7, top_k: int = 40, top_p: float = 0.9,
                                    repeat_penalty: float = 1.1, repeat_last_n: Optional[int] = 64,
                                    seed: Optional[int] = None, stream: bool = False, use_chat_format: bool = True,
-                                   images: Optional[List[str]] = None, **extra_params) -> Dict:
+                                   images: Optional[List[str]] = None,
+                                    split:Optional[bool]=False, # put to true if the prompt is a discussion
+                                    user_keyword:Optional[str]="!@>user:",
+                                    ai_keyword:Optional[str]="!@>assistant:", 
+                                   
+                                   **extra_params) -> Dict:
         payload_params = {
             "temperature": self.server_args.get("temperature", 0.7), "top_k": self.server_args.get("top_k", 40),
             "top_p": self.server_args.get("top_p", 0.9), "repeat_penalty": self.server_args.get("repeat_penalty", 1.1),
@@ -495,6 +500,10 @@ class LlamaCppServerBinding(LollmsLLMBinding):
             messages = []
             if system_prompt and system_prompt.strip(): messages.append({"role": "system", "content": system_prompt})
             user_content: Union[str, List[Dict[str, Any]]] = prompt
+            if split:
+                messages += self.split_discussion(user_content,user_keyword=user_keyword, ai_keyword=ai_keyword)
+            else:
+                messages.append({"role": "user", "content": user_content})
             if images and self.clip_model_path: # Use the binding's current clip_model_path
                 image_parts = []
                 for img_path in images:
@@ -503,8 +512,7 @@ class LlamaCppServerBinding(LollmsLLMBinding):
                         image_type = Path(img_path).suffix[1:].lower() or "png"; image_type = "jpeg" if image_type == "jpg" else image_type
                         image_parts.append({"type": "image_url", "image_url": {"url": f"data:image/{image_type};base64,{encoded_string}"}})
                     except Exception as ex: trace_exception(ex)
-                user_content = [{"type": "text", "text": prompt}] + image_parts # type: ignore
-            messages.append({"role": "user", "content": user_content})
+                messages[-1]["content"] =[{"type": "text", "text": messages[-1]["content"]}] +  image_parts # type: ignore
             final_payload = {"messages": messages, "stream": stream, **payload_params}
             if 'n_predict' in final_payload: final_payload['max_tokens'] = final_payload.pop('n_predict')
             return final_payload
@@ -521,16 +529,57 @@ class LlamaCppServerBinding(LollmsLLMBinding):
                 if image_data_list: final_payload["image_data"] = image_data_list
             return final_payload
 
-    def generate_text(self, prompt: str, images: Optional[List[str]] = None, system_prompt: str = "",
-                     n_predict: Optional[int] = None, stream: bool = False, temperature: float = None,
-                     top_k: int = None, top_p: float = None, repeat_penalty: float = None,
-                     repeat_last_n: Optional[int] = None, seed: Optional[int] = None,
-                     streaming_callback: Optional[Callable[[str, int], bool]] = None,
-                     use_chat_format_override: Optional[bool] = None, **generation_kwargs) -> Union[str, Dict[str, any]]:
+
+    def generate_text(self,
+                     prompt: str,
+                     images: Optional[List[str]] = None,
+                     system_prompt: str = "",
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: float = 0.7, # Ollama default is 0.8, common default 0.7
+                     top_k: int = 40,          # Ollama default is 40
+                     top_p: float = 0.9,       # Ollama default is 0.9
+                     repeat_penalty: float = 1.1, # Ollama default is 1.1
+                     repeat_last_n: int = 64,  # Ollama default is 64
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:", 
+                     **generation_kwargs
+                     ) -> Union[str, dict]:
+        """
+        Generate text using the active LLM binding, using instance defaults if parameters are not provided.
+
+        Args:
+            prompt (str): The input prompt for text generation.
+            images (Optional[List[str]]): List of image file paths for multimodal generation.
+            n_predict (Optional[int]): Maximum number of tokens to generate. Uses instance default if None.
+            stream (Optional[bool]): Whether to stream the output. Uses instance default if None.
+            temperature (Optional[float]): Sampling temperature. Uses instance default if None.
+            top_k (Optional[int]): Top-k sampling parameter. Uses instance default if None.
+            top_p (Optional[float]): Top-p sampling parameter. Uses instance default if None.
+            repeat_penalty (Optional[float]): Penalty for repeated tokens. Uses instance default if None.
+            repeat_last_n (Optional[int]): Number of previous tokens to consider for repeat penalty. Uses instance default if None.
+            seed (Optional[int]): Random seed for generation. Uses instance default if None.
+            n_threads (Optional[int]): Number of threads to use. Uses instance default if None.
+            ctx_size (int | None): Context size override for this generation.
+            streaming_callback (Optional[Callable[[str, str], None]]): Callback function for streaming output.
+                - First parameter (str): The chunk of text received.
+                - Second parameter (str): The message type (e.g., MSG_TYPE.MSG_TYPE_CHUNK).
+            split:Optional[bool]: put to true if the prompt is a discussion
+            user_keyword:Optional[str]: when splitting we use this to extract user prompt 
+            ai_keyword:Optional[str]": when splitting we use this to extract ai prompt
+
+        Returns:
+            Union[str, dict]: Generated text or error dictionary if failed.
+        """
         if not self.server_process or not self.server_process.is_healthy:
              return {"status": False, "error": "Llama.cpp server is not running or not healthy."}
 
-        _use_chat_format = use_chat_format_override if use_chat_format_override is not None else (self.default_completion_format == ELF_COMPLETION_FORMAT.Chat)
+        _use_chat_format = True
         payload = self._prepare_generation_payload(
             prompt=prompt, system_prompt=system_prompt, n_predict=n_predict,
             temperature=temperature if temperature is not None else self.server_args.get("temperature",0.7),
@@ -539,7 +588,8 @@ class LlamaCppServerBinding(LollmsLLMBinding):
             repeat_penalty=repeat_penalty if repeat_penalty is not None else self.server_args.get("repeat_penalty",1.1),
             repeat_last_n=repeat_last_n if repeat_last_n is not None else self.server_args.get("repeat_last_n",64),
             seed=seed if seed is not None else self.server_args.get("seed", -1), stream=stream,
-            use_chat_format=_use_chat_format, images=images, **generation_kwargs
+            use_chat_format=_use_chat_format, images=images,
+            split= split, user_keyword=user_keyword, ai_keyword=ai_keyword, **generation_kwargs
         )
         endpoint = "/v1/chat/completions" if _use_chat_format else "/completion"
         request_url = self._get_request_url(endpoint)