vellum-ai 0.13.19__py3-none-any.whl → 0.13.21__py3-none-any.whl

vellum/__init__.py

@@ -64,6 +64,7 @@ from .types import (
     ConditionCombinator,
     ConditionalNodeResult,
     ConditionalNodeResultData,
+    ContainerImageContainerImageTag,
     ContainerImageRead,
     CreateTestSuiteTestCaseRequest,
     DeploymentHistoryItem,
@@ -586,6 +587,7 @@ __all__ = [
     "ConditionCombinator",
     "ConditionalNodeResult",
     "ConditionalNodeResultData",
+    "ContainerImageContainerImageTag",
     "ContainerImageRead",
     "CreateTestSuiteTestCaseRequest",
     "DeploymentHistoryItem",

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

vellum/client/resources/test_suites/client.py

@@ -139,21 +139,39 @@ class TestSuitesClient:
 
         Examples
         --------
-        from vellum import NamedTestCaseStringVariableValueRequest, Vellum
+        from vellum import (
+            NamedTestCaseArrayVariableValueRequest,
+            NamedTestCaseStringVariableValueRequest,
+            StringVellumValueRequest,
+            Vellum,
+        )
 
         client = Vellum(
             api_key="YOUR_API_KEY",
         )
         client.test_suites.upsert_test_suite_test_case(
             id_="id",
+            label="Test Case 1",
             input_values=[
                 NamedTestCaseStringVariableValueRequest(
-                    name="name",
+                    value="What are your favorite colors?",
+                    name="var_1",
                 )
             ],
             evaluation_values=[
-                NamedTestCaseStringVariableValueRequest(
-                    name="name",
+                NamedTestCaseArrayVariableValueRequest(
+                    value=[
+                        StringVellumValueRequest(
+                            value="Red",
+                        ),
+                        StringVellumValueRequest(
+                            value="Green",
+                        ),
+                        StringVellumValueRequest(
+                            value="Blue",
+                        ),
+                    ],
+                    name="var_2",
                 )
             ],
         )
@@ -463,7 +481,12 @@ class AsyncTestSuitesClient:
         --------
         import asyncio
 
-        from vellum import AsyncVellum, NamedTestCaseStringVariableValueRequest
+        from vellum import (
+            AsyncVellum,
+            NamedTestCaseArrayVariableValueRequest,
+            NamedTestCaseStringVariableValueRequest,
+            StringVellumValueRequest,
+        )
 
         client = AsyncVellum(
             api_key="YOUR_API_KEY",
@@ -473,14 +496,27 @@ class AsyncTestSuitesClient:
         async def main() -> None:
             await client.test_suites.upsert_test_suite_test_case(
                 id_="id",
+                label="Test Case 1",
                 input_values=[
                     NamedTestCaseStringVariableValueRequest(
-                        name="name",
+                        value="What are your favorite colors?",
+                        name="var_1",
                     )
                 ],
                 evaluation_values=[
-                    NamedTestCaseStringVariableValueRequest(
-                        name="name",
+                    NamedTestCaseArrayVariableValueRequest(
+                        value=[
+                            StringVellumValueRequest(
+                                value="Red",
+                            ),
+                            StringVellumValueRequest(
+                                value="Green",
+                            ),
+                            StringVellumValueRequest(
+                                value="Blue",
+                            ),
+                        ],
+                        name="var_2",
                     )
                 ],
             )

vellum/client/types/__init__.py

@@ -68,6 +68,7 @@ from .components_schemas_pdf_search_result_meta_source_request import Components
 from .condition_combinator import ConditionCombinator
 from .conditional_node_result import ConditionalNodeResult
 from .conditional_node_result_data import ConditionalNodeResultData
+from .container_image_container_image_tag import ContainerImageContainerImageTag
 from .container_image_read import ContainerImageRead
 from .create_test_suite_test_case_request import CreateTestSuiteTestCaseRequest
 from .deployment_history_item import DeploymentHistoryItem
@@ -577,6 +578,7 @@ __all__ = [
     "ConditionCombinator",
     "ConditionalNodeResult",
     "ConditionalNodeResultData",
+    "ContainerImageContainerImageTag",
     "ContainerImageRead",
     "CreateTestSuiteTestCaseRequest",
     "DeploymentHistoryItem",

vellum/client/types/container_image_container_image_tag.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+import datetime as dt
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class ContainerImageContainerImageTag(UniversalBaseModel):
+    name: str
+    modified: dt.datetime
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum/client/types/container_image_read.py

@@ -4,6 +4,7 @@ from ..core.pydantic_utilities import UniversalBaseModel
 from .entity_visibility import EntityVisibility
 import datetime as dt
 import typing
+from .container_image_container_image_tag import ContainerImageContainerImageTag
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import pydantic
 
@@ -16,7 +17,7 @@ class ContainerImageRead(UniversalBaseModel):
     modified: dt.datetime
     repository: str
     sha: str
-    tags: typing.List[str]
+    tags: typing.List[ContainerImageContainerImageTag]
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/types/container_image_container_image_tag.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.container_image_container_image_tag import *

vellum/workflows/events/workflow.py

@@ -6,7 +6,7 @@ from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.errors import WorkflowError
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.references import ExternalInputReference
-from vellum.workflows.types.generics import OutputsType, StateType, WorkflowInputsType
+from vellum.workflows.types.generics import InputsType, OutputsType, StateType
 
 from .node import (
     NodeExecutionFulfilledEvent,
@@ -38,20 +38,20 @@ class _BaseWorkflowEvent(BaseEvent):
         return self.body.workflow_definition
 
 
-class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[WorkflowInputsType]):
-    inputs: WorkflowInputsType
+class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsType]):
+    inputs: InputsType
 
     @field_serializer("inputs")
-    def serialize_inputs(self, inputs: WorkflowInputsType, _info: Any) -> Dict[str, Any]:
+    def serialize_inputs(self, inputs: InputsType, _info: Any) -> Dict[str, Any]:
         return default_serializer(inputs)
 
 
-class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[WorkflowInputsType]):
+class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[InputsType]):
     name: Literal["workflow.execution.initiated"] = "workflow.execution.initiated"
-    body: WorkflowExecutionInitiatedBody[WorkflowInputsType]
+    body: WorkflowExecutionInitiatedBody[InputsType]
 
     @property
-    def inputs(self) -> WorkflowInputsType:
+    def inputs(self) -> InputsType:
         return self.body.inputs
 
 

vellum/workflows/graph/graph.py

@@ -118,6 +118,12 @@ class Graph:
         self._terminals = {other}
         return self
 
+    def __rrshift__(cls, other_cls: GraphTarget) -> "Graph":
+        if not isinstance(other_cls, set):
+            other_cls = {other_cls}
+
+        return Graph.from_set(other_cls) >> cls
+
     @property
     def entrypoints(self) -> Iterator[Type["BaseNode"]]:
         return iter(e.node_class for e in self._entrypoints)

vellum/workflows/graph/tests/test_graph.py

@@ -460,3 +460,27 @@ def test_graph__node_to_port():
 
     # AND two edges
     assert len(list(graph.edges)) == 2
+
+
+def test_graph__set_to_graph():
+    # GIVEN three nodes
+    class SourceNode(BaseNode):
+        pass
+
+    class MiddleNode(BaseNode):
+        pass
+
+    class TargetNode(BaseNode):
+        pass
+
+    # WHEN we create a graph from a set to a graph
+    graph: Graph = {SourceNode, MiddleNode} >> Graph.from_node(TargetNode)
+
+    # THEN the graph has the source node and middle node as the entrypoints
+    assert set(graph.entrypoints) == {SourceNode, MiddleNode}
+
+    # AND three nodes
+    assert len(list(graph.nodes)) == 3
+
+    # AND two edges
+    assert len(list(graph.edges)) == 2

vellum/workflows/nodes/bases/base.py

@@ -1,3 +1,4 @@
+from dataclasses import field
 from functools import cached_property, reduce
 import inspect
 from types import MappingProxyType
@@ -192,7 +193,7 @@ class _BaseNodeTriggerMeta(type):
 
 class _BaseNodeExecutionMeta(type):
     def __getattribute__(cls, name: str) -> Any:
-        if name.startswith("count") and issubclass(cls, BaseNode.Execution):
+        if name == "count" and issubclass(cls, BaseNode.Execution):
             return ExecutionCountReference(cls.node_class)
 
         return super().__getattribute__(name)
@@ -230,7 +231,7 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
     #   "Outputs" class inherits from "BaseOutputs" and do so automatically.
     #   https://app.shortcut.com/vellum/story/4008/auto-inherit-basenodeoutputs-in-outputs-classes
     class Outputs(BaseOutputs):
-        _node_class: Optional[Type["BaseNode"]] = None
+        _node_class: Type["BaseNode"] = field(init=False)
 
     class Ports(NodePorts):
         default = Port(default=True)

vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -1,16 +1,17 @@
-from typing import TYPE_CHECKING, ClassVar, Generic, Iterator, Optional, Set, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union
 
 from vellum.workflows.constants import UNDEF
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
-from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.bases.base import BaseNode, BaseNodeMeta
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.references import OutputReference
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.core import EntityInputsInterface
-from vellum.workflows.types.generics import StateType, WorkflowInputsType
+from vellum.workflows.types.generics import InputsType, StateType
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
@@ -19,15 +20,53 @@ if TYPE_CHECKING:
 InnerStateType = TypeVar("InnerStateType", bound=BaseState)
 
 
-class InlineSubworkflowNode(BaseNode[StateType], Generic[StateType, WorkflowInputsType, InnerStateType]):
+class _InlineSubworkflowNodeMeta(BaseNodeMeta):
+    def __new__(cls, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
+        node_class = super().__new__(cls, name, bases, dct)
+
+        subworkflow_attribute = dct.get("subworkflow")
+        if not subworkflow_attribute:
+            return node_class
+
+        if not issubclass(node_class, InlineSubworkflowNode):
+            raise ValueError("_InlineSubworkflowNodeMeta can only be used on subclasses of InlineSubworkflowNode")
+
+        subworkflow_outputs = getattr(subworkflow_attribute, "Outputs")
+        if not issubclass(subworkflow_outputs, BaseOutputs):
+            raise ValueError("subworkflow.Outputs must be a subclass of BaseOutputs")
+
+        outputs_class = dct.get("Outputs")
+        if not outputs_class:
+            raise ValueError("Outputs class not found in base classes")
+
+        if not issubclass(outputs_class, BaseNode.Outputs):
+            raise ValueError("Outputs class must be a subclass of BaseNode.Outputs")
+
+        for descriptor in subworkflow_outputs:
+            node_class.__annotate_outputs_class__(outputs_class, descriptor)
+
+        return node_class
+
+    def __getattribute__(cls, name: str) -> Any:
+        try:
+            return super().__getattribute__(name)
+        except AttributeError:
+            if name != "__wrapped_node__" and issubclass(cls, InlineSubworkflowNode):
+                return getattr(cls.__wrapped_node__, name)
+            raise
+
+
+class InlineSubworkflowNode(
+    BaseNode[StateType], Generic[StateType, InputsType, InnerStateType], metaclass=_InlineSubworkflowNodeMeta
+):
     """
     Used to execute a Subworkflow defined inline.
 
-    subworkflow: Type["BaseWorkflow[WorkflowInputsType, InnerStateType]"] - The Subworkflow to execute
+    subworkflow: Type["BaseWorkflow[InputsType, InnerStateType]"] - The Subworkflow to execute
     subworkflow_inputs: ClassVar[EntityInputsInterface] = {}
     """
 
-    subworkflow: Type["BaseWorkflow[WorkflowInputsType, InnerStateType]"]
+    subworkflow: Type["BaseWorkflow[InputsType, InnerStateType]"]
     subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs, Type[UNDEF]]] = UNDEF
 
     def run(self) -> Iterator[BaseOutput]:
@@ -70,7 +109,7 @@ class InlineSubworkflowNode(BaseNode[StateType], Generic[StateType, WorkflowInpu
                     value=output_value,
                 )
 
-    def _compile_subworkflow_inputs(self) -> WorkflowInputsType:
+    def _compile_subworkflow_inputs(self) -> InputsType:
         inputs_class = self.subworkflow.get_inputs_class()
         if self.subworkflow_inputs is UNDEF:
             inputs_dict = {}
@@ -85,3 +124,9 @@ class InlineSubworkflowNode(BaseNode[StateType], Generic[StateType, WorkflowInpu
             return self.subworkflow_inputs
         else:
             raise ValueError(f"Invalid subworkflow inputs type: {type(self.subworkflow_inputs)}")
+
+    @classmethod
+    def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
+        # Subclasses of InlineSubworkflowNode can override this method to provider their own
+        # approach to annotating the outputs class based on the `subworkflow.Outputs`
+        setattr(outputs_class, reference.name, reference)

vellum/workflows/runner/runner.py

@@ -65,7 +65,7 @@ from vellum.workflows.ports.port import Port
 from vellum.workflows.references import ExternalInputReference, OutputReference
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.cycle_map import CycleMap
-from vellum.workflows.types.generics import OutputsType, StateType, WorkflowInputsType
+from vellum.workflows.types.generics import InputsType, OutputsType, StateType
 
 if TYPE_CHECKING:
     from vellum.workflows import BaseWorkflow
@@ -82,8 +82,8 @@ class WorkflowRunner(Generic[StateType]):
 
     def __init__(
         self,
-        workflow: "BaseWorkflow[WorkflowInputsType, StateType]",
-        inputs: Optional[WorkflowInputsType] = None,
+        workflow: "BaseWorkflow[InputsType, StateType]",
+        inputs: Optional[InputsType] = None,
         state: Optional[StateType] = None,
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
         external_inputs: Optional[ExternalInputsArg] = None,

vellum/workflows/types/generics.py

@@ -10,5 +10,5 @@ if TYPE_CHECKING:
 NodeType = TypeVar("NodeType", bound="BaseNode")
 StateType = TypeVar("StateType", bound="BaseState")
 WorkflowType = TypeVar("WorkflowType", bound="BaseWorkflow")
-WorkflowInputsType = TypeVar("WorkflowInputsType", bound="BaseInputs")
+InputsType = TypeVar("InputsType", bound="BaseInputs")
 OutputsType = TypeVar("OutputsType", bound="BaseOutputs")

vellum/workflows/workflows/base.py

@@ -68,7 +68,7 @@ from vellum.workflows.runner.runner import ExternalInputsArg, RunFromNodeArg
 from vellum.workflows.state.base import BaseState, StateMeta
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.state.store import Store
-from vellum.workflows.types.generics import StateType, WorkflowInputsType
+from vellum.workflows.types.generics import InputsType, StateType
 from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.event_filters import workflow_event_filter
@@ -88,7 +88,7 @@ class _BaseWorkflowMeta(type):
 GraphAttribute = Union[Type[BaseNode], Graph, Set[Type[BaseNode]], Set[Graph]]
 
 
-class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkflowMeta):
+class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
     __id__: UUID = uuid4_from_hash(__qualname__)
     graph: ClassVar[GraphAttribute]
     emitters: List[BaseWorkflowEmitter]
@@ -99,7 +99,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
 
     WorkflowEvent = Union[  # type: ignore
         GenericWorkflowEvent,
-        WorkflowExecutionInitiatedEvent[WorkflowInputsType],  # type: ignore[valid-type]
+        WorkflowExecutionInitiatedEvent[InputsType],  # type: ignore[valid-type]
         WorkflowExecutionFulfilledEvent[Outputs],
         WorkflowExecutionSnapshottedEvent[StateType],  # type: ignore[valid-type]
     ]
@@ -181,7 +181,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
 
     def run(
         self,
-        inputs: Optional[WorkflowInputsType] = None,
+        inputs: Optional[InputsType] = None,
         *,
         state: Optional[StateType] = None,
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
@@ -198,7 +198,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
 
         Parameters
         ----------
-        inputs: Optional[WorkflowInputsType] = None
+        inputs: Optional[InputsType] = None
             The Inputs instance used to initiate the Workflow Execution.
 
         state: Optional[StateType] = None
@@ -288,7 +288,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
 
     def stream(
         self,
-        inputs: Optional[WorkflowInputsType] = None,
+        inputs: Optional[InputsType] = None,
         *,
         event_filter: Optional[Callable[[Type["BaseWorkflow"], WorkflowEvent], bool]] = None,
         state: Optional[StateType] = None,
@@ -307,7 +307,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
             A filter that can be used to filter events based on the Workflow Class and the event itself. If the method
             returns `False`, the event will not be yielded.
 
-        inputs: Optional[WorkflowInputsType] = None
+        inputs: Optional[InputsType] = None
             The Inputs instance used to initiate the Workflow Execution.
 
         state: Optional[StateType] = None
@@ -359,7 +359,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
     @lru_cache
     def _get_parameterized_classes(
         cls,
-    ) -> Tuple[Type[WorkflowInputsType], Type[StateType]]:
+    ) -> Tuple[Type[InputsType], Type[StateType]]:
         original_base = get_original_base(cls)
 
         inputs_type, state_type = get_args(original_base)
@@ -378,17 +378,17 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
         return (inputs_type, state_type)
 
     @classmethod
-    def get_inputs_class(cls) -> Type[WorkflowInputsType]:
+    def get_inputs_class(cls) -> Type[InputsType]:
         return cls._get_parameterized_classes()[0]
 
     @classmethod
     def get_state_class(cls) -> Type[StateType]:
         return cls._get_parameterized_classes()[1]
 
-    def get_default_inputs(self) -> WorkflowInputsType:
+    def get_default_inputs(self) -> InputsType:
         return self.get_inputs_class()()
 
-    def get_default_state(self, workflow_inputs: Optional[WorkflowInputsType] = None) -> StateType:
+    def get_default_state(self, workflow_inputs: Optional[InputsType] = None) -> StateType:
         return self.get_state_class()(
             meta=StateMeta(
                 parent=self._parent_state,

{vellum_ai-0.13.19.dist-info → vellum_ai-0.13.21.dist-info}/METADATA

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