smallestai 0.1.0__py3-none-any.whl

smallest/__init__.py

@@ -0,0 +1,5 @@
+from smallest.tts import Smallest
+from smallest.async_tts import AsyncSmallest
+from smallest.stream_tts import TextToAudioStream
+
+__all__ = ["Smallest", "AsyncSmallest", "TextToAudioStream"]

smallest/async_tts.py

@@ -0,0 +1,151 @@
+import os
+import copy
+import aiohttp
+import aiofiles
+from typing import Optional, Union, List
+
+from .models import TTSModels, TTSVoices
+from .exceptions import TTSError, APIError
+from .utils import (TTSOptions, validate_input, preprocess_text, add_wav_header,
+                     get_smallest_languages, get_smallest_voices, get_smallest_models, API_BASE_URL)
+
+
+class AsyncSmallest:
+    def __init__(
+            self,
+            api_key: Optional[str] = None,
+            model: TTSModels = "lightning",
+            sample_rate: int = 24000,
+            voice: TTSVoices = "emily",
+            speed: Optional[float] = 1.0,
+            add_wav_header: Optional[bool] = True,
+            transliterate: Optional[bool] = False,
+            remove_extra_silence: Optional[bool] = False
+    ) -> None:
+        """
+        AsyncSmallest Instance for asynchronous text-to-speech synthesis.
+
+        This class provides an asynchronous implementation of the text-to-speech functionality. 
+        It allows for non-blocking synthesis of speech from text, making it suitable for applications 
+        that require async processing.
+
+        Args:
+        - api_key (str): The API key for authentication, export it as 'SMALLEST_API_KEY' in your environment variables.
+        - model (TTSModels): The model to be used for synthesis.
+        - sample_rate (int): The sample rate for the audio output.
+        - voice (TTSVoices): The voice to be used for synthesis.
+        - speed (float): The speed of the speech synthesis.
+        - add_wav_header (bool): Whether to add a WAV header to the output audio.
+        - transliterate (bool): Whether to transliterate the text.
+        - remove_extra_silence (bool): Whether to remove extra silence from the synthesized audio.
+
+        Methods:
+        - get_languages: Returns a list of available languages for synthesis.
+        - get_voices: Returns a list of available voices for synthesis.
+        - get_models: Returns a list of available models for synthesis.
+        - synthesize: Asynchronously converts the provided text into speech and returns the audio content.
+        """
+        self.api_key = api_key or os.environ.get("SMALLEST_API_KEY")
+        if not self.api_key:
+            raise TTSError("API key is required")
+        
+        self.opts = TTSOptions(
+            model=model,
+            sample_rate=sample_rate,
+            voice=voice,
+            api_key=self.api_key,
+            add_wav_header=add_wav_header,
+            speed=speed,
+            transliterate=transliterate,
+            remove_extra_silence=remove_extra_silence,
+        )
+        self.session = None
+        
+    async def __aenter__(self):
+        if self.session is None:
+            self.session = aiohttp.ClientSession()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.session:
+            await self.session.close()
+
+    def get_languages(self) -> List[str]:
+        """Returns a list of available languages."""
+        return get_smallest_languages()
+    
+    def get_voices(self) -> List[str]:
+        """Returns a list of available voices."""
+        return get_smallest_voices()
+
+    def get_models(self) -> List[str]:
+        """Returns a list of available models."""
+        return get_smallest_models()
+    
+    async def synthesize(
+            self,
+            text: str,
+            save_as: Optional[str] = None,
+            **kwargs
+        ) -> Union[bytes, None]:
+        """
+        Asynchronously synthesize speech from the provided text.
+
+        Args:
+        - text (str): The text to be converted to speech.
+        - save_as (Optional[str]): If provided, the synthesized audio will be saved to this file path. 
+                                   The file must have a .wav extension.
+        - kwargs: Additional optional parameters to override `__init__` options for this call.
+
+        Returns:
+        - Union[bytes, None]: The synthesized audio content in bytes if `save_as` is not specified; 
+                              otherwise, returns None after saving the audio to the specified file.
+
+        Raises:
+        - TTSError: If the provided file name does not have a .wav extension when `save_as` is specified.
+        - APIError: If the API request fails or returns an error.
+        """
+        opts = copy.deepcopy(self.opts)
+        for key, value in kwargs.items():
+            setattr(opts, key, value)
+
+        validate_input(text, opts.voice, opts.model, opts.sample_rate, opts.speed)
+
+        payload = {
+            "text": preprocess_text(text),
+            "sample_rate": opts.sample_rate,
+            "voice_id": opts.voice,
+            "add_wav_header": opts.add_wav_header,
+            "speed": opts.speed,
+            "model": opts.model,
+            "transliterate": opts.transliterate,
+            "remove_extra_silence": opts.remove_extra_silence
+        }
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        if not self.session:
+            self.session = aiohttp.ClientSession()
+        
+        async with self.session.post(f"{API_BASE_URL}/{opts.model}/get_speech", json=payload, headers=headers) as res:
+            if res.status != 200:
+                raise APIError(f"Failed to synthesize speech: {await res.text()}. For more information, visit https://waves.smallest.ai/")
+            
+            audio_content = await res.read()
+
+        if save_as:
+            if not save_as.endswith(".wav"):
+                raise TTSError("Invalid file name. Extension must be .wav")
+            
+            if self.opts.add_wav_header:
+                async with aiofiles.open(save_as, mode='wb') as f:
+                    await f.write(audio_content)
+            else:
+                async with aiofiles.open(save_as, mode='wb') as f:
+                    await f.write(add_wav_header(audio_content, self.opts.sample_rate))
+            return None
+
+        return audio_content

