vellum-ai 0.7.11__py3-none-any.whl → 0.8.4__py3-none-any.whl

vellum/core/__init__.py

@@ -6,25 +6,41 @@ from .datetime_utils import serialize_datetime
 from .file import File, convert_file_dict_to_httpx_tuples
 from .http_client import AsyncHttpClient, HttpClient
 from .jsonable_encoder import jsonable_encoder
-from .pydantic_utilities import deep_union_pydantic_dicts, pydantic_v1
+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
 
 __all__ = [
     "ApiError",
     "AsyncClientWrapper",
     "AsyncHttpClient",
     "BaseClientWrapper",
+    "FieldMetadata",
     "File",
     "HttpClient",
+    "IS_PYDANTIC_V2",
     "RequestOptions",
     "SyncClientWrapper",
+    "UniversalBaseModel",
+    "UniversalRootModel",
+    "convert_and_respect_annotation_metadata",
     "convert_file_dict_to_httpx_tuples",
-    "deep_union_pydantic_dicts",
     "encode_query",
     "jsonable_encoder",
-    "pydantic_v1",
+    "parse_obj_as",
     "remove_none_from_dict",
     "serialize_datetime",
+    "universal_field_validator",
+    "universal_root_validator",
+    "update_forward_refs",
 ]

vellum/core/client_wrapper.py

@@ -1,11 +1,10 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from ..environment import VellumEnvironment
 import typing
-
 import httpx
-
-from ..environment import VellumEnvironment
-from .http_client import AsyncHttpClient, HttpClient
+from .http_client import HttpClient
+from .http_client import AsyncHttpClient
 
 
 class BaseClientWrapper:
@@ -18,7 +17,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.7.11",
+            "X-Fern-SDK-Version": "0.8.4",
         }
         headers["X_API_KEY"] = self.api_key
         return headers
@@ -37,7 +36,7 @@ class SyncClientWrapper(BaseClientWrapper):
         api_key: str,
         environment: VellumEnvironment,
         timeout: typing.Optional[float] = None,
