vellum-ai 0.8.9__tar.gz → 0.8.10__tar.gz

{vellum_ai-0.8.9 → vellum_ai-0.8.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.8.9
+Version: 0.8.10
 Summary: 
 License: MIT
 Requires-Python: >=3.8,<4.0

{vellum_ai-0.8.9 → vellum_ai-0.8.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.8.9"
+version = "0.8.10"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.8.9 → vellum_ai-0.8.10}/src/vellum/client.py

@@ -892,7 +892,9 @@ class Vellum:
                         ChatMessageRequest(
                             text="string",
                             role="SYSTEM",
-                            content=StringChatMessageContentRequest(),
+                            content=StringChatMessageContentRequest(
+                                value="string",
+                            ),
                             source="string",
                         )
                     ],
@@ -2116,7 +2118,9 @@ class AsyncVellum:
                             ChatMessageRequest(
                                 text="string",
                                 role="SYSTEM",
-                                content=StringChatMessageContentRequest(),
+                                content=StringChatMessageContentRequest(
+                                    value="string",
+                                ),
                                 source="string",
                             )
                         ],

{vellum_ai-0.8.9 → vellum_ai-0.8.10}/src/vellum/core/client_wrapper.py

@@ -17,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.8.9",
+            "X-Fern-SDK-Version": "0.8.10",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.8.9 → vellum_ai-0.8.10}/src/vellum/core/pydantic_utilities.py

@@ -80,6 +80,8 @@ class UniversalBaseModel(pydantic.BaseModel):
         smart_union = True
         allow_population_by_field_name = True
         json_encoders = {dt.datetime: serialize_datetime}
+        # Allow fields begining with `model_` to be used in the model
+        protected_namespaces = ()
 
     def json(self, **kwargs: typing.Any) -> str:
         kwargs_with_defaults: typing.Any = {
@@ -97,30 +99,64 @@ class UniversalBaseModel(pydantic.BaseModel):
         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,
-        }
-
+        # Note: the logic here is multi-plexed given the levers exposed in Pydantic V1 vs V2
+        # Pydantic V1's .dict can be extremely slow, so we do not want to call it twice.
+        #
+        # 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:
-            return super().model_dump(**kwargs_with_defaults_exclude_unset)  # type: ignore # Pydantic v2
+            kwargs_with_defaults_exclude_unset: typing.Any = {
+                **kwargs,
+                "by_alias": True,
+                "exclude_unset": True,
+                "exclude_none": False,
+            }
+            kwargs_with_defaults_exclude_none: typing.Any = {
+                **kwargs,
+                "by_alias": True,
+                "exclude_none": True,
+                "exclude_unset": False,
+            }
+            return deep_union_pydantic_dicts(
+                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:
-            return super().dict(**kwargs_with_defaults_exclude_unset)
+            _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_include_fields: typing.Any = {
+                "by_alias": True,
+                "exclude_unset": True,
+                "include": _fields_set,
+                **kwargs,
+            }
+
+            return super().dict(**kwargs_with_defaults_exclude_unset_include_fields)
+
+
+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)
+        else:
+            destination[key] = value
+
+    return destination
 
 
 if IS_PYDANTIC_V2:

vellum_ai-0.8.10/src/vellum/core/serialization.py