smallest/exceptions.py

@@ -0,0 +1,15 @@
+class TTSError(Exception):
+    """Base exception for TTS SDK"""
+    pass
+
+class APIError(TTSError):
+    """Raised when the API returns an error"""
+    pass
+
+class ValidationError(TTSError):
+    """Raised when input validation fails"""
+    pass
+
+class AuthenticationError(TTSError):
+    """Raised when authentication fails"""
+    pass

smallest/models.py

@@ -0,0 +1,7 @@
+from typing import Literal
+
+TTSModels = Literal["lightning"]
+TTSLanguages = Literal["en", "hi"]
+TTSVoices = Literal["emily", "jasmine", "arman", "james", "mithali", "aravind", "raj", 
+                    "arjun", "sanya", "saina", "pooja", "saurabh", "nisha", "mansi", "radhika", "kajal", 
+                    "raghav", "deepika", "niharika", "monika", "raman", "diya", "ananya", "william"]

smallest/stream_tts.py

@@ -0,0 +1,135 @@
+import asyncio
+from threading import Thread
+from queue import Queue, Empty
+from typing import AsyncGenerator, Optional, Union
+
+from .tts import Smallest
+from .exceptions import APIError
+from .async_tts import AsyncSmallest
+from .utils import SENTENCE_END_REGEX
+
+class TextToAudioStream:
+    def __init__(
+        self,
+        tts_instance: Union[Smallest, AsyncSmallest],
+        queue_timeout: float = 5.0,
+        max_retries: int = 3
+    ):
+        """
+        A real-time text-to-speech processor that converts streaming text into audio output.
+        Useful for applications requiring immediate audio feedback from text generation,
+        such as voice assistants, live captioning, or interactive chatbots.  
+
+        ⚠️ `add_wav_header` is disabled by default for streaming efficiency. Refer to the README for more information.  
+
+        Features:  
+        - Streams audio chunks as soon as text is available.
+        - Handles both sync and async text-to-speech engines.
+        - Automatically retries failed synthesis attempts.
+        - Low latency between text generation and speech output.
+
+        Args:
+            tts_instance: The text-to-speech engine to use (Smallest or AsyncSmallest)
+            queue_timeout: How long to wait for new text (seconds, default: 1.0)
+            max_retries: Number of retry attempts for failed synthesis (default: 3)
+        """
+        self.tts_instance = tts_instance
+        self.sentence_end_regex = SENTENCE_END_REGEX
+        self.queue_timeout = queue_timeout
+        self.max_retries = max_retries
+        self.queue = Queue()
+        self.buffer_size = 250
+        self.stop_flag = False
+        self.tts_instance.opts.add_wav_header = False
+
+
+    async def _stream_llm_output(self, llm_output: AsyncGenerator[str, None]) -> None:
+        """
+        Streams the LLM output, splitting it into sentences and adding each to the queue.
+
+        Parameters:
+        - llm_output (AsyncGenerator[str, None]): An async generator yielding LLM output.
+        """
+        buffer = ""
+        async for chunk in llm_output:
+            buffer += chunk
+            if self.sentence_end_regex.match(buffer) or self.buffer_size > 600:
+                self.queue.put(buffer)
+                buffer = ""
+
+        if buffer:
+            self.queue.put(buffer)
+
+        self.stop_flag = True  # completion flag when LLM output ends
+
+
+    async def _synthesize_async(self, sentence: str, retries: int = 0) -> Optional[bytes]:
+        """Asynchronously synthesizes a given sentence."""
+        try:
+            return await self.tts_instance.synthesize(sentence)
+        except APIError as e:
+            if retries < self.max_retries:
+                return await self._synthesize_async(sentence, retries + 1)
+            else:
+                print(f"Synthesis failed for sentence: {sentence} - Error: {e}. Retries Exhausted, for more information, visit https://waves.smallest.ai/")
+                return None
+
+
+    def _synthesize_sync(self, sentence: str, retries: int = 0) -> Optional[bytes]:
+        """Synchronously synthesizes a given sentence."""
+        try:
+            return self.tts_instance.synthesize(sentence)
+        except APIError as e:
+            if retries < self.max_retries:
+                return self._synthesize_sync(sentence, retries + 1)
+            else:
+                print(f"Synthesis failed for sentence: {sentence} - Error: {e}. Retries Exhausted, for more information, visit https://waves.smallest.ai/")
+                return None
+
+
+    async def _run_synthesis(self) -> AsyncGenerator[bytes, None]:
+        """
+        Continuously synthesizes sentences from the queue, yielding audio content.
+        If no sentences are in the queue, it waits until new data is available or streaming is complete.
+        """
+        while not self.stop_flag or not self.queue.empty():
+            try:
+                sentence = self.queue.get(timeout=self.queue_timeout)
+                if isinstance(self.tts_instance, AsyncSmallest):
+                    audio_content = await self._synthesize_async(sentence)
+                else:
+                    loop = asyncio.get_running_loop()
+                    audio_content = await loop.run_in_executor(None, self._synthesize_sync, sentence)
+                
+                if audio_content:
+                    yield audio_content
+            except Empty:
+                if self.stop_flag:
+                    break
+                await asyncio.sleep(0.1)  # avoid busy waiting if the queue is empty
+
+
+    async def process(self, llm_output: AsyncGenerator[str, None]) -> AsyncGenerator[bytes, None]:
+        """
+        Convert streaming text into audio in real-time.
+
+        Handles the entire pipeline from receiving text to producing audio,
+        yielding audio chunks as soon as they're ready.
+
+        Args:
+            llm_output: An async generator that yields text chunks.
+
+        Yields:
+            Raw audio data chunks (without WAV headers) that can be:
+            - Played directly through an audio device
+            - Saved to a file
+            - Streamed over a network
+            - Further processed as needed
+        """
+        llm_thread = Thread(target=asyncio.run, args=(self._stream_llm_output(llm_output),))
+        llm_thread.start()
+
+        async for audio_content in self._run_synthesis():
+            yield audio_content
+
+        llm_thread.join()

