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

sarvamai/speech_to_text/raw_client.py

@@ -1,27 +1,26 @@
 # This file was auto-generated by Fern from our API Definition.
 
 import typing
-from ..core.client_wrapper import SyncClientWrapper
+from json.decoder import JSONDecodeError
+
 from .. import core
-from ..types.speech_to_text_model import SpeechToTextModel
-from ..types.speech_to_text_language import SpeechToTextLanguage
-from ..core.request_options import RequestOptions
-from ..core.http_response import HttpResponse
-from ..types.speech_to_text_response import SpeechToTextResponse
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.http_response import AsyncHttpResponse, HttpResponse
 from ..core.pydantic_utilities import parse_obj_as
+from ..core.request_options import RequestOptions
 from ..errors.bad_request_error import BadRequestError
 from ..errors.forbidden_error import ForbiddenError
-from ..errors.unprocessable_entity_error import UnprocessableEntityError
-from ..errors.too_many_requests_error import TooManyRequestsError
 from ..errors.internal_server_error import InternalServerError
 from ..errors.service_unavailable_error import ServiceUnavailableError
+from ..errors.too_many_requests_error import TooManyRequestsError
+from ..errors.unprocessable_entity_error import UnprocessableEntityError
 from ..types.error_message import ErrorMessage
-from json.decoder import JSONDecodeError
-from ..core.api_error import ApiError
+from ..types.speech_to_text_language import SpeechToTextLanguage
+from ..types.speech_to_text_model import SpeechToTextModel
+from ..types.speech_to_text_response import SpeechToTextResponse
 from ..types.speech_to_text_translate_model import SpeechToTextTranslateModel
 from ..types.speech_to_text_translate_response import SpeechToTextTranslateResponse
-from ..core.client_wrapper import AsyncClientWrapper
-from ..core.http_response import AsyncHttpResponse
 
 # this is used as the default value for optional parameters
 OMIT = typing.cast(typing.Any, ...)
@@ -80,6 +79,7 @@ class RawSpeechToTextClient:
         """
         _response = self._client_wrapper.httpx_client.request(
             "speech-to-text",
+            base_url=self._client_wrapper.get_environment().base,
             method="POST",
             data={
                 "model": model,
@@ -90,6 +90,7 @@ class RawSpeechToTextClient:
             },
             request_options=request_options,
             omit=OMIT,
+            force_multipart=True,
         )
         try:
             if 200 <= _response.status_code < 300:
@@ -103,68 +104,74 @@ class RawSpeechToTextClient:
                 return HttpResponse(response=_response, data=_data)
             if _response.status_code == 400:
                 raise BadRequestError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 403:
                 raise ForbiddenError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 422:
                 raise UnprocessableEntityError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 429:
                 raise TooManyRequestsError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 500:
                 raise InternalServerError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 503:
                 raise ServiceUnavailableError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         ErrorMessage,
                         parse_obj_as(
                             type_=ErrorMessage,  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             _response_json = _response.json()
         except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
     def translate(
         self,
@@ -210,6 +217,7 @@ class RawSpeechToTextClient:
         """
         _response = self._client_wrapper.httpx_client.request(
             "speech-to-text-translate",
+            base_url=self._client_wrapper.get_environment().base,
             method="POST",
             data={
                 "prompt": prompt,
@@ -220,6 +228,7 @@ class RawSpeechToTextClient:
             },
             request_options=request_options,
             omit=OMIT,
+            force_multipart=True,
         )
         try:
             if 200 <= _response.status_code < 300:
@@ -233,68 +242,74 @@ class RawSpeechToTextClient:
                 return HttpResponse(response=_response, data=_data)
             if _response.status_code == 400:
                 raise BadRequestError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 403:
                 raise ForbiddenError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 422:
                 raise UnprocessableEntityError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 429:
                 raise TooManyRequestsError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 500:
                 raise InternalServerError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 503:
                 raise ServiceUnavailableError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         ErrorMessage,
                         parse_obj_as(
                             type_=ErrorMessage,  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             _response_json = _response.json()
         except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
 
 class AsyncRawSpeechToTextClient:
@@ -350,6 +365,7 @@ class AsyncRawSpeechToTextClient:
         """
         _response = await self._client_wrapper.httpx_client.request(
             "speech-to-text",
+            base_url=self._client_wrapper.get_environment().base,
             method="POST",
             data={
                 "model": model,
@@ -360,6 +376,7 @@ class AsyncRawSpeechToTextClient:
             },
             request_options=request_options,
             omit=OMIT,
+            force_multipart=True,
         )
         try:
             if 200 <= _response.status_code < 300:
@@ -373,68 +390,74 @@ class AsyncRawSpeechToTextClient:
                 return AsyncHttpResponse(response=_response, data=_data)
             if _response.status_code == 400:
                 raise BadRequestError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 403:
                 raise ForbiddenError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 422:
                 raise UnprocessableEntityError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 429:
                 raise TooManyRequestsError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 500:
                 raise InternalServerError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 503:
                 raise ServiceUnavailableError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         ErrorMessage,
                         parse_obj_as(
                             type_=ErrorMessage,  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             _response_json = _response.json()
         except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
     async def translate(
         self,
@@ -480,6 +503,7 @@ class AsyncRawSpeechToTextClient:
         """
         _response = await self._client_wrapper.httpx_client.request(
             "speech-to-text-translate",
+            base_url=self._client_wrapper.get_environment().base,
             method="POST",
             data={
                 "prompt": prompt,
@@ -490,6 +514,7 @@ class AsyncRawSpeechToTextClient:
             },
             request_options=request_options,
             omit=OMIT,
+            force_multipart=True,
         )
         try:
             if 200 <= _response.status_code < 300:
@@ -503,65 +528,71 @@ class AsyncRawSpeechToTextClient:
                 return AsyncHttpResponse(response=_response, data=_data)
             if _response.status_code == 400:
                 raise BadRequestError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 403:
                 raise ForbiddenError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 422:
                 raise UnprocessableEntityError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 429:
                 raise TooManyRequestsError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 500:
                 raise InternalServerError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         typing.Optional[typing.Any],
                         parse_obj_as(
                             type_=typing.Optional[typing.Any],  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             if _response.status_code == 503:
                 raise ServiceUnavailableError(
-                    typing.cast(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
                         ErrorMessage,
                         parse_obj_as(
                             type_=ErrorMessage,  # type: ignore
                             object_=_response.json(),
                         ),
-                    )
+                    ),
                 )
             _response_json = _response.json()
         except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, body=_response.text)
-        raise ApiError(status_code=_response.status_code, body=_response_json)
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)

sarvamai/speech_to_text_streaming/__init__.py

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

sarvamai/speech_to_text_streaming/client.py

@@ -0,0 +1,189 @@
+# 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 AsyncRawSpeechToTextStreamingClient, RawSpeechToTextStreamingClient
+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 SpeechToTextStreamingClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._raw_client = RawSpeechToTextStreamingClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> RawSpeechToTextStreamingClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawSpeechToTextStreamingClient
+        """
+        return self._raw_client
+
+    @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._raw_client._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._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 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 AsyncSpeechToTextStreamingClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._raw_client = AsyncRawSpeechToTextStreamingClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> AsyncRawSpeechToTextStreamingClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawSpeechToTextStreamingClient
+        """
+        return self._raw_client
+
+    @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._raw_client._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._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 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.",
+            )