@@ -0,0 +1,254 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import collections
+import inspect
+import typing
+
+import typing_extensions
+
+import pydantic
+
+
+class FieldMetadata:
+    """
+    Metadata class used to annotate fields to provide additional information.
+
+    Example:
+    class MyDict(TypedDict):
+        field: typing.Annotated[str, FieldMetadata(alias="field_name")]
+
+    Will serialize: `{"field": "value"}`
+    To: `{"field_name": "value"}`
+    """
+
+    alias: str
+
+    def __init__(self, *, alias: str) -> None:
+        self.alias = alias
+
+
+def convert_and_respect_annotation_metadata(
+    *,
+    object_: typing.Any,
+    annotation: typing.Any,
+    inner_type: typing.Optional[typing.Any] = None,
+    direction: typing.Literal["read", "write"],
+) -> typing.Any:
+    """
+    Respect the metadata annotations on a field, such as aliasing. This function effectively
+    manipulates the dict-form of an object to respect the metadata annotations. This is primarily used for
+    TypedDicts, which cannot support aliasing out of the box, and can be extended for additional
+    utilities, such as defaults.
+
+    Parameters
+    ----------
+    object_ : typing.Any
+
+    annotation : type
+        The type we're looking to apply typing annotations from
+
+    inner_type : typing.Optional[type]
+
+    Returns
+    -------
+    typing.Any
+    """
+
+    if object_ is None:
+        return None
+    if inner_type is None:
+        inner_type = annotation
+
+    clean_type = _remove_annotations(inner_type)
+    # Pydantic models
+    if (
+        inspect.isclass(clean_type)
+        and issubclass(clean_type, pydantic.BaseModel)
+        and isinstance(object_, typing.Mapping)
+    ):
+        return _convert_mapping(object_, clean_type, direction)
+    # TypedDicts
+    if typing_extensions.is_typeddict(clean_type) and isinstance(object_, typing.Mapping):
+        return _convert_mapping(object_, clean_type, direction)
+
+    # If you're iterating on a string, do not bother to coerce it to a sequence.
+    if not isinstance(object_, str):
+        if (
+            typing_extensions.get_origin(clean_type) == typing.Set
+            or typing_extensions.get_origin(clean_type) == set
+            or clean_type == typing.Set
+        ) and isinstance(object_, typing.Set):
+            inner_type = typing_extensions.get_args(clean_type)[0]
+            return {
+                convert_and_respect_annotation_metadata(
+                    object_=item,
+                    annotation=annotation,
+                    inner_type=inner_type,
+                    direction=direction,
+                )
+                for item in object_
+            }
+        elif (
+            (
+                typing_extensions.get_origin(clean_type) == typing.List
+                or typing_extensions.get_origin(clean_type) == list
+                or clean_type == typing.List
+            )
+            and isinstance(object_, typing.List)
+        ) or (
+            (
+                typing_extensions.get_origin(clean_type) == typing.Sequence
+                or typing_extensions.get_origin(clean_type) == collections.abc.Sequence
+                or clean_type == typing.Sequence
+            )
+            and isinstance(object_, typing.Sequence)
+        ):
+            inner_type = typing_extensions.get_args(clean_type)[0]
+            return [
+                convert_and_respect_annotation_metadata(
+                    object_=item,
+                    annotation=annotation,
+                    inner_type=inner_type,
+                    direction=direction,
+                )
+                for item in object_
+            ]
+
+    if typing_extensions.get_origin(clean_type) == typing.Union:
+        # We should be able to ~relatively~ safely try to convert keys against all
+        # member types in the union, the edge case here is if one member aliases a field
+        # of the same name to a different name from another member
+        # Or if another member aliases a field of the same name that another member does not.
+        for member in typing_extensions.get_args(clean_type):
+            object_ = convert_and_respect_annotation_metadata(
+                object_=object_,
+                annotation=annotation,
+                inner_type=member,
+                direction=direction,
+            )
+        return object_
+
+    annotated_type = _get_annotation(annotation)
+    if annotated_type is None:
+        return object_
+
+    # If the object is not a TypedDict, a Union, or other container (list, set, sequence, etc.)
+    # Then we can safely call it on the recursive conversion.
+    return object_
+
+
+def _convert_mapping(
+    object_: typing.Mapping[str, object],
+    expected_type: typing.Any,
+    direction: typing.Literal["read", "write"],
+) -> typing.Mapping[str, object]:
+    converted_object: typing.Dict[str, object] = {}
+    annotations = typing_extensions.get_type_hints(expected_type, include_extras=True)
+    aliases_to_field_names = _get_alias_to_field_name(annotations)
+    for key, value in object_.items():
+        if direction == "read" and key in aliases_to_field_names:
+            dealiased_key = aliases_to_field_names.get(key)
+            if dealiased_key is not None:
+                type_ = annotations.get(dealiased_key)
+        else:
+            type_ = annotations.get(key)
+        # Note you can't get the annotation by the field name if you're in read mode, so you must check the aliases map
+        #
+        # So this is effectively saying if we're in write mode, and we don't have a type, or if we're in read mode and we don't have an alias
+        # then we can just pass the value through as is
+        if type_ is None:
+            converted_object[key] = value
+        elif direction == "read" and key not in aliases_to_field_names:
+            converted_object[key] = convert_and_respect_annotation_metadata(
+                object_=value, annotation=type_, direction=direction
+            )
+        else:
+            converted_object[_alias_key(key, type_, direction, aliases_to_field_names)] = (
+                convert_and_respect_annotation_metadata(object_=value, annotation=type_, direction=direction)
+            )
+    return converted_object
+
+
+def _get_annotation(type_: typing.Any) -> typing.Optional[typing.Any]:
+    maybe_annotated_type = typing_extensions.get_origin(type_)
+    if maybe_annotated_type is None:
+        return None
+
+    if maybe_annotated_type == typing_extensions.NotRequired:
+        type_ = typing_extensions.get_args(type_)[0]
+        maybe_annotated_type = typing_extensions.get_origin(type_)
+
+    if maybe_annotated_type == typing_extensions.Annotated:
+        return type_
+
+    return None
+
+
+def _remove_annotations(type_: typing.Any) -> typing.Any:
+    maybe_annotated_type = typing_extensions.get_origin(type_)
+    if maybe_annotated_type is None:
+        return type_
+
+    if maybe_annotated_type == typing_extensions.NotRequired:
+        return _remove_annotations(typing_extensions.get_args(type_)[0])
+
+    if maybe_annotated_type == typing_extensions.Annotated:
+        return _remove_annotations(typing_extensions.get_args(type_)[0])
+
+    return type_
+
+
+def get_alias_to_field_mapping(type_: typing.Any) -> typing.Dict[str, str]:
+    annotations = typing_extensions.get_type_hints(type_, include_extras=True)
+    return _get_alias_to_field_name(annotations)
+
+
+def get_field_to_alias_mapping(type_: typing.Any) -> typing.Dict[str, str]:
+    annotations = typing_extensions.get_type_hints(type_, include_extras=True)
+    return _get_field_to_alias_name(annotations)
+
+
+def _get_alias_to_field_name(
+    field_to_hint: typing.Dict[str, typing.Any],
+) -> typing.Dict[str, str]:
+    aliases = {}
+    for field, hint in field_to_hint.items():
+        maybe_alias = _get_alias_from_type(hint)
+        if maybe_alias is not None:
+            aliases[maybe_alias] = field
+    return aliases
+
+
+def _get_field_to_alias_name(
+    field_to_hint: typing.Dict[str, typing.Any],
+) -> typing.Dict[str, str]:
+    aliases = {}
+    for field, hint in field_to_hint.items():
+        maybe_alias = _get_alias_from_type(hint)
+        if maybe_alias is not None:
+            aliases[field] = maybe_alias
+    return aliases
+
+
+def _get_alias_from_type(type_: typing.Any) -> typing.Optional[str]:
+    maybe_annotated_type = _get_annotation(type_)
+
+    if maybe_annotated_type is not None:
+        # The actual annotations are 1 onward, the first is the annotated type
+        annotations = typing_extensions.get_args(maybe_annotated_type)[1:]
+
+        for annotation in annotations:
+            if isinstance(annotation, FieldMetadata) and annotation.alias is not None:
+                return annotation.alias
+    return None
+
+
+def _alias_key(
+    key: str,
+    type_: typing.Any,
+    direction: typing.Literal["read", "write"],
+    aliases_to_field_names: typing.Dict[str, str],
+) -> str:
+    if direction == "read":
+        return aliases_to_field_names.get(key, key)
+    return _get_alias_from_type(type_=type_) or key