-        httpx_client: httpx.Client
+        httpx_client: httpx.Client,
     ):
         super().__init__(api_key=api_key, environment=environment, timeout=timeout)
         self.httpx_client = HttpClient(
@@ -52,7 +51,7 @@ class AsyncClientWrapper(BaseClientWrapper):
         api_key: str,
         environment: VellumEnvironment,
         timeout: typing.Optional[float] = None,
-        httpx_client: httpx.AsyncClient
+        httpx_client: httpx.AsyncClient,
     ):
         super().__init__(api_key=api_key, environment=environment, timeout=timeout)
         self.httpx_client = AsyncHttpClient(

vellum/core/file.py

@@ -13,12 +13,17 @@ File = typing.Union[
     # (filename, file (or bytes), content_type)
     typing.Tuple[typing.Optional[str], FileContent, typing.Optional[str]],
     # (filename, file (or bytes), content_type, headers)
-    typing.Tuple[typing.Optional[str], FileContent, typing.Optional[str], typing.Mapping[str, str]],
+    typing.Tuple[
+        typing.Optional[str],
+        FileContent,
+        typing.Optional[str],
+        typing.Mapping[str, str],
+    ],
 ]
 
 
 def convert_file_dict_to_httpx_tuples(
-    d: typing.Dict[str, typing.Union[File, typing.List[File]]]
+    d: typing.Dict[str, typing.Union[File, typing.List[File]]],
 ) -> typing.List[typing.Tuple[str, File]]:
     """
     The format we use is a list of tuples, where the first element is the

vellum/core/http_client.py

@@ -90,7 +90,8 @@ def _should_retry(response: httpx.Response) -> bool:
 
 
 def remove_omit_from_dict(
-    original: typing.Dict[str, typing.Optional[typing.Any]], omit: typing.Optional[typing.Any]
+    original: typing.Dict[str, typing.Optional[typing.Any]],
+    omit: typing.Optional[typing.Any],
 ) -> typing.Dict[str, typing.Any]:
     if omit is None:
         return original
@@ -142,7 +143,8 @@ def get_request_body(
         # If both data and json are None, we send json data in the event extra properties are specified
         json_body = maybe_filter_request_body(json, request_options, omit)
 
-    return json_body, data_body
+    # If you have an empty JSON body, you should just send None
+    return (json_body if json_body != {} else None), data_body if data_body != {} else None
 
 
 class HttpClient:

vellum/core/jsonable_encoder.py

@@ -11,31 +11,24 @@ https://github.com/tiangolo/fastapi/blob/master/fastapi/encoders.py
 import base64
 import dataclasses
 import datetime as dt
-from collections import defaultdict
 from enum import Enum
 from pathlib import PurePath
 from types import GeneratorType
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Set, Union
+
+import pydantic
 
 from .datetime_utils import serialize_datetime
-from .pydantic_utilities import pydantic_v1
+from .pydantic_utilities import (
+    IS_PYDANTIC_V2,
+    encode_by_type,
+    to_jsonable_with_fallback,
+)
 
 SetIntStr = Set[Union[int, str]]
 DictIntStrAny = Dict[Union[int, str], Any]
 
 
-def generate_encoders_by_class_tuples(
-    type_encoder_map: Dict[Any, Callable[[Any], Any]]
-) -> Dict[Callable[[Any], Any], Tuple[Any, ...]]:
-    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(tuple)
-    for type_, encoder in type_encoder_map.items():
-        encoders_by_class_tuples[encoder] += (type_,)
-    return encoders_by_class_tuples
-
-
-encoders_by_class_tuples = generate_encoders_by_class_tuples(pydantic_v1.json.ENCODERS_BY_TYPE)
-
-
 def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any], Any]]] = None) -> Any:
     custom_encoder = custom_encoder or {}
     if custom_encoder:
@@ -45,16 +38,21 @@ def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any]
             for encoder_type, encoder_instance in custom_encoder.items():
                 if isinstance(obj, encoder_type):
                     return encoder_instance(obj)
-    if isinstance(obj, pydantic_v1.BaseModel):
-        encoder = getattr(obj.__config__, "json_encoders", {})
+    if isinstance(obj, pydantic.BaseModel):
+        if IS_PYDANTIC_V2:
+            encoder = getattr(obj.model_config, "json_encoders", {})  # type: ignore # Pydantic v2
+        else:
+            encoder = getattr(obj.__config__, "json_encoders", {})  # type: ignore # Pydantic v1
         if custom_encoder:
             encoder.update(custom_encoder)
         obj_dict = obj.dict(by_alias=True)
         if "__root__" in obj_dict:
             obj_dict = obj_dict["__root__"]
+        if "root" in obj_dict:
+            obj_dict = obj_dict["root"]
         return jsonable_encoder(obj_dict, custom_encoder=encoder)
     if dataclasses.is_dataclass(obj):
-        obj_dict = dataclasses.asdict(obj)
+        obj_dict = dataclasses.asdict(obj)  # type: ignore
         return jsonable_encoder(obj_dict, custom_encoder=custom_encoder)
     if isinstance(obj, bytes):
         return base64.b64encode(obj).decode("utf-8")
@@ -83,20 +81,21 @@ def jsonable_encoder(obj: Any, custom_encoder: Optional[Dict[Any, Callable[[Any]
             encoded_list.append(jsonable_encoder(item, custom_encoder=custom_encoder))
         return encoded_list
 
-    if type(obj) in pydantic_v1.json.ENCODERS_BY_TYPE:
-        return pydantic_v1.json.ENCODERS_BY_TYPE[type(obj)](obj)
-    for encoder, classes_tuple in encoders_by_class_tuples.items():
-        if isinstance(obj, classes_tuple):
-            return encoder(obj)
+    def fallback_serializer(o: Any) -> Any:
+        attempt_encode = encode_by_type(o)
+        if attempt_encode is not None:
+            return attempt_encode
 
-    try:
-        data = dict(obj)
-    except Exception as e:
-        errors: List[Exception] = []
-        errors.append(e)
         try:
-            data = vars(obj)
+            data = dict(o)
         except Exception as e:
+            errors: List[Exception] = []
             errors.append(e)
-            raise ValueError(errors) from e
-    return jsonable_encoder(data, custom_encoder=custom_encoder)
+            try:
+                data = vars(o)
+            except Exception as e:
+                errors.append(e)
+                raise ValueError(errors) from e
+        return jsonable_encoder(data, custom_encoder=custom_encoder)
+
+    return to_jsonable_with_fallback(obj, fallback_serializer)

vellum/core/pydantic_utilities.py

@@ -1,28 +1,206 @@
 # This file was auto-generated by Fern from our API Definition.
 
+# nopycln: file
+import datetime as dt
 import typing
+from collections import defaultdict
+
+import typing_extensions
 
 import pydantic
 
+from .datetime_utils import serialize_datetime
+
 IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
 
 if IS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic_v1  # type: ignore  # nopycln: import
+    # 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 # 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
+
+
+T = typing.TypeVar("T")
+Model = typing.TypeVar("Model", bound=pydantic.BaseModel)
+
+
+def parse_obj_as(type_: typing.Type[T], object_: typing.Any) -> T:
+    if IS_PYDANTIC_V2:
+        adapter = pydantic.TypeAdapter(type_)  # type: ignore # Pydantic v2
+        return adapter.validate_python(object_)
+    else:
+        return pydantic.parse_obj_as(type_, object_)
+
+
+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)
+    else:
+        return fallback_serializer(obj)
+
+
+class UniversalBaseModel(pydantic.BaseModel):
+    class Config:
+        populate_by_name = True
+        smart_union = True
+        allow_population_by_field_name = True
+        json_encoders = {dt.datetime: serialize_datetime}
+
+    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 # Pydantic v2
+        else:
+            return super().json(**kwargs_with_defaults)
+
+    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.
+        """
+        _fields_set = self.__fields_set__
+
+        fields = _get_model_fields(self.__class__)
+        for name, field in fields.items():
+            if name not in _fields_set:
+                default = _get_field_default(field)
+
+                # If the default values are non-null act like they've been set
+                # This effectively allows exclude_unset to work like exclude_none where
+                # the latter passes through intentionally set none values.
+                if default != None:
+                    _fields_set.add(name)
+
+        kwargs_with_defaults_exclude_unset: typing.Any = {
+            "by_alias": True,
+            "exclude_unset": True,
+            "include": _fields_set,
+            **kwargs,
+        }
+
+        if IS_PYDANTIC_V2:
+            return super().model_dump(**kwargs_with_defaults_exclude_unset)  # type: ignore # Pydantic v2
+        else:
+            return super().dict(**kwargs_with_defaults_exclude_unset)
+
+
+if IS_PYDANTIC_V2:
+
+    class V2RootModel(UniversalBaseModel, pydantic.RootModel):  # type: ignore # Pydantic v2
+        pass
+
+    UniversalRootModel: typing_extensions.TypeAlias = V2RootModel  # type: ignore
 else:
-    import pydantic as pydantic_v1  # type: ignore  # nopycln: import
+    UniversalRootModel: typing_extensions.TypeAlias = UniversalBaseModel  # type: ignore
+
+
+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_,)
+
+    if type(o) in encoders_by_type:
+        return encoders_by_type[type(o)](o)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(o, classes_tuple):
+            return encoder(o)
+
+
+def update_forward_refs(model: typing.Type["Model"]) -> None:
+    if IS_PYDANTIC_V2:
+        model.model_rebuild(raise_errors=False)  # type: ignore # Pydantic v2
+    else:
+        model.update_forward_refs()
+
 
