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

sarvamai/core/http_client.py

@@ -11,12 +11,10 @@ from random import random
 
 import httpx
 from .file import File, convert_file_dict_to_httpx_tuples
-from .force_multipart import FORCE_MULTIPART
 from .jsonable_encoder import jsonable_encoder
 from .query_encoder import encode_query
 from .remove_none_from_dict import remove_none_from_dict
 from .request_options import RequestOptions
-from httpx._types import RequestFiles
 
 INITIAL_RETRY_DELAY_SECONDS = 0.5
 MAX_RETRY_DELAY_SECONDS = 10
@@ -180,17 +178,11 @@ class HttpClient:
         json: typing.Optional[typing.Any] = None,
         data: typing.Optional[typing.Any] = None,
         content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
-        files: typing.Optional[
-            typing.Union[
-                typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]],
-                typing.List[typing.Tuple[str, File]],
-            ]
-        ] = None,
+        files: typing.Optional[typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]]] = None,
         headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
         request_options: typing.Optional[RequestOptions] = None,
         retries: int = 2,
         omit: typing.Optional[typing.Any] = None,
-        force_multipart: typing.Optional[bool] = None,
     ) -> httpx.Response:
         base_url = self.get_base_url(base_url)
         timeout = (
@@ -201,15 +193,6 @@ class HttpClient:
 
         json_body, data_body = get_request_body(json=json, data=data, request_options=request_options, omit=omit)
 
-        request_files: typing.Optional[RequestFiles] = (
-            convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
-            if (files is not None and files is not omit and isinstance(files, dict))
-            else None
-        )
-
-        if (request_files is None or len(request_files) == 0) and force_multipart:
-            request_files = FORCE_MULTIPART
-
         response = self.httpx_client.request(
             method=method,
             url=urllib.parse.urljoin(f"{base_url}/", path),
@@ -242,7 +225,11 @@ class HttpClient:
             json=json_body,
             data=data_body,
             content=content,
-            files=request_files,
+            files=(
+                convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
+                if (files is not None and files is not omit)
+                else None
+            ),
             timeout=timeout,
         )
 
@@ -277,17 +264,11 @@ class HttpClient:
         json: typing.Optional[typing.Any] = None,
         data: typing.Optional[typing.Any] = None,
         content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
-        files: typing.Optional[
-            typing.Union[
-                typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]],
-                typing.List[typing.Tuple[str, File]],
-            ]
-        ] = None,
+        files: typing.Optional[typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]]] = None,
         headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
         request_options: typing.Optional[RequestOptions] = None,
         retries: int = 2,
         omit: typing.Optional[typing.Any] = None,
-        force_multipart: typing.Optional[bool] = None,
     ) -> typing.Iterator[httpx.Response]:
         base_url = self.get_base_url(base_url)
         timeout = (
@@ -296,15 +277,6 @@ class HttpClient:
             else self.base_timeout()
         )
 
-        request_files: typing.Optional[RequestFiles] = (
-            convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
-            if (files is not None and files is not omit and isinstance(files, dict))
-            else None
-        )
-
-        if (request_files is None or len(request_files) == 0) and force_multipart:
-            request_files = FORCE_MULTIPART
-
         json_body, data_body = get_request_body(json=json, data=data, request_options=request_options, omit=omit)
 
         with self.httpx_client.stream(
@@ -339,7 +311,11 @@ class HttpClient:
             json=json_body,
             data=data_body,
             content=content,
-            files=request_files,
+            files=(
+                convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
+                if (files is not None and files is not omit)
+                else None
+            ),
             timeout=timeout,
         ) as stream:
             yield stream
@@ -378,17 +354,11 @@ class AsyncHttpClient:
         json: typing.Optional[typing.Any] = None,
         data: typing.Optional[typing.Any] = None,
         content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
-        files: typing.Optional[
-            typing.Union[
-                typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]],
-                typing.List[typing.Tuple[str, File]],
-            ]
-        ] = None,
+        files: typing.Optional[typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]]] = None,
         headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
         request_options: typing.Optional[RequestOptions] = None,
         retries: int = 2,
         omit: typing.Optional[typing.Any] = None,
