vellum-ai 0.10.6__py3-none-any.whl → 0.10.7__py3-none-any.whl

vellum/client/resources/test_suites/client.py

@@ -232,25 +232,21 @@ class TestSuitesClient:
             api_key="YOUR_API_KEY",
         )
         response = client.test_suites.test_suite_test_cases_bulk(
-            id="string",
+            id="id",
             request=[
                 TestSuiteTestCaseCreateBulkOperationRequest(
-                    id="string",
+                    id="id",
                     data=CreateTestSuiteTestCaseRequest(
-                        label="string",
                         input_values=[
                             NamedTestCaseStringVariableValueRequest(
-                                value="string",
-                                name="string",
+                                name="name",
                             )
                         ],
                         evaluation_values=[
                             NamedTestCaseStringVariableValueRequest(
-                                value="string",
-                                name="string",
+                                name="name",
                             )
                         ],
-                        external_id="string",
                     ),
                 )
             ],
@@ -571,25 +567,21 @@ class AsyncTestSuitesClient:
 
         async def main() -> None:
             response = await client.test_suites.test_suite_test_cases_bulk(
-                id="string",
+                id="id",
                 request=[
                     TestSuiteTestCaseCreateBulkOperationRequest(
-                        id="string",
+                        id="id",
                         data=CreateTestSuiteTestCaseRequest(
-                            label="string",
                             input_values=[
                                 NamedTestCaseStringVariableValueRequest(
-                                    value="string",
-                                    name="string",
+                                    name="name",
                                 )
                             ],
                             evaluation_values=[
                                 NamedTestCaseStringVariableValueRequest(
-                                    value="string",
-                                    name="string",
+                                    name="name",
                                 )
                             ],
-                            external_id="string",
                         ),
                     )
                 ],

vellum/client/resources/workflows/client.py

@@ -47,18 +47,6 @@ class WorkflowsClient:
         ------
         typing.Iterator[bytes]
 
-
-        Examples
-        --------
-        from vellum import Vellum
-
-        client = Vellum(
-            api_key="YOUR_API_KEY",
-        )
-        client.workflows.pull(
-            id="string",
-            format="json",
-        )
         """
         with self._client_wrapper.httpx_client.stream(
             f"v1/workflows/{jsonable_encoder(id)}/pull",
@@ -196,26 +184,6 @@ class AsyncWorkflowsClient:
         ------
         typing.AsyncIterator[bytes]
 
-
-        Examples
-        --------
-        import asyncio
-
-        from vellum import AsyncVellum
-
-        client = AsyncVellum(
-            api_key="YOUR_API_KEY",
-        )
-
-
-        async def main() -> None:
-            await client.workflows.pull(
-                id="string",
-                format="json",
-            )
-
-
-        asyncio.run(main())
         """
         async with self._client_wrapper.httpx_client.stream(
             f"v1/workflows/{jsonable_encoder(id)}/pull",

vellum/client/types/__init__.py

@@ -197,6 +197,7 @@ from .metadata_filter_rule_combinator import MetadataFilterRuleCombinator
 from .metadata_filter_rule_request import MetadataFilterRuleRequest
 from .metadata_filters_request import MetadataFiltersRequest
 from .metric_definition_execution import MetricDefinitionExecution
+from .metric_definition_history_item import MetricDefinitionHistoryItem
 from .metric_definition_input import MetricDefinitionInput
 from .metric_node_result import MetricNodeResult
 from .ml_model_read import MlModelRead
@@ -685,6 +686,7 @@ __all__ = [
     "MetadataFilterRuleRequest",
     "MetadataFiltersRequest",
     "MetricDefinitionExecution",
+    "MetricDefinitionHistoryItem",
     "MetricDefinitionInput",
     "MetricNodeResult",
     "MlModelRead",

vellum/client/types/metric_definition_history_item.py

@@ -0,0 +1,39 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from __future__ import annotations
+from ..core.pydantic_utilities import UniversalBaseModel
+from .array_vellum_value import ArrayVellumValue
+import pydantic
+import typing
+from .vellum_variable import VellumVariable
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+from ..core.pydantic_utilities import update_forward_refs
+
+
+class MetricDefinitionHistoryItem(UniversalBaseModel):
+    id: str
+    label: str = pydantic.Field()
+    """
+    A human-readable label for the metric
+    """
+
+    name: str = pydantic.Field()
+    """
+    A name that uniquely identifies this metric within its workspace
+    """
+
+    description: str
+    input_variables: typing.List[VellumVariable]
+    output_variables: typing.List[VellumVariable]
+
+    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
+
+
+update_forward_refs(ArrayVellumValue, MetricDefinitionHistoryItem=MetricDefinitionHistoryItem)

vellum/types/metric_definition_history_item.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.metric_definition_history_item import *

vellum/workflows/events/node.py

@@ -1,13 +1,14 @@
-from typing import Any, Dict, Generic, Literal, Type, Union
+from typing import Any, Dict, Generic, Iterable, List, Literal, Optional, Set, Type, Union
 
-from pydantic import field_serializer
+from pydantic import ConfigDict, SerializerFunctionWrapHandler, field_serializer, model_serializer
+from pydantic.main import IncEx
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
-
 from vellum.workflows.errors import VellumError
 from vellum.workflows.expressions.accessor import AccessorExpression
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.ports.port import Port
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.types.generics import OutputsType
 
@@ -21,6 +22,15 @@ class _BaseNodeExecutionBody(UniversalBaseModel):
     def serialize_node_definition(self, node_definition: Type, _info: Any) -> Dict[str, Any]:
         return serialize_type_encoder(node_definition)
 
+    # Couldn't get this to work with model_config.exclude_none or model_config.exclude_defaults
+    # so we're excluding null invoked_ports manually here for now
+    @model_serializer(mode="wrap", when_used="json")
+    def serialize_model(self, handler: SerializerFunctionWrapHandler) -> Any:
+        serialized = super().serialize_model(handler)  # type: ignore[call-arg, arg-type]
+        if "invoked_ports" in serialized and serialized["invoked_ports"] is None:
+            del serialized["invoked_ports"]
+        return serialized
+
 
 class _BaseNodeEvent(BaseEvent):
     body: _BaseNodeExecutionBody
@@ -31,6 +41,7 @@ class _BaseNodeEvent(BaseEvent):
 
 
 NodeInputName = Union[NodeReference, AccessorExpression]
+InvokedPorts = Optional[Set["Port"]]
 
 
 class NodeExecutionInitiatedBody(_BaseNodeExecutionBody):
@@ -52,11 +63,18 @@ class NodeExecutionInitiatedEvent(_BaseNodeEvent):
 
 class NodeExecutionStreamingBody(_BaseNodeExecutionBody):
     output: BaseOutput
+    invoked_ports: InvokedPorts = None
 
     @field_serializer("output")
     def serialize_output(self, output: BaseOutput, _info: Any) -> Dict[str, Any]:
         return default_serializer(output)
 
+    @field_serializer("invoked_ports")
+    def serialize_invoked_ports(self, invoked_ports: InvokedPorts, _info: Any) -> Optional[List[Dict[str, Any]]]:
+        if not invoked_ports:
+            return None
+        return [default_serializer(port) for port in invoked_ports]
+
 
 class NodeExecutionStreamingEvent(_BaseNodeEvent):
     name: Literal["node.execution.streaming"] = "node.execution.streaming"
@@ -66,14 +84,25 @@ class NodeExecutionStreamingEvent(_BaseNodeEvent):
     def output(self) -> BaseOutput:
         return self.body.output
 
+    @property
+    def invoked_ports(self) -> InvokedPorts:
+        return self.body.invoked_ports
+
 
 class NodeExecutionFulfilledBody(_BaseNodeExecutionBody, Generic[OutputsType]):
     outputs: OutputsType
+    invoked_ports: InvokedPorts = None
 
     @field_serializer("outputs")
     def serialize_outputs(self, outputs: OutputsType, _info: Any) -> Dict[str, Any]:
         return default_serializer(outputs)
 
+    @field_serializer("invoked_ports")
+    def serialize_invoked_ports(self, invoked_ports: InvokedPorts, _info: Any) -> Optional[List[Dict[str, Any]]]:
+        if invoked_ports is None:
+            return None
+        return [default_serializer(port) for port in invoked_ports]
+
 
 class NodeExecutionFulfilledEvent(_BaseNodeEvent, Generic[OutputsType]):
     name: Literal["node.execution.fulfilled"] = "node.execution.fulfilled"
@@ -83,6 +112,10 @@ class NodeExecutionFulfilledEvent(_BaseNodeEvent, Generic[OutputsType]):
     def outputs(self) -> OutputsType:
         return self.body.outputs
 
+    @property
+    def invoked_ports(self) -> InvokedPorts:
+        return self.body.invoked_ports
+
 
 class NodeExecutionRejectedBody(_BaseNodeExecutionBody):
     error: VellumError

vellum/workflows/events/tests/test_event.py

@@ -6,7 +6,14 @@ from uuid import UUID
 from deepdiff import DeepDiff
 
 from vellum.workflows.errors.types import VellumError, VellumErrorCode
-from vellum.workflows.events.node import NodeExecutionInitiatedBody, NodeExecutionInitiatedEvent
+from vellum.workflows.events.node import (
+    NodeExecutionFulfilledBody,
+    NodeExecutionFulfilledEvent,
+    NodeExecutionInitiatedBody,
+    NodeExecutionInitiatedEvent,
+    NodeExecutionStreamingBody,
+    NodeExecutionStreamingEvent,
+)
 from vellum.workflows.events.types import NodeParentContext, WorkflowParentContext
 from vellum.workflows.events.workflow import (
     WorkflowExecutionFulfilledBody,
@@ -93,10 +100,9 @@ module_root = name_parts[: name_parts.index("events")]
                     node_definition=MockNode,
                     span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
                     parent=WorkflowParentContext(
-                        workflow_definition=MockWorkflow,
-                        span_id=UUID("123e4567-e89b-12d3-a456-426614174000")
-                    )
-                )
+                        workflow_definition=MockWorkflow, span_id=UUID("123e4567-e89b-12d3-a456-426614174000")
+                    ),
+                ),
             ),
             {
                 "id": "123e4567-e89b-12d3-a456-426614174000",
@@ -126,10 +132,10 @@ module_root = name_parts[: name_parts.index("events")]
                         },
                         "type": "WORKFLOW",
                         "parent": None,
-                        "span_id": "123e4567-e89b-12d3-a456-426614174000"
+                        "span_id": "123e4567-e89b-12d3-a456-426614174000",
                     },
                     "type": "WORKFLOW_NODE",
