sarvamai 0.1.22a3__py3-none-any.whl → 0.1.23a1__py3-none-any.whl

sarvamai/chat/raw_client.py

@@ -146,9 +146,9 @@ class RawChatClient:
                 raise BadRequestError(
                     headers=dict(_response.headers),
                     body=typing.cast(
-                        typing.Optional[typing.Any],
+                        typing.Any,
                         parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
+                            type_=typing.Any,  # type: ignore
                             object_=_response.json(),
                         ),
                     ),
@@ -157,9 +157,9 @@ class RawChatClient:
                 raise ForbiddenError(
                     headers=dict(_response.headers),
                     body=typing.cast(
-                        typing.Optional[typing.Any],
+                        typing.Any,
                         parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
+                            type_=typing.Any,  # type: ignore
                             object_=_response.json(),
                         ),
                     ),
@@ -168,9 +168,9 @@ class RawChatClient:
                 raise UnprocessableEntityError(
                     headers=dict(_response.headers),
                     body=typing.cast(
-                        typing.Optional[typing.Any],
+                        typing.Any,
                         parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
+                            type_=typing.Any,  # type: ignore
                             object_=_response.json(),
                         ),
                     ),
@@ -179,9 +179,9 @@ class RawChatClient:
                 raise TooManyRequestsError(
                     headers=dict(_response.headers),
                     body=typing.cast(
-                        typing.Optional[typing.Any],
+                        typing.Any,
                         parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
+                            type_=typing.Any,  # type: ignore
                             object_=_response.json(),
                         ),
                     ),
@@ -190,9 +190,9 @@ class RawChatClient:
                 raise InternalServerError(
                     headers=dict(_response.headers),
                     body=typing.cast(
-                        typing.Optional[typing.Any],
+                        typing.Any,
                         parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
+                            type_=typing.Any,  # type: ignore
                             object_=_response.json(),
                         ),
                     ),
@@ -326,9 +326,9 @@ class AsyncRawChatClient:
                 raise BadRequestError(
                     headers=dict(_response.headers),
                     body=typing.cast(
-                        typing.Optional[typing.Any],
+                        typing.Any,
                         parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
+                            type_=typing.Any,  # type: ignore
                             object_=_response.json(),
                         ),
                     ),
@@ -337,9 +337,9 @@ class AsyncRawChatClient:
                 raise ForbiddenError(
                     headers=dict(_response.headers),
                     body=typing.cast(
-                        typing.Optional[typing.Any],
+                        typing.Any,
                         parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
+                            type_=typing.Any,  # type: ignore
                             object_=_response.json(),
                         ),
                     ),
@@ -348,9 +348,9 @@ class AsyncRawChatClient:
                 raise UnprocessableEntityError(
                     headers=dict(_response.headers),
                     body=typing.cast(
-                        typing.Optional[typing.Any],
+                        typing.Any,
                         parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
+                            type_=typing.Any,  # type: ignore
                             object_=_response.json(),
                         ),
                     ),
@@ -359,9 +359,9 @@ class AsyncRawChatClient:
                 raise TooManyRequestsError(
                     headers=dict(_response.headers),
                     body=typing.cast(
-                        typing.Optional[typing.Any],
+                        typing.Any,
                         parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
+                            type_=typing.Any,  # type: ignore
                             object_=_response.json(),
                         ),
                     ),
@@ -370,9 +370,9 @@ class AsyncRawChatClient:
                 raise InternalServerError(
                     headers=dict(_response.headers),
                     body=typing.cast(
-                        typing.Optional[typing.Any],
+                        typing.Any,
                         parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
+                            type_=typing.Any,  # type: ignore
                             object_=_response.json(),
                         ),
                     ),

sarvamai/client.py

@@ -1,24 +1,28 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from __future__ import annotations
+
 import os
 import typing
 
 import httpx
-from .chat.client import AsyncChatClient, ChatClient
 from .core.api_error import ApiError
 from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from .environment import SarvamAIEnvironment
