vellum-ai 0.14.44__py3-none-any.whl → 0.14.46__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.44",
+            "X-Fern-SDK-Version": "0.14.46",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

vellum/client/core/pydantic_utilities.py

@@ -8,10 +8,13 @@ from collections import defaultdict
 import typing_extensions
 
 import pydantic
+import logging
 
 from .datetime_utils import serialize_datetime
 from .serialization import convert_and_respect_annotation_metadata
 
+logger = logging.getLogger(__name__)
+
 IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
 
 if IS_PYDANTIC_V2:
@@ -245,7 +248,10 @@ def update_forward_refs(model: typing.Type["Model"], **localns: typing.Any) -> N
     if IS_PYDANTIC_V2:
         model.model_rebuild(raise_errors=False)  # type: ignore # Pydantic v2
     else:
-        model.update_forward_refs(**localns)
+        try:
+            model.update_forward_refs(**localns)
+        except Exception as e:
+            logger.warning("[WARN] Failed to update forward refs for model %s", model.__name__)
 
 
 # Mirrors Pydantic's internal typing

vellum/workflows/nodes/bases/base.py

@@ -111,6 +111,7 @@ class BaseNodeMeta(type):
         # Add cls to relevant nested classes, since python should've been doing this by default
         for port in node_class.Ports:
             port.node_class = node_class
+            port.validate()
 
         node_class.Execution.node_class = node_class
         node_class.Trigger.node_class = node_class

vellum/workflows/nodes/bases/tests/test_base_node.py

@@ -283,3 +283,23 @@ def test_node_outputs__inherits_instance():
     assert foo_output.instance is undefined
     assert isinstance(bar_output, OutputReference)
     assert bar_output.instance == "hello"
+
+
+def test_base_node__iterate_over_attributes__preserves_order():
+    # GIVEN a node with two attributes
+    class MyNode(BaseNode):
+        foo = "foo"
+        bar = "bar"
+
+    # AND a node that inherits from MyNode
+    class InheritedNode(MyNode):
+        baz = "baz"
+        qux = "qux"
+        quux = "quux"
+
+    # WHEN we iterate over the attributes, multiple times
+    for i in range(10):
+        attribute_names = [attr.name for attr in InheritedNode]
+
+        # THEN the attributes are in the correct order
+        assert attribute_names == ["baz", "qux", "quux", "foo", "bar"], f"Iteration {i} failed"

vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py

@@ -15,7 +15,7 @@ from vellum import (
 )
 from vellum.client import ApiError, RequestOptions
 from vellum.client.types.chat_message_request import ChatMessageRequest
-from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
+from vellum.workflows.constants import LATEST_RELEASE_TAG
 from vellum.workflows.context import get_execution_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import vellum_error_to_workflow_error
@@ -48,13 +48,13 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
     deployment: ClassVar[Union[UUID, str]]
 
     release_tag: str = LATEST_RELEASE_TAG
-    external_id: Optional[str] = OMIT
+    external_id: Optional[str] = None
 