+# Mirrors Pydantic's internal typing
+AnyCallable = typing.Callable[..., typing.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():
-        if isinstance(value, dict):
-            node = destination.setdefault(key, {})
-            deep_union_pydantic_dicts(value, node)
+
+def universal_root_validator(
+    pre: bool = False,
+) -> typing.Callable[[AnyCallable], AnyCallable]:
+    def decorator(func: AnyCallable) -> AnyCallable:
+        if IS_PYDANTIC_V2:
+            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) -> typing.Callable[[AnyCallable], AnyCallable]:
+    def decorator(func: AnyCallable) -> AnyCallable:
+        if IS_PYDANTIC_V2:
+            return pydantic.field_validator(field_name, mode="before" if pre else "after")(func)  # type: ignore # Pydantic v2
         else:
-            destination[key] = value
+            return pydantic.validator(field_name, pre=pre)(func)  # type: ignore # Pydantic v1
+
+    return decorator
+
+
+PydanticField = typing.Union[ModelField, pydantic.fields.FieldInfo]
+
+
+def _get_model_fields(
+    model: typing.Type["Model"],
+) -> typing.Mapping[str, PydanticField]:
+    if IS_PYDANTIC_V2:
+        return model.model_fields  # type: ignore # Pydantic v2
+    else:
+        return model.__fields__  # type: ignore # Pydantic v1
 