-        force_multipart: typing.Optional[bool] = None,
     ) -> httpx.Response:
         base_url = self.get_base_url(base_url)
         timeout = (
@@ -397,15 +367,6 @@ class AsyncHttpClient:
             else self.base_timeout()
         )
 
-        request_files: typing.Optional[RequestFiles] = (
-            convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
-            if (files is not None and files is not omit and isinstance(files, dict))
-            else None
-        )
-
-        if (request_files is None or len(request_files) == 0) and force_multipart:
-            request_files = FORCE_MULTIPART
-
         json_body, data_body = get_request_body(json=json, data=data, request_options=request_options, omit=omit)
 
         # Add the input to each of these and do None-safety checks
@@ -441,7 +402,11 @@ class AsyncHttpClient:
             json=json_body,
             data=data_body,
             content=content,
-            files=request_files,
+            files=(
+                convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
+                if files is not None
+                else None
+            ),
             timeout=timeout,
         )
 
@@ -475,17 +440,11 @@ class AsyncHttpClient:
         json: typing.Optional[typing.Any] = None,
         data: typing.Optional[typing.Any] = None,
         content: typing.Optional[typing.Union[bytes, typing.Iterator[bytes], typing.AsyncIterator[bytes]]] = None,
-        files: typing.Optional[
-            typing.Union[
-                typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]],
-                typing.List[typing.Tuple[str, File]],
-            ]
-        ] = None,
+        files: typing.Optional[typing.Dict[str, typing.Optional[typing.Union[File, typing.List[File]]]]] = None,
         headers: typing.Optional[typing.Dict[str, typing.Any]] = None,
         request_options: typing.Optional[RequestOptions] = None,
         retries: int = 2,
         omit: typing.Optional[typing.Any] = None,
-        force_multipart: typing.Optional[bool] = None,
     ) -> typing.AsyncIterator[httpx.Response]:
         base_url = self.get_base_url(base_url)
         timeout = (
@@ -494,15 +453,6 @@ class AsyncHttpClient:
             else self.base_timeout()
         )
 
-        request_files: typing.Optional[RequestFiles] = (
-            convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
-            if (files is not None and files is not omit and isinstance(files, dict))
-            else None
-        )
-
-        if (request_files is None or len(request_files) == 0) and force_multipart:
-            request_files = FORCE_MULTIPART
-
         json_body, data_body = get_request_body(json=json, data=data, request_options=request_options, omit=omit)
 
         async with self.httpx_client.stream(
@@ -537,7 +487,11 @@ class AsyncHttpClient:
             json=json_body,
             data=data_body,
             content=content,
-            files=request_files,
+            files=(
+                convert_file_dict_to_httpx_tuples(remove_omit_from_dict(remove_none_from_dict(files), omit))
+                if files is not None
+                else None
+            ),
             timeout=timeout,
         ) as stream:
             yield stream

sarvamai/core/http_response.py

@@ -5,31 +5,20 @@ from typing import Dict, Generic, TypeVar
 import httpx
 
 T = TypeVar("T")
-"""Generic to represent the underlying type of the data wrapped by the HTTP response."""
 
 
-class BaseHttpResponse:
-    """Minimalist HTTP response wrapper that exposes response headers."""
-
+class HttpResponse(Generic[T]):
     _response: httpx.Response
+    _data: T
 
-    def __init__(self, response: httpx.Response):
+    def __init__(self, response: httpx.Response, data: T):
         self._response = response
+        self._data = data
 
     @property
     def headers(self) -> Dict[str, str]:
         return dict(self._response.headers)
 
-
-class HttpResponse(Generic[T], BaseHttpResponse):
-    """HTTP response wrapper that exposes response headers and data."""
-
-    _data: T
-
-    def __init__(self, response: httpx.Response, data: T):
-        super().__init__(response)
-        self._data = data
-
     @property
     def data(self) -> T:
         return self._data
@@ -38,15 +27,18 @@ class HttpResponse(Generic[T], BaseHttpResponse):
         self._response.close()
 
 
