sinapsis-speech 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

sinapsis_elevenlabs/src/sinapsis_elevenlabs/helpers/voice_utils.py

@@ -1,29 +1,35 @@
 # -*- coding: utf-8 -*-
-from elevenlabs import VoiceSettings
-from elevenlabs.client import DEFAULT_VOICE, ElevenLabs, VoiceId, VoiceName
+import json
+
+from elevenlabs import Voice, VoiceSettings
+from elevenlabs.client import ElevenLabs
 from sinapsis_core.data_containers.data_packet import TextPacket
 from sinapsis_core.utils.logging_utils import sinapsis_logger
 
 
-def create_voice_settings(settings: VoiceSettings) -> VoiceSettings | None:
+def create_voice_settings(settings: VoiceSettings, as_json: bool = False) -> VoiceSettings | None | str:
     """
     Creates or updates a `VoiceSettings` object based on the provided settings.
 
     Args:
         settings (VoiceSettings | None): An instance of `VoiceSettings` containing the settings to be applied.
             If `None`, the function returns the default settings.
+        as_json (bool): Whether to return the settings as JSON string.
 
     Returns:
-        VoiceSettings: The provided `VoiceSettings` object if `settings` is not `None`. Otherwise,
-            `DEFAULT_VOICE.settings` is returned.
+        VoiceSettings | None | str: The provided `VoiceSettings` object if `settings` is not `None`. Otherwise,
+            `None` is returned for default settings.
     """
     if not settings:
-        return DEFAULT_VOICE.settings
+        return None
+
+    if as_json:
+        return json.dumps(settings.model_dump(exclude_none=True))
 
     return settings
 
 
-def get_voice_id(client: ElevenLabs, voice: VoiceId | VoiceName) -> VoiceId:
+def get_voice_id(client: ElevenLabs, voice: str | Voice | None) -> str:
     """
     Resolves the voice ID for a given voice name or ID.
 
@@ -33,29 +39,59 @@ def get_voice_id(client: ElevenLabs, voice: VoiceId | VoiceName) -> VoiceId:
 
     Args:
         client (ElevenLabs): The ElevenLabs API client instance.
-        voice (VoiceId | VoiceName): The name or ID of the desired voice.
+        voice (str | Voice | None): The name or ID of the desired voice.
 
     Returns:
-        VoiceId: The resolved voice ID.
+        str: The resolved voice ID.
 
     Raises:
         ValueError: If no voices are available to resolve.
     """
+    if not voice:
+        return get_default_voice(client).voice_id
+
+    if isinstance(voice, Voice):
+        sinapsis_logger.debug(f"Voice object provided, using voice_id: {voice.voice_id}")
+        return voice.voice_id
+
     try:
-        voices = client.voices.get_all().voices
+        voices_response = client.voices.get_all()
+        voices = voices_response.voices
+
         for v in voices:
             if voice == v.name or voice == v.voice_id:
-                sinapsis_logger.debug("Voice '%s' resolved to ID: %s", voice, v.voice_id)
+                sinapsis_logger.debug(f"Voice {voice} resolved to ID: {v.voice_id}")
                 return v.voice_id
 
-        sinapsis_logger.error("Voice '%s' is not available.", voice)
+        sinapsis_logger.error(f"Voice {voice} is not available.")
         if voices:
-            sinapsis_logger.info("Returning default voice ID: %s", voices[0].voice_id)
+            sinapsis_logger.info(f"Returning default voice ID: {voices[0].voice_id}")
             return voices[0].voice_id
 
         raise ValueError("No available voices to resolve. Ensure the client is configured correctly.")
     except Exception as e:
-        sinapsis_logger.error("Error resolving voice ID: %s", e)
+        sinapsis_logger.error(f"Error resolving voice ID: {e}")
+        raise
+
+
+def get_default_voice(client: ElevenLabs) -> Voice:
+    """
+    Gets the first available voice as default.
+
+    Args:
+        client (ElevenLabs): The ElevenLabs API client instance.
+
+    Returns:
+        Voice: The default voice object.
+    """
+    try:
+        voices_response = client.voices.get_all()
+        voices = voices_response.voices
+        if voices:
+            return voices[0]
+        raise ValueError("No voices available")
+    except Exception as e:
+        sinapsis_logger.error(f"Error getting default voice: {e}")
         raise
 
 

sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/__init__.py

@@ -7,6 +7,8 @@ _root_lib_path = "sinapsis_elevenlabs.templates"
 _template_lookup = {
     "ElevenLabsTTS": f"{_root_lib_path}.elevenlabs_tts",
     "ElevenLabsVoiceGeneration": f"{_root_lib_path}.elevenlabs_voice_generation",
+    "ElevenLabsVoiceClone": f"{_root_lib_path}.elevenlabs_voice_clone",
+    "ElevenLabsSTS": f"{_root_lib_path}.elevenlabs_sts",
 }
 
 

sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_base.py

@@ -5,10 +5,10 @@ import abc
 import os
 import uuid
 from io import BytesIO
-from typing import IO, Iterator, Literal
+from typing import IO, Iterable, Iterator, Literal
 
 from elevenlabs import Voice, VoiceSettings, save
-from elevenlabs.client import ElevenLabs, VoiceId, VoiceName
+from elevenlabs.client import ElevenLabs
 from elevenlabs.types import OutputFormat
 from pydantic import Field
 from sinapsis_core.data_containers.data_packet import AudioPacket, DataContainer, Packet
@@ -46,12 +46,14 @@ class ElevenLabsBase(Template, abc.ABC):
         Args:
             api_key (str): The API used key to authenticate with ElevenLabs' API.
             model (Literal): The model identifier to use for speech synthesis.
+            output_file_name (str | None): Optional name for saved audio file.
+                If not provided a random UUI will be used as file name. Defaults to None.
             output_format (OutputFormat): The output audio format and quality. Options include:
                 ["mp3_22050_32", "mp3_44100_32", "mp3_44100_64", "mp3_44100_96", "mp3_44100_128",
                 "mp3_44100_192", "pcm_16000", "pcm_22050", "pcm_24000", "pcm_44100", "ulaw_8000"]
             output_folder (str): The folder where generated audio files will be saved.
             stream (bool): If True, the audio is returned as a stream; otherwise, saved to a file.
-            voice (VoiceId | VoiceName | Voice): The voice to use for speech synthesis. This can be a voice ID (str),
+            voice (str | Voice | None): The voice to use for speech synthesis. This can be a voice ID (str),
                 a voice name (str) or an elevenlabs voice object (Voice).
             voice_settings (VoiceSettings): A dictionary of settings that control the behavior of the voice.
                 - stability (float)