-from .speech_to_text.client import AsyncSpeechToTextClient, SpeechToTextClient
-from .speech_to_text_job.client import AsyncSpeechToTextJobClient, SpeechToTextJobClient
-from .speech_to_text_streaming.client import AsyncSpeechToTextStreamingClient, SpeechToTextStreamingClient
-from .speech_to_text_translate_job.client import AsyncSpeechToTextTranslateJobClient, SpeechToTextTranslateJobClient
-from .speech_to_text_translate_streaming.client import (
-    AsyncSpeechToTextTranslateStreamingClient,
-    SpeechToTextTranslateStreamingClient,
-)
-from .text.client import AsyncTextClient, TextClient
-from .text_to_speech.client import AsyncTextToSpeechClient, TextToSpeechClient
-from .text_to_speech_streaming.client import AsyncTextToSpeechStreamingClient, TextToSpeechStreamingClient
+
+if typing.TYPE_CHECKING:
+    from .chat.client import AsyncChatClient, ChatClient
+    from .speech_to_text.client import AsyncSpeechToTextClient, SpeechToTextClient
+    from .speech_to_text_job.client import AsyncSpeechToTextJobClient, SpeechToTextJobClient
+    from .speech_to_text_streaming.client import AsyncSpeechToTextStreamingClient, SpeechToTextStreamingClient
+    from .speech_to_text_translate_job.client import AsyncSpeechToTextTranslateJobClient, SpeechToTextTranslateJobClient
+    from .speech_to_text_translate_streaming.client import (
+        AsyncSpeechToTextTranslateStreamingClient,
+        SpeechToTextTranslateStreamingClient,
+    )
+    from .text.client import AsyncTextClient, TextClient
+    from .text_to_speech.client import AsyncTextToSpeechClient, TextToSpeechClient
+    from .text_to_speech_streaming.client import AsyncTextToSpeechStreamingClient, TextToSpeechStreamingClient
 
 
 class SarvamAI:
@@ -86,17 +90,89 @@ class SarvamAI:
             else httpx.Client(timeout=_defaulted_timeout),
             timeout=_defaulted_timeout,
         )
-        self.text = TextClient(client_wrapper=self._client_wrapper)
-        self.speech_to_text = SpeechToTextClient(client_wrapper=self._client_wrapper)
-        self.text_to_speech = TextToSpeechClient(client_wrapper=self._client_wrapper)
-        self.chat = ChatClient(client_wrapper=self._client_wrapper)
-        self.speech_to_text_job = SpeechToTextJobClient(client_wrapper=self._client_wrapper)
-        self.speech_to_text_translate_job = SpeechToTextTranslateJobClient(client_wrapper=self._client_wrapper)
-        self.speech_to_text_streaming = SpeechToTextStreamingClient(client_wrapper=self._client_wrapper)
-        self.speech_to_text_translate_streaming = SpeechToTextTranslateStreamingClient(
-            client_wrapper=self._client_wrapper
-        )
-        self.text_to_speech_streaming = TextToSpeechStreamingClient(client_wrapper=self._client_wrapper)
+        self._text: typing.Optional[TextClient] = None
+        self._speech_to_text: typing.Optional[SpeechToTextClient] = None
+        self._text_to_speech: typing.Optional[TextToSpeechClient] = None
+        self._chat: typing.Optional[ChatClient] = None
+        self._speech_to_text_job: typing.Optional[SpeechToTextJobClient] = None
+        self._speech_to_text_translate_job: typing.Optional[SpeechToTextTranslateJobClient] = None
+        self._speech_to_text_streaming: typing.Optional[SpeechToTextStreamingClient] = None
+        self._speech_to_text_translate_streaming: typing.Optional[SpeechToTextTranslateStreamingClient] = None
+        self._text_to_speech_streaming: typing.Optional[TextToSpeechStreamingClient] = None
+
+    @property
+    def text(self):
+        if self._text is None:
+            from .text.client import TextClient  # noqa: E402
+
+            self._text = TextClient(client_wrapper=self._client_wrapper)
+        return self._text
+
+    @property
+    def speech_to_text(self):
+        if self._speech_to_text is None:
+            from .speech_to_text.client import SpeechToTextClient  # noqa: E402
+
+            self._speech_to_text = SpeechToTextClient(client_wrapper=self._client_wrapper)
+        return self._speech_to_text
+
+    @property
+    def text_to_speech(self):
+        if self._text_to_speech is None:
+            from .text_to_speech.client import TextToSpeechClient  # noqa: E402
+
+            self._text_to_speech = TextToSpeechClient(client_wrapper=self._client_wrapper)
+        return self._text_to_speech
+
+    @property
+    def chat(self):
+        if self._chat is None:
+            from .chat.client import ChatClient  # noqa: E402
+
+            self._chat = ChatClient(client_wrapper=self._client_wrapper)
+        return self._chat
+
+    @property
+    def speech_to_text_job(self):
+        if self._speech_to_text_job is None:
+            from .speech_to_text_job.client import SpeechToTextJobClient  # noqa: E402
+
+            self._speech_to_text_job = SpeechToTextJobClient(client_wrapper=self._client_wrapper)
+        return self._speech_to_text_job
+
+    @property
+    def speech_to_text_translate_job(self):
+        if self._speech_to_text_translate_job is None:
+            from .speech_to_text_translate_job.client import SpeechToTextTranslateJobClient  # noqa: E402
+
+            self._speech_to_text_translate_job = SpeechToTextTranslateJobClient(client_wrapper=self._client_wrapper)
+        return self._speech_to_text_translate_job
+
+    @property
+    def speech_to_text_streaming(self):
+        if self._speech_to_text_streaming is None:
+            from .speech_to_text_streaming.client import SpeechToTextStreamingClient  # noqa: E402
+
+            self._speech_to_text_streaming = SpeechToTextStreamingClient(client_wrapper=self._client_wrapper)
+        return self._speech_to_text_streaming
+
+    @property
+    def speech_to_text_translate_streaming(self):
+        if self._speech_to_text_translate_streaming is None:
+            from .speech_to_text_translate_streaming.client import SpeechToTextTranslateStreamingClient  # noqa: E402
+
+            self._speech_to_text_translate_streaming = SpeechToTextTranslateStreamingClient(
+                client_wrapper=self._client_wrapper
+            )
+        return self._speech_to_text_translate_streaming
+
+    @property
+    def text_to_speech_streaming(self):
+        if self._text_to_speech_streaming is None:
+            from .text_to_speech_streaming.client import TextToSpeechStreamingClient  # noqa: E402
+
+            self._text_to_speech_streaming = TextToSpeechStreamingClient(client_wrapper=self._client_wrapper)
+        return self._text_to_speech_streaming
 
 
 class AsyncSarvamAI:
