vellum-ai 0.14.22__tar.gz → 0.14.23__tar.gz

vellum_ai-0.14.23/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: vellum-ai
+Version: 0.14.23
+Summary: 
+License: MIT
+Requires-Python: >=3.9,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: Jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: cdktf (>=0.20.5,<0.21.0)
+Requires-Dist: click (==8.1.7)
+Requires-Dist: docker (==7.1.0)
+Requires-Dist: httpx (>=0.21.2)
+Requires-Dist: openai (>=1.0.0)
+Requires-Dist: orderly-set (>=5.2.2,<6.0.0)
+Requires-Dist: publication (==0.0.3)
+Requires-Dist: pydantic (>=1.9.2)
+Requires-Dist: pydantic-core (>=2.18.2,<3.0.0)
+Requires-Dist: pydash (==7.0.6)
+Requires-Dist: python-dotenv (==1.0.1)
+Requires-Dist: pytz (==2025.1)
+Requires-Dist: pyyaml (==6.0.2)
+Requires-Dist: requests (==2.32.3)
+Requires-Dist: tomli (==2.0.2)
+Requires-Dist: typing_extensions (>=4.0.0)
+Project-URL: Repository, https://github.com/vellum-ai/vellum-python-sdks
+Description-Content-Type: text/markdown
+
+<p align="center">
+   <a href="https://vellum.ai">
+    <picture>
+      <img alt="Vellum README banner" src="https://storage.googleapis.com/vellum-public/assets/github-readme-banner.png" height="128">
+    </picture>
+  </a>
+  <p align="center">
+    <a href="https://vellum.ai">Learn more</a>
+    ·
+    <a href="https://www.vellum.ai/landing-pages/request-demo">Talk to us</a>
+  </p>
+</p>
+
+<p align="center">
+  <a href="https://pepy.tech/project/vellum-ai">
+    <img src="https://img.shields.io/pypi/dm/vellum-ai" alt="Vellum AI PyPI - Downloads" >
+  </a>
+  <a href="https://pypi.org/project/vellum-ai" target="_blank">
+    <img src="https://img.shields.io/pypi/v/vellum-ai?color=%2334D058&label=pypi%20package" alt="Package version">
+  </a>
+  <a href="https://www.ycombinator.com/companies/vellum">
+    <img src="https://img.shields.io/badge/Y%20Combinator-W23-orange?style=flat-square" alt="Y Combinator S24">
+  </a>
+</p>
+
+# Introduction
+
+[Vellum](https://www.vellum.ai/) is the end-to-end development platform for building production-grade AI applications.
+
+### Core Features
+
+- **Orchestration:** A powerful SDK and IDE for defining and debugging the control flow of your AI applications
+- **Prompting:** A best-in-class prompt playground for iterating on and refining prompts between models from any provider
+- **Evaluations**: An evaluations framework that makes it easy to measure the quality of your AI systems at scale
+- **Retrieval:** A ready-to-go service for turning unstructured content into intelligent, context-aware solutions
+  optimized for AI systems
+- **Deployment:** Decouple updates to your AI systems from your application code with an easy integration +
+  one-click deploy
+- **Observability:** Monitor and debug your AI systems in real-time with detailed logs, metrics, and end-user feedback
+
+## Table of Contents
+
+- [Get Started](#get-started)
+- [Client SDK](#client-sdk)
+- [Workflows SDK](#workflows-sdk)
+- [Contributing](#contributing)
+- [Open-source vs paid](#open-source-vs-paid)
+
+## Get Started
+
+Most functionality within the Vellum SDK requires a Vellum account and API key. You can sign up for free [here](https://app.vellum.ai/signup?f=wsdk&utm_source=github&utm_medium=repo_readme&utm_campaign=sdk) or visit our [pricing page](https://www.vellum.ai/pricing) for paid options.
+
+Even without a Vellum account, you can use the Workflows SDK to define the control flow of your AI systems. [Learn
+more below](#workflows-sdk).
+
+## Client SDK
+
+The Vellum Client SDK, found within `src/vellum/client` is a low-level client used to interact directly with the Vellum API.
+Learn more and get started by visiting the [Vellum Client SDK README](/src/vellum/client/README.md).
+
+## Workflows SDK
+
+The Vellum Workflows SDK is a high-level framework for defining and debugging the control flow of AI systems. At
+it's core, it's a powerful workflow engine with syntactic sugar for declaratively defining graphs, the nodes within,
+and the relationships between them.
+
+The Workflows SDK can be used with or without a Vellum account, but a Vellum account is required to use certain
+out-of-box nodes and features, including the ability to push and pull your Workflow definition to Vellum for editing
+and debugging via a UI.
+
+To learn more and get started, visit the [Vellum Workflows SDK README](/src/vellum/workflows/README.md).
+
+## Contributing
+
+See the [CONTRIBUTING.md](/CONTRIBUTING.md) for information on how to contribute to the Vellum SDKs.
+
+## Open-Source vs. Paid
+
+This repo is available under the [MIT expat license](https://github.com/vellum-ai/vellum-python-sdks/blob/main/LICENSE), except
+for the `ee` directory (which has its [license here](https://github.com/vellum-ai/vellum-python-sdks/blob/main/ee/LICENSE)) if applicable.
+
+To learn more, [book a demo](https://www.vellum.ai/landing-pages/request-demo) or see our [pricing page](https://www.vellum.ai/pricing).
+

vellum_ai-0.14.23/ee/vellum_ee/workflows/display/nodes/vellum/final_output_node.py

@@ -0,0 +1,70 @@
+from uuid import UUID
+from typing import Any, ClassVar, Generic, Optional, TypeVar
+
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.types.core import JsonObject
+from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.utils import to_kebab_case
+from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
+
+_FinalOutputNodeType = TypeVar("_FinalOutputNodeType", bound=FinalOutputNode)
+
+
+class BaseFinalOutputNodeDisplay(BaseNodeVellumDisplay[_FinalOutputNodeType], Generic[_FinalOutputNodeType]):
+    output_id: ClassVar[Optional[UUID]] = None
+    output_name: ClassVar[Optional[str]] = None
+    node_input_id: ClassVar[Optional[UUID]] = None
+
+    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        node_input = create_node_input(
+            node_id,
+            "node_input",
+            # Get the pointer that the Terminal Node's output is referencing
+            node.Outputs.value.instance,
+            display_context,
+            self._get_node_input_id(),
+        )
+        inferred_type = infer_vellum_variable_type(node.Outputs.value)
+
+        return {
+            "id": str(node_id),
+            "type": "TERMINAL",
+            "data": {
+                "label": self.label,
+                "name": self._get_output_name(),
+                "target_handle_id": str(self.get_target_handle_id()),
+                "output_id": str(self._get_output_id()),
+                "output_type": inferred_type,
+                "node_input_id": str(node_input.id),
+            },
+            "inputs": [node_input.dict()],
+            "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
+            "definition": self.get_definition().dict(),
+            "outputs": [
+                {
+                    "id": str(self._get_output_id()),
+                    "name": node.Outputs.value.name,
+                    "type": inferred_type,
+                    "value": self.serialize_value(display_context, node.Outputs.value.instance),
+                }
+            ],
+        }
+
+    def _get_output_id(self) -> UUID:
+        explicit_value = self._get_explicit_node_display_attr("output_id", UUID)
+        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|output_id")
+
+    def _get_output_name(self) -> str:
+        explicit_value = self._get_explicit_node_display_attr("output_name", str)
+        return explicit_value if explicit_value else to_kebab_case(self._node.__name__)
+
+    def _get_node_input_id(self) -> UUID:
+        explicit_value = self._get_explicit_node_display_attr("node_input_id", UUID)
+        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|node_input_id")

vellum_ai-0.14.23/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py

@@ -0,0 +1,110 @@
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_final_output_node.workflow import BasicFinalOutputNodeWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a Final Output Node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=BasicFinalOutputNodeWorkflow
+    )
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+    assert input_variables == [
+        {
+            "id": "e39a7b63-de15-490a-ae9b-8112c767aea0",
+            "key": "input",
+            "type": "STRING",
+            "required": True,
+            "default": None,
+            "extensions": {"color": None},
+        }
+    ]
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert output_variables == [
+        {
+            "id": "a34cd21e-40e5-47f4-8fdb-910593f3e9e2",
+            "key": "value",
+            "type": "STRING",
+        }
+    ]
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert workflow_raw_data.keys() == {"edges", "nodes", "display_data", "definition"}
+    assert len(workflow_raw_data["edges"]) == 1
+    assert len(workflow_raw_data["nodes"]) == 2
+
+    # AND each node should be serialized correctly
+    entrypoint_node = workflow_raw_data["nodes"][0]
+    assert entrypoint_node == {
+        "id": "631e2789-d60d-4088-9e3a-0ea93517075b",
+        "type": "ENTRYPOINT",
+        "inputs": [],
+        "data": {"label": "Entrypoint Node", "source_handle_id": "8b8d52a2-844f-44fe-a6c4-142fa70d391b"},
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "base": None,
+        "definition": None,
+    }
+
+    final_output_node = workflow_raw_data["nodes"][1]
+    assert final_output_node == {
+        "id": "620ec17b-e330-4212-b619-3c39dc63fb22",
+        "type": "TERMINAL",
+        "data": {
+            "label": "Basic Final Output Node",
+            "name": "basic-final-output-node",
+            "target_handle_id": "0173d3c6-11d1-44b7-b070-ca9ff5119046",
+            "output_id": "97349956-d228-4b51-a64b-1331f788373f",
+            "output_type": "STRING",
+            "node_input_id": "5322567a-f40c-400a-96b3-c3b054db543e",
+        },
+        "inputs": [
+            {
+                "id": "5322567a-f40c-400a-96b3-c3b054db543e",
+                "key": "node_input",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "e39a7b63-de15-490a-ae9b-8112c767aea0"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            }
+        ],
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "base": {
+            "name": "FinalOutputNode",
+            "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+        },
+        "definition": {
+            "name": "BasicFinalOutputNode",
+            "module": ["tests", "workflows", "basic_final_output_node", "workflow"],
+        },
+        "outputs": [
+            {
+                "id": "97349956-d228-4b51-a64b-1331f788373f",
+                "name": "value",
+                "type": "STRING",
+                "value": {"type": "WORKFLOW_INPUT", "input_variable_id": "e39a7b63-de15-490a-ae9b-8112c767aea0"},
+            }
+        ],
+    }

vellum_ai-0.14.23/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py

@@ -0,0 +1,190 @@
+import pytest
+
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.complex_final_output_node.missing_final_output_node import MissingFinalOutputNodeWorkflow
+from tests.workflows.complex_final_output_node.missing_workflow_output import MissingWorkflowOutputWorkflow
+
+
+def test_serialize_workflow__missing_final_output_node():
+    # GIVEN a Workflow that is missing a Terminal Node
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=MissingFinalOutputNodeWorkflow
+    )
+
+    # WHEN we serialize it
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 2
+    assert not DeepDiff(
+        [
+            {
+                "id": "da086239-d743-4246-b666-5c91e22fb88c",
+                "key": "alpha",
+                "type": "STRING",
+                "required": True,
+                "default": None,
+                "extensions": {"color": None},
+            },
+            {
+                "id": "a8b6c5d4-a0e9-4457-834b-46b633c466a6",
+                "key": "beta",
+                "type": "STRING",
+                "required": True,
+                "default": None,
+                "extensions": {"color": None},
+            },
+        ],
+        input_variables,
+        ignore_order=True,
+    )
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+    assert not DeepDiff(
+        [
+            {"id": "a360aef6-3bb4-4c56-b407-478042ef224d", "key": "alpha", "type": "STRING"},
+            {"id": "5e6d3ea6-ef91-4937-8fff-f33e07446e6a", "key": "beta", "type": "STRING"},
+        ],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert workflow_raw_data.keys() == {"edges", "nodes", "display_data", "definition"}
+    assert len(workflow_raw_data["edges"]) == 3
+    assert len(workflow_raw_data["nodes"]) == 4
+
+    # AND each node should be serialized correctly
+    entrypoint_node = workflow_raw_data["nodes"][0]
+    assert entrypoint_node == {
+        "id": "b109349f-ca1b-4a5a-a66e-a1321cf297f7",
+        "type": "ENTRYPOINT",
+        "inputs": [],
+        "data": {"label": "Entrypoint Node", "source_handle_id": "943ac183-d107-4604-aed1-619bd7fef09c"},
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "base": None,
+        "definition": None,
+    }
+
+    passthrough_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "GENERIC")
+    assert passthrough_node["id"] == "32d88cab-e9fa-4a56-9bc2-fb6e1fd0897f"
+
+    final_output_nodes = [node for node in workflow_raw_data["nodes"] if node["type"] == "TERMINAL"]
+    assert not DeepDiff(
+        [
+            {
+                "id": "acc91103-f761-47a5-bdd4-0e5e7650bb30",
+                "type": "TERMINAL",
+                "data": {
+                    "label": "First Final Output Node",
+                    "name": "first-final-output-node",
+                    "target_handle_id": "a0c2eb7a-398e-4f28-b63d-f3bae9b563ee",
+                    "output_id": "5517e50d-7f40-4f7c-acb2-e329d79a25bf",
+                    "output_type": "STRING",
+                    "node_input_id": "16363762-c14a-4162-8fab-525079d3cffe",
+                },
+                "inputs": [
+                    {
+                        "id": "16363762-c14a-4162-8fab-525079d3cffe",
+                        "key": "node_input",
+                        "value": {
+                            "rules": [
+                                {
+                                    "type": "INPUT_VARIABLE",
+                                    "data": {"input_variable_id": "da086239-d743-4246-b666-5c91e22fb88c"},
+                                }
+                            ],
+                            "combinator": "OR",
+                        },
+                    }
+                ],
+                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "base": {
+                    "name": "FinalOutputNode",
+                    "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+                },
+                "definition": {
+                    "name": "FirstFinalOutputNode",
+                    "module": ["tests", "workflows", "complex_final_output_node", "missing_final_output_node"],
+                },
+                "outputs": [
+                    {
+                        "id": "5517e50d-7f40-4f7c-acb2-e329d79a25bf",
+                        "name": "value",
+                        "type": "STRING",
+                        "value": {
+                            "type": "WORKFLOW_INPUT",
+                            "input_variable_id": "da086239-d743-4246-b666-5c91e22fb88c",
+                        },
+                    }
+                ],
+            },
+            {
+                "id": "bb88768d-472e-4997-b7ea-de09163d1b4c",
+                "type": "TERMINAL",
+                "data": {
+                    "label": "Final Output",
+                    "name": "beta",
+                    "target_handle_id": "5e337b19-cef6-45af-802b-46da4ad7e794",
+                    "output_id": "5e6d3ea6-ef91-4937-8fff-f33e07446e6a",
+                    "output_type": "STRING",
+                    "node_input_id": "590161f1-20ed-4339-9ce3-61aade3a142a",
+                },
+                "inputs": [
+                    {
+                        "id": "590161f1-20ed-4339-9ce3-61aade3a142a",
+                        "key": "node_input",
+                        "value": {
+                            "rules": [
+                                {
+                                    "type": "NODE_OUTPUT",
+                                    "data": {
+                                        "node_id": "32d88cab-e9fa-4a56-9bc2-fb6e1fd0897f",
+                                        "output_id": "04df0e76-690a-4ae1-ab52-fe825a334dcc",
+                                    },
+                                }
+                            ],
+                            "combinator": "OR",
+                        },
+                    }
+                ],
+                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "base": {
+                    "name": "FinalOutputNode",
+                    "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+                },
+                "definition": None,
+            },
+        ],
+        final_output_nodes,
+        ignore_order=True,
+    )
+
+
+def test_serialize_workflow__missing_workflow_output():
+    # GIVEN a Workflow that contains a terminal node that is unreferenced by the Workflow's Outputs
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=MissingWorkflowOutputWorkflow
+    )
+
+    # WHEN we serialize it, it should throw an error
+    with pytest.raises(ValueError) as exc_info:
+        workflow_display.serialize()
+
+    assert exc_info.value.args[0] == "Unable to serialize terminal nodes that are not referenced by workflow outputs."