@@ -70,11 +72,11 @@ class ElevenLabsBase(Template, abc.ABC):
             "eleven_english_sts_v2",
             "eleven_multilingual_sts_v2",
         ] = "eleven_turbo_v2_5"
+        output_file_name: str | None = None
         output_format: OutputFormat = "mp3_44100_128"
         output_folder: str = os.path.join(SINAPSIS_CACHE_DIR, "elevenlabs", "audios")
         stream: bool = False
-        file_name : str = str(uuid.uuid4())
-        voice: VoiceId | VoiceName | Voice = None
+        voice: str | Voice | None = None
         voice_settings: VoiceSettings = Field(default_factory=dict)  # type: ignore[arg-type]
 
     UIProperties = UIPropertiesMetadata(category="Elevenlabs", output_type=OutputTypes.AUDIO)
@@ -98,9 +100,14 @@ class ElevenLabsBase(Template, abc.ABC):
     def synthesize_speech(self, input_data: list[Packet]) -> RESPONSE_TYPE:
         """Abstract method for ElevenLabs speech synthesis."""
 
-    def _save_audio(self, response: Iterator[bytes] | bytes, file_format: str) -> str:
+    def _save_audio(self, response: Iterable | bytes, file_format: str, idx: int) -> str:
         """Saves the audio to a file and returns the file path."""
-        output_file = os.path.join(self.attributes.output_folder, f"{self.attributes.file_name}.{file_format}")
+        if self.attributes.output_file_name:
+            file_name = self.attributes.output_file_name + "_" + str(idx)
+        else:
+            file_name = uuid.uuid4()
+
+        output_file = os.path.join(self.attributes.output_folder, f"{file_name}.{file_format}")
         try:
             save(response, output_file)
             self.logger.info(f"Audio saved to: {output_file}")
@@ -109,7 +116,7 @@ class ElevenLabsBase(Template, abc.ABC):
             self.logger.error(f"File system error while saving speech to file: {e}")
             raise
 
-    def _generate_audio_stream(self, response: Iterator[bytes] | bytes) -> IO[bytes]:
+    def _generate_audio_stream(self, response: Iterable | bytes) -> IO[bytes]:
         """Generates and returns the audio stream."""
         audio_stream = BytesIO()
         try:
@@ -132,13 +139,12 @@ class ElevenLabsBase(Template, abc.ABC):
             self.logger.error(f"Value error while processing audio chunks: {e}")
             raise
 
-    def _process_audio_output(self, response: Iterator[bytes] | bytes) -> str | IO[bytes]:
+    def _process_audio_output(self, idx: int, response: Iterable | bytes) -> str | IO[bytes]:
         """Processes a single audio output (either stream or file)."""
         if self.attributes.stream:
             return self._generate_audio_stream(response)
-        else:
-            file_format = "mp3" if "mp3" in self.attributes.output_format else "wav"
-            return self._save_audio(response, file_format)
+        file_format = "mp3" if "mp3" in self.attributes.output_format else "wav"
+        return self._save_audio(response, file_format, idx)
 
     def generate_speech(self, input_data: list[Packet]) -> list[str | IO[bytes]] | None:
         """Generates speech and saves it to a file."""
@@ -149,7 +155,7 @@ class ElevenLabsBase(Template, abc.ABC):
         if isinstance(responses, Iterator):
             responses = [responses]
 
-        audio_outputs = [self._process_audio_output(response) for response in responses]
+        audio_outputs = [self._process_audio_output(idx, response) for idx, response in enumerate(responses)]
         return audio_outputs
 
     def _handle_streaming_output(self, audio_outputs: list[str | IO[bytes]]) -> list[AudioPacket]:

sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_sts.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+"""Speech-To-Speech template for ElevenLabs."""
+
+from typing import Callable, Iterator, Literal
+
+from sinapsis_core.data_containers.data_packet import AudioPacket
+
+from sinapsis_elevenlabs.helpers.voice_utils import create_voice_settings, get_voice_id
+from sinapsis_elevenlabs.templates.elevenlabs_base import ElevenLabsBase
+
+
+class ElevenLabsSTS(ElevenLabsBase):
+    """Template to interact with the ElevenLabs Speech-to-Speech API.
+
+    This template takes an input audio and converts it to a new voice using
+    the ElevenLabs Speech-to-Speech (STS) API.
+
+    Usage example:
+
+    agent:
+      name: my_test_agent
+    templates:
+    - template_name: InputTemplate
+      class_name: InputTemplate
+      attributes: {}
+    - template_name: ElevenLabsSTS
+      class_name: ElevenLabsSTS
+      template_input: InputTemplate
+      attributes:
+        api_key: null
+        model: eleven_multilingual_sts_v2
+        output_file_name: null
+        output_format: mp3_44100_128
+        output_folder: ~/.cache/sinapsis/elevenlabs/audios
+        stream: false
+        voice: null
+        voice_settings:
+            stability: null
+            similarity_boost: null
+            style: null
+            use_speaker_boost: null
+            speed: null
+        streaming_latency: null
+
+    """
+
+    PACKET_TYPE_NAME: str = "audios"
+
+    class AttributesBaseModel(ElevenLabsBase.AttributesBaseModel):
+        """Attributes specific to ElevenLabs STS API interaction.
+
+        Attributes:
+            model (Literal): The STS model to use. Options are "eleven_english_sts_v2" or "eleven_multilingual_sts_v2".
+            streaming_latency (int | None): Optional latency optimization for streaming. Defaults to None.
+        """
+
+        model: Literal["eleven_english_sts_v2", "eleven_multilingual_sts_v2"] = "eleven_multilingual_sts_v2"
+        streaming_latency: int | None = None
+
+    def synthesize_speech(self, input_data: list[AudioPacket]) -> Iterator[bytes]:
+        """Sends an audio input to the ElevenLabs API for speech-to-speech synthesis.
+
+        Args:
+            input_data (list[AudioPacket]): List of AudioPacket objects containing the audio to be converted.
+                Only the first AudioPacket in the list is used.
+
+        Returns:
+            Iterator[bytes]: An iterator yielding audio data chunks in the output format specified.
+
+        Raises:
+            ValueError: If there is a problem with the input data or parameters.
+            TypeError: If the input data or files are of incorrect type.
+            KeyError: If the expected key is missing in the API response.
+        """
+        try:
+            method: Callable[..., Iterator[bytes]] = (
+                self.client.speech_to_speech.stream if self.attributes.stream else self.client.speech_to_speech.convert
+            )
+            return method(
+                voice_id=get_voice_id(self.client, voice=self.attributes.voice),
+                audio=input_data[0].content,
+                model_id=self.attributes.model,
+                voice_settings=create_voice_settings(self.attributes.voice_settings, as_json=True),
+                output_format=self.attributes.output_format,
+                optimize_streaming_latency=self.attributes.streaming_latency,
+            )
+        except ValueError as e:
+            self.logger.error(f"Value error synthesizing speech: {e}")
+            raise
+        except TypeError as e:
+            self.logger.error(f"Type error in input data or parameters: {e}")
+            raise
+        except KeyError as e:
+            self.logger.error(f"Missing key in input data or settings: {e}")
+            raise

sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_tts.py

@@ -1,12 +1,13 @@
 # -*- coding: utf-8 -*-
 """Text-To-Speech template for ElevenLabs"""
 
-from typing import Iterator, Literal
+from typing import Callable, Iterator, Literal
 
 from sinapsis_core.data_containers.data_packet import TextPacket
 
 from sinapsis_elevenlabs.helpers.voice_utils import (
     create_voice_settings,
+    get_voice_id,
     load_input_text,
 )
 from sinapsis_elevenlabs.templates.elevenlabs_base import ElevenLabsBase
@@ -64,16 +65,16 @@ class ElevenLabsTTS(ElevenLabsBase):
         """
         input_text: str = load_input_text(input_data)
         try:
-            response: Iterator[bytes] = self.client.generate(
+            method: Callable[..., Iterator[bytes]] = (
+                self.client.text_to_speech.stream if self.attributes.stream else self.client.text_to_speech.convert
+            )
+            return method(
                 text=input_text,
-                voice=self.attributes.voice,
-                model=self.attributes.model,
+                voice_id=get_voice_id(self.client, self.attributes.voice),
+                model_id=self.attributes.model,
                 voice_settings=create_voice_settings(self.attributes.voice_settings),
                 output_format=self.attributes.output_format,
-                stream=self.attributes.stream,
             )
-
-            return response
         except ValueError as e:
             self.logger.error(f"Value error synthesizing speech: {e}")
             raise

sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_voice_clone.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""Text-To-Speech template for ElevenLabs Voice Cloning."""
+
+from elevenlabs import Voice
+from sinapsis_core.data_containers.data_packet import AudioPacket, DataContainer
+
+from sinapsis_elevenlabs.templates.elevenlabs_tts import ElevenLabsTTS
+
+
+class ElevenLabsVoiceClone(ElevenLabsTTS):
+    """Template to clone a voice using the ElevenLabs API.
+
+    This template allows you to create a new custom voice in ElevenLabs by providing
+    one or more audio samples. The cloned voice can then be used for subsequent
+    text-to-speech synthesis within the Sinapsis pipeline.
+
+    Usage example:
+
+    agent:
+    name: my_test_agent
+    templates:
+    - template_name: InputTemplate
+      class_name: InputTemplate
+      attributes: {}
+    - template_name: ElevenLabsVoiceClone
+      class_name: ElevenLabsVoiceClone
+      template_input: InputTemplate
+      attributes:
+        api_key: null
+        model: eleven_turbo_v2_5
+        output_file_name: null
+        output_format: mp3_44100_128
+        output_folder: ~/.cache/sinapsis/elevenlabs/audios
+        stream: false
+        voice: null
+        voice_settings:
+            stability: null
+            similarity_boost: null
+            style: null
+            use_speaker_boost: null
+            speed: null
+        name: null
+        description: null
+        remove_background_noise: false
+
+    """
+
+    class AttributesBaseModel(ElevenLabsTTS.AttributesBaseModel):
+        """Attributes specific to the ElevenLabsVoiceClone class.
+
+        Attributes:
+            name (str | None): Name for the cloned voice. If None, a default name may be used.
+            description (str | None): Description for the cloned voice. Optional.
+            remove_background_noise (bool): Whether to remove background noise from samples. Defaults to False.
+        """
+
+        name: str | None = None
+        description: str | None = None
+        remove_background_noise: bool = False
+
+    def clone_voice(self, input_data: list[AudioPacket]) -> Voice:
+        """Clones a voice using the provided audio files.
+
+        Args:
+            input_data (list[AudioPacket]): List of AudioPacket objects containing the audio samples
+                to be used for voice cloning. Each AudioPacket's `content` should be a file-like object
+                or bytes representing the audio data.
+                **NOTE:** All provided audio packets are used as reference for a single cloned voice.
+
+        Returns:
+            Voice: The cloned Voice object as returned by the ElevenLabs API.
+
+        Raises:
+            ValueError: If there is a problem with the input data or parameters.
+            TypeError: If the input data or files are of incorrect type.
+            KeyError: If the expected key is missing in the API response.
+        """
+        files = [audio.content for audio in input_data]
+        try:
+            clone_response = self.client.voices.ivc.create(
+                name=self.attributes.name,
+                files=files,
+                description=self.attributes.description,
+                remove_background_noise=self.attributes.remove_background_noise,
+            )
+            cloned_voice = self.client.voices.get(clone_response.voice_id)
+            self.logger.info(f"Voice cloned successfully with IVC: {cloned_voice.name}")
+            return cloned_voice
+        except ValueError as e:
+            self.logger.error(f"Value error in input data or parameters: {e}")
+            raise
+        except TypeError as e:
+            self.logger.error(f"Type error with input data or files: {e}")
+            raise
+        except KeyError as e:
+            self.logger.error(f"Missing expected key in API response: {e}")
+            raise
+
+    def execute(self, container: DataContainer) -> DataContainer:
+        """Executes the voice cloning process and generates the speech output.
+
+        Args:
+            container (DataContainer): The input DataContainer, expected to contain
+                one or more AudioPacket objects in the `audios` attribute.
+
+        Returns:
+            DataContainer: The updated DataContainer. If cloning is successful,
+                the cloned voice is set in `self.attributes.voice` and the parent
+                TTS execution is performed using the new voice.
+
+        Side Effects:
+            - Updates `self.attributes.voice` with the cloned Voice object.
+            - May log errors or info messages.
+        """
+        audios = container.audios
+        if not audios:
+            self.logger.debug("No audios provided to clone voice")
+            return container
+        self.attributes.voice = self.clone_voice(audios)
+
+        container = super().execute(container)
+
+        return container

sinapsis_orpheus_cpp/src/sinapsis_orpheus_cpp/templates/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+import importlib
+from typing import Callable
+
+_root_lib_path = "sinapsis_orpheus_cpp.templates"
+
+_template_lookup = {
+    "OrpheusTTS": f"{_root_lib_path}.orpheus_tts",
+}
+
+
+def __getattr__(name: str) -> Callable:
+    if name in _template_lookup:
+        module = importlib.import_module(_template_lookup[name])
+        return getattr(module, name)
+
+    raise AttributeError(f"template `{name}` not found in {_root_lib_path}")
+
+
+__all__ = list(_template_lookup.keys())

