Delete engines

engines/__init__.py

@@ -1,30 +0,0 @@
-from RealtimeTTS.engines import BaseEngine, TimingInfo  
-from .orpheus_engine import OrpheusEngine
-
-__all__ = [
-    "BaseEngine", "TimingInfo",
-    "OrpheusEngine", "OrpheusVoice",
-]
-
-
-# Lazy loader functions for the engines in this subpackage.
-
-
-def _load_orpheus_engine():
-    from .orpheus_engine import OrpheusEngine, OrpheusVoice
-    globals()["OrpheusEngine"] = OrpheusEngine
-    globals()["OrpheusVoice"] = OrpheusVoice
-    return OrpheusEngine
-
-
-# Map attribute names to lazy loader functions.
-_lazy_imports = {
-    "OrpheusEngine": _load_orpheus_engine,
-    "OrpheusVoice": _load_orpheus_engine,
-}
-
-
-def __getattr__(name):
-    if name in _lazy_imports:
-        return _lazy_imports[name]()
-    raise AttributeError(f"module {__name__} has no attribute {name}")

engines/base_engines.py

@@ -1,299 +0,0 @@
-"""
-This module defines a base framework for speech synthesis engines. It includes:
-- A TimingInfo class to capture timing details (start, end, and word) of audio segments.
-- A BaseEngine abstract class (using a custom metaclass) that sets up default properties and common audio processing methods (such as applying fade-ins/outs and trimming silence) along with abstract methods for voice management and synthesis.
-"""
-
-import torch.multiprocessing as mp
-from abc import ABCMeta, ABC
-from typing import Union
-import numpy as np
-import shutil
-import queue
-
-class TimingInfo:
-    def __init__(self, start_time, end_time, word):
-        self.start_time = start_time
-        self.end_time = end_time
-        self.word = word
-
-    def __str__(self):
-        return f"Word: {self.word}, Start Time: {self.start_time}, End Time: {self.end_time}"
-
-# Define a meta class that will automatically call the BaseEngine's __init__ method
-# and also the post_init method if it exists.
-class BaseInitMeta(ABCMeta):
-    def __call__(cls, *args, **kwargs):
-        # Create an instance of the class that this meta class is used on.
-        instance = super().__call__(*args, **kwargs)
-
-        # Call the __init__ method of BaseEngine to set default properties.
-        BaseEngine.__init__(instance)
-
-        # If the instance has a post_init method, call it.
-        # This allows subclasses to define additional initialization steps.
-        if hasattr(instance, "post_init"):
-            instance.post_init()
-
-        return instance
-
-
-# Define a base class for engines with the custom meta class.
-class BaseEngine(ABC, metaclass=BaseInitMeta):
-    def __init__(self):
-        self.engine_name = "unknown"
-
-        # Indicates if the engine can handle generators.
-        self.can_consume_generators = False
-
-        # Queue to manage audio chunks for the engine.
-        self.queue = queue.Queue()
-
-        # Queue to manage word level timings for the engine.
-        self.timings = queue.Queue()
-
-        # Callback to be called when an audio chunk is available.
-        self.on_audio_chunk = None
-
-        # Callback to be called when the engine is starting to synthesize audio.
-        self.on_playback_start = None
-
-        self.stop_synthesis_event = mp.Event()
-
-        self.reset_audio_duration()
-
-    def reset_audio_duration(self):
-        """
-        Resets the audio duration to 0.
-        """
-        self.audio_duration = 0
-
-    def apply_fade_in(self, audio: np.ndarray, sample_rate: int = -1, fade_duration_ms: int = 15) -> np.ndarray:
-        """
-        Applies a linear fade-in over fade_duration_ms at the start of the audio.
-        """
-        sample_rate = self.verify_sample_rate(sample_rate)
-        audio = audio.copy()
-
-        fade_samples = int(sample_rate * fade_duration_ms / 1000)
-        if fade_samples == 0 or len(audio) < fade_samples:
-            fade_samples = len(audio)
-        fade_in = np.linspace(0.0, 1.0, fade_samples)
-        audio[:fade_samples] *= fade_in
-        return audio
-
-    def apply_fade_out(self, audio: np.ndarray, sample_rate: int = -1, fade_duration_ms: int = 15) -> np.ndarray:
-        """
-        Applies a linear fade-out over fade_duration_ms at the end of the audio.
-        """
-        sample_rate = self.verify_sample_rate(sample_rate)
-        audio = audio.copy()
-
-        fade_samples = int(sample_rate * fade_duration_ms / 1000)
-        if fade_samples == 0 or len(audio) < fade_samples:
-            fade_samples = len(audio)
-        fade_out = np.linspace(1.0, 0.0, fade_samples)
-        audio[-fade_samples:] *= fade_out
-        return audio
-
-    def trim_silence_start(
-        self,
-        audio_data: np.ndarray,
-        sample_rate: int = 24000,
-        silence_threshold: float = 0.01,
-        extra_ms: int = 25,
-        fade_in_ms: int = 15
-    ) -> np.ndarray:
-        """
-        Removes leading silence from audio_data, applies extra trimming, and fades-in if trimming occurred.
-
-        Args:
-            audio_data (np.ndarray): The audio data to process.
-            sample_rate (int): The sample rate of the audio data.
-            silence_threshold (float): The threshold for silence detection.
-            extra_ms (int): Additional milliseconds to trim from the start.
-            fade_in_ms (int): Milliseconds for fade-in effect.
-        """
-        sample_rate = self.verify_sample_rate(sample_rate)
-        trimmed = False
-        audio_data = audio_data.copy()
-        non_silent = np.where(np.abs(audio_data) > silence_threshold)[0]
-        if len(non_silent) > 0:
-            start_index = non_silent[0]
-            if start_index > 0:
-                trimmed = True
-            audio_data = audio_data[start_index:]
-
-        extra_samples = int(extra_ms * sample_rate / 1000)
-        if extra_samples > 0 and len(audio_data) > extra_samples:
-            audio_data = audio_data[extra_samples:]
-            trimmed = True
-
-        if trimmed:
-            audio_data = self.apply_fade_in(audio_data, sample_rate, fade_in_ms)
-        return audio_data
-
-    def trim_silence_end(
-        self,
-        audio_data: np.ndarray,
-        sample_rate: int = -1,
-        silence_threshold: float = 0.01,
-        extra_ms: int = 50,
-        fade_out_ms: int = 15
-    ) -> np.ndarray:
-        """
-        Removes trailing silence from audio_data, applies extra trimming, and fades-out if trimming occurred.
-
-        Args:
-            audio_data (np.ndarray): The audio data to be trimmed.
-            sample_rate (int): The sample rate of the audio data. Default is -1.
-            silence_threshold (float): The threshold below which audio is considered silent. Default is 0.01.
-            extra_ms (int): Extra milliseconds to trim from the end of the audio. Default is 50.
-            fade_out_ms (int): Milliseconds for fade-out effect at the end of the audio. Default is 15.
-        """
-        sample_rate = self.verify_sample_rate(sample_rate)
-        trimmed = False
-        audio_data = audio_data.copy()
-        non_silent = np.where(np.abs(audio_data) > silence_threshold)[0]
-        if len(non_silent) > 0:
-            end_index = non_silent[-1] + 1
-            if end_index < len(audio_data):
-                trimmed = True
-            audio_data = audio_data[:end_index]
-
-        extra_samples = int(extra_ms * sample_rate / 1000)
-        if extra_samples > 0 and len(audio_data) > extra_samples:
-            audio_data = audio_data[:-extra_samples]
-            trimmed = True
-
-        if trimmed:
-            audio_data = self.apply_fade_out(audio_data, sample_rate, fade_out_ms)
-        return audio_data
-
-    def verify_sample_rate(self, sample_rate: int) -> int:
-        """
-        Verifies and returns the sample rate.
-        If the sample rate is -1, it will be obtained from the engine's configuration.
-        """
-        if sample_rate == -1:
-            _, _, sample_rate = self.get_stream_info()
-            if sample_rate == -1:
-                raise ValueError("Sample rate must be provided or obtained from get_stream_info.")
-        return sample_rate
-
-    def _trim_silence(
-        self,
-        audio_data: np.ndarray,
-        sample_rate: int = -1,
-        silence_threshold: float = 0.005,
-        extra_start_ms: int = 15,
-        extra_end_ms: int = 15,
-        fade_in_ms: int = 10,
-        fade_out_ms: int = 10
-    ) -> np.ndarray:
-        """
-        Removes silence from both the start and end of audio_data.
-        If trimming occurs on either end, the corresponding fade is applied.
-        """
-        sample_rate = self.verify_sample_rate(sample_rate)
-
-        audio_data = self.trim_silence_start(
-            audio_data, sample_rate, silence_threshold, extra_start_ms, fade_in_ms
-        )
-        audio_data = self.trim_silence_end(
-            audio_data, sample_rate, silence_threshold, extra_end_ms, fade_out_ms
-        )
-        return audio_data
-
-
-    def get_stream_info(self):
-        """
-        Returns the audio stream configuration information suitable for PyAudio.
-
-        Returns:
-            tuple: A tuple containing the audio format, number of channels, and the sample rate.
-                  - Format (int): The format of the audio stream. pyaudio.paInt16 represents 16-bit integers.
-                  - Channels (int): The number of audio channels. 1 represents mono audio.
-                  - Sample Rate (int): The sample rate of the audio in Hz. 16000 represents 16kHz sample rate.
-        """
-        raise NotImplementedError(
-            "The get_stream_info method must be implemented by the derived class."
-        )
-
-    def synthesize(self, text: str) -> bool:
-        """
-        Synthesizes text to audio stream.
-
-        Args:
-            text (str): Text to synthesize.
-        """
-        self.stop_synthesis_event.clear()
-
-    def get_voices(self):
-        """
-        Retrieves the voices available from the specific voice source.
-
-        This method should be overridden by the derived class to fetch the list of available voices.
-
-        Returns:
-            list: A list containing voice objects representing each available voice.
-        """
-        raise NotImplementedError(
-            "The get_voices method must be implemented by the derived class."
-        )
-
-    def set_voice(self, voice: Union[str, object]):
-        """
-        Sets the voice to be used for speech synthesis.
-
-        Args:
-            voice (Union[str, object]): The voice to be used for speech synthesis.
-
-        This method should be overridden by the derived class to set the desired voice.
-        """
-        raise NotImplementedError(
-            "The set_voice method must be implemented by the derived class."
-        )
-
-    def set_voice_parameters(self, **voice_parameters):
-        """
-        Sets the voice parameters to be used for speech synthesis.
-
-        Args:
-            **voice_parameters: The voice parameters to be used for speech synthesis.
-
-        This method should be overridden by the derived class to set the desired voice parameters.
-        """
-        raise NotImplementedError(
-            "The set_voice_parameters method must be implemented by the derived class."
-        )
-
-    def shutdown(self):
-        """
-        Shuts down the engine.
-        """
-        pass
-
-    def is_installed(self, lib_name: str) -> bool:
-        """
-        Check if the given library or software is installed and accessible.
-
-        This method uses shutil.which to determine if the given library or software is
-        installed and available in the system's PATH.
-
-        Args:
-            lib_name (str): Name of the library or software to check.
-
-        Returns:
-            bool: True if the library is installed, otherwise False.
-        """
-        lib = shutil.which(lib_name)
-        if lib is None:
-            return False
-        return True
-
-    def stop(self):
-        """
-        Stops the engine.
-        """
-        self.stop_synthesis_event.set()