smallest/tts.py

@@ -0,0 +1,134 @@
+import os
+import copy
+import requests
+from typing import Optional, Union, List
+
+from .models import TTSModels, TTSVoices
+from .exceptions import TTSError, APIError
+from .utils import (TTSOptions, validate_input, preprocess_text, 
+get_smallest_languages, get_smallest_voices, get_smallest_models, API_BASE_URL)
+
+class Smallest:
+    def __init__(
+            self,
+            api_key: Optional[str] = None,
+            model: TTSModels = "lightning",
+            sample_rate: int = 24000,
+            voice: TTSVoices = "emily",
+            speed: Optional[float] = 1.0,
+            add_wav_header: Optional[bool] = True,
+            transliterate: Optional[bool] = False,
+            remove_extra_silence: Optional[bool] = True
+    ) -> None:
+        """
+        Smallest Instance for text-to-speech synthesis.
+
+        This is a synchronous implementation of the text-to-speech functionality. 
+        For an asynchronous version, please refer to the AsyncSmallest Instance.
+
+        Args:
+        - api_key (str): The API key for authentication, export it as 'SMALLEST_API_KEY' in your environment variables.
+        - model (TTSModels): The model to be used for synthesis.
+        - sample_rate (int): The sample rate for the audio output.
+        - voice (TTSVoices): The voice to be used for synthesis.
+        - speed (float): The speed of the speech synthesis.
+        - add_wav_header (bool): Whether to add a WAV header to the output audio.
+        - transliterate (bool): Whether to transliterate the text.
+        - remove_extra_silence (bool): Whether to remove extra silence from the synthesized audio.
+
+        Methods:
+        - get_languages: Returns a list of available languages for synthesis.
+        - get_voices: Returns a list of available voices for synthesis.
+        - get_models: Returns a list of available models for synthesis.
+        - synthesize: Converts the provided text into speech and returns the audio content.
+        """
+        self.api_key = api_key or os.environ.get("SMALLEST_API_KEY")
+        if not self.api_key:
+            raise TTSError("API key is required")
+        
+        self.opts = TTSOptions(
+            model=model,
+            sample_rate=sample_rate,
+            voice=voice,
+            api_key=self.api_key,
+            add_wav_header=add_wav_header,
+            speed=speed,
+            transliterate=transliterate,
+            remove_extra_silence=remove_extra_silence
+        )
+        
+    def get_languages(self) -> List[str]:
+        """Returns a list of available languages."""
+        return get_smallest_languages()
+    
+    def get_voices(self) -> List[str]:
+        """Returns a list of available voices."""
+        return get_smallest_voices()
+
+    def get_models(self) -> List[str]:
+        """Returns a list of available models."""
+        return get_smallest_models()
+    
+    def synthesize(
+            self,
+            text: str,
+            save_as: Optional[str] = None,
+            **kwargs
+        ) -> Union[bytes, None]:
+        """
+        Synthesize speech from the provided text.
+
+        Args:
+        - text (str): The text to be converted to speech.
+        - save_as (Optional[str]): If provided, the synthesized audio will be saved to this file path. 
+                                   The file must have a .wav extension.
+        - kwargs: Additional optional parameters to override `__init__` options for this call.
+
+        Returns:
+        - Union[bytes, None]: The synthesized audio content in bytes if `save_as` is not specified; 
+                              otherwise, returns None after saving the audio to the specified file.
+
+        Raises:
+        - TTSError: If the provided file name does not have a .wav extension when `save_as` is specified.
+        - APIError: If the API request fails or returns an error.
+        """
+        opts = copy.deepcopy(self.opts)
+        for key, value in kwargs.items():
+            setattr(opts, key, value)
+
+        validate_input(text, opts.voice, opts.model, opts.sample_rate, opts.speed)
+
+        payload = {
+            "text": preprocess_text(text),
+            "sample_rate": opts.sample_rate,
+            "voice_id": opts.voice,
+            "add_wav_header": opts.add_wav_header,
+            "speed": opts.speed,
+            "model": opts.model,
+            "transliterate": opts.transliterate,
+            "remove_extra_silence": opts.remove_extra_silence,
+        }
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        res = requests.post(f"{API_BASE_URL}/{opts.model}/get_speech", json=payload, headers=headers)
+        if res.status_code != 200:
+            raise APIError(f"Failed to synthesize speech: {res.text}. Please check if you have set the correct API key. For more information, visit https://waves.smallest.ai/")
+        
+        audio_content = res.content
+
+        if save_as:
+            if not save_as.endswith(".wav"):
+                raise TTSError("Invalid file name. Extension must be .wav")
+            
+            if self.opts.add_wav_header:
+                with open(save_as, "wb") as wf:
+                    wf.write(audio_content)
+            else:
+                raise TTSError("WAV header is required for saving audio. Set 'add_wav_header=True' to add a WAV header.")
+            return None
+            
+        return audio_content