sinapsis_orpheus_cpp/src/sinapsis_orpheus_cpp/templates/orpheus_tts.py

@@ -0,0 +1,300 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from llama_cpp import Llama
+from orpheus_cpp import OrpheusCpp
+from orpheus_cpp.model import TTSOptions
+from pydantic import TypeAdapter
+from sinapsis_core.data_containers.data_packet import (
+    AudioPacket,
+    DataContainer,
+)
+from sinapsis_core.template_base import Template
+from sinapsis_core.template_base.base_models import (
+    OutputTypes,
+    TemplateAttributes,
+    TemplateAttributeType,
+    UIPropertiesMetadata,
+)
+from sinapsis_core.utils.env_var_keys import SINAPSIS_CACHE_DIR
+
+from sinapsis_orpheus_cpp.thirdparty.helpers import download_model, setup_snac_session
+
+
+class OrpheusTTSAttributes(TemplateAttributes):
+    """Attributes configuration for Orpheus TTS Template.
+
+    This class defines all configurable parameters for the Orpheus TTS model,
+    including model configuration, GPU settings, and audio generation parameters.
+
+    Attributes:
+        n_gpu_layers (int): Number of model layers to offload to GPU.
+            -1 means use all available layers on GPU for maximum performance.
+            0 means use CPU only. Default: -1.
+        n_threads (int): Number of CPU threads to use for model inference.
+            0 means auto-detect optimal thread count. Default: 0.
+        n_ctx (int): Context window size (maximum number of tokens).
+            0 means use the model's maximum trained context size.
+            Larger values require more GPU/RAM memory. Default: 8192.
+        model_id (str): Hugging Face model repository ID.
+            Must be a valid repository containing GGUF model files.
+            Required parameter with no default.
+        model_variant (str | None): Specific GGUF file to download from the repository.
+            If None, will auto-detect based on model_id naming convention.
+            Use this to specify exact quantization (e.g., "model-q4_k_m.gguf").
+            Default: None.
+        cache_dir (str): Directory to store downloaded models and cache files.
+            Default: SINAPSIS_CACHE_DIR environment variable.
+        verbose (bool): Enable verbose logging for model operations.
+            Shows detailed model loading and inference information. Default: False.
+        voice_id (str): Voice identifier for speech synthesis.
+            Must be a valid voice supported by the Orpheus model.
+            Available voices depend on the specific model variant.
+            Required parameter with no default.
+        batch_size (int): Batch size for model inference.
+            Higher values may improve throughput but require more memory.
+            Default: 1.
+        max_tokens (int): Maximum number of tokens to generate for speech.
+            Controls the length of generated audio sequences. Default: 2048.
+        temperature (float): Sampling temperature for token generation.
+            Higher values (>1.0) make output more random, lower values (<1.0)
+            make it more deterministic. Default: 0.8.
+        top_p (float): Nucleus sampling probability threshold.
+            Only tokens with cumulative probability <= top_p are considered.
+            Range: 0.0-1.0. Default: 0.95.
+        top_k (int): Top-k sampling parameter.
+            Only the top k most likely tokens are considered for sampling.
+            Default: 40.
+        min_p (float): Minimum probability threshold for token selection.
+            Tokens with probability below this threshold are filtered out.
+            Range: 0.0-1.0. Default: 0.05.
+        pre_buffer_size (float): Duration in seconds of audio to generate
+            before yielding the first chunk during streaming.
+            Larger values provide smoother audio but higher latency.
+            Default: 1.5.
+    """
+
+    n_gpu_layers: int = -1
+    n_threads: int = 0
+    n_ctx: int = 8192
+    model_id: str
+    model_variant: str | None = None
+    cache_dir: str = SINAPSIS_CACHE_DIR
+    verbose: bool = False
+    voice_id: str
+    batch_size: int = 1
+    max_tokens: int = 2048
+    temperature: float = 0.8
+    top_p: float = 0.95
+    top_k: int = 40
+    min_p: float = 0.05
+    pre_buffer_size: float = 1.5
+
+
+class OrpheusTTS(Template):
+    """Text-to-Speech template using Orpheus model for speech synthesis.
+
+    This template converts text input into high-quality speech audio using
+    the Orpheus neural TTS model. It handles model downloading, initialization,
+    and audio generation with configurable voice parameters.
+
+    Usage example:
+
+    agent:
+        name: my_test_agent
+    templates:
+    - template_name: InputTemplate
+      class_name: InputTemplate
+      attributes: {}
+    - template_name: OrpheusTTS
+      class_name: OrpheusTTS
+      template_input: InputTemplate
+      attributes:
+        n_gpu_layers: -1
+        n_threads: 0
+        n_ctx: 8192
+        model_id: '`replace_me:<class ''str''>`'
+        model_variant: null
+        cache_dir: ~/sinapsis
+        verbose: false
+        voice_id: '`replace_me:<class ''str''>`'
+        batch_size: 1
+        max_tokens: 2048
+        temperature: 0.8
+        top_p: 0.95
+        top_k: 40
+        min_p: 0.05
+        pre_buffer_size: 1.5
+
+    """
+
+    AttributesBaseModel = OrpheusTTSAttributes
+    UIProperties = UIPropertiesMetadata(category="TTS", output_type=OutputTypes.AUDIO)
+
+    def __init__(self, attributes: TemplateAttributeType) -> None:
+        super().__init__(attributes)
+        self._engine: OrpheusCpp
+        self._llm_available: bool = False
+        self._initialize_engine()
+
+    def _initialize_engine(self) -> None:
+        """Initialize the OrpheusCpp engine with downloaded model.
+
+        Creates a new OrpheusCpp instance without calling its constructor
+        to avoid default parameter conflicts, then manually configures
+        both the LLM and SNAC session components.
+
+        Raises:
+            ValueError: If model download fails.
+            RuntimeError: If engine initialization fails.
+        """
+        self._engine = OrpheusCpp.__new__(OrpheusCpp)
+        model_file = download_model(
+            model_id=self.attributes.model_id,
+            model_variant=self.attributes.model_variant,
+            cache_dir=self.attributes.cache_dir,
+        )
+        self._setup_llm(model_file)
+        self._setup_snac_session()
+
+    def _setup_llm(self, model_file: str) -> None:
+        """Setup the Large Language Model component with specified parameters.
+
+        Initializes the Llama model with custom configuration parameters.
+        Implements graceful error handling for Out-of-Memory conditions
+        by setting the LLM as unavailable instead of crashing.
+
+        Args:
+            model_file (str): Path to the downloaded GGUF model file.
+
+        Raises:
+            ValueError: For non-OOM related model initialization errors.
+
+        Note:
+            If a "Failed to create llama_context" error occurs (typically OOM),
+            the method logs the error and disables TTS functionality instead
+            of terminating the program.
+        """
+        try:
+            self._engine._llm = Llama(
+                model_path=model_file,
+                n_ctx=self.attributes.n_ctx,
+                verbose=self.attributes.verbose,
+                n_gpu_layers=self.attributes.n_gpu_layers,
+                n_threads=self.attributes.n_threads,
+                batch_size=self.attributes.batch_size,
+            )
+            self._llm_available = True
+        except ValueError as e:
+            if "Failed to create llama_context" in str(e):
+                error_msg = (
+                    f"Failed to create llama_context - Out of Memory (OOM) issue. "
+                    f"Current n_ctx: {self.attributes.n_ctx}, n_gpu_layers: {self.attributes.n_gpu_layers}. "
+                    f"Try reducing n_ctx or "
+                    f"reduce n_gpu_layers if using GPU. "
+                )
+                self.logger.error(error_msg)
+                self._engine._llm = None
+                self._llm_available = False
+            else:
+                raise
+
+    def _setup_snac_session(self) -> None:
+        """
+        Initializes the SNAC (Streaming Neural Audio Codec) session required
+        for converting model tokens to audio waveforms. Only sets up the session
+        if the LLM was successfully initialized.
+
+        Note:
+            SNAC session is only created when LLM is available to avoid
+            unnecessary resource allocation when TTS is disabled.
+        """
+        if self._llm_available:
+            self._engine._snac_session = setup_snac_session(self.attributes.cache_dir)
+        else:
+            self._engine._snac_session = None
+
+    def _create_tts_options(self) -> TTSOptions:
+        """
+        Dynamically builds a TTSOptions dictionary by filtering template attributes
+        to include only those that are valid TTSOptions parameters.
+
+        Returns:
+            TTSOptions: Dictionary containing TTS generation parameters.
+        """
+        tts_option_fields = TypeAdapter(TTSOptions)
+        attributes_dict = self.attributes.model_dump()
+        return tts_option_fields.validate_python(attributes_dict)
+
+    def generate_speech(self, text: str) -> tuple[int, np.ndarray] | None:
+        """
+        Converts text to speech using the Orpheus TTS model with configured
+        voice and generation parameters.
+
+        Args:
+            text (str): Input text to convert to speech.
+
+        Returns:
+            tuple[int, np.ndarray] | None: Tuple of (sample_rate, audio_array)
+                if generation succeeds, None if LLM is unavailable.
+
+        Note:
+            Returns None when LLM is not available (e.g., due to OOM errors)
+            instead of raising an exception, allowing graceful degradation.
+        """
+        if not self._llm_available:
+            return None
+        return self._engine.tts(text, options=self._create_tts_options())
+
+    def create_audio_packet(self, text: str, source: str | None = None) -> AudioPacket | None:
+        """
+        Generates speech from text and wraps the result in a
+        `AudioPacket` for data pipeline compatibility.
+
+        Args:
+            text (str): Input text to convert to speech.
+            source (str | None): Optional source identifier for traceability.
+
+        Returns:
+            AudioPacket | None: Audio packet containing generated speech,
+                or None if speech generation fails or is unavailable.
+        """
+        speech_result = self.generate_speech(text)
+        if speech_result is None:
+            return None
+
+        sample_rate, audio_data = speech_result
+        return AudioPacket(
+            content=audio_data,
+            source=source,
+            sample_rate=sample_rate,
+        )
+
+    def execute(self, container: DataContainer) -> DataContainer:
+        """
+        Processes all text packets in the input container and generates
+        corresponding audio packets using the Orpheus TTS model.
+
+        Args:
+            container (DataContainer): Input container with text packets to process.
+
+        Returns:
+            DataContainer: Updated container with generated audio packets added.
+
+        Note:
+            When LLM is unavailable (due to initialization failures), the method
+            logs a warning and returns the container without modifications rather
+            than raising an exception.
+        """
+        if not container.texts:
+            return container
+
+        if not self._llm_available:
+            return container
+
+        for text_packet in container.texts:
+            audio_packet = self.create_audio_packet(text=text_packet.content, source=text_packet.source)
+            if audio_packet is not None:
+                container.audios.append(audio_packet)
+
+        return container