-class AsyncHttpResponse(Generic[T], BaseHttpResponse):
-    """HTTP response wrapper that exposes response headers and data."""
-
+class AsyncHttpResponse(Generic[T]):
+    _response: httpx.Response
     _data: T
 
     def __init__(self, response: httpx.Response, data: T):
-        super().__init__(response)
+        self._response = response
         self._data = data
 
+    @property
+    def headers(self) -> Dict[str, str]:
+        return dict(self._response.headers)
+
     @property
     def data(self) -> T:
         return self._data

sarvamai/core/pydantic_utilities.py

@@ -2,65 +2,87 @@
 
 # nopycln: file
 import datetime as dt
+import typing
 from collections import defaultdict
-from typing import Any, Callable, ClassVar, Dict, List, Mapping, Optional, Set, Tuple, Type, TypeVar, Union, cast
 
 import pydantic
+import typing_extensions
+from .datetime_utils import serialize_datetime
+from .serialization import convert_and_respect_annotation_metadata
 
 IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
 
 if IS_PYDANTIC_V2:
-    from pydantic.v1.datetime_parse import parse_date as parse_date
-    from pydantic.v1.datetime_parse import parse_datetime as parse_datetime
-    from pydantic.v1.fields import ModelField as ModelField
-    from pydantic.v1.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore[attr-defined]
-    from pydantic.v1.typing import get_args as get_args
-    from pydantic.v1.typing import get_origin as get_origin
-    from pydantic.v1.typing import is_literal_type as is_literal_type
-    from pydantic.v1.typing import is_union as is_union
+    # isort will try to reformat the comments on these imports, which breaks mypy
+    # isort: off
+    from pydantic.v1.datetime_parse import (  # type: ignore # pyright: ignore[reportMissingImports] # Pydantic v2
+        parse_date as parse_date,
+    )
+    from pydantic.v1.datetime_parse import (  # pyright: ignore[reportMissingImports] # Pydantic v2
+        parse_datetime as parse_datetime,
+    )
+    from pydantic.v1.json import (  # type: ignore # pyright: ignore[reportMissingImports] # Pydantic v2
+        ENCODERS_BY_TYPE as encoders_by_type,
+    )
+    from pydantic.v1.typing import (  # type: ignore # pyright: ignore[reportMissingImports] # Pydantic v2
+        get_args as get_args,
+    )
+    from pydantic.v1.typing import (  # pyright: ignore[reportMissingImports] # Pydantic v2
+        get_origin as get_origin,
+    )
+    from pydantic.v1.typing import (  # pyright: ignore[reportMissingImports] # Pydantic v2
+        is_literal_type as is_literal_type,
+    )
+    from pydantic.v1.typing import (  # pyright: ignore[reportMissingImports] # Pydantic v2
+        is_union as is_union,
+    )
+    from pydantic.v1.fields import ModelField as ModelField  # type: ignore # pyright: ignore[reportMissingImports] # Pydantic v2
 else:
-    from pydantic.datetime_parse import parse_date as parse_date  # type: ignore[no-redef]
-    from pydantic.datetime_parse import parse_datetime as parse_datetime  # type: ignore[no-redef]
-    from pydantic.fields import ModelField as ModelField  # type: ignore[attr-defined, no-redef]
-    from pydantic.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore[no-redef]
-    from pydantic.typing import get_args as get_args  # type: ignore[no-redef]
-    from pydantic.typing import get_origin as get_origin  # type: ignore[no-redef]
-    from pydantic.typing import is_literal_type as is_literal_type  # type: ignore[no-redef]
-    from pydantic.typing import is_union as is_union  # type: ignore[no-redef]
+    from pydantic.datetime_parse import parse_date as parse_date  # type: ignore # Pydantic v1
+    from pydantic.datetime_parse import parse_datetime as parse_datetime  # type: ignore # Pydantic v1
+    from pydantic.fields import ModelField as ModelField  # type: ignore # Pydantic v1
+    from pydantic.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore # Pydantic v1
+    from pydantic.typing import get_args as get_args  # type: ignore # Pydantic v1
+    from pydantic.typing import get_origin as get_origin  # type: ignore # Pydantic v1
+    from pydantic.typing import is_literal_type as is_literal_type  # type: ignore # Pydantic v1
+    from pydantic.typing import is_union as is_union  # type: ignore # Pydantic v1
+
+    # isort: on
 