smallest/utils.py

@@ -0,0 +1,69 @@
+import re
+import io
+import unicodedata
+from typing import List
+from pydub import AudioSegment
+from dataclasses import dataclass
+from sacremoses import MosesPunctNormalizer
+
+from .exceptions import ValidationError
+from .models import TTSModels, TTSLanguages, TTSVoices
+
+
+API_BASE_URL = "https://waves-api.smallest.ai/api/v1"
+SENTENCE_END_REGEX = re.compile(r'.*[-.!?;:…\n]$')
+SAMPLE_WIDTH = 2
+CHANNELS = 1
+
+
+@dataclass
+class TTSOptions:
+    model: TTSModels
+    sample_rate: int
+    voice: TTSVoices
+    api_key: str
+    add_wav_header: bool
+    speed: float
+    transliterate: bool
+    remove_extra_silence: bool
+
+
+def validate_input(text: str, voice: TTSVoices, model: TTSModels, sample_rate: int, speed: float):
+    if not text:
+        raise ValidationError("Text cannot be empty")
+    if voice not in TTSVoices.__args__:
+        raise ValidationError(f"Invalid voice: {voice}")
+    if model not in ['lightning']:
+        raise ValidationError(f"Invalid model: {model}")
+    if not 8000 <= sample_rate <= 48000:
+        raise ValidationError(f"Invalid sample rate: {sample_rate}. Must be between 8000 and 48000")
+    if not 0.5 <= speed <= 2.0:
+        raise ValidationError(f"Invalid speed: {speed}. Must be between 0.5 and 2.0")
+
+
+def add_wav_header(frame_input: bytes, sample_rate: int = 24000, sample_width: int = 2, channels: int = 1) -> bytes:
+        audio = AudioSegment(data=frame_input, sample_width=sample_width, frame_rate=sample_rate, channels=channels)
+        wav_buf = io.BytesIO()
+        audio.export(wav_buf, format="wav")
+        wav_buf.seek(0)
+        return wav_buf.read()
+
+
+def preprocess_text(text: str) -> str:
+    # Replace special characters with their normal form
+    text = unicodedata.normalize('NFKD', text).encode('ASCII', 'ignore').decode('ASCII')
+    text = text.lower()
+    # Normalize punctuation using Moses punct normalizer
+    mpn = MosesPunctNormalizer()
+    text = mpn.normalize(text)
+    return text.strip()
+
+
+def get_smallest_languages() -> List[str]:
+    return list(TTSLanguages.__args__)
+
+def get_smallest_voices() -> List[str]:
+    return list(TTSVoices.__args__)
+
+def get_smallest_models() -> List[str]:
+    return ["lightning"]