@@ -164,14 +240,90 @@ class AsyncSarvamAI:
             else httpx.AsyncClient(timeout=_defaulted_timeout),
             timeout=_defaulted_timeout,
         )
-        self.text = AsyncTextClient(client_wrapper=self._client_wrapper)
-        self.speech_to_text = AsyncSpeechToTextClient(client_wrapper=self._client_wrapper)
-        self.text_to_speech = AsyncTextToSpeechClient(client_wrapper=self._client_wrapper)
-        self.chat = AsyncChatClient(client_wrapper=self._client_wrapper)
-        self.speech_to_text_job = AsyncSpeechToTextJobClient(client_wrapper=self._client_wrapper)
-        self.speech_to_text_translate_job = AsyncSpeechToTextTranslateJobClient(client_wrapper=self._client_wrapper)
-        self.speech_to_text_streaming = AsyncSpeechToTextStreamingClient(client_wrapper=self._client_wrapper)
-        self.speech_to_text_translate_streaming = AsyncSpeechToTextTranslateStreamingClient(
-            client_wrapper=self._client_wrapper
-        )
-        self.text_to_speech_streaming = AsyncTextToSpeechStreamingClient(client_wrapper=self._client_wrapper)
+        self._text: typing.Optional[AsyncTextClient] = None
+        self._speech_to_text: typing.Optional[AsyncSpeechToTextClient] = None
+        self._text_to_speech: typing.Optional[AsyncTextToSpeechClient] = None
+        self._chat: typing.Optional[AsyncChatClient] = None
+        self._speech_to_text_job: typing.Optional[AsyncSpeechToTextJobClient] = None
+        self._speech_to_text_translate_job: typing.Optional[AsyncSpeechToTextTranslateJobClient] = None
+        self._speech_to_text_streaming: typing.Optional[AsyncSpeechToTextStreamingClient] = None
+        self._speech_to_text_translate_streaming: typing.Optional[AsyncSpeechToTextTranslateStreamingClient] = None
+        self._text_to_speech_streaming: typing.Optional[AsyncTextToSpeechStreamingClient] = None
+
+    @property
+    def text(self):
+        if self._text is None:
+            from .text.client import AsyncTextClient  # noqa: E402
+
+            self._text = AsyncTextClient(client_wrapper=self._client_wrapper)
+        return self._text
+
+    @property
+    def speech_to_text(self):
+        if self._speech_to_text is None:
+            from .speech_to_text.client import AsyncSpeechToTextClient  # noqa: E402
+
+            self._speech_to_text = AsyncSpeechToTextClient(client_wrapper=self._client_wrapper)
+        return self._speech_to_text
+
+    @property
+    def text_to_speech(self):
+        if self._text_to_speech is None:
+            from .text_to_speech.client import AsyncTextToSpeechClient  # noqa: E402
+
+            self._text_to_speech = AsyncTextToSpeechClient(client_wrapper=self._client_wrapper)
+        return self._text_to_speech
+
+    @property
+    def chat(self):
+        if self._chat is None:
+            from .chat.client import AsyncChatClient  # noqa: E402
+
+            self._chat = AsyncChatClient(client_wrapper=self._client_wrapper)
+        return self._chat
+
+    @property
+    def speech_to_text_job(self):
+        if self._speech_to_text_job is None:
+            from .speech_to_text_job.client import AsyncSpeechToTextJobClient  # noqa: E402
+
+            self._speech_to_text_job = AsyncSpeechToTextJobClient(client_wrapper=self._client_wrapper)
+        return self._speech_to_text_job
+
+    @property
+    def speech_to_text_translate_job(self):
+        if self._speech_to_text_translate_job is None:
+            from .speech_to_text_translate_job.client import AsyncSpeechToTextTranslateJobClient  # noqa: E402
+
+            self._speech_to_text_translate_job = AsyncSpeechToTextTranslateJobClient(
+                client_wrapper=self._client_wrapper
+            )
+        return self._speech_to_text_translate_job
+
+    @property
+    def speech_to_text_streaming(self):
+        if self._speech_to_text_streaming is None:
+            from .speech_to_text_streaming.client import AsyncSpeechToTextStreamingClient  # noqa: E402
+
+            self._speech_to_text_streaming = AsyncSpeechToTextStreamingClient(client_wrapper=self._client_wrapper)
+        return self._speech_to_text_streaming
+
+    @property
+    def speech_to_text_translate_streaming(self):
+        if self._speech_to_text_translate_streaming is None:
+            from .speech_to_text_translate_streaming.client import (
+                AsyncSpeechToTextTranslateStreamingClient,  # noqa: E402
+            )
+
+            self._speech_to_text_translate_streaming = AsyncSpeechToTextTranslateStreamingClient(
+                client_wrapper=self._client_wrapper
+            )
+        return self._speech_to_text_translate_streaming
+
+    @property
+    def text_to_speech_streaming(self):
+        if self._text_to_speech_streaming is None:
+            from .text_to_speech_streaming.client import AsyncTextToSpeechStreamingClient  # noqa: E402
+
+            self._text_to_speech_streaming = AsyncTextToSpeechStreamingClient(client_wrapper=self._client_wrapper)
+        return self._text_to_speech_streaming