sinapsis_orpheus_cpp/src/sinapsis_orpheus_cpp/thirdparty/helpers.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+"""
+Themethods declared in this file are inspired in the following source:
+
+https://github.com/freddyaboulton/orpheus-cpp
+
+which is Licensed under the MIT License.
+
+"""
+
+import onnxruntime
+from huggingface_hub import hf_hub_download
+from sinapsis_core.utils.logging_utils import sinapsis_logger
+
+
+def download_model(cache_dir: str, model_id: str, model_variant: str | None = None) -> str | None:
+    """
+    Download a model from Hugging Face Hub.
+
+    Args:
+        model_id: The model ID on Hugging Face Hub.
+        model_variant: The specific model variant file to download.
+        cache_dir: Directory to store downloaded models.
+
+    Returns:
+        Path to the downloaded model file or None if download fails.
+    """
+    if model_variant:
+        filename = model_variant
+    elif model_id.endswith(("-GGUF", "-gguf")):
+        filename = model_id.split("/")[-1].lower().replace("-gguf", ".gguf")
+    else:
+        filename = f"{model_id.split('/')[-1]}.gguf"
+
+    sinapsis_logger.info(f"Downloading model {model_id} with filename {filename}")
+
+    model_file = hf_hub_download(
+        repo_id=model_id,
+        filename=filename,
+        cache_dir=cache_dir,
+    )
+
+    sinapsis_logger.info(f"Successfully downloaded model to {model_file}")
+    return model_file
+
+
+def setup_snac_session(cache_dir: str) -> onnxruntime.InferenceSession:
+    """
+    Download and setup the SNAC ONNX session for audio processing.
+
+    Args:
+        cache_dir: Directory to store downloaded models.
+
+    Returns:
+        Configured ONNX inference session.
+    """
+    repo_id = "onnx-community/snac_24khz-ONNX"
+    snac_model_file = "decoder_model.onnx"
+    snac_model_path = hf_hub_download(
+        repo_id,
+        subfolder="onnx",
+        filename=snac_model_file,
+        cache_dir=cache_dir,
+    )
+
+    return onnxruntime.InferenceSession(
+        snac_model_path,
+        providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+    )