{vellum_ai-0.8.9 → vellum_ai-0.8.10}/src/vellum/resources/ad_hoc/client.py

@@ -112,7 +112,9 @@ class AdHocClient:
                     ),
                     id="string",
                     state="ENABLED",
-                    cache_config=EphemeralPromptCacheConfigRequest(),
+                    cache_config=EphemeralPromptCacheConfigRequest(
+                        type={"key": "value"},
+                    ),
                 )
             ],
             expand_meta=AdHocExpandMetaRequest(
@@ -288,7 +290,9 @@ class AsyncAdHocClient:
                         ),
                         id="string",
                         state="ENABLED",
-                        cache_config=EphemeralPromptCacheConfigRequest(),
+                        cache_config=EphemeralPromptCacheConfigRequest(
+                            type={"key": "value"},
+                        ),
                     )
                 ],
                 expand_meta=AdHocExpandMetaRequest(

{vellum_ai-0.8.9 → vellum_ai-0.8.10}/src/vellum/resources/test_suites/client.py

@@ -229,8 +229,18 @@ class TestSuitesClient:
                     id="string",
                     data=CreateTestSuiteTestCaseRequest(
                         label="string",
-                        input_values=[NamedTestCaseStringVariableValueRequest()],
-                        evaluation_values=[NamedTestCaseStringVariableValueRequest()],
+                        input_values=[
+                            NamedTestCaseStringVariableValueRequest(
+                                value="string",
+                                name="string",
+                            )
+                        ],
+                        evaluation_values=[
+                            NamedTestCaseStringVariableValueRequest(
+                                value="string",
+                                name="string",
+                            )
+                        ],
                         external_id="string",
                     ),
                 )