-    expand_meta: Optional[PromptDeploymentExpandMetaRequest] = OMIT
-    raw_overrides: Optional[RawPromptExecutionOverridesRequest] = OMIT
-    expand_raw: Optional[Sequence[str]] = OMIT
-    metadata: Optional[Dict[str, Optional[Any]]] = OMIT
-    ml_model_fallbacks: Optional[Sequence[str]] = OMIT
+    expand_meta: Optional[PromptDeploymentExpandMetaRequest] = None
+    raw_overrides: Optional[RawPromptExecutionOverridesRequest] = None
+    expand_raw: Optional[Sequence[str]] = None
+    metadata: Optional[Dict[str, Optional[Any]]] = None
+    ml_model_fallbacks: Optional[Sequence[str]] = None
 
     class Trigger(BasePromptNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
@@ -103,12 +103,7 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
                 prompt_event_stream = self._get_prompt_event_stream()
                 next(prompt_event_stream)
             except ApiError as e:
-                if (
-                    e.status_code
-                    and e.status_code < 500
-                    and self.ml_model_fallbacks is not OMIT
-                    and self.ml_model_fallbacks is not None
-                ):
+                if e.status_code and e.status_code < 500 and self.ml_model_fallbacks is not None:
                     prompt_event_stream = self._retry_prompt_stream_with_fallbacks(tried_fallbacks)
                 else:
                     self._handle_api_error(e)
@@ -127,7 +122,6 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
                     if (
                         event.error
                         and event.error.code == WorkflowErrorCode.PROVIDER_ERROR.value
-                        and self.ml_model_fallbacks is not OMIT
                         and self.ml_model_fallbacks is not None
                     ):
                         try:

vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py

@@ -821,3 +821,65 @@ def main(arg1: list) -> str:
 
     # AND the result should be the correct output
     assert outputs == {"result": "bar", "log": ""}
+
+
+def test_run_node__string_value_wrapper__get_attr():
+    # GIVEN a node that accesses the 'value' property of a string input
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = """\
+def main(text: str) -> str:
+    return text.value
+"""
+        code_inputs = {
+            "text": "hello",
+        }
+        runtime = "PYTHON_3_11_6"
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should successfully access the string value through the .value property
+    assert outputs == {"result": "hello", "log": ""}
+
+
+def test_run_node__string_value_wrapper__get_item():
+    # GIVEN a node that accesses the 'value' property of a string input
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = """\
+def main(text: str) -> str:
+    return text["value"]
+"""
+        code_inputs = {
+            "text": "hello",
+        }
+        runtime = "PYTHON_3_11_6"
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should successfully access the string value through the .value property
+    assert outputs == {"result": "hello", "log": ""}
+
+
+def test_run_node__string_value_wrapper__list_of_dicts():
+    # GIVEN a node that accesses the 'value' property of a string input
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Any]):
+        code = """\
+def main(output: list[str]) -> list[str]:
+    results = []
+    for item in output:
+        results.append(item['value'])
+
+    return results
+"""
+        code_inputs = {"output": ['{"foo": "bar"}', '{"foo2": "bar2"}']}
+        runtime = "PYTHON_3_11_6"
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should successfully access the string value
+    assert outputs == {"result": ['{"foo": "bar"}', '{"foo2": "bar2"}'], "log": ""}

vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -8,6 +8,7 @@ from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.utils import cast_to_output_type
 from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.types.code_execution_node_wrappers import ListWrapper, clean_for_dict_wrapper
 from vellum.workflows.types.core import EntityInputsInterface
 
 
@@ -35,58 +36,6 @@ def read_file_from_path(
         return None
 
 
-class ListWrapper(list):
-    def __getitem__(self, key):
-        item = super().__getitem__(key)
-        if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):
-            self.__setitem__(key, _clean_for_dict_wrapper(item))
-
-        return super().__getitem__(key)
-
-
-class DictWrapper(dict):
-    """
-    This wraps a dict object to make it behave basically the same as a standard javascript object
-    and enables us to use vellum types here without a shared library since we don't actually
-    typecheck things here.
-    """
-
-    def __getitem__(self, key):
-        return self.__getattr__(key)
-
-    def __getattr__(self, attr):
-        if attr not in self:
-            if attr == "value":
-                # In order to be backwards compatible with legacy Workflows, which wrapped
-                # several values as VellumValue objects, we use the "value" key to return itself
-                return self
-
-            raise AttributeError(f"dict has no key: '{attr}'")
-
-        item = super().__getitem__(attr)
-        if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):
-            self.__setattr__(attr, _clean_for_dict_wrapper(item))
-
-        return super().__getitem__(attr)
-
-    def __setattr__(self, name, value):
-        self[name] = value
-
-
-def _clean_for_dict_wrapper(obj):
-    if isinstance(obj, dict):
-        wrapped = DictWrapper(obj)
-        for key in wrapped:
-            wrapped[key] = _clean_for_dict_wrapper(wrapped[key])
-
-        return wrapped
-
-    elif isinstance(obj, list):
-        return ListWrapper(map(lambda item: _clean_for_dict_wrapper(item), obj))
-
-    return obj
-
-
 def run_code_inline(
     code: str,
     inputs: EntityInputsInterface,
@@ -107,12 +56,12 @@ def run_code_inline(
                     (
                         item.model_dump()
                         if isinstance(item, BaseModel)
-                        else _clean_for_dict_wrapper(item) if isinstance(item, (dict, list)) else item
+                        else clean_for_dict_wrapper(item) if isinstance(item, (dict, list, str)) else item
                     )
                     for item in value
                 ]
             )
