sarvamai 0.1.8rc3__tar.gz → 0.1.8rc5__tar.gz

{sarvamai-0.1.8rc3 → sarvamai-0.1.8rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sarvamai
-Version: 0.1.8rc3
+Version: 0.1.8rc5
 Summary: 
 Requires-Python: >=3.8,<4.0
 Classifier: Intended Audience :: Developers

{sarvamai-0.1.8rc3 → sarvamai-0.1.8rc5}/pyproject.toml

@@ -3,7 +3,7 @@ name = "sarvamai"
 
 [tool.poetry]
 name = "sarvamai"
-version = "0.1.8rc3"
+version = "0.1.8rc5"
 description = ""
 readme = "README.md"
 authors = []

{sarvamai-0.1.8rc3 → sarvamai-0.1.8rc5}/src/sarvamai/__init__.py

@@ -16,7 +16,6 @@ from .types import (
     ChatCompletionRequestUserMessage,
     ChatCompletionResponseMessage,
     Choice,
-    CloseConnection,
     CompletionUsage,
     ConfigMessage,
     CreateChatCompletionResponse,
@@ -30,6 +29,7 @@ from .types import (
     ErrorResponseData,
     EventsData,
     FinishReason,
+    FlushSignal,
     Format,
     InitializeConnection,
     InitializeConnectionData,
@@ -110,7 +110,6 @@ from .requests import (
     ChatCompletionRequestUserMessageParams,
     ChatCompletionResponseMessageParams,
     ChoiceParams,
-    CloseConnectionParams,
     CompletionUsageParams,
     ConfigMessageParams,
     CreateChatCompletionResponseParams,
@@ -122,6 +121,7 @@ from .requests import (
     ErrorResponseDataParams,
     ErrorResponseParams,
     EventsDataParams,
+    FlushSignalParams,
     InitializeConnectionDataParams,
     InitializeConnectionParams,
     LanguageIdentificationResponseParams,
@@ -186,8 +186,6 @@ __all__ = [
     "ChatCompletionResponseMessageParams",
     "Choice",
     "ChoiceParams",
-    "CloseConnection",
-    "CloseConnectionParams",
     "CompletionUsage",
     "CompletionUsageParams",
     "ConfigMessage",
@@ -212,6 +210,8 @@ __all__ = [
     "EventsData",
     "EventsDataParams",
     "FinishReason",
+    "FlushSignal",
+    "FlushSignalParams",
     "ForbiddenError",
     "Format",
     "InitializeConnection",

{sarvamai-0.1.8rc3 → sarvamai-0.1.8rc5}/src/sarvamai/core/client_wrapper.py

@@ -17,10 +17,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "sarvamai/0.1.8rc3",
+            "User-Agent": "sarvamai/0.1.8rc5",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "sarvamai",
-            "X-Fern-SDK-Version": "0.1.8rc3",
+            "X-Fern-SDK-Version": "0.1.8rc5",
         }
         headers["api-subscription-key"] = self.api_subscription_key
         return headers

{sarvamai-0.1.8rc3 → sarvamai-0.1.8rc5}/src/sarvamai/requests/__init__.py

@@ -17,7 +17,6 @@ from .chat_completion_request_system_message import ChatCompletionRequestSystemM
 from .chat_completion_request_user_message import ChatCompletionRequestUserMessageParams
 from .chat_completion_response_message import ChatCompletionResponseMessageParams
 from .choice import ChoiceParams
-from .close_connection import CloseConnectionParams
 from .completion_usage import CompletionUsageParams
 from .config_message import ConfigMessageParams
 from .create_chat_completion_response import CreateChatCompletionResponseParams
@@ -29,6 +28,7 @@ from .error_message import ErrorMessageParams
 from .error_response import ErrorResponseParams
 from .error_response_data import ErrorResponseDataParams
 from .events_data import EventsDataParams
+from .flush_signal import FlushSignalParams
 from .initialize_connection import InitializeConnectionParams
 from .initialize_connection_data import InitializeConnectionDataParams
 from .language_identification_response import LanguageIdentificationResponseParams
@@ -64,7 +64,6 @@ __all__ = [
     "ChatCompletionRequestUserMessageParams",
     "ChatCompletionResponseMessageParams",
     "ChoiceParams",
-    "CloseConnectionParams",
     "CompletionUsageParams",
     "ConfigMessageParams",
     "CreateChatCompletionResponseParams",
@@ -76,6 +75,7 @@ __all__ = [
     "ErrorResponseDataParams",
     "ErrorResponseParams",
     "EventsDataParams",
+    "FlushSignalParams",
     "InitializeConnectionDataParams",
     "InitializeConnectionParams",
     "LanguageIdentificationResponseParams",

sarvamai-0.1.8rc3/src/sarvamai/requests/close_connection.py → sarvamai-0.1.8rc5/src/sarvamai/requests/flush_signal.py

@@ -5,5 +5,5 @@ import typing
 import typing_extensions
 
 
-class CloseConnectionParams(typing_extensions.TypedDict):
+class FlushSignalParams(typing_extensions.TypedDict):
     type: typing.Literal["flush"]

sarvamai-0.1.8rc5/src/sarvamai/text_to_speech_streaming/socket_client.py

@@ -0,0 +1,275 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import json
+import typing
+
+import websockets
+import websockets.sync.connection as websockets_sync_connection
+from ..core.events import EventEmitterMixin, EventType
+from ..core.pydantic_utilities import parse_obj_as
+from ..types.audio_output import AudioOutput
+from ..types.flush_signal import FlushSignal
+from ..types.error_response import ErrorResponse
+from ..types.initialize_connection import InitializeConnection
+from ..types.initialize_connection_data import InitializeConnectionData
+from ..types.ping_signal import PingSignal
+from ..types.send_text import SendText
+from ..types.send_text_data import SendTextData
+
+TextToSpeechStreamingSocketClientResponse = typing.Union[AudioOutput, ErrorResponse]
+
+
+class AsyncTextToSpeechStreamingSocketClient(EventEmitterMixin):
+    def __init__(self, *, websocket: websockets.WebSocketClientProtocol):
+        super().__init__()
+        self._websocket = websocket
+
+    async def __aiter__(self):
+        async for message in self._websocket:
+            message = json.loads(message) if isinstance(message, str) else message
+            yield parse_obj_as(TextToSpeechStreamingSocketClientResponse, message)  # type: ignore
+
+    async def start_listening(self):
+        """
+        Start listening for messages on the websocket connection.
+
+        Emits events in the following order:
+        - EventType.OPEN when connection is established
+        - EventType.MESSAGE for each message received
+        - EventType.ERROR if an error occurs
+        - EventType.CLOSE when connection is closed
+        """
+        self._emit(EventType.OPEN, None)
+        try:
+            async for raw_message in self._websocket:
+                raw_message = (
+                    json.loads(raw_message)
+                    if isinstance(raw_message, str)
+                    else raw_message
+                )
+                parsed = parse_obj_as(TextToSpeechStreamingSocketClientResponse, raw_message)  # type: ignore
+                self._emit(EventType.MESSAGE, parsed)
+        except websockets.WebSocketException as exc:
+            self._emit(EventType.ERROR, exc)
+        finally:
+            self._emit(EventType.CLOSE, None)
+
+    async def initialize_connection(
+        self,
+        target_language_code: str,
+        speaker: str,
+        pitch: float = 0.0,
+        pace: float = 1.0,
+        loudness: float = 1.0,
+        speech_sample_rate: int = 22050,
+        enable_preprocessing: bool = False,
+        output_audio_codec: str = "mp3",
+        output_audio_bitrate: str = "128k",
+        min_buffer_size: int = 50,
+        max_chunk_length: int = 150,
+    ) -> None:
+        """
+        Initialize the TTS connection with configuration parameters.
+
+        :param target_language_code: Target language code (e.g., 'hi-IN')
+        :param speaker: Voice speaker name (e.g., 'meera', 'arvind')
+        :param pitch: Voice pitch adjustment (-1.0 to 1.0, default: 0.0)
+        :param pace: Speech pace (0.3 to 3.0, default: 1.0)
+        :param loudness: Voice loudness (0.1 to 3.0, default: 1.0)
+        :param speech_sample_rate: Audio sample rate, default: 22050
+        :param enable_preprocessing: Enable text preprocessing, default: False
+        :param output_audio_codec: Audio codec, default: 'mp3'
+        :param output_audio_bitrate: Audio bitrate, default: '128k'
+        :param min_buffer_size: Minimum buffer size, default: 50
+        :param max_chunk_length: Maximum chunk length, default: 150
+        """
+        data = InitializeConnectionData(
+            target_language_code=target_language_code,
+            speaker=speaker,
+            pitch=pitch,
+            pace=pace,
+            loudness=loudness,
+            speech_sample_rate=speech_sample_rate,
+            enable_preprocessing=enable_preprocessing,
+            output_audio_codec=output_audio_codec,
+            output_audio_bitrate=output_audio_bitrate,
+            min_buffer_size=min_buffer_size,
+            max_chunk_length=max_chunk_length,
+        )
+        message = InitializeConnection(data=data)
+        await self._send_model(message)
+
+    async def convert(self, text: str) -> None:
+        """
+        Send text to be converted to speech.
+
+        :param text: Text to be synthesized (1-2500 characters)
+        """
+        data = SendTextData(text=text)
+        message = SendText(data=data)
+        await self._send_model(message)
+
+    async def flush(self) -> None:
+        """
+        Signal to flush the buffer and finalize audio output.
+        This indicates the end of text input.
+        """
+        message = FlushSignal()
+        await self._send_model(message)
+
+    async def ping(self) -> None:
+        """
+        Send ping signal to keep the WebSocket connection alive.
+        """
+        message = PingSignal()
+        await self._send_model(message)
+
+    async def recv(self) -> TextToSpeechStreamingSocketClientResponse:
+        """
+        Receive a message from the websocket connection.
+        """
+        data = await self._websocket.recv()
+        data = json.loads(data) if isinstance(data, str) else data
+        return parse_obj_as(TextToSpeechStreamingSocketClientResponse, data)  # type: ignore
+
+    async def _send(self, data: typing.Any) -> None:
+        """
+        Send a message to the websocket connection.
+        """
+        if isinstance(data, dict):
+            data = json.dumps(data)
+        await self._websocket.send(data)
+
+    async def _send_model(self, data: typing.Any) -> None:
+        """
+        Send a Pydantic model to the websocket connection.
+        """
+        await self._send(data.dict())
+
+
+class TextToSpeechStreamingSocketClient(EventEmitterMixin):
+    def __init__(self, *, websocket: websockets_sync_connection.Connection):
+        super().__init__()
+        self._websocket = websocket
+
+    def __iter__(self):
+        for message in self._websocket:
+            message = json.loads(message) if isinstance(message, str) else message
+            yield parse_obj_as(TextToSpeechStreamingSocketClientResponse, message)  # type: ignore
+
+    def start_listening(self):
+        """
+        Start listening for messages on the websocket connection.
+
+        Emits events in the following order:
+        - EventType.OPEN when connection is established
+        - EventType.MESSAGE for each message received
+        - EventType.ERROR if an error occurs
+        - EventType.CLOSE when connection is closed
+        """
+        self._emit(EventType.OPEN, None)
+        try:
+            for raw_message in self._websocket:
+                raw_message = (
+                    json.loads(raw_message)
+                    if isinstance(raw_message, str)
+                    else raw_message
+                )
+                parsed = parse_obj_as(TextToSpeechStreamingSocketClientResponse, raw_message)  # type: ignore
+                self._emit(EventType.MESSAGE, parsed)
+        except websockets.WebSocketException as exc:
+            self._emit(EventType.ERROR, exc)
+        finally:
+            self._emit(EventType.CLOSE, None)
+
+    def initialize_connection(
+        self,
+        target_language_code: str,
+        speaker: str,
+        pitch: float = 0.0,
+        pace: float = 1.0,
+        loudness: float = 1.0,
+        speech_sample_rate: int = 22050,
+        enable_preprocessing: bool = False,
+        output_audio_codec: str = "mp3",
+        output_audio_bitrate: str = "128k",
+        min_buffer_size: int = 50,
+        max_chunk_length: int = 150,
+    ) -> None:
+        """
+        Initialize the TTS connection with configuration parameters.
+
+        :param target_language_code: Target language code (e.g., 'hi-IN')
+        :param speaker: Voice speaker name (e.g., 'meera', 'arvind')
+        :param pitch: Voice pitch adjustment (-1.0 to 1.0, default: 0.0)
+        :param pace: Speech pace (0.3 to 3.0, default: 1.0)
+        :param loudness: Voice loudness (0.1 to 3.0, default: 1.0)
+        :param speech_sample_rate: Audio sample rate, default: 22050
+        :param enable_preprocessing: Enable text preprocessing, default: False
+        :param output_audio_codec: Audio codec, default: 'mp3'
+        :param output_audio_bitrate: Audio bitrate, default: '128k'
+        :param min_buffer_size: Minimum buffer size, default: 50
+        :param max_chunk_length: Maximum chunk length, default: 150
+        """
+        data = InitializeConnectionData(
+            target_language_code=target_language_code,
+            speaker=speaker,
+            pitch=pitch,
+            pace=pace,
+            loudness=loudness,
+            speech_sample_rate=speech_sample_rate,
+            enable_preprocessing=enable_preprocessing,
+            output_audio_codec=output_audio_codec,
+            output_audio_bitrate=output_audio_bitrate,
+            min_buffer_size=min_buffer_size,
+            max_chunk_length=max_chunk_length,
+        )
+        message = InitializeConnection(data=data)
+        self._send_model(message)
+
+    def convert(self, text: str) -> None:
+        """
+        Send text to be converted to speech.
+
+        :param text: Text to be synthesized (1-2500 characters)
+        """
+        data = SendTextData(text=text)
+        message = SendText(data=data)
+        self._send_model(message)
+
+    def flush(self) -> None:
+        """
+        Signal to flush the buffer and finalize audio output.
+        This indicates the end of text input.
+        """
+        message = FlushSignal()
+        self._send_model(message)
+
+    def ping(self) -> None:
+        """
+        Send ping signal to keep the WebSocket connection alive.
+        """
+        message = PingSignal()
+        self._send_model(message)
+
+    def recv(self) -> TextToSpeechStreamingSocketClientResponse:
+        """
+        Receive a message from the websocket connection.
+        """
+        data = self._websocket.recv()
+        data = json.loads(data) if isinstance(data, str) else data
+        return parse_obj_as(TextToSpeechStreamingSocketClientResponse, data)  # type: ignore
+
+    def _send(self, data: typing.Any) -> None:
+        """
+        Send a message to the websocket connection.
+        """
+        if isinstance(data, dict):
+            data = json.dumps(data)
+        self._websocket.send(data)
+
+    def _send_model(self, data: typing.Any) -> None:
+        """
+        Send a Pydantic model to the websocket connection.
+        """
+        self._send(data.dict())

{sarvamai-0.1.8rc3 → sarvamai-0.1.8rc5}/src/sarvamai/types/__init__.py

@@ -17,7 +17,6 @@ from .chat_completion_request_system_message import ChatCompletionRequestSystemM
 from .chat_completion_request_user_message import ChatCompletionRequestUserMessage
 from .chat_completion_response_message import ChatCompletionResponseMessage
 from .choice import Choice
-from .close_connection import CloseConnection
 from .completion_usage import CompletionUsage
 from .config_message import ConfigMessage
 from .create_chat_completion_response import CreateChatCompletionResponse
@@ -31,6 +30,7 @@ from .error_response import ErrorResponse
 from .error_response_data import ErrorResponseData
 from .events_data import EventsData
 from .finish_reason import FinishReason
+from .flush_signal import FlushSignal
 from .format import Format
 from .initialize_connection import InitializeConnection
 from .initialize_connection_data import InitializeConnectionData
@@ -92,7 +92,6 @@ __all__ = [
     "ChatCompletionRequestUserMessage",
     "ChatCompletionResponseMessage",
     "Choice",
-    "CloseConnection",
     "CompletionUsage",
     "ConfigMessage",
     "CreateChatCompletionResponse",
@@ -106,6 +105,7 @@ __all__ = [
     "ErrorResponseData",
     "EventsData",
     "FinishReason",
+    "FlushSignal",
     "Format",
     "InitializeConnection",
     "InitializeConnectionData",

sarvamai-0.1.8rc3/src/sarvamai/types/close_connection.py → sarvamai-0.1.8rc5/src/sarvamai/types/flush_signal.py

@@ -6,7 +6,7 @@ import pydantic
 from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
 
 
-class CloseConnection(UniversalBaseModel):
+class FlushSignal(UniversalBaseModel):
     type: typing.Literal["flush"] = "flush"
 
     if IS_PYDANTIC_V2:

sarvamai-0.1.8rc3/src/sarvamai/text_to_speech_streaming/socket_client.py

@@ -1,175 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-import json
-import typing
-
-import websockets
-import websockets.sync.connection as websockets_sync_connection
-from ..core.events import EventEmitterMixin, EventType
-from ..core.pydantic_utilities import parse_obj_as
-from ..types.audio_output import AudioOutput
-from ..types.close_connection import CloseConnection
-from ..types.error_response import ErrorResponse
-from ..types.initialize_connection import InitializeConnection
-from ..types.ping_signal import PingSignal
-from ..types.send_text import SendText
-
-TextToSpeechStreamingSocketClientResponse = typing.Union[AudioOutput, ErrorResponse]
-
-
-class AsyncTextToSpeechStreamingSocketClient(EventEmitterMixin):
-    def __init__(self, *, websocket: websockets.WebSocketClientProtocol):
-        super().__init__()
-        self._websocket = websocket
-
-    async def __aiter__(self):
-        async for message in self._websocket:
-            yield parse_obj_as(TextToSpeechStreamingSocketClientResponse, message)  # type: ignore
-
-    async def start_listening(self):
-        """
-        Start listening for messages on the websocket connection.
-
-        Emits events in the following order:
-        - EventType.OPEN when connection is established
-        - EventType.MESSAGE for each message received
-        - EventType.ERROR if an error occurs
-        - EventType.CLOSE when connection is closed
-        """
-        self._emit(EventType.OPEN, None)
-        try:
-            async for raw_message in self._websocket:
-                parsed = parse_obj_as(TextToSpeechStreamingSocketClientResponse, raw_message)  # type: ignore
-                self._emit(EventType.MESSAGE, parsed)
-        except websockets.WebSocketException as exc:
-            self._emit(EventType.ERROR, exc)
-        finally:
-            self._emit(EventType.CLOSE, None)
-
-    async def send_initialize_connection(self, message: InitializeConnection) -> None:
-        """
-        Send a message to the websocket connection.
-        The message will be sent as a InitializeConnection.
-        """
-        await self._send_model(message)
-
-    async def send_send_text(self, message: SendText) -> None:
-        """
-        Send a message to the websocket connection.
-        The message will be sent as a SendText.
-        """
-        await self._send_model(message)
-
-    async def send_close_connection(self, message: CloseConnection) -> None:
-        """
-        Send a message to the websocket connection.
-        The message will be sent as a CloseConnection.
-        """
-        await self._send_model(message)
-
-    async def send_ping_signal(self, message: PingSignal) -> None:
-        """
-        Send a message to the websocket connection.
-        The message will be sent as a PingSignal.
-        """
-        await self._send_model(message)
-
-    async def recv(self) -> TextToSpeechStreamingSocketClientResponse:
-        """
-        Receive a message from the websocket connection.
-        """
-        data = await self._websocket.recv()
-        return parse_obj_as(TextToSpeechStreamingSocketClientResponse, data)  # type: ignore
-
-    async def _send(self, data: typing.Any) -> None:
-        """
-        Send a message to the websocket connection.
-        """
-        if isinstance(data, dict):
-            data = json.dumps(data)
-        await self._websocket.send(data)
-
-    async def _send_model(self, data: typing.Any) -> None:
-        """
-        Send a Pydantic model to the websocket connection.
-        """
-        await self._send(data.dict())
-
-
-class TextToSpeechStreamingSocketClient(EventEmitterMixin):
-    def __init__(self, *, websocket: websockets_sync_connection.Connection):
-        super().__init__()
-        self._websocket = websocket
-
-    def __iter__(self):
-        for message in self._websocket:
-            yield parse_obj_as(TextToSpeechStreamingSocketClientResponse, message)  # type: ignore
-
-    def start_listening(self):
-        """
-        Start listening for messages on the websocket connection.
-
-        Emits events in the following order:
-        - EventType.OPEN when connection is established
-        - EventType.MESSAGE for each message received
-        - EventType.ERROR if an error occurs
-        - EventType.CLOSE when connection is closed
-        """
-        self._emit(EventType.OPEN, None)
-        try:
-            for raw_message in self._websocket:
-                parsed = parse_obj_as(TextToSpeechStreamingSocketClientResponse, raw_message)  # type: ignore
-                self._emit(EventType.MESSAGE, parsed)
-        except websockets.WebSocketException as exc:
-            self._emit(EventType.ERROR, exc)
-        finally:
-            self._emit(EventType.CLOSE, None)
-
-    def send_initialize_connection(self, message: InitializeConnection) -> None:
-        """
-        Send a message to the websocket connection.
-        The message will be sent as a InitializeConnection.
-        """
-        self._send_model(message)
-
-    def send_send_text(self, message: SendText) -> None:
-        """
-        Send a message to the websocket connection.
-        The message will be sent as a SendText.
-        """
-        self._send_model(message)
-
-    def send_close_connection(self, message: CloseConnection) -> None:
-        """
-        Send a message to the websocket connection.
-        The message will be sent as a CloseConnection.
-        """
-        self._send_model(message)
-
-    def send_ping_signal(self, message: PingSignal) -> None:
-        """
-        Send a message to the websocket connection.
-        The message will be sent as a PingSignal.
-        """
-        self._send_model(message)
-
-    def recv(self) -> TextToSpeechStreamingSocketClientResponse:
-        """
-        Receive a message from the websocket connection.
-        """
-        data = self._websocket.recv()
-        return parse_obj_as(TextToSpeechStreamingSocketClientResponse, data)  # type: ignore
-
-    def _send(self, data: typing.Any) -> None:
-        """
-        Send a message to the websocket connection.
-        """
-        if isinstance(data, dict):
-            data = json.dumps(data)
-        self._websocket.send(data)
-
-    def _send_model(self, data: typing.Any) -> None:
-        """
-        Send a Pydantic model to the websocket connection.
-        """
-        self._send(data.dict())