-from .datetime_utils import serialize_datetime
-from .serialization import convert_and_respect_annotation_metadata
-from typing_extensions import TypeAlias
 
-T = TypeVar("T")
-Model = TypeVar("Model", bound=pydantic.BaseModel)
+T = typing.TypeVar("T")
+Model = typing.TypeVar("Model", bound=pydantic.BaseModel)
 
 
-def parse_obj_as(type_: Type[T], object_: Any) -> T:
+def parse_obj_as(type_: typing.Type[T], object_: typing.Any) -> T:
     dealiased_object = convert_and_respect_annotation_metadata(object_=object_, annotation=type_, direction="read")
     if IS_PYDANTIC_V2:
-        adapter = pydantic.TypeAdapter(type_)  # type: ignore[attr-defined]
+        adapter = pydantic.TypeAdapter(type_)  # type: ignore # Pydantic v2
         return adapter.validate_python(dealiased_object)
-    return pydantic.parse_obj_as(type_, dealiased_object)
+    else:
+        return pydantic.parse_obj_as(type_, dealiased_object)
 
 
-def to_jsonable_with_fallback(obj: Any, fallback_serializer: Callable[[Any], Any]) -> Any:
+def to_jsonable_with_fallback(
+    obj: typing.Any, fallback_serializer: typing.Callable[[typing.Any], typing.Any]
+) -> typing.Any:
     if IS_PYDANTIC_V2:
         from pydantic_core import to_jsonable_python
 
         return to_jsonable_python(obj, fallback=fallback_serializer)
-    return fallback_serializer(obj)
+    else:
+        return fallback_serializer(obj)
 
 
 class UniversalBaseModel(pydantic.BaseModel):
     if IS_PYDANTIC_V2:
-        model_config: ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(  # type: ignore[typeddict-unknown-key]
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(
             # Allow fields beginning with `model_` to be used in the model
             protected_namespaces=(),
-        )
+        )  # type: ignore # Pydantic v2
 
-        @pydantic.model_serializer(mode="wrap", when_used="json")  # type: ignore[attr-defined]
-        def serialize_model(self, handler: pydantic.SerializerFunctionWrapHandler) -> Any:  # type: ignore[name-defined]
+        @pydantic.model_serializer(mode="wrap", when_used="json")  # type: ignore # Pydantic v2
+        def serialize_model(self, handler: pydantic.SerializerFunctionWrapHandler) -> typing.Any:  # type: ignore # Pydantic v2
             serialized = handler(self)
             data = {k: serialize_datetime(v) if isinstance(v, dt.datetime) else v for k, v in serialized.items()}
             return data
@@ -72,28 +94,34 @@ class UniversalBaseModel(pydantic.BaseModel):
             json_encoders = {dt.datetime: serialize_datetime}
 
     @classmethod
-    def model_construct(cls: Type["Model"], _fields_set: Optional[Set[str]] = None, **values: Any) -> "Model":
+    def model_construct(
+        cls: typing.Type["Model"], _fields_set: typing.Optional[typing.Set[str]] = None, **values: typing.Any
+    ) -> "Model":
         dealiased_object = convert_and_respect_annotation_metadata(object_=values, annotation=cls, direction="read")
         return cls.construct(_fields_set, **dealiased_object)
 
     @classmethod
-    def construct(cls: Type["Model"], _fields_set: Optional[Set[str]] = None, **values: Any) -> "Model":
+    def construct(
+        cls: typing.Type["Model"], _fields_set: typing.Optional[typing.Set[str]] = None, **values: typing.Any
+    ) -> "Model":
         dealiased_object = convert_and_respect_annotation_metadata(object_=values, annotation=cls, direction="read")
         if IS_PYDANTIC_V2:
-            return super().model_construct(_fields_set, **dealiased_object)  # type: ignore[misc]
-        return super().construct(_fields_set, **dealiased_object)
+            return super().model_construct(_fields_set, **dealiased_object)  # type: ignore # Pydantic v2
+        else:
+            return super().construct(_fields_set, **dealiased_object)
 
-    def json(self, **kwargs: Any) -> str:
-        kwargs_with_defaults = {
+    def json(self, **kwargs: typing.Any) -> str:
+        kwargs_with_defaults: typing.Any = {
             "by_alias": True,
             "exclude_unset": True,
             **kwargs,
         }
         if IS_PYDANTIC_V2:
-            return super().model_dump_json(**kwargs_with_defaults)  # type: ignore[misc]
-        return super().json(**kwargs_with_defaults)
+            return super().model_dump_json(**kwargs_with_defaults)  # type: ignore # Pydantic v2
+        else:
+            return super().json(**kwargs_with_defaults)
 
-    def dict(self, **kwargs: Any) -> Dict[str, Any]:
+    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
         """
         Override the default dict method to `exclude_unset` by default. This function patches
         `exclude_unset` to work include fields within non-None default values.
@@ -104,21 +132,21 @@ class UniversalBaseModel(pydantic.BaseModel):
         # We'd ideally do the same for Pydantic V2, but it shells out to a library to serialize models
         # that we have less control over, and this is less intrusive than custom serializers for now.
         if IS_PYDANTIC_V2:
-            kwargs_with_defaults_exclude_unset = {
+            kwargs_with_defaults_exclude_unset: typing.Any = {
                 **kwargs,
                 "by_alias": True,
                 "exclude_unset": True,
                 "exclude_none": False,
             }
-            kwargs_with_defaults_exclude_none = {
+            kwargs_with_defaults_exclude_none: typing.Any = {
                 **kwargs,
                 "by_alias": True,
                 "exclude_none": True,
                 "exclude_unset": False,
             }
             dict_dump = deep_union_pydantic_dicts(
-                super().model_dump(**kwargs_with_defaults_exclude_unset),  # type: ignore[misc]
-                super().model_dump(**kwargs_with_defaults_exclude_none),  # type: ignore[misc]
+                super().model_dump(**kwargs_with_defaults_exclude_unset),  # type: ignore # Pydantic v2
+                super().model_dump(**kwargs_with_defaults_exclude_none),  # type: ignore # Pydantic v2
             )
 
         else:
@@ -138,7 +166,7 @@ class UniversalBaseModel(pydantic.BaseModel):
                         if default is not None:
                             self.__fields_set__.add(name)
 
-            kwargs_with_defaults_exclude_unset_include_fields = {
+            kwargs_with_defaults_exclude_unset_include_fields: typing.Any = {
                 "by_alias": True,
                 "exclude_unset": True,
                 "include": _fields_set,
@@ -150,10 +178,12 @@ class UniversalBaseModel(pydantic.BaseModel):
         return convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write")
 
 
-def _union_list_of_pydantic_dicts(source: List[Any], destination: List[Any]) -> List[Any]:
-    converted_list: List[Any] = []
+def _union_list_of_pydantic_dicts(
+    source: typing.List[typing.Any], destination: typing.List[typing.Any]
+) -> typing.List[typing.Any]:
+    converted_list: typing.List[typing.Any] = []
     for i, item in enumerate(source):
-        destination_value = destination[i]
+        destination_value = destination[i]  # type: ignore
         if isinstance(item, dict):
             converted_list.append(deep_union_pydantic_dicts(item, destination_value))
         elif isinstance(item, list):
@@ -163,7 +193,9 @@ def _union_list_of_pydantic_dicts(source: List[Any], destination: List[Any]) ->
     return converted_list
 
 
-def deep_union_pydantic_dicts(source: Dict[str, Any], destination: Dict[str, Any]) -> Dict[str, Any]:
+def deep_union_pydantic_dicts(
+    source: typing.Dict[str, typing.Any], destination: typing.Dict[str, typing.Any]
+) -> typing.Dict[str, typing.Any]:
     for key, value in source.items():
         node = destination.setdefault(key, {})
         if isinstance(value, dict):
@@ -181,16 +213,18 @@ def deep_union_pydantic_dicts(source: Dict[str, Any], destination: Dict[str, Any
 
 if IS_PYDANTIC_V2:
 
-    class V2RootModel(UniversalBaseModel, pydantic.RootModel):  # type: ignore[misc, name-defined, type-arg]
+    class V2RootModel(UniversalBaseModel, pydantic.RootModel):  # type: ignore # Pydantic v2
         pass
 
-    UniversalRootModel: TypeAlias = V2RootModel  # type: ignore[misc]
+    UniversalRootModel: typing_extensions.TypeAlias = V2RootModel  # type: ignore
 else:
-    UniversalRootModel: TypeAlias = UniversalBaseModel  # type: ignore[misc, no-redef]
+    UniversalRootModel: typing_extensions.TypeAlias = UniversalBaseModel  # type: ignore
 
 
-def encode_by_type(o: Any) -> Any:
-    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(tuple)
+def encode_by_type(o: typing.Any) -> typing.Any:
+    encoders_by_class_tuples: typing.Dict[typing.Callable[[typing.Any], typing.Any], typing.Tuple[typing.Any, ...]] = (
+        defaultdict(tuple)
+    )
     for type_, encoder in encoders_by_type.items():
         encoders_by_class_tuples[encoder] += (type_,)
 
@@ -201,49 +235,54 @@ def encode_by_type(o: Any) -> Any:
             return encoder(o)
 
 
-def update_forward_refs(model: Type["Model"], **localns: Any) -> None:
+def update_forward_refs(model: typing.Type["Model"], **localns: typing.Any) -> None:
     if IS_PYDANTIC_V2:
-        model.model_rebuild(raise_errors=False)  # type: ignore[attr-defined]
+        model.model_rebuild(raise_errors=False)  # type: ignore # Pydantic v2
     else:
         model.update_forward_refs(**localns)
 
 
 # Mirrors Pydantic's internal typing
-AnyCallable = Callable[..., Any]
+AnyCallable = typing.Callable[..., typing.Any]
 
 
 def universal_root_validator(
     pre: bool = False,
-) -> Callable[[AnyCallable], AnyCallable]:
+) -> typing.Callable[[AnyCallable], AnyCallable]:
     def decorator(func: AnyCallable) -> AnyCallable:
         if IS_PYDANTIC_V2:
-            return cast(AnyCallable, pydantic.model_validator(mode="before" if pre else "after")(func))  # type: ignore[attr-defined]
-        return cast(AnyCallable, pydantic.root_validator(pre=pre)(func))  # type: ignore[call-overload]
+            return pydantic.model_validator(mode="before" if pre else "after")(func)  # type: ignore # Pydantic v2
+        else:
+            return pydantic.root_validator(pre=pre)(func)  # type: ignore # Pydantic v1
 
     return decorator
 
 
-def universal_field_validator(field_name: str, pre: bool = False) -> Callable[[AnyCallable], AnyCallable]:
+def universal_field_validator(field_name: str, pre: bool = False) -> typing.Callable[[AnyCallable], AnyCallable]:
     def decorator(func: AnyCallable) -> AnyCallable:
         if IS_PYDANTIC_V2:
-            return cast(AnyCallable, pydantic.field_validator(field_name, mode="before" if pre else "after")(func))  # type: ignore[attr-defined]
-        return cast(AnyCallable, pydantic.validator(field_name, pre=pre)(func))
+            return pydantic.field_validator(field_name, mode="before" if pre else "after")(func)  # type: ignore # Pydantic v2
+        else:
+            return pydantic.validator(field_name, pre=pre)(func)  # type: ignore # Pydantic v1
 
     return decorator
 
 
-PydanticField = Union[ModelField, pydantic.fields.FieldInfo]
+PydanticField = typing.Union[ModelField, pydantic.fields.FieldInfo]
 
 
-def _get_model_fields(model: Type["Model"]) -> Mapping[str, PydanticField]:
+def _get_model_fields(
+    model: typing.Type["Model"],
+) -> typing.Mapping[str, PydanticField]:
     if IS_PYDANTIC_V2:
-        return cast(Mapping[str, PydanticField], model.model_fields)  # type: ignore[attr-defined]
-    return cast(Mapping[str, PydanticField], model.__fields__)
+        return model.model_fields  # type: ignore # Pydantic v2
+    else:
+        return model.__fields__  # type: ignore # Pydantic v1
 
 
-def _get_field_default(field: PydanticField) -> Any:
+def _get_field_default(field: PydanticField) -> typing.Any:
     try:
-        value = field.get_default()  # type: ignore[union-attr]
+        value = field.get_default()  # type: ignore # Pydantic < v1.10.15
     except:
         value = field.default
     if IS_PYDANTIC_V2:

sarvamai/environment.py

@@ -1,14 +1,7 @@
 # This file was auto-generated by Fern from our API Definition.
 
-from __future__ import annotations
+import enum
 
 
-class SarvamAIEnvironment:
-    PRODUCTION: SarvamAIEnvironment
-
-    def __init__(self, *, base: str, production: str):
-        self.base = base
-        self.production = production
-
-
-SarvamAIEnvironment.PRODUCTION = SarvamAIEnvironment(base="https://api.sarvam.ai", production="wss://api.sarvam.ai")
+class SarvamAIEnvironment(enum.Enum):
+    PRODUCTION = "https://api.sarvam.ai"

sarvamai/errors/__init__.py

@@ -1,7 +1,5 @@
 # This file was auto-generated by Fern from our API Definition.
 
-# isort: skip_file
-
 from .bad_request_error import BadRequestError
 from .forbidden_error import ForbiddenError
 from .internal_server_error import InternalServerError

sarvamai/errors/bad_request_error.py

@@ -1,10 +1,9 @@
 # This file was auto-generated by Fern from our API Definition.
 
-import typing
-
 from ..core.api_error import ApiError
+import typing
 
 
 class BadRequestError(ApiError):
-    def __init__(self, body: typing.Optional[typing.Any], headers: typing.Optional[typing.Dict[str, str]] = None):
-        super().__init__(status_code=400, headers=headers, body=body)
+    def __init__(self, body: typing.Optional[typing.Any]):
+        super().__init__(status_code=400, body=body)

sarvamai/errors/forbidden_error.py

@@ -1,10 +1,9 @@
 # This file was auto-generated by Fern from our API Definition.
 
-import typing
-
 from ..core.api_error import ApiError
+import typing
 
 
 class ForbiddenError(ApiError):
-    def __init__(self, body: typing.Optional[typing.Any], headers: typing.Optional[typing.Dict[str, str]] = None):
-        super().__init__(status_code=403, headers=headers, body=body)
+    def __init__(self, body: typing.Optional[typing.Any]):
+        super().__init__(status_code=403, body=body)

sarvamai/errors/internal_server_error.py

@@ -1,10 +1,9 @@
 # This file was auto-generated by Fern from our API Definition.
 
-import typing
-
 from ..core.api_error import ApiError
+import typing
 
 
 class InternalServerError(ApiError):
-    def __init__(self, body: typing.Optional[typing.Any], headers: typing.Optional[typing.Dict[str, str]] = None):
-        super().__init__(status_code=500, headers=headers, body=body)
+    def __init__(self, body: typing.Optional[typing.Any]):
+        super().__init__(status_code=500, body=body)

sarvamai/errors/service_unavailable_error.py

@@ -1,11 +1,9 @@
 # This file was auto-generated by Fern from our API Definition.
 
-import typing
-
 from ..core.api_error import ApiError
 from ..types.error_message import ErrorMessage
 
 
 class ServiceUnavailableError(ApiError):
-    def __init__(self, body: ErrorMessage, headers: typing.Optional[typing.Dict[str, str]] = None):
-        super().__init__(status_code=503, headers=headers, body=body)
+    def __init__(self, body: ErrorMessage):
+        super().__init__(status_code=503, body=body)