-        return _clean_for_dict_wrapper(value)
+        return clean_for_dict_wrapper(value)
 
     exec_globals = {
         "__arg__inputs": {name: wrap_value(value) for name, value in inputs.items()},

vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py

@@ -9,7 +9,6 @@ from vellum import (
     PromptOutput,
     StringVellumValue,
 )
-from vellum.workflows.constants import OMIT
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes import PromptDeploymentNode
 from vellum.workflows.state import BaseState
@@ -66,14 +65,14 @@ def test_text_prompt_deployment_node__basic(vellum_client):
 
     # AND we should have made the expected call to stream the prompt execution
     vellum_client.execute_prompt_stream.assert_called_once_with(
-        expand_meta=OMIT,
-        expand_raw=OMIT,
-        external_id=OMIT,
+        expand_meta=None,
+        expand_raw=None,
+        external_id=None,
         inputs=[],
-        metadata=OMIT,
+        metadata=None,
         prompt_deployment_id=None,
         prompt_deployment_name="my-deployment",
-        raw_overrides=OMIT,
+        raw_overrides=None,
         release_tag="LATEST",
         request_options={
             "additional_body_parameters": {"execution_context": {"parent_context": None, "trace_id": mock.ANY}}

vellum/workflows/nodes/utils.py

@@ -1,4 +1,5 @@
 from functools import cache
+import inspect
 import json
 import sys
 from types import ModuleType
@@ -14,6 +15,7 @@ from vellum.workflows.nodes import BaseNode
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.ports.port import Port
 from vellum.workflows.state.base import BaseState
+from vellum.workflows.types.code_execution_node_wrappers import StringValueWrapper
 from vellum.workflows.types.core import Json
 from vellum.workflows.types.generics import NodeType
 
@@ -176,6 +178,8 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
 
 
 def _get_type_name(obj: Any) -> str:
+    if inspect.isclass(obj) and issubclass(obj, StringValueWrapper):
+        return "str"
     if isinstance(obj, type):
         return obj.__name__
 

vellum/workflows/ports/port.py

@@ -7,7 +7,7 @@ from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.edges.edge import Edge
 from vellum.workflows.errors.types import WorkflowErrorCode
-from vellum.workflows.exceptions import NodeException
+from vellum.workflows.exceptions import NodeException, WorkflowInitializationException
 from vellum.workflows.graph import Graph, GraphTarget
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import ConditionType
@@ -73,11 +73,11 @@ class Port:
         return Graph.from_edge(edge)
 
     @staticmethod
-    def on_if(condition: BaseDescriptor, fork_state: bool = False) -> "Port":
+    def on_if(condition: Optional[BaseDescriptor] = None, fork_state: bool = False):
         return Port(condition=condition, condition_type=ConditionType.IF, fork_state=fork_state)
 
     @staticmethod
-    def on_elif(condition: BaseDescriptor, fork_state: bool = False) -> "Port":
+    def on_elif(condition: Optional[BaseDescriptor] = None, fork_state: bool = False) -> "Port":
         return Port(condition=condition, condition_type=ConditionType.ELIF, fork_state=fork_state)
 
     @staticmethod
@@ -107,3 +107,13 @@ class Port:
         cls, source_type: Type[Any], handler: GetCoreSchemaHandler
     ) -> core_schema.CoreSchema:
         return core_schema.is_instance_schema(cls)
+
+    def validate(self):
+        if (
+            not self.default
+            and self._condition_type in (ConditionType.IF, ConditionType.ELIF)
+            and self._condition is None
+        ):
+            raise WorkflowInitializationException(
+                f"Class {self.node_class.__name__}'s {self.name} should have a defined condition and cannot be empty."
+            )

vellum/workflows/types/code_execution_node_wrappers.py

@@ -0,0 +1,64 @@
+class StringValueWrapper(str):
+    def __getitem__(self, key):
+        if key == "value":
+            return self
+        raise KeyError(key)
+
+    def __getattr__(self, attr):
+        if attr == "value":
+            return self
+        raise AttributeError(f"'str' object has no attribute '{attr}'")
+
+
+class ListWrapper(list):
+    def __getitem__(self, key):
+        item = super().__getitem__(key)
+        if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):
+            self.__setitem__(key, clean_for_dict_wrapper(item))
+
+        return super().__getitem__(key)
+
+
+class DictWrapper(dict):
+    """
+    This wraps a dict object to make it behave basically the same as a standard javascript object
+    and enables us to use vellum types here without a shared library since we don't actually
+    typecheck things here.
+    """
+
+    def __getitem__(self, key):
+        return self.__getattr__(key)
+
+    def __getattr__(self, attr):
+        if attr not in self:
+            if attr == "value":
+                # In order to be backwards compatible with legacy Workflows, which wrapped
+                # several values as VellumValue objects, we use the "value" key to return itself
+                return self
+
+            raise AttributeError(f"dict has no key: '{attr}'")
+
+        item = super().__getitem__(attr)
+        if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):
+            self.__setattr__(attr, clean_for_dict_wrapper(item))
+
+        return super().__getitem__(attr)
+
+    def __setattr__(self, name, value):
+        self[name] = value
+
+
+def clean_for_dict_wrapper(obj):
+    if isinstance(obj, dict):
+        wrapped = DictWrapper(obj)
+        for key in wrapped:
+            wrapped[key] = clean_for_dict_wrapper(wrapped[key])
+
+        return wrapped
+
+    elif isinstance(obj, list):
+        return ListWrapper(map(lambda item: clean_for_dict_wrapper(item), obj))
+    elif isinstance(obj, str):
+        return StringValueWrapper(obj)
+
+    return obj