engines/orpheus_decoder.py

@@ -1,141 +0,0 @@
-from snac import SNAC
-import numpy as np
-import torch
-import asyncio
-import threading
-import queue
-
-
-model = SNAC.from_pretrained("hubertsiuzdak/snac_24khz").eval()
-
-# Check if CUDA is available and set device accordingly
-snac_device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
-model = model.to(snac_device)
-snac_device = "cuda"
-
-def convert_to_audio(multiframe, count):
-  frames = []
-  if len(multiframe) < 7:
-    return
-  
-  codes_0 = torch.tensor([], device=snac_device, dtype=torch.int32)
-  codes_1 = torch.tensor([], device=snac_device, dtype=torch.int32)
-  codes_2 = torch.tensor([], device=snac_device, dtype=torch.int32)
-
-  num_frames = len(multiframe) // 7
-  frame = multiframe[:num_frames*7]
-
-  for j in range(num_frames):
-    i = 7*j
-    if codes_0.shape[0] == 0:
-      codes_0 = torch.tensor([frame[i]], device=snac_device, dtype=torch.int32)
-    else:
-      codes_0 = torch.cat([codes_0, torch.tensor([frame[i]], device=snac_device, dtype=torch.int32)])
-
-    if codes_1.shape[0] == 0:
-      
-      codes_1 = torch.tensor([frame[i+1]], device=snac_device, dtype=torch.int32)
-      codes_1 = torch.cat([codes_1, torch.tensor([frame[i+4]], device=snac_device, dtype=torch.int32)])
-    else:
-      codes_1 = torch.cat([codes_1, torch.tensor([frame[i+1]], device=snac_device, dtype=torch.int32)])
-      codes_1 = torch.cat([codes_1, torch.tensor([frame[i+4]], device=snac_device, dtype=torch.int32)])
-    
-    if codes_2.shape[0] == 0:
-      codes_2 = torch.tensor([frame[i+2]], device=snac_device, dtype=torch.int32)
-      codes_2 = torch.cat([codes_2, torch.tensor([frame[i+3]], device=snac_device, dtype=torch.int32)])
-      codes_2 = torch.cat([codes_2, torch.tensor([frame[i+5]], device=snac_device, dtype=torch.int32)])
-      codes_2 = torch.cat([codes_2, torch.tensor([frame[i+6]], device=snac_device, dtype=torch.int32)])
-    else:
-      codes_2 = torch.cat([codes_2, torch.tensor([frame[i+2]], device=snac_device, dtype=torch.int32)])
-      codes_2 = torch.cat([codes_2, torch.tensor([frame[i+3]], device=snac_device, dtype=torch.int32)])
-      codes_2 = torch.cat([codes_2, torch.tensor([frame[i+5]], device=snac_device, dtype=torch.int32)])
-      codes_2 = torch.cat([codes_2, torch.tensor([frame[i+6]], device=snac_device, dtype=torch.int32)])
-
-  codes = [codes_0.unsqueeze(0), codes_1.unsqueeze(0), codes_2.unsqueeze(0)]
-  # check that all tokens are between 0 and 4096 otherwise return *
-  if torch.any(codes[0] < 0) or torch.any(codes[0] > 4096) or torch.any(codes[1] < 0) or torch.any(codes[1] > 4096) or torch.any(codes[2] < 0) or torch.any(codes[2] > 4096):
-    return
-
-  with torch.inference_mode():
-    audio_hat = model.decode(codes)
-  
-  audio_slice = audio_hat[:, :, 2048:4096]
-  detached_audio = audio_slice.detach().cpu()
-  audio_np = detached_audio.numpy()
-  audio_int16 = (audio_np * 32767).astype(np.int16)
-  audio_bytes = audio_int16.tobytes()
-  return audio_bytes
-
-def turn_token_into_id(token_string, index):
-    # Strip whitespace
-    token_string = token_string.strip()
-    
-    # Find the last token in the string
-    last_token_start = token_string.rfind("<custom_token_")
-    
-    if last_token_start == -1:
-        print("No token found in the string")
-        return None
-    
-    # Extract the last token
-    last_token = token_string[last_token_start:]
-    
-    # Process the last token
-    if last_token.startswith("<custom_token_") and last_token.endswith(">"):
-        try:
-            number_str = last_token[14:-1]
-            return int(number_str) - 10 - ((index % 7) * 4096)
-        except ValueError:
-            return None
-    else:
-        return None
-  
-    
-async def tokens_decoder(token_gen):
-    buffer = []
-    count = 0
-    async for token_sim in token_gen:       
-        token = turn_token_into_id(token_sim, count)
-        if token is None:
-            pass
-        else:
-            if token > 0:
-                buffer.append(token)
-                count += 1
-
-                if count % 7 == 0 and count > 27:
-                    buffer_to_proc = buffer[-28:]
-                    audio_samples = convert_to_audio(buffer_to_proc, count)
-                    if audio_samples is not None:
-                        yield audio_samples
-
-
-# ------------------ Synchronous Tokens Decoder Wrapper ------------------ #
-def tokens_decoder_sync(syn_token_gen):
-
-    audio_queue = queue.Queue()
-
-    # Convert the synchronous token generator into an async generator.
-    async def async_token_gen():
-        for token in syn_token_gen:
-            yield token
-
-    async def async_producer():
-        # tokens_decoder.tokens_decoder is assumed to be an async generator that processes tokens.
-        async for audio_chunk in tokens_decoder(async_token_gen()):
-            audio_queue.put(audio_chunk)
-        audio_queue.put(None)  # Sentinel
-
-    def run_async():
-        asyncio.run(async_producer())
-
-    thread = threading.Thread(target=run_async)
-    thread.start()
-
-    while True:
-        audio = audio_queue.get()
-        if audio is None:
-            break
-        yield audio
-
-    thread.join()