sinapsis_parakeet_tdt/src/sinapsis_parakeet_tdt/templates/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+import importlib
+from typing import Callable
+
+_root_lib_path = "sinapsis_parakeet_tdt.templates"
+
+_template_lookup = {
+    "ParakeetTDTInference": f"{_root_lib_path}.parakeet_tdt",
+}
+
+
+def __getattr__(name: str) -> Callable:
+    if name in _template_lookup:
+        module = importlib.import_module(_template_lookup[name])
+        return getattr(module, name)
+
+    raise AttributeError(f"template `{name}` not found in {_root_lib_path}")
+
+
+__all__ = list(_template_lookup.keys())

sinapsis_parakeet_tdt/src/sinapsis_parakeet_tdt/templates/parakeet_tdt.py

@@ -0,0 +1,270 @@
+# -*- coding: utf-8 -*-
+import os
+from typing import Any, Literal
+
+import nemo.collections.asr as nemo_asr
+from sinapsis_core.data_containers.data_packet import (
+    AudioPacket,
+    DataContainer,
+    TextPacket,
+)
+from sinapsis_core.template_base.base_models import (
+    OutputTypes,
+    TemplateAttributes,
+    UIPropertiesMetadata,
+)
+from sinapsis_core.template_base.template import Template
+
+
+class ParakeetTDTInferenceAttributes(TemplateAttributes):
+    """
+    Attributes for the ParakeetTDT model.
+
+    Attributes:
+        model_name (str): Name or path of the Parakeet TDT model. Defaults to "nvidia/parakeet-tdt-0.6b-v2".
+        audio_paths (list[str]): Optional list of audio file paths to transcribe. If empty, audio will be
+            taken from the `AudioPackets` in the `DataContainer`. Defaults to an empty list.
+        enable_timestamps (bool): Whether to generate timestamps for the transcription. Defaults to False.
+        timestamp_level (Literal["char", "word", "segment"]): Level of timestamp detail. Defaults to "word".
+        device (Literal["cpu", "cuda"]): Device to run the model on. Defaults to "cuda".
+        refresh_cache (bool): Whether to refresh the cache when downloading the model. Defaults to False.
+            This is useful if the model has been updated and you want to ensure you have the latest version.
+    """
+
+    model_name: str = "nvidia/parakeet-tdt-0.6b-v2"
+    audio_paths: list[str] | None = None
+    enable_timestamps: bool = False
+    timestamp_level: Literal["char", "word", "segment"] = "word"
+    device: Literal["cpu", "cuda"] = "cuda"
+    refresh_cache: bool = False
+
+
+class ParakeetTDTInference(Template):
+    """Template for NVIDIA Parakeet TDT 0.6B speech recognition.
+
+    This template uses NVIDIA's Parakeet TDT 0.6B automatic speech recognition (ASR) model
+    to transcribe audio. It can read audio directly from AudioPackets in the DataContainer
+    or from specified file paths. The model supports punctuation, capitalization, and
+    timestamp prediction.
+
+    Usage example:
+
+    agent:
+      name: my_transcription_agent
+    templates:
+    - template_name: InputTemplate
+      class_name: InputTemplate
+      attributes: {}
+
+    - template_name: ParakeetTDT
+      class_name: ParakeetTDTInference
+      template_input: InputTemplate
+      attributes:
+        model_name: "nvidia/parakeet-tdt-0.6b-v2"
+        audio_paths: ['/path/to/file.wav']
+        enable_timestamps: True
+        timestamp_level: "word"
+        device: "cuda"
+        refresh_cache: False
+    """
+
+    UIProperties = UIPropertiesMetadata(category="Parakeet TDT", output_type=OutputTypes.TEXT)
+
+    AttributesBaseModel = ParakeetTDTInferenceAttributes
+
+    def __init__(self, attributes: TemplateAttributes) -> None:
+        super().__init__(attributes)
+        self._load_model()
+
+    def _load_model(self) -> None:
+        """
+        Load the ASR model from pretrained source.
+
+        This method initializes the NeMo ASR model using the specified model name
+        and device configuration from the template attributes.
+        """
+        self.model = nemo_asr.models.ASRModel.from_pretrained(
+            model_name=self.attributes.model_name,
+            map_location=self.attributes.device,
+        )
+
+    def get_sources_from_packets(self, audio_packets: list[AudioPacket]) -> list[str]:
+        """
+        Extract valid audio file paths from AudioPackets.
+
+        Args:
+            audio_packets: List of audio packets to extract source paths from.
+
+        Returns:
+            list[str]: List of valid audio file paths extracted from the packets.
+        """
+        sources = []
+        for audio_packet in audio_packets:
+            if not audio_packet or not audio_packet.source:
+                self.logger.warning(f"Invalid or nonexistent audio source: {audio_packet.source}")
+            sources.append(audio_packet.source)
+        return sources
+
+    def get_sources_from_paths(self, paths: list[str]) -> list[str]:
+        """
+        Extract valid audio file paths from a list of paths.
+
+        Args:
+            paths: List of file paths to validate and extract.
+
+        Returns:
+            list[str]: List of valid audio file paths.
+        """
+        sources = []
+        for path in paths:
+            if not os.path.exists(path):
+                self.logger.warning(f"Audio file not found: {path}")
+            sources.append(path)
+        return sources
+
+    def get_audio_sources(self, container: DataContainer) -> list[str]:
+        """
+        Get audio sources from container or attributes.
+
+        This method first attempts to extract audio sources from the DataContainer's
+        audio packets. If no sources are found, it falls back to using the audio paths
+        specified in the template attributes.
+
+        Args:
+            container: DataContainer containing possible audio packets.
+
+        Returns:
+            list[str]: List of audio file paths to be transcribed.
+        """
+        sources = []
+        if container.audios:
+            sources = self.get_sources_from_packets(container.audios)
+
+        if not sources and self.attributes.audio_paths:
+            sources = self.get_sources_from_paths(self.attributes.audio_paths)
+
+        return sources
+
+    @staticmethod
+    def _process_transcription_result(result: Any) -> str:
+        """
+        Extract text from transcription result.
+
+        Args:
+            result: Transcription result object from the ASR model.
+
+        Returns:
+            str: The extracted text content.
+        """
+        return result.text if hasattr(result, "text") else str(result)
+
+    def _extract_timestamps(self, result: Any) -> dict | None:
+        """
+        Extract timestamps from result if available.
+
+        Args:
+            result: Transcription result object from the ASR model.
+
+        Returns:
+            dict | None: Dictionary containing timestamp information at the specified
+            level (char, word, or segment) or None if no timestamps are available.
+        """
+        if not result.timestamp:
+            return None
+
+        return result.timestamp.get(self.attributes.timestamp_level, [])
+
+    @staticmethod
+    def create_text_packet(text: str, source: str) -> TextPacket:
+        """
+        Create text packet from transcription data.
+
+        Args:
+            text: Transcribed text content.
+            source: Source identifier for the text packet.
+
+        Returns:
+            TextPacket: A text packet containing the transcription.
+        """
+        text_packet = TextPacket(
+            content=text,
+            source=source,
+        )
+
+        return text_packet
+
+    def transcribe_sources(self, sources: list[str]) -> list[Any]:
+        """
+        Transcribe audio sources and return results.
+
+        This method passes the audio sources to the ASR model for transcription,
+        with timestamp generation enabled based on the template attributes.
+
+        Args:
+            sources: List of audio file paths to transcribe.
+
+        Returns:
+            list[Any]: List of transcription results from the ASR model.
+        """
+        return self.model.transcribe(
+            sources,
+            timestamps=self.attributes.enable_timestamps,
+        )
+
+    def process_results(
+        self,
+        transcription_results: list[Any],
+        sources: list[str],
+        container: DataContainer,
+    ) -> list[TextPacket]:
+        """
+        Process transcription results into text packets.
+
+        This method extracts text and timestamps from the transcription results
+        and creates corresponding text packets. Timestamps are stored in the
+        container's generic data dictionary.
+
+        Args:
+            transcription_results: List of transcription results from the ASR model.
+            sources: List of audio file paths that were transcribed.
+            container: DataContainer to store additional data.
+
+        Returns:
+            list[TextPacket]: List of text packets containing the transcriptions.
+        """
+        text_packets = []
+
+        for i, result in enumerate(transcription_results):
+            source = sources[i] if i < len(sources) else f"transcription_{i}"
+            text = self._process_transcription_result(result)
+            timestamps = self._extract_timestamps(result)
+            text_packet = self.create_text_packet(text, source)
+            text_packets.append(text_packet)
+            if timestamps:
+                self._set_generic_data(container, {f"timestamps_{source}": timestamps})
+
+        return text_packets
+
+    def execute(self, container: DataContainer) -> DataContainer:
+        """
+        Transcribe audio to text using the Parakeet TDT model.
+
+        Args:
+            container: DataContainer with audio packets to transcribe.
+
+        Returns:
+            DataContainer: The same container with added text packets containing transcriptions.
+        """
+        sources = self.get_audio_sources(container)
+
+        if not sources:
+            self.logger.info("No audio sources found for transcription")
+            return container
+
+        self.logger.info(f"Transcribing {len(sources)} audio files")
+        transcription_results = self.transcribe_sources(sources)
+        text_packets = self.process_results(transcription_results, sources, container)
+        container.texts = container.texts or []
+        container.texts.extend(text_packets)
+
+        return container