vellum/workflows/types/tests/test_utils.py

@@ -83,9 +83,9 @@ def test_infer_types(cls, attr_name, expected_type):
 @pytest.mark.parametrize(
     "cls, expected_attr_names",
     [
-        (ExampleClass, {"alpha", "beta", "gamma", "epsilon", "zeta", "eta", "kappa", "mu"}),
-        (ExampleGenericClass, {"delta"}),
-        (ExampleInheritedClass, {"alpha", "beta", "gamma", "epsilon", "zeta", "eta", "theta", "kappa", "mu"}),
+        (ExampleClass, ["beta", "epsilon", "alpha", "gamma", "zeta", "eta", "kappa", "mu"]),
+        (ExampleGenericClass, ["delta"]),
+        (ExampleInheritedClass, ["theta", "beta", "epsilon", "alpha", "gamma", "zeta", "eta", "kappa", "mu"]),
     ],
 )
 def test_class_attr_names(cls, expected_attr_names):

vellum/workflows/types/utils.py

@@ -7,6 +7,7 @@ from typing import (
     ClassVar,
     Dict,
     Generic,
+    List,
     Optional,
     Set,
     Tuple,
@@ -101,22 +102,42 @@ def infer_types(object_: Type, attr_name: str, localns: Optional[Dict[str, Any]]
         )
 
 
-def get_class_attr_names(cls: Type) -> Set[str]:
-    # gets type-annotated attributes `foo: int`
-    type_annotated_attributes: Set[str] = set()
+def get_class_attr_names(cls: Type) -> List[str]:
+    # make sure we don't duplicate attributes
+    collected_attributes: Set[str] = set()
 
-    # gets attributes declared `foo = 1`
-    class_attributes: Set[str] = set()
+    # we want to preserve the order of attributes on each class
+    ordered_attr_names: List[str] = []
 
-    for base in reversed(cls.__mro__):
+    for base in cls.__mro__:
+        # gets attributes declared `foo = 1`
+        for class_attribute in vars(base).keys():
+            if class_attribute in collected_attributes:
+                continue
+
+            if class_attribute.startswith("_"):
+                continue
+
+            collected_attributes.add(class_attribute)
+            ordered_attr_names.append(class_attribute)
+
+        # gets type-annotated attributes `foo: int`
         ann = base.__dict__.get("__annotations__", {})
-        type_annotated_attributes.update(ann.keys())
+        for attr_name in ann.keys():
+            if not isinstance(attr_name, str):
+                continue
+
+            if attr_name in collected_attributes:
+                continue
+
+            if attr_name.startswith("_"):
+                continue
 
-        base_vars = vars(base).keys()
-        class_attributes.update(base_vars)
+            collected_attributes.add(attr_name)
+            ordered_attr_names.append(attr_name)
 
     # combine and filter out private attributes
-    return {a for a in list(set(class_attributes) | set(type_annotated_attributes)) if not a.startswith("_")}
+    return ordered_attr_names
 
 
 def deepcopy_with_exclusions(

vellum/workflows/vellum_client.py

@@ -1,22 +1,34 @@
 import os
-from typing import Optional
+from typing import List, Optional
 
 from vellum import Vellum, VellumEnvironment
 
 
-def create_vellum_client(api_key: Optional[str] = None) -> Vellum:
+def create_vellum_client(api_key: Optional[str] = None, api_url: Optional[str] = None) -> Vellum:
     if api_key is None:
         api_key = os.getenv("VELLUM_API_KEY", default="")
 
     return Vellum(
         api_key=api_key,
-        environment=create_vellum_environment(),
+        environment=create_vellum_environment(api_url),
     )
 
 
-def create_vellum_environment() -> VellumEnvironment:
+def create_vellum_environment(api_url: Optional[str] = None) -> VellumEnvironment:
     return VellumEnvironment(
-        default=os.getenv("VELLUM_DEFAULT_API_URL", os.getenv("VELLUM_API_URL", "https://api.vellum.ai")),
-        documents=os.getenv("VELLUM_DOCUMENTS_API_URL", os.getenv("VELLUM_API_URL", "https://documents.vellum.ai")),
-        predict=os.getenv("VELLUM_PREDICT_API_URL", os.getenv("VELLUM_API_URL", "https://predict.vellum.ai")),
+        default=_resolve_env([api_url, "VELLUM_DEFAULT_API_URL", "VELLUM_API_URL"], "https://api.vellum.ai"),
+        documents=_resolve_env([api_url, "VELLUM_DOCUMENTS_API_URL", "VELLUM_API_URL"], "https://documents.vellum.ai"),
+        predict=_resolve_env([api_url, "VELLUM_PREDICT_API_URL", "VELLUM_API_URL"], "https://predict.vellum.ai"),
     )
+
+
+def _resolve_env(names: List[Optional[str]], default: str = "") -> str:
+    for name in names:
+        if not name:
+            continue
+
+        value = os.getenv(name)
+        if value:
+            return value
+
+    return default

{vellum_ai-0.14.44.dist-info → vellum_ai-0.14.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.14.44
+Version: 0.14.46
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0