engines/orpheus_engine.py

@@ -1,325 +0,0 @@
-# -*- coding: utf-8 -*-
-"""OrpheusEngine
-~~~~~~~~~~~~~~~~
-A drop‑in replacement for the original ``orpheus_engine.py`` that fixes
-all outstanding token‑streaming issues and eliminates audible clicks by
-
-* streaming **token‑IDs** instead of partial text
-* dynamically sending a *tiny* first audio chunk (3×7 codes) followed by
-  steady blocks (30×7)
-* mapping vLLM/OpenAI token‑IDs → SNAC codes without fragile
-  ``"<custom_token_"`` string parsing
-* adding an optional fade‑in / fade‑out per chunk
-* emitting a proper WAV header as the first element in the queue so that
-  browsers / HTML5 `<audio>` tags start playback immediately.
-
-The API (``get_voices()``, ``set_voice()``, …) is unchanged, so you can
-keep using it from RealTimeTTS.
-"""
-
-from __future__ import annotations
-from snac import SNAC, __version__ as snac_version  
-
-
-###############################################################################
-# Standard library & 3rd‑party imports                                      #
-###############################################################################
-import json
-import logging
-import struct
-import time
-import os
-import torch
-from queue import Queue
-from typing import Generator, Iterable, List, Optional
-
-import numpy as np
-import pyaudio  # provided by RealTimeTTS[system]
-import requests
-from RealtimeTTS.engines import BaseEngine
-        
-
-###############################################################################
-# Constants                                                                  #
-###############################################################################
-DEFAULT_API_URL = "http://127.0.0.1:1234"
-DEFAULT_MODEL = "SebastianBodza/Kartoffel_Orpheus-3B_german_synthetic-v0.1"
-DEFAULT_HEADERS = {"Content-Type": "application/json"}
-DEFAULT_VOICE = "Martin"
-
-# Audio
-SAMPLE_RATE = 24_000
-BITS_PER_SAMPLE = 16
-AUDIO_CHANNELS = 1
-
-# Token‑ID magic numbers (defined in the model card)
-CODE_START_TOKEN_ID   = 128257  # <|audio|>
-CODE_REMOVE_TOKEN_ID  = 128258
-CODE_TOKEN_OFFSET     = 128266  # <custom_token_?> – first usable code id
-
-# Chunking strategy
-_INITIAL_GROUPS = 3    # 3×7 = 21 codes ≈ 90 ms @24 kHz
-_STEADY_GROUPS  = 30   # 30×7 = 210 codes ≈ 900 ms
-
-
-SNAC_MODEL = os.getenv("SNAC_MODEL", "hubertsiuzdak/snac_24khz")
-
-
-
-
-###############################################################################
-# Helper functions                                                           #
-###############################################################################
-
-def _create_wav_header(sample_rate: int, bits_per_sample: int, channels: int) -> bytes:
-    """Return a 44‑byte WAV/PCM header with unknown data size (0xFFFFFFFF)."""
-    riff_size = 0xFFFFFFFF
-    header = b"RIFF" + struct.pack("<I", riff_size) + b"WAVEfmt "
-    header += struct.pack("<IHHIIHH", 16, 1, channels, sample_rate,
-                           sample_rate * channels * bits_per_sample // 8,
-                           channels * bits_per_sample // 8, bits_per_sample)
-    header += b"data" + struct.pack("<I", 0xFFFFFFFF)
-    return header
-
-
-def _fade_in_out(audio: np.ndarray, fade_ms: int = 50) -> np.ndarray:
-    """Apply linear fade‑in/out to avoid clicks."""
-    if fade_ms <= 0:
-        return audio
-    fade_samples = int(SAMPLE_RATE * fade_ms / 1000)
-    fade_samples -= fade_samples % 2  # keep it even
-    if fade_samples == 0 or audio.size < 2 * fade_samples:
-        return audio
-    ramp = np.linspace(0.0, 1.0, fade_samples, dtype=np.float32)
-    audio[:fade_samples] *= ramp
-    audio[-fade_samples:] *= ramp[::-1]
-    return audio
-
-###############################################################################
-# SNAC – lightweight wrapper                                                 #
-###############################################################################
-    try:
-        from snac import SNAC
-        _snac_model: Optional[SNAC] = SNAC.from_pretrained("hubertsiuzdak/snac_24khz").eval()
-        _snac_model = _snac_model.to("cuda" if _snac_model and _snac_model.torch.cuda.is_available() else "cpu")
-    except Exception as exc:  # pragma: no cover
-        logging.warning("SNAC model could not be loaded – %s", exc)
-        _snac_model = None
-
-
-def _codes_to_audio(codes: List[int]) -> bytes:
-    """Convert a *flat* list of SNAC codes to 16‑bit PCM bytes."""
-    if not _snac_model or not codes:
-        return b""
-
-    # --- redistribute into 3 snac layers (see original paper) --------------
-    groups = len(codes) // 7
-    codes = codes[: groups * 7]  # trim incomplete tail
-    if groups == 0:
-        return b""
-
-    l1, l2, l3 = [], [], []
-    for g in range(groups):
-        base = g * 7
-        l1.append(codes[base])
-        l2.append(codes[base + 1] - 4096)
-        l3.extend([
-            codes[base + 2] - 2 * 4096,
-            codes[base + 3] - 3 * 4096,
-            codes[base + 5] - 5 * 4096,
-            codes[base + 6] - 6 * 4096,
-        ])
-        l2.append(codes[base + 4] - 4 * 4096)
-
-    import torch
-
-    with torch.no_grad():
-        layers = [
-            torch.tensor(l1, device=_snac_model.device).unsqueeze(0),
-            torch.tensor(l2, device=_snac_model.device).unsqueeze(0),
-            torch.tensor(l3, device=_snac_model.device).unsqueeze(0),
-        ]
-        wav = _snac_model.decode(layers).cpu().numpy().squeeze()
-
-    wav = _fade_in_out(wav)
-    pcm = np.clip(wav * 32767, -32768, 32767).astype(np.int16).tobytes()
-    return pcm
-
-###############################################################################
-# Main class                                                                 #
-###############################################################################
-class OrpheusVoice:
-    def __init__(self, name: str, gender: str | None = None):
-        self.name = name
-        self.gender = gender
-
-
-class OrpheusEngine(BaseEngine):
-    """Realtime TTS engine using the Orpheus SNAC model via vLLM."""
-
-    _SPEAKERS = [
-        OrpheusVoice("Martin", "m"), OrpheusVoice("Emma", "f"),
-        OrpheusVoice("Luca", "m"), OrpheusVoice("Anna", "f"),
-        OrpheusVoice("Jakob", "m"), OrpheusVoice("Anton", "m"),
-        OrpheusVoice("Julian", "m"), OrpheusVoice("Jan", "m"),
-        OrpheusVoice("Alexander", "m"), OrpheusVoice("Emil", "m"),
-        OrpheusVoice("Ben", "m"), OrpheusVoice("Elias", "m"),
-        OrpheusVoice("Felix", "m"), OrpheusVoice("Jonas", "m"),
-        OrpheusVoice("Noah", "m"), OrpheusVoice("Maximilian", "m"),
-        OrpheusVoice("Sophie", "f"), OrpheusVoice("Marie", "f"),
-        OrpheusVoice("Mia", "f"), OrpheusVoice("Maria", "f"),
-        OrpheusVoice("Sophia", "f"), OrpheusVoice("Lina", "f"),
-        OrpheusVoice("Lea", "f"),
-    ]
-    def _load_snac(self, model_name: str = SNAC_MODEL):
-        """
-        Lädt den SNAC-Decoder auf CPU/GPU.
-        Fällt bei jedem Fehler sauber auf CPU zurück.
-        """
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        try:
-            snac = SNAC.from_pretrained(model_name).to(device)
-            if device == "cuda":                       # half() nur auf GPU – ältere SNAC-Versionen haben keine .half()
-                snac = snac.half()
-            snac.eval()
-            logging.info(f"SNAC {snac_version} loaded on {device}")
-            return snac
-        except Exception as e:
-            logging.exception("SNAC load failed – running with silent fallback")
-            return None
-    # ---------------------------------------------------------------------
-    def __init__(
-        self,
-        api_url: str = DEFAULT_API_URL,
-        model: str = DEFAULT_MODEL,
-        headers: dict = DEFAULT_HEADERS,
-        voice: Optional[OrpheusVoice] = None,
-        temperature: float = 0.6,
-        top_p: float = 0.9,
-        max_tokens: int = 1200,
-        repetition_penalty: float = 1.1,
-        debug: bool = False,
-    ) -> None:
-        super().__init__()
-        self.api_url = api_url.rstrip("/")
-        self.model = model
-        self.headers = headers
-        self.voice = voice or OrpheusVoice(DEFAULT_VOICE)
-        self.temperature = temperature
-        self.top_p = top_p
-        self.max_tokens = max_tokens
-        self.repetition_penalty = repetition_penalty
-        self.debug = debug
-        self.queue: "Queue[bytes | None]" = Queue()
-        self.snac = self._load_snac()            # Decoder laden
-        if self.snac is None:                    # Fallback-Hinweis
-            logging.warning("⚠️  No SNAC – audio generation disabled.")
-        self.engine_name = "orpheus"
-
-    # ------------------------------------------------------------------ API
-    def get_stream_info(self):
-        return pyaudio.paInt16, AUDIO_CHANNELS, SAMPLE_RATE
-
-    def get_voices(self):
-        return self._SPEAKERS
-
-    def set_voice(self, voice_name: str):
-        if voice_name not in {v.name for v in self._SPEAKERS}:
-            raise ValueError(f"Unknown Orpheus speaker '{voice_name}'")
-        self.voice = OrpheusVoice(voice_name)
-
-    # --------------------------------------------------------------- public
-    def synthesize(self, text: str) -> bool:  # noqa: C901 (long)
-        """Start streaming TTS for **text** – blocks until finished."""
-        super().synthesize(text)
-        self.queue.put(_create_wav_header(SAMPLE_RATE, BITS_PER_SAMPLE, AUDIO_CHANNELS))
-
-        try:
-            code_stream = self._stream_snac_codes(text)
-            first_chunk = True
-            buffer: List[int] = []
-            sent = 0
-            groups_needed = _INITIAL_GROUPS
-
-            for code_id in code_stream:
-                buffer.append(code_id)
-                available = len(buffer) - sent
-                if available >= groups_needed * 7:
-                    chunk_codes = buffer[sent : sent + groups_needed * 7]
-                    sent += groups_needed * 7
-                    pcm = _codes_to_audio(chunk_codes)
-                    if pcm:
-                        self.queue.put(pcm)
-                        first_chunk = False
-                        groups_needed = _STEADY_GROUPS
-
-            # flush remaining full groups
-            remaining = len(buffer) - sent
-            final_groups = remaining // 7
-            if final_groups:
-                pcm = _codes_to_audio(buffer[sent : sent + final_groups * 7])
-                if pcm:
-                    self.queue.put(pcm)
-
-            return True
-        except Exception as exc:  # pragma: no cover
-            logging.exception("OrpheusEngine: synthesis failed – %s", exc)
-            return False
-        finally:
-            self.queue.put(None)  # close stream
-
-    # ------------------------------------------------------------ internals
-    def _format_prompt(self, prompt: str) -> str:
-        return f"<|audio|>{self.voice.name}: {prompt}<|eot_id|>"
-
-    def _stream_snac_codes(self, prompt: str) -> Generator[int, None, None]:
-        """Yield SNAC code‑IDs as they arrive from the model."""
-        payload = {
-            "model": self.model,
-            "prompt": self._format_prompt(prompt),
-            "max_tokens": self.max_tokens,
-            "temperature": self.temperature,
-            "top_p": self.top_p,
-            "stream": True,
-            "skip_special_tokens": False,
-            "frequency_penalty": self.repetition_penalty,
-        }
-        url = f"{self.api_url}/v1/completions"  # plain completion endpoint
-        with requests.post(url, headers=self.headers, json=payload, stream=True, timeout=600) as r:
-            r.raise_for_status()
-            started = False
-            for line in r.iter_lines():
-                if not line:
-                    continue
-                if line.startswith(b"data: "):
-                    data = line[6:].decode()
-                    if data.strip() == "[DONE]":
-                        break
-                    try:
-                        obj = json.loads(data)
-                        delta = obj["choices"][0]
-                        tid: int = delta.get("token_id")  # vLLM ≥0.9 provides this
-                        if tid is None:
-                            # fallback: derive from text
-                            text_piece = delta.get("text", "")
-                            if not text_piece:
-                                continue
-                            tid = ord(text_piece[-1])  # NOT reliable; skip
-                            continue
-                    except Exception:
-                        continue
-
-                    if not started:
-                        if tid == CODE_START_TOKEN_ID:
-                            started = True
-                        continue
-                    if tid == CODE_REMOVE_TOKEN_ID or tid < CODE_TOKEN_OFFSET:
-                        continue
-                    yield tid - CODE_TOKEN_OFFSET
-
-    # ------------------------------------------------------------------ misc
-    def __del__(self):
-        try:
-            self.queue.put(None)
-        except Exception:
-            pass

engines/orpheus_engine_BU.py

@@ -1,374 +0,0 @@
-import json
-import time
-import logging
-import pyaudio
-import requests
-import traceback
-import numpy as np
-from queue import Queue
-from typing import Optional, Union
-from RealtimeTTS.engines import BaseEngine, TimingInfo
-
-# Default configuration values
-DEFAULT_API_URL = "http://127.0.0.1:1234"
-DEFAULT_HEADERS = {"Content-Type": "application/json"}
-DEFAULT_MODEL = "SebastianBodza/Kartoffel_Orpheus-3B_german_synthetic-v0.1"
-DEFAULT_VOICE = "Martin"
-STOP_SEQUENCE = "<custom_token_2>"
-SAMPLE_RATE = 24000  # Specific sample rate for Orpheus
-
-# Special token definitions for prompt formatting and token decoding
-START_TOKEN_ID = 128259
-END_TOKEN_IDS = [128009, 128260, 128261, 128257]
-CUSTOM_TOKEN_PREFIX = "<custom_token_"
-
-class OrpheusVoice:
-    def __init__(self, name: str, gender: str | None = None):
-        self.name   = name
-        self.gender = gender    # optional, falls du es anzeigen willst
-
-
-
-class OrpheusEngine(BaseEngine):
-    """
-    Real-time Text-to-Speech (TTS) engine for the Orpheus model via LM Studio API.
-    
-    This engine supports real-time token generation, audio synthesis, and voice configuration.
-    
-    _SPEAKERS = [
-        # männlich
-        OrpheusVoice("Jakob",       "m"),
-        OrpheusVoice("Anton",       "m"),
-        OrpheusVoice("Julian",      "m"),
-        OrpheusVoice("Jan",         "m"),
-        OrpheusVoice("Alexander",   "m"),
-        OrpheusVoice("Emil",        "m"),
-        OrpheusVoice("Ben",         "m"),
-        OrpheusVoice("Elias",       "m"),
-        OrpheusVoice("Felix",       "m"),
-        OrpheusVoice("Jonas",       "m"),
-        OrpheusVoice("Noah",        "m"),
-        OrpheusVoice("Maximilian",  "m"),
-        # weiblich
-        OrpheusVoice("Sophie",      "f"),
-        OrpheusVoice("Marie",       "f"),
-        OrpheusVoice("Mia",         "f"),
-        OrpheusVoice("Maria",       "f"),
-        OrpheusVoice("Sophia",      "f"),
-        OrpheusVoice("Lina",        "f"),
-        OrpheusVoice("Lea",         "f"),
-    ]
-    """
-    _SPEAKERS = [
-        # männlich
-        OrpheusVoice("Martin",       "m"),
-        OrpheusVoice("Luca",       "m"),
-        # weiblich
-        OrpheusVoice("Anne",      "f"),
-        OrpheusVoice("Emma",       "f"),
-    ]
-    def __init__(
-        self,
-        api_url: str = DEFAULT_API_URL,
-        model: str = DEFAULT_MODEL,
-        headers: dict = DEFAULT_HEADERS,
-        voice: Optional[OrpheusVoice] = None,
-        temperature: float = 0.6,
-        top_p: float = 0.9,
-        max_tokens: int = 1200,
-        repetition_penalty: float = 1.1,
-        debug: bool = False
-    ):
-        """
-        Initialize the Orpheus TTS engine with the given parameters.
-
-        Args:
-            api_url (str): Endpoint URL for the LM Studio API.
-            model (str): Model name to use for synthesis.
-            headers (dict): HTTP headers for API requests.
-            voice (Optional[OrpheusVoice]): OrpheusVoice configuration. Defaults to DEFAULT_VOICE.
-            temperature (float): Sampling temperature (0-1) for text generation.
-            top_p (float): Top-p sampling parameter for controlling diversity.
-            max_tokens (int): Maximum tokens to generate per API request.
-            repetition_penalty (float): Penalty factor for repeated phrases.
-            debug (bool): Flag to enable debug output.
-        """
-        super().__init__()
-        self.api_url = api_url
-        self.model = model
-        self.headers = headers
-        self.voice = voice or OrpheusVoice(DEFAULT_VOICE)
-        self.temperature = temperature
-        self.top_p = top_p
-        self.max_tokens = max_tokens
-        self.repetition_penalty = repetition_penalty
-        self.debug = debug
-        self.queue = Queue()
-        self.post_init()
-    
-    def post_init(self):
-        """Set up additional engine attributes."""
-        self.engine_name = "orpheus"
-
-    def get_stream_info(self):
-        """
-        Retrieve PyAudio stream configuration.
-
-        Returns:
-            tuple: Format, channel count, and sample rate for PyAudio.
-        """
-        return pyaudio.paInt16, 1, SAMPLE_RATE
-
-    def synthesize(self, text: str) -> bool:
-        """
-        Convert text to speech and stream audio data.
-
-        Args:
-            text (str): The input text to be synthesized.
-
-        Returns:
-            bool: True if synthesis was successful, False otherwise.
-        """
-        super().synthesize(text)
-
-        try:
-            # Process tokens and put generated audio chunks into the queue
-            for audio_chunk in self._token_decoder(self._generate_tokens(text)):
-                # bail out immediately if someone called .stop()
-                if self.stop_synthesis_event.is_set():
-                    logging.info("OrpheusEngine: synthesis stopped by user")
-                    return False
-                print(f"Audio chunk size: {len(audio_chunk)}")
-                self.queue.put(audio_chunk)
-            return True
-        except Exception as e:
-            traceback.print_exc()
-            logging.error(f"Synthesis error: {e}")
-            return False
-
-    def synthesize(self, text: str) -> bool:
-        """
-        Convert text to speech and stream audio data via Orpheus.
-        Drops initial and trailing near-silent chunks.
-        """
-        super().synthesize(text)
-
-        try:
-            for audio_chunk in self._token_decoder(self._generate_tokens(text)):
-                # bail out if user called .stop()
-                if self.stop_synthesis_event.is_set():
-                    logging.info("OrpheusEngine: synthesis stopped by user")
-                    return False
-
-                # forward this chunk
-                self.queue.put(audio_chunk)
-
-            return True
-
-        except Exception as e:
-            traceback.print_exc()
-            logging.error(f"Synthesis error: {e}")
-            return False
-
-
-    def _generate_tokens(self, prompt: str):
-        """
-        Generate a token stream using the LM Studio API.
-
-        Args:
-            prompt (str): The input text prompt.
-
-        Yields:
-            str: Each token's text as it is received from the API.
-        """
-        logging.debug(f"Generating tokens for prompt: {prompt}")
-        formatted_prompt = self._format_prompt(prompt)
-        
-        payload = {
-            "model": self.model,
-            "messages": [{"role": "user", "content": f"<|audio|>{voice}: {text}<|eot_id|>"}],
-            "max_tokens": self.max_tokens,
-            "temperature": self.temperature,
-            "top_p": self.top_p,
-            "frequency_penalty": self.repetition_penalty,  # optional,
-            "stream": True,
-            "skip_special_tokens": False
-        }
-
-        try:
-            logging.debug(f"Requesting API URL: {self.api_url} with payload: {payload} and headers: {self.headers}")
-            response = requests.post(
-                f"{self.api_url}/v1/chat/completions",   # <—— neuer Pfad
-                headers=self.headers,
-                json=payload,
-                stream=True
-            )
-            response.raise_for_status()
-
-            token_counter = 0
-            start_time = time.time()  # Start timing token generation
-            for line in response.iter_lines():
-                # stop on demand
-                if self.stop_synthesis_event.is_set():
-                    logging.debug("OrpheusEngine: token generation aborted")
-                    break
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith('data: '):
-                        data_str = line[6:]
-                        if data_str.strip() == '[DONE]':
-                            break
-                        
-                        try:
-                            data = json.loads(data_str)
-                            if 'choices' in data and data['choices']:
-                                delta = data["choices"][0]["delta"]
-                                token_text = delta.get("content", "")
-                                if "<custom_token_" in token_text:
-                                    logging.debug(f"SNAC-frame: {token_text[:40]}")
-                                if token_text:
-                                    token_counter += 1
-                                    # Print the time it took to get the first token
-                                    if token_counter == 1:
-                                        elapsed = time.time() - start_time
-                                        logging.info(f"Time to first token: {elapsed:.2f} seconds")
-                                    yield token_text
-                        except json.JSONDecodeError as e:
-                            logging.error(f"Error decoding JSON: {e}")
-                            continue
-
-        except requests.RequestException as e:
-            logging.error(f"API request failed: {e}")
-
-    def _format_prompt(self, prompt: str) -> str:
-        """
-        Format the text prompt with special tokens required by Orpheus.
-
-        Args:
-            prompt (str): The raw text prompt.
-
-        Returns:
-            str: The formatted prompt including voice and termination token.
-        """
-        return f"<|audio|>{self.voice.name}: {prompt}<|eot_id|>"
-
-    def _token_decoder(self, token_gen):
-        """
-        Decode tokens from the generator and convert them into audio samples.
-
-        This method aggregates tokens in a buffer and converts them into audio chunks
-        once enough tokens have been collected.
-
-        Args:
-            token_gen: Generator yielding token strings.
-
-        Yields:
-            Audio samples ready to be streamed.
-        """
-        buffer = []
-        count = 0
-
-        logging.debug("Starting token decoding from token generator.")
-        for token_text in token_gen:
-            # bail out if stop was requested
-            if self.stop_synthesis_event.is_set():
-                logging.debug("OrpheusEngine: token decoding aborted")
-                break
-            token = self.turn_token_into_id(token_text, count)
-            if token is not None and token > 0:
-                buffer.append(token)
-                count += 1
-
-                # Process every 7 tokens after an initial threshold
-                if count % 7 == 0 and count > 27:
-                    buffer_to_proc = buffer[-28:]
-                    audio_samples = self._convert_buffer(buffer_to_proc, count)
-                    if audio_samples is not None:
-                        yield audio_samples
-
-    def turn_token_into_id(self, token_string: str, index: int) -> Optional[int]:
-        """
-        Convert a token string to a numeric ID for audio processing.
-
-        The conversion takes into account the custom token prefix and an index-based offset.
-
-        Args:
-            token_string (str): The token text.
-            index (int): The current token index.
-
-        Returns:
-            Optional[int]: The numeric token ID or None if conversion fails.
-        """
-        token_string = token_string.strip()
-        last_token_start = token_string.rfind(CUSTOM_TOKEN_PREFIX)
-        
-        if last_token_start == -1:
-            return None
-        
-        last_token = token_string[last_token_start:]
-        
-        if last_token.startswith(CUSTOM_TOKEN_PREFIX) and last_token.endswith(">"):
-            try:
-                number_str = last_token[14:-1]
-                token_id = int(number_str) - 10 - ((index % 7) * 4096)
-                return token_id
-            except ValueError:
-                return None
-        else:
-            return None
-
-    def _convert_buffer(self, multiframe, count: int):
-        """
-        Convert a buffer of token frames into audio samples.
-
-        This method uses an external decoder to convert the collected token frames.
-
-        Args:
-            multiframe: List of token IDs to be converted.
-            count (int): The current token count (used for conversion logic).
-
-        Returns:
-            Converted audio samples if successful; otherwise, None.
-        """
-        try:
-            from .orpheus_decoder import convert_to_audio as orpheus_convert_to_audio
-            converted = orpheus_convert_to_audio(multiframe, count)
-            if converted is None:
-                logging.warning("Conversion returned None.")
-            return converted
-        except Exception as e:
-            logging.error(f"Failed to convert buffer to audio: {e}")
-        logging.info("Returning None after failed conversion.")
-        return None
-
-    def get_voices(self):                  # FastAPI /voices-Route
-        return self._SPEAKERS
-
-    def set_voice(self, voice_name: str) -> None:
-        if voice_name not in [v.name for v in self._SPEAKERS]:
-            raise ValueError(f"Unknown Orpheus speaker '{voice_name}'")
-        self.voice = OrpheusVoice(voice_name)
-
-    def set_voice_parameters(self, **kwargs):
-        """
-        Update voice generation parameters.
-
-        Valid parameters include 'temperature', 'top_p', 'max_tokens', and 'repetition_penalty'.
-
-        Args:
-            **kwargs: Arbitrary keyword arguments for valid voice parameters.
-        """
-        valid_params = ['temperature', 'top_p', 'max_tokens', 'repetition_penalty']
-        for param, value in kwargs.items():
-            if param in valid_params:
-                setattr(self, param, value)
-            elif self.debug:
-                logging.warning(f"Ignoring invalid parameter: {param}")
-
-    def __del__(self):
-        """
-        Destructor to clean up resources.
-
-        Puts a None into the queue to signal termination of audio processing.
-        """
-        self.queue.put(None)