-                    "span_id": "123e4567-e89b-12d3-a456-426614174000"
+                    "span_id": "123e4567-e89b-12d3-a456-426614174000",
                 },
             },
         ),
@@ -164,7 +170,7 @@ module_root = name_parts[: name_parts.index("events")]
                         "value": "foo",
                     },
                 },
-                "parent": None
+                "parent": None,
             },
         ),
         (
@@ -233,6 +239,78 @@ module_root = name_parts[: name_parts.index("events")]
                 "parent": None,
             },
         ),
+        (
+            NodeExecutionStreamingEvent(
+                id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                timestamp=datetime(2024, 1, 1, 12, 0, 0),
+                trace_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                body=NodeExecutionStreamingBody(
+                    node_definition=MockNode,
+                    output=BaseOutput(
+                        name="example",
+                        value="foo",
+                    ),
+                ),
+            ),
+            {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "api_version": "2024-10-25",
+                "timestamp": "2024-01-01T12:00:00",
+                "trace_id": "123e4567-e89b-12d3-a456-426614174000",
+                "span_id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "node.execution.streaming",
+                "body": {
+                    "node_definition": {
+                        "name": "MockNode",
+                        "module": module_root + ["events", "tests", "test_event"],
+                    },
+                    "output": {
+                        "name": "example",
+                        "value": "foo",
+                    },
+                },
+                "parent": None,
+            },
+        ),
+        (
+            NodeExecutionFulfilledEvent(
+                id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                timestamp=datetime(2024, 1, 1, 12, 0, 0),
+                trace_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
+                body=NodeExecutionFulfilledBody(
+                    node_definition=MockNode,
+                    outputs=MockNode.Outputs(
+                        example="foo",
+                    ),
+                    invoked_ports={MockNode.Ports.default},
+                ),
+            ),
+            {
+                "id": "123e4567-e89b-12d3-a456-426614174000",
+                "api_version": "2024-10-25",
+                "timestamp": "2024-01-01T12:00:00",
+                "trace_id": "123e4567-e89b-12d3-a456-426614174000",
+                "span_id": "123e4567-e89b-12d3-a456-426614174000",
+                "name": "node.execution.fulfilled",
+                "body": {
+                    "node_definition": {
+                        "name": "MockNode",
+                        "module": module_root + ["events", "tests", "test_event"],
+                    },
+                    "outputs": {
+                        "example": "foo",
+                    },
+                    "invoked_ports": [
+                        {
+                            "name": "default",
+                        }
+                    ],
+                },
+                "parent": None,
+            },
+        ),
     ],
     ids=[
         "workflow.execution.initiated",
@@ -240,7 +318,9 @@ module_root = name_parts[: name_parts.index("events")]
         "workflow.execution.streaming",
         "workflow.execution.fulfilled",
         "workflow.execution.rejected",
+        "node.execution.streaming",
+        "node.execution.fulfilled",
     ],
 )
 def test_event_serialization(event, expected_json):
