smallestai 3.1.0__tar.gz → 4.0.0__tar.gz

{smallestai-3.1.0/smallestai.egg-info → smallestai-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smallestai
-Version: 3.1.0
+Version: 4.0.0
 Summary: Official Python client for the Smallest AI API
 Author-email: Smallest <support@smallest.ai>
 License: MIT
@@ -16,6 +16,7 @@ Requires-Dist: aiohttp
 Requires-Dist: aiofiles
 Requires-Dist: requests
 Requires-Dist: pydub
+Requires-Dist: websocket-client
 Requires-Dist: urllib3<3.0.0,>=1.25.3
 Requires-Dist: python-dateutil>=2.8.2
 Requires-Dist: pydantic>=2

{smallestai-3.1.0 → smallestai-4.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "smallestai"
-version = "3.1.0"
+version = "4.0.0"
 description = "Official Python client for the Smallest AI API"
 authors = [
     {name = "Smallest", email = "support@smallest.ai"},
@@ -19,6 +19,7 @@ dependencies = [
     "aiofiles",
     "requests",
     "pydub",
+    "websocket-client",
     "urllib3 >= 1.25.3, < 3.0.0",
     "python-dateutil >= 2.8.2",
     "pydantic >= 2",

{smallestai-3.1.0 → smallestai-4.0.0}/smallestai/__init__.py

@@ -84,7 +84,7 @@ from smallestai.atoms import (
 from smallestai.waves import (
     WavesClient,
     AsyncWavesClient,
-    TextToAudioStream
+    WavesStreamingTTS
 )
 
 from smallestai.atoms import __all__ as atoms_all

smallestai-4.0.0/smallestai/waves/__init__.py

@@ -0,0 +1,5 @@
+from smallestai.waves.waves_client import WavesClient
+from smallestai.waves.async_waves_client import AsyncWavesClient
+from smallestai.waves.stream_tts import WavesStreamingTTS, TTSConfig
+
+__all__ = ["WavesClient", "AsyncWavesClient", "WavesStreamingTTS", "TTSConfig"]

{smallestai-3.1.0 → smallestai-4.0.0}/smallestai/waves/async_waves_client.py

@@ -4,10 +4,10 @@ import json
 import aiohttp
 import aiofiles
 import requests
-from typing import Optional, Union, List, AsyncIterator
+from typing import Optional, Union, List
 
 from smallestai.waves.exceptions import TTSError, APIError
-from smallestai.waves.utils import (TTSOptions, validate_input, preprocess_text, add_wav_header, chunk_text,
+from smallestai.waves.utils import (TTSOptions, validate_input,
                      get_smallest_languages, get_smallest_models, ALLOWED_AUDIO_EXTENSIONS, API_BASE_URL)
 
 
@@ -22,7 +22,8 @@ class AsyncWavesClient:
         consistency: Optional[float] = 0.5,
         similarity: Optional[float] = 0.0,
         enhancement: Optional[int] = 1,
-        add_wav_header: Optional[bool] = True
+        language: Optional[str] = "en",
+        output_format: Optional[str] = "wav"
     ) -> None:
         """
         AsyncSmallest Instance for asynchronous text-to-speech synthesis.
@@ -40,7 +41,8 @@ class AsyncWavesClient:
         - consistency (float): This parameter controls word repetition and skipping. Decrease it to prevent skipped words, and increase it to prevent repetition. Only supported in `lightning-large` model. Range - [0, 1]
         - similarity (float): This parameter controls the similarity between the synthesized audio and the reference audio. Increase it to make the speech more similar to the reference audio. Only supported in `lightning-large` model. Range - [0, 1]
         - enhancement (int): Enhances speech quality at the cost of increased latency. Only supported in `lightning-large` model. Range - [0, 2].
-        - add_wav_header (bool): Whether to add a WAV header to the output audio.
+        - language (str): The language for synthesis. Default is "en".
+        - output_format (str): The output audio format. Options: "pcm", "mp3", "wav", "mulaw". Default is "pcm".
 
         Methods:
         - get_languages: Returns a list of available languages for synthesis.
@@ -61,11 +63,12 @@ class AsyncWavesClient:
             sample_rate=sample_rate,
             voice_id=voice_id,
             api_key=self.api_key,
-            add_wav_header=add_wav_header,
             speed=speed,
             consistency=consistency,
             similarity=similarity,
-            enhancement=enhancement
+            enhancement=enhancement,
+            language=language,
+            output_format=output_format
         )
         self.session = None
 
@@ -130,18 +133,14 @@ class AsyncWavesClient:
     async def synthesize(
             self,
             text: str,
-            stream: Optional[bool] = False,
-            save_as: Optional[str] = None,
             **kwargs
-        ) -> Union[bytes, None, AsyncIterator[bytes]]:
+        ) -> Union[bytes]:
         """
         Asynchronously synthesize speech from the provided text.
 
         Args:
         - text (str): The text to be converted to speech.
         - stream (Optional[bool]): If True, returns an iterator yielding audio chunks instead of a full byte array.
-        - 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:
@@ -151,7 +150,7 @@ class AsyncWavesClient:
             - Otherwise, returns the synthesized audio content as bytes.
 
         Raises:
-        - TTSError: If the provided file name does not have a .wav extension when `save_as` is specified.
+        - TTSError: If the provided file name does not have a .wav or .mp3 extension when `save_as` is specified.
         - APIError: If the API request fails or returns an error.
         - ValueError: If an unexpected parameter is passed in `kwargs`.
         """
@@ -172,65 +171,40 @@ class AsyncWavesClient:
             for key, value in kwargs.items():
                 setattr(opts, key, value)
 
-            text = preprocess_text(text)
             validate_input(text, opts.model, opts.sample_rate, opts.speed, opts.consistency, opts.similarity, opts.enhancement)
 
-            self.chunk_size = 250
-            if opts.model == 'lightning-large' or opts.model == "lightning-v2":
-                self.chunk_size = 140
-
-            chunks = chunk_text(text, self.chunk_size)
-
-            async def audio_stream():
-                for chunk in chunks:
-                    payload = {
-                        "text": chunk,
-                        "sample_rate": opts.sample_rate,
-                        "voice_id": opts.voice_id,
-                        "add_wav_header": False,
-                        "speed": opts.speed,
-                        "model": opts.model
-                    }
-                    
-                    if opts.model == "lightning-large" or opts.model == "lightning-v2":
-                        if opts.consistency is not None:
-                            payload["consistency"] = opts.consistency
-                        if opts.similarity is not None:
-                            payload["similarity"] = opts.similarity
-                        if opts.enhancement is not None:
-                            payload["enhancement"] = opts.enhancement
-
-
-                    headers = {
-                        "Authorization": f"Bearer {self.api_key}",
-                        "Content-Type": "application/json",
-                    }
-
-                    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/")
-
-                        yield await res.read()
+            payload = {
+                "text": text,
+                "voice_id": opts.voice_id,
+                "sample_rate": opts.sample_rate,
+                "speed": opts.speed,
+                "consistency": opts.consistency,
+                "similarity": opts.similarity,
+                "enhancement": opts.enhancement,
+                "language": opts.language,
+                "output_format": opts.output_format
+            }
             
-            if stream:
-                return audio_stream()
-
-            audio_content = b"".join([chunk async for chunk in audio_stream()])
-
-            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)
+            if opts.model == "lightning-large" or opts.model == "lightning-v2":
+                if opts.consistency is not None:
+                    payload["consistency"] = opts.consistency
+                if opts.similarity is not None:
+                    payload["similarity"] = opts.similarity
+                if opts.enhancement is not None:
+                    payload["enhancement"] = opts.enhancement
+                    
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            }
 
-            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_bytes = await res.content.read()  
 
+            return audio_bytes
         finally:
             if should_cleanup and self.session:
                 await self.session.close()
@@ -316,9 +290,8 @@ class AsyncWavesClient:
                 if res.status != 200:
                     raise APIError(f"Failed to delete voice: {await res.text()}. For more information, visit https://waves.smallest.ai/")
 
-                return await res.text()
-        
+                return json.dumps(await res.json(), indent=4, ensure_ascii=False)
         finally:
             if should_cleanup and self.session:
                 await self.session.close()
-                self.session = None
+                self.session = None

smallestai-4.0.0/smallestai/waves/stream_tts.py

@@ -0,0 +1,207 @@
+import json
+import base64
+import time
+import threading
+import queue
+from typing import Generator
+from dataclasses import dataclass
+from websocket import WebSocketApp
+
+@dataclass
+class TTSConfig:
+    voice_id: str
+    api_key: str
+    language: str = "en"
+    sample_rate: int = 24000
+    speed: float = 1.0
+    consistency: float = 0.5
+    enhancement: int = 1
+    similarity: float = 0
+    max_buffer_flush_ms: int = 0
+
+class WavesStreamingTTS:
+    def __init__(self, config: TTSConfig):
+        self.config = config
+        self.ws_url = "wss://waves-api.smallest.ai/api/v1/lightning-v2/get_speech/stream"
+        self.ws = None
+        self.audio_queue = queue.Queue()
+        self.error_queue = queue.Queue()
+        self.is_complete = False
+        self.is_connected = False
+        self.request_id = None
+        
+    def _get_headers(self):
+        return [f"Authorization: Bearer {self.config.api_key}"]
+    
+    def _create_payload(self, text: str, continue_stream: bool = False, flush: bool = False):
+        return {
+            "voice_id": self.config.voice_id,
+            "text": text,
+            "language": self.config.language,
+            "sample_rate": self.config.sample_rate,
+            "speed": self.config.speed,
+            "consistency": self.config.consistency,
+            "similarity": self.config.similarity,
+            "enhancement": self.config.enhancement,
+            "max_buffer_flush_ms": self.config.max_buffer_flush_ms,
+            "continue": continue_stream,
+            "flush": flush
+        }
+    
+    def _on_open(self, ws):
+        self.is_connected = True
+        
+    def _on_message(self, ws, message):
+        try:
+            data = json.loads(message)
+            status = data.get("status", "")
+            
+            if status == "error":
+                self.error_queue.put(Exception(data.get("message", "Unknown error")))
+                return
+                
+            if not self.request_id:
+                self.request_id = data.get("request_id")
+                
+            audio_b64 = data.get("data", {}).get("audio")
+            if audio_b64:
+                self.audio_queue.put(base64.b64decode(audio_b64))
+                
+            if status == "complete":
+                self.is_complete = True
+                self.audio_queue.put(None)
+                
+        except Exception as e:
+            self.error_queue.put(e)
+    
+    def _on_error(self, ws, error):
+        self.error_queue.put(error)
+        
+    def _on_close(self, ws, *args):
+        self.is_connected = False
+        if not self.is_complete:
+            self.audio_queue.put(None)
+    
+    def _connect(self):
+        if self.ws:
+            self.ws.close()
+            
+        self.ws = WebSocketApp(
+            self.ws_url,
+            header=self._get_headers(),
+            on_open=self._on_open,
+            on_message=self._on_message,
+            on_error=self._on_error,
+            on_close=self._on_close
+        )
+        
+        ws_thread = threading.Thread(target=self.ws.run_forever)
+        ws_thread.daemon = True
+        ws_thread.start()
+        
+        timeout = 5.0
+        start_time = time.time()
+        while not self.is_connected and time.time() - start_time < timeout:
+            time.sleep(0.1)
+            
+        if not self.is_connected:
+            raise Exception("Failed to connect to WebSocket")
+    
+    def synthesize(self, text: str) -> Generator[bytes, None, None]:
+        self._reset_state()
+        self._connect()
+        
+        payload = self._create_payload(text)
+        self.ws.send(json.dumps(payload))
+        
+        while True:
+            if not self.error_queue.empty():
+                raise self.error_queue.get()
+                
+            try:
+                chunk = self.audio_queue.get(timeout=1.0)
+                if chunk is None:
+                    break
+                yield chunk
+            except queue.Empty:
+                if self.is_complete:
+                    break
+                continue
+                
+        self.ws.close()
+    
+    def synthesize_streaming(self, text_stream: Generator[str, None, None], 
+                           continue_stream: bool = True, 
+                           auto_flush: bool = True) -> Generator[bytes, None, None]:
+        self._reset_state()
+        self._connect()
+        
+        def send_text():
+            try:
+                for text_chunk in text_stream:
+                    if text_chunk.strip():
+                        payload = self._create_payload(text_chunk, continue_stream=continue_stream)
+                        self.ws.send(json.dumps(payload))
+                
+                if auto_flush:
+                    flush_payload = self._create_payload("", flush=True)
+                    self.ws.send(json.dumps(flush_payload))
+            except Exception as e:
+                self.error_queue.put(e)
+        
+        sender_thread = threading.Thread(target=send_text)
+        sender_thread.daemon = True
+        sender_thread.start()
+        
+        while True:
+            if not self.error_queue.empty():
+                raise self.error_queue.get()
+                
+            try:
+                chunk = self.audio_queue.get(timeout=1.0)
+                if chunk is None:
+                    break
+                yield chunk
+            except queue.Empty:
+                if self.is_complete:
+                    break
+                continue
+                
+        self.ws.close()
+    
+    def send_text_chunk(self, text: str, continue_stream: bool = True, flush: bool = False):
+        if not self.is_connected:
+            raise Exception("WebSocket not connected")
+        payload = self._create_payload(text, continue_stream=continue_stream, flush=flush)
+        self.ws.send(json.dumps(payload))
+    
+    def flush_buffer(self):
+        if not self.is_connected:
+            raise Exception("WebSocket not connected")
+        payload = self._create_payload("", flush=True)
+        self.ws.send(json.dumps(payload))
+    
+    def start_streaming_session(self) -> Generator[bytes, None, None]:
+        self._reset_state()
+        self._connect()
+        
+        while True:
+            if not self.error_queue.empty():
+                raise self.error_queue.get()
+                
+            try:
+                chunk = self.audio_queue.get(timeout=0.1)
+                if chunk is None:
+                    break
+                yield chunk
+            except queue.Empty:
+                if self.is_complete:
+                    break
+                continue
+    
+    def _reset_state(self):
+        self.audio_queue = queue.Queue()
+        self.error_queue = queue.Queue()
+        self.is_complete = False
+        self.is_connected = False
+        self.request_id = None

{smallestai-3.1.0 → smallestai-4.0.0}/smallestai/waves/utils.py

@@ -1,8 +1,5 @@
-import re
-import io
 from typing import List
 from typing import Optional
-from pydub import AudioSegment
 from dataclasses import dataclass
 
 from smallestai.waves.exceptions import ValidationError
@@ -10,7 +7,7 @@ from smallestai.waves.models import TTSModels, TTSLanguages_lightning, TTSLangua
 
 
 API_BASE_URL = "https://waves-api.smallest.ai/api/v1"
-SENTENCE_END_REGEX = re.compile(r'.*[-.—!?,;:…।|]$')
+WEBSOCKET_URL = "wss://waves-api.smallest.ai/api/v1/lightning-v2/get_speech/stream"
 SAMPLE_WIDTH = 2
 CHANNELS = 1
 ALLOWED_AUDIO_EXTENSIONS = ['.mp3', '.wav']
@@ -22,11 +19,12 @@ class TTSOptions:
     sample_rate: int
     voice_id: str
     api_key: str
-    add_wav_header: bool
     speed: float
     consistency: float
     similarity: float
     enhancement: int
+    language: str
+    output_format: str
 
 
 def validate_input(text: str, model: str, sample_rate: int, speed: float, consistency: Optional[float] = None, similarity: Optional[float] = None, enhancement: Optional[int] = None):
@@ -46,50 +44,6 @@ def validate_input(text: str, model: str, sample_rate: int, speed: float, consis
         raise ValidationError(f"Invalid enhancement: {enhancement}. Must be between 0 and 2.")
 
 
-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:
-    text = text.replace("\n", " ").replace("\t", " ")
-    text = re.sub(r'\s+', ' ', text)
-    return text.strip()
-
-
-def chunk_text(text: str, chunk_size: int = 250) -> List[str]:
-    chunks = []
-    while text:
-        if len(text) <= chunk_size:
-            chunks.append(text.strip())
-            break
-
-        chunk_text = text[:chunk_size]
-        last_break_index = -1
-
-        # 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
-
-        chunks.append(text[:last_break_index + 1].strip())
-        text = text[last_break_index + 1:].strip()
-
-    return chunks
-
-
 def get_smallest_languages(model: str = 'lightning') -> List[str]:
     if model == 'lightning':
         return TTSLanguages_lightning