-    return destination
 
+def _get_field_default(field: PydanticField) -> typing.Any:
+    try:
+        value = field.get_default()  # type: ignore # Pydantic < v1.10.15
+    except:
+        value = field.default
+    if IS_PYDANTIC_V2:
+        from pydantic_core import PydanticUndefined
 
-__all__ = ["pydantic_v1"]
+        if value == PydanticUndefined:
+            return None
+        return value
+    return value

vellum/core/query_encoder.py

@@ -1,33 +1,58 @@
 # This file was auto-generated by Fern from our API Definition.
 
-from collections import ChainMap
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
-from .pydantic_utilities import pydantic_v1
+import pydantic
 
 
 # Flattens dicts to be of the form {"key[subkey][subkey2]": value} where value is not a dict
-def traverse_query_dict(dict_flat: Dict[str, Any], key_prefix: Optional[str] = None) -> Dict[str, Any]:
-    result = {}
+def traverse_query_dict(dict_flat: Dict[str, Any], key_prefix: Optional[str] = None) -> List[Tuple[str, Any]]:
+    result = []
     for k, v in dict_flat.items():
         key = f"{key_prefix}[{k}]" if key_prefix is not None else k
         if isinstance(v, dict):
-            result.update(traverse_query_dict(v, key))
+            result.extend(traverse_query_dict(v, key))
+        elif isinstance(v, list):
+            for arr_v in v:
+                if isinstance(arr_v, dict):
+                    result.extend(traverse_query_dict(arr_v, key))
+                else:
+                    result.append((key, arr_v))
         else:
-            result[key] = v
+            result.append((key, v))
     return result
 
 
-def single_query_encoder(query_key: str, query_value: Any) -> Dict[str, Any]:
-    if isinstance(query_value, pydantic_v1.BaseModel) or isinstance(query_value, dict):
-        if isinstance(query_value, pydantic_v1.BaseModel):
+def single_query_encoder(query_key: str, query_value: Any) -> List[Tuple[str, Any]]:
+    if isinstance(query_value, pydantic.BaseModel) or isinstance(query_value, dict):
+        if isinstance(query_value, pydantic.BaseModel):
             obj_dict = query_value.dict(by_alias=True)
         else:
             obj_dict = query_value
         return traverse_query_dict(obj_dict, query_key)
+    elif isinstance(query_value, list):
+        encoded_values: List[Tuple[str, Any]] = []
+        for value in query_value:
+            if isinstance(value, pydantic.BaseModel) or isinstance(value, dict):
+                if isinstance(value, pydantic.BaseModel):
+                    obj_dict = value.dict(by_alias=True)
+                elif isinstance(value, dict):
+                    obj_dict = value
 
-    return {query_key: query_value}
+                encoded_values.extend(single_query_encoder(query_key, obj_dict))
+            else:
+                encoded_values.append((query_key, value))
 
+        return encoded_values
 
-def encode_query(query: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
-    return dict(ChainMap(*[single_query_encoder(k, v) for k, v in query.items()])) if query is not None else None
+    return [(query_key, query_value)]
+
+
+def encode_query(query: Optional[Dict[str, Any]]) -> Optional[List[Tuple[str, Any]]]:
+    if query is None:
+        return None
+
+    encoded_query = []
+    for k, v in query.items():
+        encoded_query.extend(single_query_encoder(k, v))
+    return encoded_query