sarvamai 0.1.5a6__py3-none-any.whl → 0.1.5a8__py3-none-any.whl

sarvamai/speech_to_text_streaming/raw_client.py

@@ -0,0 +1,166 @@
+# 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 AsyncSpeechToTextStreamingSocketClient, SpeechToTextStreamingSocketClient
+from .types.speech_to_text_streaming_language_code import SpeechToTextStreamingLanguageCode
+from .types.speech_to_text_streaming_model import SpeechToTextStreamingModel
+
+
+class RawSpeechToTextStreamingClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    @contextmanager
+    def connect(
+        self,
+        *,
+        language_code: SpeechToTextStreamingLanguageCode,
+        model: SpeechToTextStreamingModel,
+        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[SpeechToTextStreamingSocketClient]:
+        """
+        WebSocket channel for real-time speech to text streaming
+
+        Parameters
+        ----------
+        language_code : SpeechToTextStreamingLanguageCode
+            Language code for speech recognition
+
+        model : SpeechToTextStreamingModel
+            Speech to text model to use
+
+        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
+        -------
+        SpeechToTextStreamingSocketClient
+        """
+        ws_url = self._client_wrapper.get_environment().production + "/speech-to-text/ws"
+        query_params = httpx.QueryParams()
+        if language_code is not None:
+            query_params = query_params.add("language-code", language_code)
+        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 SpeechToTextStreamingSocketClient(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 AsyncRawSpeechToTextStreamingClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    @asynccontextmanager
+    async def connect(
+        self,
+        *,
+        language_code: SpeechToTextStreamingLanguageCode,
+        model: SpeechToTextStreamingModel,
+        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[AsyncSpeechToTextStreamingSocketClient]:
+        """
+        WebSocket channel for real-time speech to text streaming
+
+        Parameters
+        ----------
+        language_code : SpeechToTextStreamingLanguageCode
+            Language code for speech recognition
+
+        model : SpeechToTextStreamingModel
+            Speech to text model to use
+
+        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
+        -------
+        AsyncSpeechToTextStreamingSocketClient
+        """
+        ws_url = self._client_wrapper.get_environment().production + "/speech-to-text/ws"
+        query_params = httpx.QueryParams()
+        if language_code is not None:
+            query_params = query_params.add("language-code", language_code)
+        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 AsyncSpeechToTextStreamingSocketClient(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_streaming/socket_client.py

@@ -0,0 +1,133 @@
+# 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_message import AudioMessage
+from ..types.speech_to_text_streaming_response import SpeechToTextStreamingResponse
+
+SpeechToTextStreamingSocketClientResponse = typing.Union[SpeechToTextStreamingResponse]
+
+
+class AsyncSpeechToTextStreamingSocketClient(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(SpeechToTextStreamingSocketClientResponse, 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(SpeechToTextStreamingSocketClientResponse, 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_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 recv(self) -> SpeechToTextStreamingSocketClientResponse:
+        """
+        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(SpeechToTextStreamingSocketClientResponse, 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 SpeechToTextStreamingSocketClient(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(SpeechToTextStreamingSocketClientResponse, 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(SpeechToTextStreamingSocketClientResponse, 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_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 recv(self) -> SpeechToTextStreamingSocketClientResponse:
+        """
+        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(SpeechToTextStreamingSocketClientResponse, 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/speech_to_text_streaming/types/__init__.py

@@ -0,0 +1,8 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+from .speech_to_text_streaming_language_code import SpeechToTextStreamingLanguageCode
+from .speech_to_text_streaming_model import SpeechToTextStreamingModel
+
+__all__ = ["SpeechToTextStreamingLanguageCode", "SpeechToTextStreamingModel"]

sarvamai/speech_to_text_streaming/types/speech_to_text_streaming_language_code.py

@@ -0,0 +1,8 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+SpeechToTextStreamingLanguageCode = typing.Union[
+    typing.Literal["en-IN", "hi-IN", "bn-IN", "gu-IN", "kn-IN", "ml-IN", "mr-IN", "od-IN", "pa-IN", "ta-IN", "te-IN"],
+    typing.Any,
+]

sarvamai/speech_to_text_streaming/types/speech_to_text_streaming_model.py

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

sarvamai/text/__init__.py

@@ -1,2 +1,4 @@
 # This file was auto-generated by Fern from our API Definition.
 
+# isort: skip_file
+

sarvamai/text/client.py

@@ -1,24 +1,23 @@
 # This file was auto-generated by Fern from our API Definition.
 
 import typing
-from ..core.client_wrapper import SyncClientWrapper
-from .raw_client import RawTextClient
-from ..types.translate_source_language import TranslateSourceLanguage
-from ..types.translate_target_language import TranslateTargetLanguage
-from ..types.translate_speaker_gender import TranslateSpeakerGender
+
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.request_options import RequestOptions
+from ..types.language_identification_response import LanguageIdentificationResponse
+from ..types.numerals_format import NumeralsFormat
+from ..types.spoken_form_numerals_format import SpokenFormNumeralsFormat
 from ..types.translate_mode import TranslateMode
 from ..types.translate_model import TranslateModel
-from ..types.transliterate_mode import TransliterateMode
-from ..types.numerals_format import NumeralsFormat
-from ..core.request_options import RequestOptions
+from ..types.translate_source_language import TranslateSourceLanguage
+from ..types.translate_speaker_gender import TranslateSpeakerGender
+from ..types.translate_target_language import TranslateTargetLanguage
 from ..types.translation_response import TranslationResponse
-from ..types.language_identification_response import LanguageIdentificationResponse
-from ..types.transliterate_source_language import TransliterateSourceLanguage
 from ..types.translatiterate_target_language import TranslatiterateTargetLanguage
-from ..types.spoken_form_numerals_format import SpokenFormNumeralsFormat
+from ..types.transliterate_mode import TransliterateMode
+from ..types.transliterate_source_language import TransliterateSourceLanguage
 from ..types.transliteration_response import TransliterationResponse
-from ..core.client_wrapper import AsyncClientWrapper
-from .raw_client import AsyncRawTextClient
+from .raw_client import AsyncRawTextClient, RawTextClient
 
 # this is used as the default value for optional parameters
 OMIT = typing.cast(typing.Any, ...)
@@ -180,7 +179,7 @@ class TextClient:
             target_language_code="bn-IN",
         )
         """
-        response = self._raw_client.translate(
+        _response = self._raw_client.translate(
             input=input,
             source_language_code=source_language_code,
             target_language_code=target_language_code,
@@ -192,7 +191,7 @@ class TextClient:
             numerals_format=numerals_format,
             request_options=request_options,
         )
-        return response.data
+        return _response.data
 
     def identify_language(
         self, *, input: str, request_options: typing.Optional[RequestOptions] = None
@@ -224,8 +223,8 @@ class TextClient:
             input="input",
         )
         """
-        response = self._raw_client.identify_language(input=input, request_options=request_options)
-        return response.data
+        _response = self._raw_client.identify_language(input=input, request_options=request_options)
+        return _response.data
 
     def transliterate(
         self,
@@ -336,7 +335,7 @@ class TextClient:
             target_language_code="bn-IN",
         )
         """
-        response = self._raw_client.transliterate(
+        _response = self._raw_client.transliterate(
             input=input,
             source_language_code=source_language_code,
             target_language_code=target_language_code,
@@ -345,7 +344,7 @@ class TextClient:
             spoken_form=spoken_form,
             request_options=request_options,
         )
-        return response.data
+        return _response.data
 
 
 class AsyncTextClient:
@@ -512,7 +511,7 @@ class AsyncTextClient:
 
         asyncio.run(main())
         """
-        response = await self._raw_client.translate(
+        _response = await self._raw_client.translate(
             input=input,
             source_language_code=source_language_code,
             target_language_code=target_language_code,
@@ -524,7 +523,7 @@ class AsyncTextClient:
             numerals_format=numerals_format,
             request_options=request_options,
         )
-        return response.data
+        return _response.data
 
     async def identify_language(
         self, *, input: str, request_options: typing.Optional[RequestOptions] = None
@@ -564,8 +563,8 @@ class AsyncTextClient:
 
         asyncio.run(main())
         """
-        response = await self._raw_client.identify_language(input=input, request_options=request_options)
-        return response.data
+        _response = await self._raw_client.identify_language(input=input, request_options=request_options)
+        return _response.data
 
     async def transliterate(
         self,
@@ -684,7 +683,7 @@ class AsyncTextClient:
 
         asyncio.run(main())
         """
-        response = await self._raw_client.transliterate(
+        _response = await self._raw_client.transliterate(
             input=input,
             source_language_code=source_language_code,
             target_language_code=target_language_code,
@@ -693,4 +692,4 @@ class AsyncTextClient:
             spoken_form=spoken_form,
             request_options=request_options,
         )
-        return response.data
+        return _response.data