sarvamai/core/__init__.py

@@ -2,27 +2,82 @@
 
 # isort: skip_file
 
-from .api_error import ApiError
-from .client_wrapper import AsyncClientWrapper, BaseClientWrapper, SyncClientWrapper
-from .datetime_utils import serialize_datetime
-from .events import EventEmitterMixin, EventType
-from .file import File, convert_file_dict_to_httpx_tuples, with_content_type
-from .http_client import AsyncHttpClient, HttpClient
-from .http_response import AsyncHttpResponse, HttpResponse
-from .jsonable_encoder import jsonable_encoder
-from .pydantic_utilities import (
-    IS_PYDANTIC_V2,
-    UniversalBaseModel,
-    UniversalRootModel,
-    parse_obj_as,
-    universal_field_validator,
-    universal_root_validator,
-    update_forward_refs,
-)
-from .query_encoder import encode_query
-from .remove_none_from_dict import remove_none_from_dict
-from .request_options import RequestOptions
-from .serialization import FieldMetadata, convert_and_respect_annotation_metadata
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from .api_error import ApiError
+    from .client_wrapper import AsyncClientWrapper, BaseClientWrapper, SyncClientWrapper
+    from .datetime_utils import serialize_datetime
+    from .events import EventEmitterMixin, EventType
+    from .file import File, convert_file_dict_to_httpx_tuples, with_content_type
+    from .http_client import AsyncHttpClient, HttpClient
+    from .http_response import AsyncHttpResponse, HttpResponse
+    from .jsonable_encoder import jsonable_encoder
+    from .pydantic_utilities import (
+        IS_PYDANTIC_V2,
+        UniversalBaseModel,
+        UniversalRootModel,
+        parse_obj_as,
+        universal_field_validator,
+        universal_root_validator,
+        update_forward_refs,
+    )
+    from .query_encoder import encode_query
+    from .remove_none_from_dict import remove_none_from_dict
+    from .request_options import RequestOptions
+    from .serialization import FieldMetadata, convert_and_respect_annotation_metadata
+_dynamic_imports: typing.Dict[str, str] = {
+    "ApiError": ".api_error",
+    "AsyncClientWrapper": ".client_wrapper",
+    "AsyncHttpClient": ".http_client",
+    "AsyncHttpResponse": ".http_response",
+    "BaseClientWrapper": ".client_wrapper",
+    "EventEmitterMixin": ".events",
+    "EventType": ".events",
+    "FieldMetadata": ".serialization",
+    "File": ".file",
+    "HttpClient": ".http_client",
+    "HttpResponse": ".http_response",
+    "IS_PYDANTIC_V2": ".pydantic_utilities",
+    "RequestOptions": ".request_options",
+    "SyncClientWrapper": ".client_wrapper",
+    "UniversalBaseModel": ".pydantic_utilities",
+    "UniversalRootModel": ".pydantic_utilities",
+    "convert_and_respect_annotation_metadata": ".serialization",
+    "convert_file_dict_to_httpx_tuples": ".file",
+    "encode_query": ".query_encoder",
+    "jsonable_encoder": ".jsonable_encoder",
+    "parse_obj_as": ".pydantic_utilities",
+    "remove_none_from_dict": ".remove_none_from_dict",
+    "serialize_datetime": ".datetime_utils",
+    "universal_field_validator": ".pydantic_utilities",
+    "universal_root_validator": ".pydantic_utilities",
+    "update_forward_refs": ".pydantic_utilities",
+    "with_content_type": ".file",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
 
 __all__ = [
     "ApiError",

sarvamai/core/client_wrapper.py

@@ -22,11 +22,15 @@ class BaseClientWrapper:
         self._timeout = timeout
 
     def get_headers(self) -> typing.Dict[str, str]:
+        import platform
+
         headers: typing.Dict[str, str] = {
-            "User-Agent": "sarvamai/0.1.22a3",
+            "User-Agent": "sarvamai/0.1.23a1",
             "X-Fern-Language": "Python",
+            "X-Fern-Runtime": f"python/{platform.python_version()}",
+            "X-Fern-Platform": f"{platform.system().lower()}/{platform.release()}",
             "X-Fern-SDK-Name": "sarvamai",
-            "X-Fern-SDK-Version": "0.1.22a3",
+            "X-Fern-SDK-Version": "0.1.23a1",
             **(self.get_custom_headers() or {}),
         }
         headers["api-subscription-key"] = self.api_subscription_key
@@ -68,11 +72,23 @@ class AsyncClientWrapper(BaseClientWrapper):
         headers: typing.Optional[typing.Dict[str, str]] = None,
         environment: SarvamAIEnvironment,
         timeout: typing.Optional[float] = None,
+        async_token: typing.Optional[typing.Callable[[], typing.Awaitable[str]]] = None,
         httpx_client: httpx.AsyncClient,
     ):
         super().__init__(
             api_subscription_key=api_subscription_key, headers=headers, environment=environment, timeout=timeout
         )
+        self._async_token = async_token
         self.httpx_client = AsyncHttpClient(
-            httpx_client=httpx_client, base_headers=self.get_headers, base_timeout=self.get_timeout
+            httpx_client=httpx_client,
+            base_headers=self.get_headers,
+            base_timeout=self.get_timeout,
+            async_base_headers=self.async_get_headers,
         )
+
+    async def async_get_headers(self) -> typing.Dict[str, str]:
+        headers = self.get_headers()
+        if self._async_token is not None:
+            token = await self._async_token()
+            headers["Authorization"] = f"Bearer {token}"
+        return headers

sarvamai/core/force_multipart.py

@@ -1,7 +1,9 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from typing import Any, Dict
 
-class ForceMultipartDict(dict):
+
+class ForceMultipartDict(Dict[str, Any]):
     """
     A dictionary subclass that always evaluates to True in boolean contexts.
 
@@ -9,7 +11,7 @@ class ForceMultipartDict(dict):
     the dictionary is empty, which would normally evaluate to False.
     """
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return True