sarvamai 0.1.5a10__py3-none-any.whl → 0.1.5a13__py3-none-any.whl

sarvamai/speech_to_text_translate_streaming/client.py

@@ -0,0 +1,176 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from contextlib import asynccontextmanager, contextmanager
+
+import httpx
+import websockets
+import websockets.sync.client as websockets_sync_client
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.request_options import RequestOptions
+from .raw_client import AsyncRawSpeechToTextTranslateStreamingClient, RawSpeechToTextTranslateStreamingClient
+from .socket_client import AsyncSpeechToTextTranslateStreamingSocketClient, SpeechToTextTranslateStreamingSocketClient
+from .types.speech_to_text_translate_streaming_model import SpeechToTextTranslateStreamingModel
+
+
+class SpeechToTextTranslateStreamingClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._raw_client = RawSpeechToTextTranslateStreamingClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> RawSpeechToTextTranslateStreamingClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawSpeechToTextTranslateStreamingClient
+        """
+        return self._raw_client
+
+    @contextmanager
+    def connect(
+        self,
+        *,
+        model: typing.Optional[SpeechToTextTranslateStreamingModel] = None,
+        high_vad_sensitivity: typing.Optional[str] = None,
+        vad_signals: typing.Optional[str] = None,
+        api_subscription_key: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.Iterator[SpeechToTextTranslateStreamingSocketClient]:
+        """
+        WebSocket channel for real-time speech to text streaming with English translation
+
+        Parameters
+        ----------
+        model : typing.Optional[SpeechToTextTranslateStreamingModel]
+            Speech to text model to use (defaults to "saaras:v2.5" if not specified)
+
+        high_vad_sensitivity : typing.Optional[str]
+            Enable high VAD (Voice Activity Detection) sensitivity
+
+        vad_signals : typing.Optional[str]
+            Enable VAD signals in response
+
+        api_subscription_key : typing.Optional[str]
+            API subscription key for authentication
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        SpeechToTextTranslateStreamingSocketClient
+        """
+        ws_url = self._raw_client._client_wrapper.get_environment().production + "/speech-to-text-translate/ws"
+        query_params = httpx.QueryParams()
+        if model is not None:
+            query_params = query_params.add("model", model)
+        if high_vad_sensitivity is not None:
+            query_params = query_params.add("high_vad_sensitivity", high_vad_sensitivity)
+        if vad_signals is not None:
+            query_params = query_params.add("vad_signals", vad_signals)
+        ws_url = ws_url + f"?{query_params}"
+        headers = self._raw_client._client_wrapper.get_headers()
+        if api_subscription_key is not None:
+            headers["Api-Subscription-Key"] = str(api_subscription_key)
+        if request_options and "additional_headers" in request_options:
+            headers.update(request_options["additional_headers"])
+        try:
+            with websockets_sync_client.connect(ws_url, additional_headers=headers) as protocol:
+                yield SpeechToTextTranslateStreamingSocketClient(websocket=protocol)
+        except websockets.exceptions.InvalidStatusCode as exc:
+            status_code: int = exc.status_code
+            if status_code == 401:
+                raise ApiError(
+                    status_code=status_code,
+                    headers=dict(headers),
+                    body="Websocket initialized with invalid credentials.",
+                )
+            raise ApiError(
+                status_code=status_code,
+                headers=dict(headers),
+                body="Unexpected error when initializing websocket connection.",
+            )
+
+
+class AsyncSpeechToTextTranslateStreamingClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._raw_client = AsyncRawSpeechToTextTranslateStreamingClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> AsyncRawSpeechToTextTranslateStreamingClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawSpeechToTextTranslateStreamingClient
+        """
+        return self._raw_client
+
+    @asynccontextmanager
+    async def connect(
+        self,
+        *,
+        model: typing.Optional[SpeechToTextTranslateStreamingModel] = None,
+        high_vad_sensitivity: typing.Optional[str] = None,
+        vad_signals: typing.Optional[str] = None,
+        api_subscription_key: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.AsyncIterator[AsyncSpeechToTextTranslateStreamingSocketClient]:
+        """
+        WebSocket channel for real-time speech to text streaming with English translation
+
+        Parameters
+        ----------
+        model : typing.Optional[SpeechToTextTranslateStreamingModel]
+            Speech to text model to use (defaults to "saaras:v2.5" if not specified)
+
+        high_vad_sensitivity : typing.Optional[str]
+            Enable high VAD (Voice Activity Detection) sensitivity
+
+        vad_signals : typing.Optional[str]
+            Enable VAD signals in response
+
+        api_subscription_key : typing.Optional[str]
+            API subscription key for authentication
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncSpeechToTextTranslateStreamingSocketClient
+        """
+        ws_url = self._raw_client._client_wrapper.get_environment().production + "/speech-to-text-translate/ws"
+        query_params = httpx.QueryParams()
+        if model is not None:
+            query_params = query_params.add("model", model)
+        if high_vad_sensitivity is not None:
+            query_params = query_params.add("high_vad_sensitivity", high_vad_sensitivity)
+        if vad_signals is not None:
+            query_params = query_params.add("vad_signals", vad_signals)
+        ws_url = ws_url + f"?{query_params}"
+        headers = self._raw_client._client_wrapper.get_headers()
+        if api_subscription_key is not None:
+            headers["Api-Subscription-Key"] = str(api_subscription_key)
+        if request_options and "additional_headers" in request_options:
+            headers.update(request_options["additional_headers"])
+        try:
+            async with websockets.connect(ws_url, extra_headers=headers) as protocol:
+                yield AsyncSpeechToTextTranslateStreamingSocketClient(websocket=protocol)
+        except websockets.exceptions.InvalidStatusCode as exc:
+            status_code: int = exc.status_code
+            if status_code == 401:
+                raise ApiError(
+                    status_code=status_code,
+                    headers=dict(headers),
+                    body="Websocket initialized with invalid credentials.",
+                )
+            raise ApiError(
+                status_code=status_code,
+                headers=dict(headers),
+                body="Unexpected error when initializing websocket connection.",
+            )

sarvamai/speech_to_text_translate_streaming/raw_client.py

@@ -0,0 +1,153 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from contextlib import asynccontextmanager, contextmanager
+
+import httpx
+import websockets
+import websockets.sync.client as websockets_sync_client
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.request_options import RequestOptions
+from .socket_client import AsyncSpeechToTextTranslateStreamingSocketClient, SpeechToTextTranslateStreamingSocketClient
+from .types.speech_to_text_translate_streaming_model import SpeechToTextTranslateStreamingModel
+
+
+class RawSpeechToTextTranslateStreamingClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    @contextmanager
+    def connect(
+        self,
+        *,
+        model: typing.Optional[SpeechToTextTranslateStreamingModel] = None,
+        high_vad_sensitivity: typing.Optional[str] = None,
+        vad_signals: typing.Optional[str] = None,
+        api_subscription_key: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.Iterator[SpeechToTextTranslateStreamingSocketClient]:
+        """
+        WebSocket channel for real-time speech to text streaming with English translation
+
+        Parameters
+        ----------
+        model : typing.Optional[SpeechToTextTranslateStreamingModel]
+            Speech to text model to use (defaults to "saaras:v2.5" if not specified)
+
+        high_vad_sensitivity : typing.Optional[str]
+            Enable high VAD (Voice Activity Detection) sensitivity
+
+        vad_signals : typing.Optional[str]
+            Enable VAD signals in response
+
+        api_subscription_key : typing.Optional[str]
+            API subscription key for authentication
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        SpeechToTextTranslateStreamingSocketClient
+        """
+        ws_url = self._client_wrapper.get_environment().production + "/speech-to-text-translate/ws"
+        query_params = httpx.QueryParams()
+        if model is not None:
+            query_params = query_params.add("model", model)
+        if high_vad_sensitivity is not None:
+            query_params = query_params.add("high_vad_sensitivity", high_vad_sensitivity)
+        if vad_signals is not None:
+            query_params = query_params.add("vad_signals", vad_signals)
+        ws_url = ws_url + f"?{query_params}"
+        headers = self._client_wrapper.get_headers()
+        if api_subscription_key is not None:
+            headers["Api-Subscription-Key"] = str(api_subscription_key)
+        if request_options and "additional_headers" in request_options:
+            headers.update(request_options["additional_headers"])
+        try:
+            with websockets_sync_client.connect(ws_url, additional_headers=headers) as protocol:
+                yield SpeechToTextTranslateStreamingSocketClient(websocket=protocol)
+        except websockets.exceptions.InvalidStatusCode as exc:
+            status_code: int = exc.status_code
+            if status_code == 401:
+                raise ApiError(
+                    status_code=status_code,
+                    headers=dict(headers),
+                    body="Websocket initialized with invalid credentials.",
+                )
+            raise ApiError(
+                status_code=status_code,
+                headers=dict(headers),
+                body="Unexpected error when initializing websocket connection.",
+            )
+
+
+class AsyncRawSpeechToTextTranslateStreamingClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    @asynccontextmanager
+    async def connect(
+        self,
+        *,
+        model: typing.Optional[SpeechToTextTranslateStreamingModel] = None,
+        high_vad_sensitivity: typing.Optional[str] = None,
+        vad_signals: typing.Optional[str] = None,
+        api_subscription_key: typing.Optional[str] = None,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.AsyncIterator[AsyncSpeechToTextTranslateStreamingSocketClient]:
+        """
+        WebSocket channel for real-time speech to text streaming with English translation
+
+        Parameters
+        ----------
+        model : typing.Optional[SpeechToTextTranslateStreamingModel]
+            Speech to text model to use (defaults to "saaras:v2.5" if not specified)
+
+        high_vad_sensitivity : typing.Optional[str]
+            Enable high VAD (Voice Activity Detection) sensitivity
+
+        vad_signals : typing.Optional[str]
+            Enable VAD signals in response
+
+        api_subscription_key : typing.Optional[str]
+            API subscription key for authentication
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncSpeechToTextTranslateStreamingSocketClient
+        """
+        ws_url = self._client_wrapper.get_environment().production + "/speech-to-text-translate/ws"
+        query_params = httpx.QueryParams()
+        if model is not None:
+            query_params = query_params.add("model", model)
+        if high_vad_sensitivity is not None:
+            query_params = query_params.add("high_vad_sensitivity", high_vad_sensitivity)
+        if vad_signals is not None:
+            query_params = query_params.add("vad_signals", vad_signals)
+        ws_url = ws_url + f"?{query_params}"
+        headers = self._client_wrapper.get_headers()
+        if api_subscription_key is not None:
+            headers["Api-Subscription-Key"] = str(api_subscription_key)
+        if request_options and "additional_headers" in request_options:
+            headers.update(request_options["additional_headers"])
+        try:
+            async with websockets.connect(ws_url, extra_headers=headers) as protocol:
+                yield AsyncSpeechToTextTranslateStreamingSocketClient(websocket=protocol)
+        except websockets.exceptions.InvalidStatusCode as exc:
+            status_code: int = exc.status_code
+            if status_code == 401:
+                raise ApiError(
+                    status_code=status_code,
+                    headers=dict(headers),
+                    body="Websocket initialized with invalid credentials.",
+                )
+            raise ApiError(
+                status_code=status_code,
+                headers=dict(headers),
+                body="Unexpected error when initializing websocket connection.",
+            )

sarvamai/speech_to_text_translate_streaming/socket_client.py

@@ -0,0 +1,191 @@
+# 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_data import AudioData
+from ..types.audio_message import AudioMessage
+from ..types.config_message import ConfigMessage
+from ..types.speech_to_text_translate_streaming_response import SpeechToTextTranslateStreamingResponse
+
+SpeechToTextTranslateStreamingSocketClientResponse = typing.Union[SpeechToTextTranslateStreamingResponse]
+
+
+class AsyncSpeechToTextTranslateStreamingSocketClient(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(SpeechToTextTranslateStreamingSocketClientResponse, 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(SpeechToTextTranslateStreamingSocketClientResponse, 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 translate(self, audio: str, encoding: str = "audio/wav", sample_rate: int = 16000):
+        """
+        Sends audio translation request to the server.
+        :param audio: Base64 encoded audio data
+        :param encoding (Optional): Audio encoding format (default is "audio/wav")
+        :param sample_rate (Optional): Audio sample rate in Hz (default is 16000)
+        """
+        return await self._send_speech_to_text_translate_streaming_audio_message(
+            message=AudioMessage(audio=AudioData(data=audio, encoding=encoding, sample_rate=sample_rate))
+        )
+
+    async def set_prompt(self, prompt: str) -> None:
+        """
+        Set the prompt for the translation.
+        The prompt is useful for detecting hotwords in the audio stream.
+        This will send a ConfigMessage to the websocket connection.
+        """
+        message = ConfigMessage(prompt=prompt)
+        await self._send_config_message(message)
+
+    async def recv(self) -> SpeechToTextTranslateStreamingSocketClientResponse:
+        """
+        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(SpeechToTextTranslateStreamingSocketClientResponse, data)  # type: ignore
+
+    async def _send_speech_to_text_translate_streaming_audio_message(self, message: AudioMessage) -> None:
+        """
+        Send a message to the websocket connection.
+        The message will be sent as a AudioMessage.
+        """
+        await self._send_model(message)
+
+    async def _send_config_message(self, message: ConfigMessage) -> None:
+        """
+        Send a message to the websocket connection.
+        The message will be sent as a ConfigMessage.
+        """
+        await self._send_model(message)
+
+    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 SpeechToTextTranslateStreamingSocketClient(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(SpeechToTextTranslateStreamingSocketClientResponse, 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(SpeechToTextTranslateStreamingSocketClientResponse, 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 translate(self, audio: str, encoding: str = "audio/wav", sample_rate: int = 16000):
+        """
+        Sends audio translation request to the server.
+        :param audio: Base64 encoded audio data
+        :param encoding: Audio encoding format (default is "audio/wav")
+        :param sample_rate: Audio sample rate in Hz (default is 16000)
+        """
+        return self._send_speech_to_text_translate_streaming_audio_message(
+            message=AudioMessage(audio=AudioData(data=audio, encoding=encoding, sample_rate=sample_rate))
+        )
+
+    def set_prompt(self, prompt: str) -> None:
+        """
+        Set the prompt for the translation.
+        The prompt is useful for detecting hotwords in the audio stream.
+        This will send a ConfigMessage to the websocket connection.
+        """
+        message = ConfigMessage(prompt=prompt)
+        self._send_config_message(message)
+
+    def recv(self) -> SpeechToTextTranslateStreamingSocketClientResponse:
+        """
+        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(SpeechToTextTranslateStreamingSocketClientResponse, data)  # type: ignore
+
+    def _send_config_message(self, message: ConfigMessage) -> None:
+        """
+        Send a message to the websocket connection.
+        The message will be sent as a ConfigMessage.
+        """
+        self._send_model(message)
+
+    def _send_speech_to_text_translate_streaming_audio_message(self, message: AudioMessage) -> None:
+        """
+        Send a message to the websocket connection.
+        The message will be sent as a AudioMessage.
+        """
+        self._send_model(message)
+
+    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/speech_to_text_translate_streaming/types/__init__.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+from .speech_to_text_translate_streaming_model import SpeechToTextTranslateStreamingModel
+
+__all__ = ["SpeechToTextTranslateStreamingModel"]

sarvamai/speech_to_text_translate_streaming/types/speech_to_text_translate_streaming_model.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+SpeechToTextTranslateStreamingModel = typing.Union[typing.Literal["saaras:v2.5", "saaras:v2"], typing.Any]

sarvamai/types/__init__.py

@@ -17,6 +17,7 @@ from .chat_completion_request_user_message import ChatCompletionRequestUserMessa
 from .chat_completion_response_message import ChatCompletionResponseMessage
 from .choice import Choice
 from .completion_usage import CompletionUsage
+from .config_message import ConfigMessage
 from .create_chat_completion_response import CreateChatCompletionResponse
 from .diarized_entry import DiarizedEntry
 from .diarized_transcript import DiarizedTranscript
@@ -30,18 +31,22 @@ from .format import Format
 from .language_identification_response import LanguageIdentificationResponse
 from .numerals_format import NumeralsFormat
 from .reasoning_effort import ReasoningEffort
+from .response_type import ResponseType
 from .role import Role
 from .sarvam_model_ids import SarvamModelIds
 from .speech_sample_rate import SpeechSampleRate
 from .speech_to_text_language import SpeechToTextLanguage
 from .speech_to_text_model import SpeechToTextModel
 from .speech_to_text_response import SpeechToTextResponse
+from .speech_to_text_response_data import SpeechToTextResponseData
 from .speech_to_text_streaming_response import SpeechToTextStreamingResponse
-from .speech_to_text_streaming_response_data import SpeechToTextStreamingResponseData
-from .speech_to_text_streaming_response_type import SpeechToTextStreamingResponseType
+from .speech_to_text_transcription_data import SpeechToTextTranscriptionData
 from .speech_to_text_translate_language import SpeechToTextTranslateLanguage
 from .speech_to_text_translate_model import SpeechToTextTranslateModel
 from .speech_to_text_translate_response import SpeechToTextTranslateResponse
+from .speech_to_text_translate_response_data import SpeechToTextTranslateResponseData
+from .speech_to_text_translate_streaming_response import SpeechToTextTranslateStreamingResponse
+from .speech_to_text_translate_transcription_data import SpeechToTextTranslateTranscriptionData
 from .spoken_form_numerals_format import SpokenFormNumeralsFormat
 from .stop_configuration import StopConfiguration
 from .text_to_speech_language import TextToSpeechLanguage
@@ -49,7 +54,6 @@ from .text_to_speech_model import TextToSpeechModel
 from .text_to_speech_response import TextToSpeechResponse
 from .text_to_speech_speaker import TextToSpeechSpeaker
 from .timestamps_model import TimestampsModel
-from .transcription_data import TranscriptionData
 from .transcription_metrics import TranscriptionMetrics
 from .translate_mode import TranslateMode
 from .translate_model import TranslateModel
@@ -76,6 +80,7 @@ __all__ = [
     "ChatCompletionResponseMessage",
     "Choice",
     "CompletionUsage",
+    "ConfigMessage",
     "CreateChatCompletionResponse",
     "DiarizedEntry",
     "DiarizedTranscript",
@@ -89,18 +94,22 @@ __all__ = [
     "LanguageIdentificationResponse",
     "NumeralsFormat",
     "ReasoningEffort",
+    "ResponseType",
     "Role",
     "SarvamModelIds",
     "SpeechSampleRate",
     "SpeechToTextLanguage",
     "SpeechToTextModel",
     "SpeechToTextResponse",
+    "SpeechToTextResponseData",
     "SpeechToTextStreamingResponse",
-    "SpeechToTextStreamingResponseData",
-    "SpeechToTextStreamingResponseType",
+    "SpeechToTextTranscriptionData",
     "SpeechToTextTranslateLanguage",
     "SpeechToTextTranslateModel",
     "SpeechToTextTranslateResponse",
+    "SpeechToTextTranslateResponseData",
+    "SpeechToTextTranslateStreamingResponse",
+    "SpeechToTextTranslateTranscriptionData",
     "SpokenFormNumeralsFormat",
     "StopConfiguration",
     "TextToSpeechLanguage",
@@ -108,7 +117,6 @@ __all__ = [
     "TextToSpeechResponse",
     "TextToSpeechSpeaker",
     "TimestampsModel",
-    "TranscriptionData",
     "TranscriptionMetrics",
     "TranslateMode",
     "TranslateModel",

sarvamai/types/config_message.py

@@ -0,0 +1,27 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class ConfigMessage(UniversalBaseModel):
+    type: typing.Literal["config"] = pydantic.Field(default="config")
+    """
+    Message type identifier for configuration
+    """
+
+    prompt: typing.Optional[str] = pydantic.Field(default=None)
+    """
+    Prompt for ASR model to improve transcription accuracy
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

sarvamai/types/response_type.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+ResponseType = typing.Union[typing.Literal["data", "error", "events"], typing.Any]

sarvamai/types/speech_to_text_response_data.py

@@ -0,0 +1,9 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from .error_data import ErrorData
+from .events_data import EventsData
+from .speech_to_text_transcription_data import SpeechToTextTranscriptionData
+
+SpeechToTextResponseData = typing.Union[SpeechToTextTranscriptionData, ErrorData, EventsData]

sarvamai/types/speech_to_text_streaming_response.py

@@ -4,13 +4,13 @@ import typing
 
 import pydantic
 from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
-from .speech_to_text_streaming_response_data import SpeechToTextStreamingResponseData
-from .speech_to_text_streaming_response_type import SpeechToTextStreamingResponseType
+from .response_type import ResponseType
+from .speech_to_text_response_data import SpeechToTextResponseData
 
 
 class SpeechToTextStreamingResponse(UniversalBaseModel):
-    type: SpeechToTextStreamingResponseType
-    data: SpeechToTextStreamingResponseData
+    type: ResponseType
+    data: SpeechToTextResponseData
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2