smallestai 1.3.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

smallest/async_tts.py

@@ -1,22 +1,23 @@
 import os
 import copy
+import json
 import aiohttp
 import aiofiles
+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, add_wav_header, split_into_chunks,
-                     get_smallest_languages, get_smallest_voices, get_smallest_models, SENTENCE_END_REGEX, API_BASE_URL)
+from smallest.exceptions import TTSError, APIError
+from smallest.utils import (TTSOptions, validate_input, preprocess_text, add_wav_header, chunk_text,
+                     get_smallest_languages, 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",
+        api_key: str = None,
+        model: Optional[str] = "lightning",
+        sample_rate: Optional[int] = 24000,
+        voice_id: Optional[str] = "emily",
         speed: Optional[float] = 1.0,
         add_wav_header: Optional[bool] = True,
         transliterate: Optional[bool] = False,
@@ -25,15 +26,15 @@ class AsyncSmallest:
         """
         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 
+        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.
+        - voice_id (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.
@@ -49,11 +50,11 @@ class AsyncSmallest:
         if not self.api_key:
             raise TTSError()
         self.chunk_size = 250
-        
+
         self.opts = TTSOptions(
             model=model,
             sample_rate=sample_rate,
-            voice=voice,
+            voice_id=voice_id,
             api_key=self.api_key,
             add_wav_header=add_wav_header,
             speed=speed,
@@ -61,29 +62,65 @@ class AsyncSmallest:
             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()
 
 
+    async def _ensure_session(self):
+        """Ensure session exists for direct calls"""
+        if not self.session:
+            self.session = aiohttp.ClientSession()
+            return True
+        return False
+    
+
     def get_languages(self) -> List[str]:
         """Returns a list of available languages."""
         return get_smallest_languages()
+
+    def get_cloned_voices(self) -> str:
+        """Returns a list of your cloned voices."""
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        res = requests.request("GET", f"{API_BASE_URL}/lightning-large/get_cloned_voices", headers=headers)
+        if res.status_code != 200:
+            raise APIError(f"Failed to get cloned voices: {res.text}. For more information, visit https://waves.smallest.ai/")
+        
+        return json.dumps(res.json(), indent=4, ensure_ascii=False)
     
-    def get_voices(self) -> List[str]:
+
+    def get_voices(
+            self,
+            model: Optional[str] = "lightning"
+        ) -> str:
         """Returns a list of available voices."""
-        return get_smallest_voices()
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        res = requests.request("GET", f"{API_BASE_URL}/{model}/get_voices", headers=headers)
+        if res.status_code != 200:
+            raise APIError(f"Failed to get voices: {res.text}. For more information, visit https://waves.smallest.ai/")
+        
+        return json.dumps(res.json(), indent=4, ensure_ascii=False)
+
 
     def get_models(self) -> List[str]:
         """Returns a list of available models."""
         return get_smallest_models()
-    
+
+
     async def synthesize(
             self,
             text: str,
@@ -95,62 +132,129 @@ class AsyncSmallest:
 
         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. 
+        - 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; 
+        - 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)
-        chunks = split_into_chunks(text)
-        audio_content = b""
-
-        for chunk in chunks:
-            payload = {
-                "text": preprocess_text(chunk),
-                "sample_rate": opts.sample_rate,
-                "voice_id": opts.voice,
-                "add_wav_header": False,
-                "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()
+        should_cleanup = await self._ensure_session()
+
+        try:
+            opts = copy.deepcopy(self.opts)
+            for key, value in kwargs.items():
+                setattr(opts, key, value)
+
+            validate_input(preprocess_text(text), opts.model, opts.sample_rate, opts.speed)
+
+            self.chunk_size = 250
+            if opts.model == 'ligtning-large':
+                self.chunk_size = 140
+
+            chunks = chunk_text(text, self.chunk_size)
+            audio_content = b""
+
+            for chunk in chunks:
+                payload = {
+                    "text": preprocess_text(chunk),
+                    "sample_rate": opts.sample_rate,
+                    "voice_id": opts.voice_id,
+                    "add_wav_header": False,
+                    "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")
+
+                async with aiofiles.open(save_as, mode='wb') as f:
+                    await f.write(add_wav_header(audio_content, opts.sample_rate))
+
+                return None
+
+            if opts.add_wav_header:
+                return add_wav_header(audio_content, opts.sample_rate)
+
+            return audio_content
         
-            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()
+        finally:
+            if should_cleanup and self.session:
+                await self.session.close()
+                self.session = None
+
+
+    async def add_voice(self, display_name: str, file_path: str) -> str:
+        """
+        Instantly clone your voice asynchronously.
+
+        Args:
+        - display_name (str): The display name for the new voice.
+        - file_path (str): The path to the reference audio file to be cloned.
 
-        if save_as:
-            if not save_as.endswith(".wav"):
-                raise TTSError("Invalid file name. Extension must be .wav")
+        Returns:
+        - str: The response from the API as a formatted JSON string.
+
+        Raises:
+        - TTSError: If the file does not exist or is not a valid audio file.
+        - APIError: If the API request fails or returns an error.
+        """
+        url = f"{API_BASE_URL}/lightning-large/add_voice"
+
+        if not os.path.exists(file_path):
+            raise TTSError("Invalid file path. File does not exist.")
+
+        ALLOWED_AUDIO_EXTENSIONS = ['.mp3', '.wav']
+        file_extension = os.path.splitext(file_path)[1].lower()
+        if file_extension not in ALLOWED_AUDIO_EXTENSIONS:
+            raise TTSError(f"Invalid file type. Supported formats are: {ALLOWED_AUDIO_EXTENSIONS}")
+
+        headers = {
+            'Authorization': f"Bearer {self.api_key}",
+        }
+
+        should_cleanup = await self._ensure_session()
+
+        try:
+            async with aiofiles.open(file_path, 'rb') as f:
+                file_data = await f.read()
+
+            data = aiohttp.FormData()
+            content_type = file_extension[1:]
             
-            async with aiofiles.open(save_as, mode='wb') as f:
-                await f.write(add_wav_header(audio_content, self.opts.sample_rate))
+            data.add_field('displayName', display_name)
+            data.add_field('file', file_data, filename=file_path, content_type=f"audio/{content_type}")
 
-            return None
+            async with self.session.post(url, headers=headers, data=data) as res:
+                if res.status != 200:
+                    raise APIError(f"Failed to add voice: {await res.text()}. For more information, visit https://waves.smallest.ai/")
 
-        if opts.add_wav_header:
-            return add_wav_header(audio_content, self.opts.sample_rate)
+                return json.dumps(await res.json(), indent=4, ensure_ascii=False)
         
-        return audio_content
+        finally:
+            if should_cleanup and self.session:
+                await self.session.close()
+                self.session = None
+

smallest/models.py

@@ -1,7 +1,5 @@
-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"]
+TTSLanguages = ["en", "hi"]
+TTSModels = [
+    "lightning", 
+    "lightning-large"
+]

smallest/stream_tts.py

@@ -3,17 +3,17 @@ 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
+from smallest.tts import Smallest
+from smallest.exceptions import APIError
+from smallest.async_tts import AsyncSmallest
+from smallest.utils import SENTENCE_END_REGEX
 
 class TextToAudioStream:
     def __init__(
         self,
         tts_instance: Union[Smallest, AsyncSmallest],
-        queue_timeout: float = 5.0,
-        max_retries: int = 3
+        queue_timeout: Optional[float] = 5.0,
+        max_retries: Optional[int] = 3
     ):
         """
         A real-time text-to-speech processor that converts streaming text into audio output.
@@ -35,7 +35,6 @@ class TextToAudioStream:
         """
         self.tts_instance = tts_instance
         self.tts_instance.opts.add_wav_header = False
-
         self.sentence_end_regex = SENTENCE_END_REGEX
         self.queue_timeout = queue_timeout
         self.max_retries = max_retries
@@ -43,6 +42,9 @@ class TextToAudioStream:
         self.buffer_size = 250
         self.stop_flag = False
 
+        if self.tts_instance.opts.model == 'lightning-large':
+            self.buffer_size = 140
+
 
     async def _stream_llm_output(self, llm_output: AsyncGenerator[str, None]) -> None:
         """
@@ -58,51 +60,46 @@ class TextToAudioStream:
         async for chunk in llm_output:
             buffer += chunk
             i = 0
-
             while i < len(buffer):
                 current_chunk = buffer[:i + 1]
                 if self.sentence_end_regex.match(current_chunk):
                     last_break_index = i
-
                 if len(current_chunk) >= self.buffer_size:
                     if last_break_index > 0:
-                        self.queue.put(buffer[:last_break_index + 1].replace("—", " ").strip())
+                        self.queue.put(f'{buffer[:last_break_index + 1].replace("—", " ").strip()} ')
                         buffer = buffer[last_break_index + 1:] 
                     else:
                         # No sentence boundary, split at max chunk size
-                        self.queue.put(buffer[:self.buffer_size].replace("—", " ").strip())
+                        self.queue.put(f'{buffer[:self.buffer_size].replace("—", " ").strip()} ')
                         buffer = buffer[self.buffer_size:] 
-
                     last_break_index = 0
                     i = -1 
-
                 i += 1
-
+                
         if buffer:
-            self.queue.put(buffer.replace("—", " ").strip())
-
-        self.stop_flag = True  # completion flag when LLM output ends
+            self.queue.put(f'{buffer.replace("—", " ").strip()} ')
+        self.stop_flag = True
 
 
-    async def _synthesize_async(self, sentence: str, retries: int = 0) -> Optional[bytes]:
-        """Asynchronously synthesizes a given sentence."""
+    def _synthesize_sync(self, sentence: str, retries: int = 0) -> Optional[bytes]:
+        """Synchronously synthesizes a given sentence."""
         try:
-            return await self.tts_instance.synthesize(sentence)
+            return self.tts_instance.synthesize(sentence)
         except APIError as e:
             if retries < self.max_retries:
-                return await self._synthesize_async(sentence, retries + 1)
+                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
+            
 
-
-    def _synthesize_sync(self, sentence: str, retries: int = 0) -> Optional[bytes]:
-        """Synchronously synthesizes a given sentence."""
+    async def _synthesize_async(self, sentence: str, retries: int = 0) -> Optional[bytes]:
+        """Asynchronously synthesizes a given sentence."""
         try:
-            return self.tts_instance.synthesize(sentence)
+            return await self.tts_instance.synthesize(sentence)
         except APIError as e:
             if retries < self.max_retries:
-                return self._synthesize_sync(sentence, retries + 1)
+                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

smallest/tts.py

@@ -1,21 +1,21 @@
 import os
+import json
 import wave
 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, add_wav_header, split_into_chunks,
-get_smallest_languages, get_smallest_voices, get_smallest_models, SENTENCE_END_REGEX, API_BASE_URL)
+from smallest.exceptions import TTSError, APIError
+from smallest.utils import (TTSOptions, validate_input, preprocess_text, add_wav_header, chunk_text,
+get_smallest_languages, 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",
+        api_key: str = None,
+        model: Optional[str] = "lightning",
+        sample_rate: Optional[int] = 24000,
+        voice_id: Optional[str] = "emily",
         speed: Optional[float] = 1.0,
         add_wav_header: Optional[bool] = True,
         transliterate: Optional[bool] = False,
@@ -31,7 +31,7 @@ class Smallest:
         - 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.
+        - voice_id (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.
@@ -52,7 +52,7 @@ class Smallest:
         self.opts = TTSOptions(
             model=model,
             sample_rate=sample_rate,
-            voice=voice,
+            voice_id=voice_id,
             api_key=self.api_key,
             add_wav_header=add_wav_header,
             speed=speed,
@@ -65,14 +65,40 @@ class Smallest:
         """Returns a list of available languages."""
         return get_smallest_languages()
     
-    def get_voices(self) -> List[str]:
+    def get_cloned_voices(self) -> str:
+        """Returns a list of your cloned voices."""
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        res = requests.request("GET", f"{API_BASE_URL}/lightning-large/get_cloned_voices", headers=headers)
+        if res.status_code != 200:
+            raise APIError(f"Failed to get cloned voices: {res.text}. For more information, visit https://waves.smallest.ai/")
+        
+        return json.dumps(res.json(), indent=4, ensure_ascii=False)
+    
+
+    def get_voices(
+            self,
+            model: Optional[str] = "lightning"
+        ) -> str:
         """Returns a list of available voices."""
-        return get_smallest_voices()
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        res = requests.request("GET", f"{API_BASE_URL}/{model}/get_voices", headers=headers)
+        if res.status_code != 200:
+            raise APIError(f"Failed to get voices: {res.text}. For more information, visit https://waves.smallest.ai/")
+        
+        return json.dumps(res.json(), indent=4, ensure_ascii=False)
+    
 
     def get_models(self) -> List[str]:
         """Returns a list of available models."""
         return get_smallest_models()
     
+    
     def synthesize(
             self,
             text: str,
@@ -100,16 +126,20 @@ class Smallest:
         for key, value in kwargs.items():
             setattr(opts, key, value)
 
-        validate_input(text, opts.voice, opts.model, opts.sample_rate, opts.speed)
+        validate_input(preprocess_text(text), opts.model, opts.sample_rate, opts.speed)
+
+        self.chunk_size = 250
+        if opts.model == "lightning-large":
+            self.chunk_size = 140
 
-        chunks = split_into_chunks(text)
+        chunks = chunk_text(text, self.chunk_size)
         audio_content = b""
 
         for chunk in chunks:
             payload = {
                 "text": preprocess_text(chunk),
                 "sample_rate": opts.sample_rate,
-                "voice_id": opts.voice,
+                "voice_id": opts.voice_id,
                 "add_wav_header": False,
                 "speed": opts.speed,
                 "model": opts.model,
@@ -128,11 +158,6 @@ class Smallest:
             
             audio_content += res.content
 
-
-        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/")
-
         if save_as:
             if not save_as.endswith(".wav"):
                 raise TTSError("Invalid file name. Extension must be .wav")
@@ -140,11 +165,50 @@ class Smallest:
             with wave.open(save_as, "wb") as wf:
                 wf.setnchannels(1)
                 wf.setsampwidth(2)
-                wf.setframerate(self.opts.sample_rate)
+                wf.setframerate(opts.sample_rate)
                 wf.writeframes(audio_content)
             return None
         
-        if self.opts.add_wav_header:
-            return add_wav_header(audio_content, self.opts.sample_rate)
+        if opts.add_wav_header:
+            return add_wav_header(audio_content, opts.sample_rate)
     
         return audio_content
+    
+    
+    def add_voice(self, display_name: str, file_path: str) -> str:
+        """
+        Instantly clone your voice synchronously.
+
+        Args:
+        - display_name (str): The display name for the new voice.
+        - file_path (str): The path to the reference audio file to be cloned.
+
+        Returns:
+        - str: The response from the API as a formatted JSON string.
+
+        Raises:
+        - TTSError: If the file does not exist or is not a valid audio file.
+        - APIError: If the API request fails or returns an error.
+        """
+        if not os.path.isfile(file_path):
+            raise TTSError("Invalid file path. File does not exist.")
+        
+        ALLOWED_AUDIO_EXTENSIONS = ['.mp3', '.wav']
+        file_extension = os.path.splitext(file_path)[1].lower()
+        if file_extension not in ALLOWED_AUDIO_EXTENSIONS:
+            raise TTSError(f"Invalid file type. Supported formats are: {ALLOWED_AUDIO_EXTENSIONS}")
+        
+        url = f"{API_BASE_URL}/lightning-large/add_voice"
+        payload = {'displayName': display_name}
+
+        files = [('file', (os.path.basename(file_path), open(file_path, 'rb'), 'audio/wav'))]
+
+        headers = {
+            'Authorization': f"Bearer {self.api_key}",
+        }
+
+        response = requests.post(url, headers=headers, data=payload, files=files)
+        if response.status_code != 200:
+            raise APIError(f"Failed to add voice: {response.text}. For more information, visit https://waves.smallest.ai/")
+        
+        return json.dumps(response.json(), indent=4, ensure_ascii=False)

smallest/utils.py

@@ -1,27 +1,26 @@
 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
+from smallest.exceptions import ValidationError
+from smallest.models import TTSModels, TTSLanguages
 
 
 API_BASE_URL = "https://waves-api.smallest.ai/api/v1"
-SENTENCE_END_REGEX = re.compile(r'.*[-.—!?;:…\n]$')
-CHUNK_SIZE = 250
+SENTENCE_END_REGEX = re.compile(r'.*[-.—!?,;:…।|]$')
+mpn = MosesPunctNormalizer()
 SAMPLE_WIDTH = 2
 CHANNELS = 1
 
 
 @dataclass
 class TTSOptions:
-    model: TTSModels
+    model: str
     sample_rate: int
-    voice: TTSVoices
+    voice_id: str
     api_key: str
     add_wav_header: bool
     speed: float
@@ -29,15 +28,13 @@ class TTSOptions:
     remove_extra_silence: bool
 
 
-def validate_input(text: str, voice: TTSVoices, model: TTSModels, sample_rate: int, speed: float):
+def validate_input(text: str, model: str, 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")
+        raise ValidationError("Text cannot be empty.")
+    if model not in TTSModels:
+        raise ValidationError(f"Invalid model: {model}. Must be one of {TTSModels}")
+    if not 8000 <= sample_rate <= 24000:
+        raise ValidationError(f"Invalid sample rate: {sample_rate}. Must be between 8000 and 24000")
     if not 0.5 <= speed <= 2.0:
         raise ValidationError(f"Invalid speed: {speed}. Must be between 0.5 and 2.0")
 
@@ -51,65 +48,49 @@ def add_wav_header(frame_input: bytes, sample_rate: int = 24000, sample_width: i
 
 
 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()
-    text = text.replace("—", " ")
-    # Normalize punctuation using Moses punct normalizer
-    mpn = MosesPunctNormalizer()
+    text = text.replace("\n", " ").replace("\t", " ").replace("—", " ").replace("-", " ").replace("–", " ")
+    text = re.sub(r'\s+', ' ', text)
     text = mpn.normalize(text)
     return text.strip()
 
-def split_into_chunks(text: str) -> List[str]:
-        """
-        Splits the input text into chunks based on sentence boundaries 
-        defined by SENTENCE_END_REGEX and the maximum chunk size.
-        """
-        chunks = []
-        current_chunk = ""
-        last_break_index = 0
-
-        i = 0
-        while i < len(text):
-            current_chunk += text[i]
-
-            # Check for sentence boundary using regex
-            if SENTENCE_END_REGEX.match(current_chunk):
-                last_break_index = i
 
-            if len(current_chunk) >= CHUNK_SIZE:
-                if last_break_index > 0:
-                    # Split at the last valid sentence boundary
-                    chunk = text[:last_break_index + 1].strip()
-                    chunk = chunk.replace("—", " ")
-                    chunks.append(chunk)
-
-                    text = text[last_break_index + 1:]
-                    i = -1  # Reset index to process the remaining text
-                    current_chunk = ""
-                    last_break_index = 0
-                else:
-                    # No sentence boundary found, split at max length
-                    current_chunk = current_chunk.replace("—", " ")
-                    chunks.append(current_chunk.strip())
-                    text = text[CHUNK_SIZE:]
-                    i = -1  # Reset index to process the remaining text
-                    current_chunk = ""
-
-            i += 1
-
-        if text:
-            text = text.replace("—", " ")
+def chunk_text(text: str, chunk_size: int = 250) -> List[str]:
+    """
+    Splits the input text into chunks based on sentence boundaries
+    defined by SENTENCE_END_REGEX and the maximum chunk size.
+    Only splits at valid sentence boundaries to avoid breaking words.
+    """
+    chunks = []
+    while text:
+        if len(text) <= chunk_size:
             chunks.append(text.strip())
+            break
+
+        chunk_text = text[:chunk_size]
+        last_break_index = -1
 
-        return chunks
+        # Find last sentence boundary using regex
+        for i in range(len(chunk_text) - 1, -1, -1):
+            if SENTENCE_END_REGEX.match(chunk_text[:i + 1]):
+                last_break_index = i
+                break
 
+        if last_break_index == -1:
+            # Fallback to space if no sentence boundary found
+            last_space = chunk_text.rfind(' ')
+            if last_space != -1:
+                last_break_index = last_space 
+            else:
+                last_break_index = chunk_size - 1
 
-def get_smallest_languages() -> List[str]:
-    return list(TTSLanguages.__args__)
+        chunks.append(text[:last_break_index + 1].strip())
+        text = text[last_break_index + 1:].strip()
 
-def get_smallest_voices() -> List[str]:
-    return list(TTSVoices.__args__)
+    return chunks
+
+
+def get_smallest_languages() -> List[str]:
+    return TTSLanguages
 
 def get_smallest_models() -> List[str]:
-    return ["lightning"]
+    return TTSModels

{smallestai-1.3.3.dist-info → smallestai-2.0.0.dist-info}/METADATA

@@ -1,8 +1,8 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: smallestai
-Version: 1.3.3
+Version: 2.0.0
 Summary: Official Python client for the Smallest AI API
-Author-email: Smallest <info@smallest.ai>
+Author-email: Smallest <support@smallest.ai>
 License: MIT
 Project-URL: Homepage, https://github.com/smallest-inc/smallest-python-sdk
 Keywords: smallest,smallest.ai,tts,text-to-speech
@@ -53,10 +53,14 @@ Currently, the library supports direct synthesis and the ability to synthesize s
 
 - [Installation](#installation)
 - [Get the API Key](#get-the-api-key)
+- [Best Practices for Input Text](#best-practices-for-input-text)
 - [Examples](#examples)
-  - [Sync](#sync)
-  - [Async](#async)
+  - [Synchronous](#Synchronous)
+  - [Aynchronous](#Synchronous)
   - [LLM to Speech](#llm-to-speech)
+  - [Add your Voice](#add-your-voice)
+    - [Synchronously](#synchronously)
+    - [Asynchronously](#asynchronously)
 - [Available Methods](#available-methods)
 - [Technical Note: WAV Headers in Streaming Audio](#technical-note-wav-headers-in-streaming-audio)
 
@@ -76,19 +80,30 @@ When using an SDK in your application, make sure to pin to at least the major ve
 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.
 
+## Best Practices for Input Text
+While the `transliterate` parameter is provided, please note that it is not fully supported and may not perform consistently across all cases. It is recommended to use the model without relying on this parameter.
+
+For optimal voice generation results:
+
+1. For English, provide the input in Latin script (e.g., "Hello, how are you?").
+2. For Hindi, provide the input in Devanagari script (e.g., "नमस्ते, आप कैसे हैं?").
+3. For code-mixed input, use Latin script for English and Devanagari script for Hindi (e.g., "Hello, आप कैसे हैं?").
+
 ## Examples
 
-### Sync  
+### Synchronous  
 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"))
-    client.synthesize("Hello, this is a test for sync synthesis function.", save_as="sync_synthesize.wav")
+    client = Smallest(api_key="SMALLEST_API_KEY")
+    client.synthesize(
+        text="Hello, this is a test for sync synthesis function.",
+        save_as="sync_synthesize.wav"
+    )
 
 if __name__ == "__main__":
     main()
@@ -98,7 +113,7 @@ if __name__ == "__main__":
 - `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")
+- `voice_id`: 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)
@@ -117,17 +132,16 @@ client.synthesize(
 ```
 
 
-### Async   
+### Asynchronous   
 Asynchronous 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"))
+client = AsyncSmallest(api_key="SMALLEST_API_KEY")
 
 async def main():
     async with client as tts:
@@ -143,7 +157,7 @@ if __name__ == "__main__":
 - `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")
+- `voice_id`: 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)
@@ -162,18 +176,16 @@ audio_bytes = await tts.synthesize(
 
 ### 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.
+The `TextToAudioStream` class provides real-time text-to-speech processing, converting streaming text into audio output. 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
+from smallest import Smallest, TextToAudioStream
 
-llm = Groq(api_key=os.environ.get("GROQ_API_KEY"))
-tts = Smallest(api_key=os.environ.get("SMALLEST_API_KEY"))
+llm = Groq(api_key="GROQ_API_KEY")
+tts = Smallest(api_key="SMALLEST_API_KEY")
 
 async def generate_text(prompt):
     """Async generator for streaming text from Groq. You can use any LLM"""
@@ -230,16 +242,46 @@ The processor yields raw audio data chunks without WAV headers for streaming eff
 - Streamed over a network
 - Further processed as needed
 
+## Add your Voice   
+The Smallest AI SDK allows you to clone your voice by uploading an audio file. This feature is available both synchronously and asynchronously, making it flexible for different use cases. Below are examples of how to use this functionality.  
+
+### Synchronously
+```python
+from smallest import Smallest
+
+def main():
+    client = Smallest(api_key="YOUR_API_KEY")
+    res = client.add_voice(display_name="My Voice", file_path="my_voice.wav")
+    print(res)
+
+if __name__ == "__main__":
+    main()
+```  
+
+### Asynchronously
+```python
+import asyncio
+from smallest import AsyncSmallest
+
+async def main():
+    client = AsyncSmallest(api_key="YOUR_API_KEY")
+    res = await client.add_voice(display_name="My Voice", file_path="my_voice.wav")
+    print(res)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
 
 ## Available Methods
 
 ```python
-from smallest.tts import Smallest
+from smallest import Smallest
 
-client = Smallest()
+client = Smallest(api_key="SMALLEST_API_KEY")
 
-print(f"Avalaible Languages: {client.get_languages()}")
-print(f"Available Voices: {client.get_voices()}")
+print(f"Available Languages: {client.get_languages()}")
+print(f"Available Voices: {client.get_voices(model='lightning')}")
+print(f"Available Voices: {client.get_cloned_voices()}")
 print(f"Available Models: {client.get_models()}")
 ```
 
@@ -254,7 +296,7 @@ When implementing audio streaming with chunks of synthesized speech, WAV headers
 - 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
+### Best Practices for Audio Streaming
 1. Stream raw PCM audio data without headers
 2. Add a single WAV header only when:
    - Saving the complete stream to a file

smallestai-2.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+smallest/__init__.py,sha256=vaoIBml_IobavpVvFazB86iikg2iEy4h3ddxqv_0Fy4,190
+smallest/async_tts.py,sha256=5qW7owlMeSWFx0rpn9dYfbO76mmNY0DXcytNjLfbbz8,9727
+smallest/exceptions.py,sha256=nY6I8fCXe2By54CytQ0-i3hFiYtt8TYAKj0g6OYsCjc,585
+smallest/models.py,sha256=g2e_4nU5P48vyXZandKLWqZC1TkoEGeLvYKqJIqurSI,83
+smallest/stream_tts.py,sha256=SeP9A9zXJWiV62Eezv0L1J5sRIR304Llc_mwVtOOSUI,6348
+smallest/tts.py,sha256=xBBEk_byRPGT6SYkE6qvhfEupgHl6XBdAqtxmzw2rF8,8311
+smallest/utils.py,sha256=FCZkvbbHJBoN0jpBSqmt1hJjvks56t8i82we4XnqjYk,3016
+smallestai-2.0.0.dist-info/LICENSE,sha256=kK3HNKhN7luQhkjkNWIvy9_gizbEDUM4mSv_HWq9uuM,1068
+smallestai-2.0.0.dist-info/METADATA,sha256=EIyZZqzAvHgQ7jfEs5x5LUx3HjzoCUhzJoXfkb3CuoI,11538
+smallestai-2.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+smallestai-2.0.0.dist-info/top_level.txt,sha256=i5ktbWkG-2aS28vrYTeuhKtA-tY2ZG7SHgLHi87QTLw,9
+smallestai-2.0.0.dist-info/RECORD,,

{smallestai-1.3.3.dist-info → smallestai-2.0.0.dist-info}/WHEEL

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

smallestai-1.3.3.dist-info/RECORD

@@ -1,12 +0,0 @@
-smallest/__init__.py,sha256=vaoIBml_IobavpVvFazB86iikg2iEy4h3ddxqv_0Fy4,190
-smallest/async_tts.py,sha256=ReYTePzR0e3UcWxwnetGnwO4q_F7g2LRZPxIVfmgB4Y,6120
-smallest/exceptions.py,sha256=nY6I8fCXe2By54CytQ0-i3hFiYtt8TYAKj0g6OYsCjc,585
-smallest/models.py,sha256=R5UZZA9SibrJ2DsWPi_mkKI13WfyC-MLd-7kptfjns4,390
-smallest/stream_tts.py,sha256=0OypcUzgP7CN3VGcGJDnQ2FDw2JOzPaSQ1cXK69k5dY,6198
-smallest/tts.py,sha256=l8VHaOE8-Feg3Ey8C3osOrLs3ffYz0q_J1ACiEtZ8y0,5999
-smallest/utils.py,sha256=hrta82o-rJRaOHTVKqHqC86_T56jAuvqJHIizAEqFok,3796
-smallestai-1.3.3.dist-info/LICENSE,sha256=kK3HNKhN7luQhkjkNWIvy9_gizbEDUM4mSv_HWq9uuM,1068
-smallestai-1.3.3.dist-info/METADATA,sha256=ji7TsSt2C9_GGNjRuh8DAyBXipVRuFeouLoGi76JFAU,9856
-smallestai-1.3.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-smallestai-1.3.3.dist-info/top_level.txt,sha256=i5ktbWkG-2aS28vrYTeuhKtA-tY2ZG7SHgLHi87QTLw,9
-smallestai-1.3.3.dist-info/RECORD,,