{sinapsis_speech-0.3.4.dist-info → sinapsis_speech-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sinapsis-speech
-Version: 0.3.4
+Version: 0.4.0
 Summary: Generate speech using various libraries.
 Author-email: SinapsisAI <dev@sinapsis.tech>
 Project-URL: Homepage, https://sinapsis.tech
@@ -18,6 +18,8 @@ Requires-Dist: sinapsis-f5-tts[all]; extra == "all"
 Requires-Dist: sinapsis-kokoro[all]; extra == "all"
 Requires-Dist: sinapsis-speech[gradio-app]; extra == "all"
 Requires-Dist: sinapsis-zonos[all]; extra == "all"
+Requires-Dist: sinapsis-parakeet-tdt[all]; extra == "all"
+Requires-Dist: sinapsis-orpheus-cpp[all]; extra == "all"
 Provides-Extra: gradio-app
 Requires-Dist: sinapsis[webapp]>=0.2.3; extra == "gradio-app"
 Dynamic: license-file
@@ -55,8 +57,10 @@ This repo includes packages for performing speech synthesis using different tool
 
 * <code>sinapsis-elevenlabs</code>
 * <code>sinapsis-f5-tts</code>
-* * <code>sinapsis-kokoro</code>
+* <code>sinapsis-kokoro</code>
 * <code>sinapsis-zonos</code>
+* <code>sinapsis-orpheus-cpp</code>
+* <code>sinapsis-parakeet</code>
 
 Install using your preferred package manager. We strongly recommend using <code>uv</code>. To install <code>uv</code>, refer to the [official documentation](https://docs.astral.sh/uv/getting-started/installation/#installation-methods).
 
@@ -205,6 +209,16 @@ docker compose -f docker/compose_apps.yaml up -d sinapsis-kokoro
 docker compose -f docker/compose_apps.yaml up -d sinapsis-zonos
 ```
 
+- For Orpheus-CPP:
+```bash
+docker compose -f docker/compose_apps.yaml up -d sinapsis-orpheus-tts
+```
+
+- For Parakeet:
+```bash
+docker compose -f docker/compose_apps.yaml up -d sinapsis-parakeet
+```
+
 3. **Check the logs**
 
 - For ElevenLabs:
@@ -224,6 +238,17 @@ docker logs -f sinapsis-kokoro
 ```bash
 docker logs -f sinapsis-zonos
 ```
+
+- For Orpheus-CPP:
+```bash
+docker logs -f sinapsis-orpheus-tts
+```
+
+- For Parakeet:
+```bash
+docker logs -f sinapsis-parakeet
+```
+
 4. **The logs will display the URL to access the webapp, e.g.,:**:
 ```bash
 Running on local URL:  http://127.0.0.1:7860
@@ -240,6 +265,17 @@ docker compose -f docker/compose_apps.yaml down
 
 To run the webapp using the <code>uv</code> package manager, follow these steps:
 
+
+> [!IMPORTANT]
+> If you're using sinapsis-orpheus-cpp, you need to export cuda environment variables:
+
+
+```bash
+export CMAKE_ARGS="-DGGML_CUDA=on"
+export FORCE_CMAKE="1"
+export CUDACXX=$(command -v nvcc)
+```
+
 1. **Sync the virtual environment**:
 
 ```bash

{sinapsis_speech-0.3.4.dist-info → sinapsis_speech-0.4.0.dist-info}/RECORD

@@ -1,10 +1,12 @@
 sinapsis_elevenlabs/src/sinapsis_elevenlabs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sinapsis_elevenlabs/src/sinapsis_elevenlabs/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sinapsis_elevenlabs/src/sinapsis_elevenlabs/helpers/env_var_keys.py,sha256=j8J64iplBNaff1WvmfJ03eJozE1f5SdqtqQeldV2vPY,998
-sinapsis_elevenlabs/src/sinapsis_elevenlabs/helpers/voice_utils.py,sha256=fR1r1aaoFy_rQGfJLunUNdZfVxDyAo7shevS4TAXH_M,2420
-sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/__init__.py,sha256=pyTWPBLN_P6sxFTF1QqfL7iTZd9E0EaggpfwB0qLLHI,579
-sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_base.py,sha256=R5JXaOGN-XLoq0lB3mEyyMuKGdxSDZRK75R-I_GCUCs,8533
-sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_tts.py,sha256=WVTROfB2ODAksHmWwV5RKcub3Hoc29OM_eAw75c9yio,2847
+sinapsis_elevenlabs/src/sinapsis_elevenlabs/helpers/voice_utils.py,sha256=2Ym4suCk8wy-Nj2Hmk0uu3_-3nu1QlSs_KubDydm5wY,3383
+sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/__init__.py,sha256=UG35_hown3HITVR42iK_e3yVsUbuq2oYTLpCGwJ89L4,708
+sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_base.py,sha256=Dyxv_VAsjjuCGpdmW0anG5gqON8GS0oQWptgwX2pB44,8832
+sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_sts.py,sha256=O6BK05Noc-HffWNXY-4ow-RQ1xLK9f3jZ-8w71TpDAY,3659
+sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_tts.py,sha256=ll1l17VIgAsJJukZvQBmHO1-77XcpVzNCZr7frnZQEY,2982
+sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_voice_clone.py,sha256=oZKUuG6TrNFHG8vUCTkUbR0IFFp7ZoPE-6nDKhsD0Yg,4738
 sinapsis_elevenlabs/src/sinapsis_elevenlabs/templates/elevenlabs_voice_generation.py,sha256=bKo7zhfsiZwsn-qZx_MCVAIx_MmaKnaP3lc-07AwAaY,2819
 sinapsis_f5_tts/src/sinapsis_f5_tts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sinapsis_f5_tts/src/sinapsis_f5_tts/templates/__init__.py,sha256=28BOPAr9GG1jYcrXi45ZWO1n2FAZJOdDcmRkOXdEYmk,496
@@ -12,14 +14,19 @@ sinapsis_f5_tts/src/sinapsis_f5_tts/templates/f5_tts_inference.py,sha256=lEkcimV
 sinapsis_kokoro/src/sinapsis_kokoro/helpers/kokoro_utils.py,sha256=2IMJuwURPKK7keIkgS-rpGD28REG5M1FwW0COGcm3nI,1573
 sinapsis_kokoro/src/sinapsis_kokoro/templates/__init__.py,sha256=aX25GCUNGzIBeY5kifomsB-nSzW-unfq0-aC2Rpnaws,485
 sinapsis_kokoro/src/sinapsis_kokoro/templates/kokoro_tts.py,sha256=eRSEpH1HAUR3sy9Eb7ZRWhrk1IPZ7Z-ymS34ONFmxOg,5440
-sinapsis_speech-0.3.4.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+sinapsis_orpheus_cpp/src/sinapsis_orpheus_cpp/templates/__init__.py,sha256=XC7cqr1xC-0_yiKsNeob7CzEcHuduBFqvoXQBWVBKtI,492
+sinapsis_orpheus_cpp/src/sinapsis_orpheus_cpp/templates/orpheus_tts.py,sha256=I9aw_QmsCj6r4XXmPHL85rqjvtfyU2F33jCFFES-i9E,11715
+sinapsis_orpheus_cpp/src/sinapsis_orpheus_cpp/thirdparty/helpers.py,sha256=5Kat4QDPf1g-lC8CUF8T6yRHWyLQ4VoV7ELKazFMmRA,1964
+sinapsis_parakeet_tdt/src/sinapsis_parakeet_tdt/templates/__init__.py,sha256=3LppgbS6v70Rmx__yXXQgnoZ2ZBHcXkXeWZYQQf6Zwg,504
+sinapsis_parakeet_tdt/src/sinapsis_parakeet_tdt/templates/parakeet_tdt.py,sha256=PNE_SQkN72-kzfqvCit-GSEVP5NE8HjvTwxWd6wcem8,9456
+sinapsis_speech-0.4.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
 sinapsis_zonos/src/sinapsis_zonos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sinapsis_zonos/src/sinapsis_zonos/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sinapsis_zonos/src/sinapsis_zonos/helpers/zonos_keys.py,sha256=m1GdOYfzP73JGmtxH30mNiqbNkzFsQl9o2QaT7QxSVU,2470
 sinapsis_zonos/src/sinapsis_zonos/helpers/zonos_tts_utils.py,sha256=8Tr2YgxjBfRqv_Hf6sw36X2pLzW7fdQWqa6QPBxNZK8,6419
 sinapsis_zonos/src/sinapsis_zonos/templates/__init__.py,sha256=A-_F0K3hbEFqeWWAh4YftgU9CFX-WHrauSiCAww9yp8,482
 sinapsis_zonos/src/sinapsis_zonos/templates/zonos_tts.py,sha256=Zz0hcXVevPyho7d0q3Q2Zl9yDTPl_XhtueerxmzY_Jc,7687
-sinapsis_speech-0.3.4.dist-info/METADATA,sha256=wrawwEgomcDqfseVNbV25YTsBrIF3knbIASB_mkvY7Y,10030
-sinapsis_speech-0.3.4.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-sinapsis_speech-0.3.4.dist-info/top_level.txt,sha256=dd-bGAKXxelJCHcNxFZM4OTJ2mylgM2astOGPpj91yo,67
-sinapsis_speech-0.3.4.dist-info/RECORD,,
+sinapsis_speech-0.4.0.dist-info/METADATA,sha256=s0-CB1Db680tyrtrEbiajzlCP1-Khte1z4hAei-9KJg,10751
+sinapsis_speech-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sinapsis_speech-0.4.0.dist-info/top_level.txt,sha256=KvdwXupt5wnqb_4XGRcuJaL9Glgdw-DBvRkNzhgl_Ds,110
+sinapsis_speech-0.4.0.dist-info/RECORD,,

{sinapsis_speech-0.3.4.dist-info → sinapsis_speech-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{sinapsis_speech-0.3.4.dist-info → sinapsis_speech-0.4.0.dist-info}/top_level.txt

@@ -1,4 +1,6 @@
 sinapsis_elevenlabs
 sinapsis_f5_tts
 sinapsis_kokoro
+sinapsis_orpheus_cpp
+sinapsis_parakeet_tdt
 sinapsis_zonos