-    assert not DeepDiff(json.loads(event.model_dump_json()), expected_json)
+    assert not DeepDiff(event.model_dump(mode="json"), expected_json)

vellum/workflows/nodes/displayable/conditional_node/node.py

@@ -1,4 +1,4 @@
-from typing import Iterable
+from typing import Set
 
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
@@ -15,7 +15,7 @@ class ConditionalNode(BaseNode):
     """
 
     class Ports(NodePorts):
-        def __call__(self, outputs: BaseOutputs, state: BaseState) -> Iterable[Port]:
+        def __call__(self, outputs: BaseOutputs, state: BaseState) -> Set[Port]:    
             all_ports = [port for port in self.__class__]
             enforce_single_invoked_port = validate_ports(all_ports)
 

vellum/workflows/ports/node_ports.py

@@ -33,7 +33,7 @@ class _NodePortsMeta(type):
 
 
 class NodePorts(metaclass=_NodePortsMeta):
-    def __call__(self, outputs: BaseOutputs, state: BaseState) -> Iterable[Port]:
+    def __call__(self, outputs: BaseOutputs, state: BaseState) -> Set[Port]:
         """
         Invokes the appropriate ports based on the fulfilled outputs and state.
         """
@@ -67,7 +67,7 @@ class NodePorts(metaclass=_NodePortsMeta):
 
         return invoked_ports
 
-    def __lt__(self, output: BaseOutput) -> Iterable[Port]:
+    def __lt__(self, output: BaseOutput) -> Set[Port]:
         """
         Invokes the appropriate ports based on the streamed output
         """

vellum/workflows/ports/port.py

@@ -1,5 +1,8 @@
 from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Type
 
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import core_schema
+
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges.edge import Edge
 from vellum.workflows.graph import Graph, GraphTarget
@@ -73,3 +76,14 @@ class Port:
 
         value = self._condition.resolve(state)
         return bool(value)
+
+    def serialize(self) -> dict:
+        return {
+            "name": self.name,
+        }
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Type[Any], handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        return core_schema.is_instance_schema(cls)

vellum/workflows/references/__init__.py

@@ -4,6 +4,7 @@ from .lazy import LazyReference
 from .node import NodeReference
 from .output import OutputReference
 from .state_value import StateValueReference
+from .vellum_secret import VellumSecretReference
 from .workflow_input import WorkflowInputReference
 
 __all__ = [
@@ -13,5 +14,6 @@ __all__ = [
     "NodeReference",
     "OutputReference",
     "StateValueReference",
+    "VellumSecretReference",
     "WorkflowInputReference",
 ]

vellum/workflows/runner/runner.py

@@ -188,9 +188,9 @@ class WorkflowRunner(Generic[StateType]):
                                 body=NodeExecutionStreamingBody(
                                     node_definition=node.__class__,
                                     output=BaseOutput(name=output.name),
+                                    invoked_ports=invoked_ports,
                                 ),
                             ),
-                            invoked_ports=invoked_ports,
                         )
                     )
 
@@ -212,9 +212,9 @@ class WorkflowRunner(Generic[StateType]):
                                     body=NodeExecutionStreamingBody(
                                         node_definition=node.__class__,
                                         output=output,
+                                        invoked_ports=invoked_ports,
                                     ),
                                 ),
-                                invoked_ports=invoked_ports,
                             )
                         )
                     elif output.is_fulfilled:
@@ -231,9 +231,9 @@ class WorkflowRunner(Generic[StateType]):
                                     body=NodeExecutionStreamingBody(
                                         node_definition=node.__class__,
                                         output=output,
+                                        invoked_ports=invoked_ports,
                                     ),
                                 ),
-                                invoked_ports=invoked_ports,
                             )
                         )
 
@@ -257,9 +257,9 @@ class WorkflowRunner(Generic[StateType]):
                         body=NodeExecutionFulfilledBody(
                             node_definition=node.__class__,
                             outputs=outputs,
+                            invoked_ports=invoked_ports,
                         ),
                     ),
-                    invoked_ports=invoked_ports,
                 )
             )
         except NodeException as e:
@@ -339,7 +339,6 @@ class WorkflowRunner(Generic[StateType]):
     def _handle_work_item_event(self, work_item_event: WorkItemEvent[StateType]) -> Optional[VellumError]:
         node = work_item_event.node
         event = work_item_event.event
-        invoked_ports = work_item_event.invoked_ports
 
         if event.name == "node.execution.initiated":
             return None
@@ -368,13 +367,13 @@ class WorkflowRunner(Generic[StateType]):
                     )
                 )
 
-            self._handle_invoked_ports(node.state, invoked_ports)
+            self._handle_invoked_ports(node.state, event.invoked_ports)
 
             return None
 
         if event.name == "node.execution.fulfilled":
             self._active_nodes_by_execution_id.pop(event.span_id)
-            self._handle_invoked_ports(node.state, invoked_ports)
+            self._handle_invoked_ports(node.state, event.invoked_ports)
 
             return None
 

vellum/workflows/runner/types.py

@@ -1,18 +1,16 @@
 """Only intenral types and enums for WorkflowRunner should be defined in this module."""
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Generic, Iterable, Optional
+from typing import TYPE_CHECKING, Generic
 
 from vellum.workflows.types.generics import StateType
 
 if TYPE_CHECKING:
     from vellum.workflows.events import NodeEvent
     from vellum.workflows.nodes.bases import BaseNode
-    from vellum.workflows.ports import Port
 
 
 @dataclass(frozen=True)
 class WorkItemEvent(Generic[StateType]):
     node: "BaseNode[StateType]"
     event: "NodeEvent"
-    invoked_ports: Optional[Iterable["Port"]] = None

vellum/workflows/state/encoder.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel
 
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
+from vellum.workflows.ports.port import Port
 from vellum.workflows.state.base import BaseState, NodeExecutionCache
 
 
@@ -22,7 +23,7 @@ class DefaultStateEncoder(JSONEncoder):
         if isinstance(obj, (BaseInputs, BaseOutputs)):
             return {descriptor.name: value for descriptor, value in obj}
 
-        if isinstance(obj, BaseOutput):
+        if isinstance(obj, (BaseOutput, Port)):
             return obj.serialize()
 
         if isinstance(obj, NodeExecutionCache):

vellum/workflows/types/tests/test_utils.py

@@ -1,5 +1,5 @@
 import pytest
-from typing import ClassVar, Generic, List, TypeVar, Union
+from typing import Any, ClassVar, Generic, List, TypeVar, Union
 
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
@@ -20,6 +20,7 @@ class ExampleClass:
     )
     zeta: ClassVar[str]
     eta: List[str]
+    kappa: Any
 
 
 T = TypeVar("T")
@@ -53,6 +54,7 @@ class ExampleNode(BaseNode):
         (ExampleInheritedClass, "alpha", (str,)),
         (ExampleInheritedClass, "beta", (int,)),
         (ExampleNode.Outputs, "iota", (str,)),
+        (ExampleClass, "kappa", (Any,)),
     ],
     ids=[
         "str",
@@ -67,6 +69,7 @@ class ExampleNode(BaseNode):
         "inherited_parent_annotation",
         "inherited_parent_class_var",
         "try_node_output",
+        "any",
     ],
 )
 def test_infer_types(cls, attr_name, expected_type):
@@ -76,9 +79,9 @@ def test_infer_types(cls, attr_name, expected_type):
 @pytest.mark.parametrize(
     "cls, expected_attr_names",
     [
-        (ExampleClass, {"alpha", "beta", "gamma", "epsilon", "zeta", "eta"}),
+        (ExampleClass, {"alpha", "beta", "gamma", "epsilon", "zeta", "eta", "kappa"}),
         (ExampleGenericClass, {"delta"}),
-        (ExampleInheritedClass, {"alpha", "beta", "gamma", "epsilon", "zeta", "eta", "theta"}),
+        (ExampleInheritedClass, {"alpha", "beta", "gamma", "epsilon", "zeta", "eta", "theta", "kappa"}),
     ],
 )
 def test_class_attr_names(cls, expected_attr_names):

vellum/workflows/types/utils.py

@@ -13,6 +13,7 @@ from typing import (
     Type,
     TypeVar,
     Union,
+    cast,
     get_args,
     get_origin,
     get_type_hints,
@@ -81,6 +82,8 @@ def infer_types(object_: Type, attr_name: str, localns: Optional[Dict[str, Any]]
                 if type_hint in type_var_mapping:
                     return (type_var_mapping[type_hint],)
                 return type_hint.__constraints__
+            if type_hint is Any:
+                return cast(Tuple[Type[Any], ...], (Any,))
 
         for base in reversed(class_.__mro__):
             class_attributes = vars(base)

{vellum_ai-0.10.6.dist-info → vellum_ai-0.10.7.dist-info}/METADATA

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