@@ -548,9 +558,17 @@ class AsyncTestSuitesClient:
                         id="string",
                         data=CreateTestSuiteTestCaseRequest(
                             label="string",
-                            input_values=[NamedTestCaseStringVariableValueRequest()],
+                            input_values=[
+                                NamedTestCaseStringVariableValueRequest(
+                                    value="string",
+                                    name="string",
+                                )
+                            ],
                             evaluation_values=[
-                                NamedTestCaseStringVariableValueRequest()
+                                NamedTestCaseStringVariableValueRequest(
+                                    value="string",
+                                    name="string",
+                                )
                             ],
                             external_id="string",
                         ),

vellum_ai-0.8.9/src/vellum/core/serialization.py

@@ -1,170 +0,0 @@
-# This file was auto-generated by Fern from our API Definition.
-
-import collections
-import typing
-
-import typing_extensions
-
-
-class FieldMetadata:
-    """
-    Metadata class used to annotate fields to provide additional information.
-
-    Example:
-    class MyDict(TypedDict):
-        field: typing.Annotated[str, FieldMetadata(alias="field_name")]
-
-    Will serialize: `{"field": "value"}`
-    To: `{"field_name": "value"}`
-    """
-
-    alias: str
-
-    def __init__(self, *, alias: str) -> None:
-        self.alias = alias
-
-
-def convert_and_respect_annotation_metadata(
-    *,
-    object_: typing.Any,
-    annotation: typing.Any,
-    inner_type: typing.Optional[typing.Any] = None,
-) -> typing.Any:
-    """
-    Respect the metadata annotations on a field, such as aliasing. This function effectively
-    manipulates the dict-form of an object to respect the metadata annotations. This is primarily used for
-    TypedDicts, which cannot support aliasing out of the box, and can be extended for additional
-    utilities, such as defaults.
-
-    Parameters
-    ----------
-    object_ : typing.Any
-
-    annotation : type
-        The type we're looking to apply typing annotations from
-
-    inner_type : typing.Optional[type]
-
-    Returns
-    -------
-    typing.Any
-    """
-
-    if object_ is None:
-        return None
-    if inner_type is None:
-        inner_type = annotation
-
-    clean_type = _remove_annotations(inner_type)
-    if typing_extensions.is_typeddict(clean_type) and isinstance(object_, typing.Mapping):
-        return _convert_typeddict(object_, clean_type)
-
-    if (
-        # If you're iterating on a string, do not bother to coerce it to a sequence.
-        (not isinstance(object_, str))
-        and (
-            (
-                (
-                    typing_extensions.get_origin(clean_type) == typing.List
-                    or typing_extensions.get_origin(clean_type) == list
-                    or clean_type == typing.List
-                )
-                and isinstance(object_, typing.List)
-            )
-            or (
-                (
-                    typing_extensions.get_origin(clean_type) == typing.Set
-                    or typing_extensions.get_origin(clean_type) == set
-                    or clean_type == typing.Set
-                )
-                and isinstance(object_, typing.Set)
-            )
-            or (
-                (
-                    typing_extensions.get_origin(clean_type) == typing.Sequence
-                    or typing_extensions.get_origin(clean_type) == collections.abc.Sequence
-                    or clean_type == typing.Sequence
-                )
-                and isinstance(object_, typing.Sequence)
-            )
-        )
-    ):
-        inner_type = typing_extensions.get_args(clean_type)[0]
-        return [
-            convert_and_respect_annotation_metadata(object_=item, annotation=annotation, inner_type=inner_type)
-            for item in object_
-        ]
-
-    if typing_extensions.get_origin(clean_type) == typing.Union:
-        # We should be able to ~relatively~ safely try to convert keys against all
-        # member types in the union, the edge case here is if one member aliases a field
-        # of the same name to a different name from another member
-        # Or if another member aliases a field of the same name that another member does not.
-        for member in typing_extensions.get_args(clean_type):
-            object_ = convert_and_respect_annotation_metadata(object_=object_, annotation=annotation, inner_type=member)
-        return object_
-
-    annotated_type = _get_annotation(annotation)
-    if annotated_type is None:
-        return object_
-
-    # If the object is not a TypedDict, a Union, or other container (list, set, sequence, etc.)
-    # Then we can safely call it on the recursive conversion.
-    return object_
-
-
-def _convert_typeddict(object_: typing.Mapping[str, object], expected_type: typing.Any) -> typing.Mapping[str, object]:
-    converted_object: typing.Dict[str, object] = {}
-    annotations = typing_extensions.get_type_hints(expected_type, include_extras=True)
-    for key, value in object_.items():
-        type_ = annotations.get(key)
-        if type_ is None:
-            converted_object[key] = value
-        else:
-            converted_object[_alias_key(key, type_)] = convert_and_respect_annotation_metadata(
-                object_=value, annotation=type_
-            )
-    return converted_object
-
-
-def _get_annotation(type_: typing.Any) -> typing.Optional[typing.Any]:
-    maybe_annotated_type = typing_extensions.get_origin(type_)
-    if maybe_annotated_type is None:
-        return None
-
-    if maybe_annotated_type == typing_extensions.NotRequired:
-        type_ = typing_extensions.get_args(type_)[0]
-        maybe_annotated_type = typing_extensions.get_origin(type_)
-
-    if maybe_annotated_type == typing_extensions.Annotated:
-        return type_
-
-    return None
-
-
-def _remove_annotations(type_: typing.Any) -> typing.Any:
-    maybe_annotated_type = typing_extensions.get_origin(type_)
-    if maybe_annotated_type is None:
-        return type_
-
-    if maybe_annotated_type == typing_extensions.NotRequired:
-        return _remove_annotations(typing_extensions.get_args(type_)[0])
-
-    if maybe_annotated_type == typing_extensions.Annotated:
-        return _remove_annotations(typing_extensions.get_args(type_)[0])
-
-    return type_
-
-
-def _alias_key(key: str, type_: typing.Any) -> str:
-    maybe_annotated_type = _get_annotation(type_)
-
-    if maybe_annotated_type is not None:
-        # The actual annotations are 1 onward, the first is the annotated type
-        annotations = typing_extensions.get_args(maybe_annotated_type)[1:]
-
-        for annotation in annotations:
-            if isinstance(annotation, FieldMetadata) and annotation.alias is not None:
-                return annotation.alias
-
-    return key