smallestai-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 smallest.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

smallestai-0.1.0.dist-info/METADATA

@@ -0,0 +1,246 @@
+Metadata-Version: 2.1
+Name: smallestai
+Version: 0.1.0
+Summary: Official Python client for the Smallest AI API
+Author-email: Smallest <info@smallest.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/smallest-inc/smallest-python-sdk
+Keywords: smallest,smallest.ai,tts,text-to-speech
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: aiofiles
+Requires-Dist: requests
+Requires-Dist: sacremoses
+Requires-Dist: pydub
+Provides-Extra: test
+Requires-Dist: jiwer ; extra == 'test'
+Requires-Dist: httpx ; extra == 'test'
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: pytest-asyncio ; extra == 'test'
+Requires-Dist: deepgram-sdk ; extra == 'test'
+Requires-Dist: python-dotenv ; extra == 'test'
+
+![image](https://i.imgur.com/TJ2tT4g.png)   
+
+
+<div align="center">
+  <a href="https://twitter.com/smallest_AI">
+    <img src="https://img.shields.io/twitter/url/https/twitter.com/smallest_AI.svg?style=social&label=Follow%20smallest_AI" alt="Twitter">
+  </a>
+  <a href="https://discord.gg/ywShEyXHBW">
+    <img src="https://dcbadge.vercel.app/api/server/ywShEyXHBW?style=flat" alt="Discord">
+  </a>
+  <a href="https://www.linkedin.com/company/smallest">
+    <img src="https://img.shields.io/badge/LinkedIn-Connect-blue" alt="Linkedin">
+  </a>
+  <a href="https://www.youtube.com/@smallest_ai">
+    <img src="https://img.shields.io/static/v1?message=smallest_ai&logo=youtube&label=&color=FF0000&logoColor=white&labelColor=&style=for-the-badge" height=20 alt="Youtube">
+  </a>
+</div> 
+
+## Official Python Client for Smallest AI API   
+
+Smallest AI builds high-speed multi-lingual voice models tailored for real-time applications, achieving ultra-realistic audio generation in as fast as ~100 milliseconds for 10 seconds of audio. With this sdk, you can easily convert text into high-quality audio with humanlike expressiveness.
+
+Currently, the library supports direct synthesis and the ability to synthesize streamed LLM output, both synchronously and asynchronously.  
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Get the API Key](#get-the-api-key)
+- [Examples](#examples)
+  - [Sync](#sync)
+  - [Async](#async)
+  - [LLM to Speech](#llm-to-speech)
+- [Available Methods](#available-methods)
+- [Technical Note: WAV Headers in Streaming Audio](#technical-note-wav-headers-in-streaming-audio)
+
+## Installation
+
+To install the package, follow these steps:
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/smallest-inc/smallest-python-sdk.git
+   ```
+
+2. Navigate to the cloned directory and install the package:
+   ```bash
+   cd smallest-python
+   pip install .
+   ```    
+
+## Get the API Key  
+
+1. Visit [waves.smallest.ai](https://waves.smallest.ai/) and sign up for an account or log in if you already have an account.  
+2. Navigate to `API Key` tab in your account dashboard.
+3. Create a new API Key and copy it.
+4. Export the API Key in your environment with the name `SMALLEST_API_KEY`, ensuring that your application can access it securely for authentication.
+
+## Examples
+
+### Sync  
+A synchronous text-to-speech synthesis client. 
+
+**Basic Usage:**   
+```python
+import os
+from smallest import Smallest
+
+def main():
+    client = Smallest(api_key=os.environ.get("SMALLEST_API_KEY"))
+    audio_data = client.synthesize("Hello, this is a test for sync synthesis function.")
+    with open("sync_synthesize.wav", "wb") as f:
+        f.write(audio_data)
+
+if __name__ == "__main__":
+    main()
+```
+
+**Parameters:**   
+- `api_key`: Your API key (can be set via SMALLEST_API_KEY environment variable)
+- `model`: TTS model to use (default: "lightning")
+- `sample_rate`: Audio sample rate (default: 24000)
+- `voice`: Voice ID (default: "emily")
+- `speed`: Speech speed multiplier (default: 1.0)
+- `add_wav_header`: Include WAV header in output (default: True)
+- `transliterate`: Enable text transliteration (default: False)
+- `remove_extra_silence`: Remove additional silence (default: True)
+
+### Async   
+A synchronous text-to-speech synthesis client.    
+
+**Basic Usage:**   
+```python
+import os
+import asyncio
+import aiofiles
+from smallest import AsyncSmallest
+
+client = AsyncSmallest(api_key=os.environ.get("SMALLEST_API_KEY"))
+
+async def main():
+    async with client as tts:
+        audio_bytes = await tts.synthesize("Hello, this is a test of the async synthesis function.")
+        async with aiofiles.open("async_synthesize.wav", "wb") as f:
+            await f.write(audio_bytes)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+**Parameters:**    
+- `api_key`: Your API key (can be set via SMALLEST_API_KEY environment variable)
+- `model`: TTS model to use (default: "lightning")
+- `sample_rate`: Audio sample rate (default: 24000)
+- `voice`: Voice ID (default: "emily")
+- `speed`: Speech speed multiplier (default: 1.0)
+- `add_wav_header`: Include WAV header in output (default: True)
+- `transliterate`: Enable text transliteration (default: False)
+- `remove_extra_silence`: Remove additional silence (default: True)
+
+### LLM to Speech    
+
+The `TextToAudioStream` class provides real-time text-to-speech processing, converting streaming text into audio output with minimal latency. It's particularly useful for applications like voice assistants, live captioning, or interactive chatbots that require immediate audio feedback from text generation. Supports both synchronous and asynchronous TTS instance.
+
+```python
+import os
+import wave
+import asyncio
+from groq import Groq
+from smallest import Smallest
+from smallest import TextToAudioStream
+
+llm = Groq(api_key=os.environ.get("GROQ_API_KEY"))
+tts = Smallest(api_key=os.environ.get("SMALLEST_API_KEY"))
+
+async def generate_text(prompt):
+    """Async generator for streaming text from Groq. You can use any LLM"""
+    completion = llm.chat.completions.create(
+        messages=[
+            {
+                "role": "user",
+                "content": prompt,
+            }
+        ],
+        model="llama3-8b-8192",
+        stream=True,
+    )
+
+    for chunk in completion:
+        text = chunk.choices[0].delta.content
+        if text is not None:
+            yield text
+
+async def save_audio_to_wav(file_path, processor, llm_output):
+    with wave.open(file_path, "wb") as wav_file:
+        wav_file.setnchannels(1)
+        wav_file.setsampwidth(2) 
+        wav_file.setframerate(24000)
+        
+        async for audio_chunk in processor.process(llm_output):
+            wav_file.writeframes(audio_chunk)
+
+async def main():
+    # Initialize the TTS processor with the TTS instance
+    processor = TextToAudioStream(tts_instance=tts)
+    
+    # Generate text asynchronously and process it
+    llm_output = generate_text("Explain text to speech like I am five in 5 sentences.")
+    
+    # As an example, save the generated audio to a WAV file.
+    await save_audio_to_wav("llm_to_speech.wav", processor, llm_output)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+**Parameters:**   
+
+- `tts_instance`: Text-to-speech engine (Smallest or AsyncSmallest)
+- `queue_timeout`: Wait time for new text (seconds, default: 5.0)
+- `max_retries`: Number of retry attempts for failed synthesis (default: 3)
+
+**Output Format:**   
+The processor yields raw audio data chunks without WAV headers for streaming efficiency. These chunks can be:
+
+- Played directly through an audio device
+- Saved to a file
+- Streamed over a network
+- Further processed as needed
+
+
+## Available Methods
+
+```python
+from smallest.tts import Smallest
+
+client = Smallest()
+
+print(f"Avalaible Languages: {client.get_languages()}")
+print(f"Available Voices: {client.get_voices()}")
+print(f"Available Models: {client.get_models()}")
+```
+
+## Technical Note: WAV Headers in Streaming Audio
+
+When implementing audio streaming with chunks of synthesized speech, WAV headers are omitted from individual chunks because:
+
+#### Technical Issues
+- Each WAV header contains metadata about the entire audio file.
+- Multiple headers would make chunks appear as separate audio files and add redundancy.
+- Headers contain file-specific data (like total size) that's invalid for chunks.
+- Sequential playback of chunks with headers causes audio artifacts (pop sounds) when concatenating or playing audio sequentially.
+- Audio players would try to reinitialize audio settings for each chunk.
+
+### Best Practices
+1. Stream raw PCM audio data without headers
+2. Add a single WAV header only when:
+   - Saving the complete stream to a file
+   - Initializing the audio playback system
+   - Converting the stream to a standard audio format

smallestai-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+smallest/__init__.py,sha256=vaoIBml_IobavpVvFazB86iikg2iEy4h3ddxqv_0Fy4,190
+smallest/async_tts.py,sha256=w_SY1Oetn5Zorq-8JXA7lGeRHR3kTtBzqotc_hF0hOQ,6010
+smallest/exceptions.py,sha256=41GLVvNTfRQMQsPLGk0lHuhK2mak8_dVtiFLEtT23Dc,333
+smallest/models.py,sha256=R5UZZA9SibrJ2DsWPi_mkKI13WfyC-MLd-7kptfjns4,390
+smallest/stream_tts.py,sha256=1j4JpAwrAmwprC98mKQwuhXf0HFxFTlMcZ3_JAdcAK0,5416
+smallest/tts.py,sha256=Gr13I-O0qH7EclnR_g29qcpiqITWjgfjCFxFwNxyZrA,5410
+smallest/utils.py,sha256=hAgyEfZEnvayzu8qS4LXhpZR8qK7z4gatLWGVOkS3Yg,2183
+smallestai-0.1.0.dist-info/LICENSE,sha256=kK3HNKhN7luQhkjkNWIvy9_gizbEDUM4mSv_HWq9uuM,1068
+smallestai-0.1.0.dist-info/METADATA,sha256=SFv_JOl8POo4AdpYJV-tgqekj9jz24nf0usA5O1gRvg,8696
+smallestai-0.1.0.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+smallestai-0.1.0.dist-info/top_level.txt,sha256=i5ktbWkG-2aS28vrYTeuhKtA-tY2ZG7SHgLHi87QTLw,9
+smallestai-0.1.0.dist-info/RECORD,,

smallestai-0.1.0.dist-info/WHEEL

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

smallestai-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+smallest