vellum-ai 0.13.1__tar.gz → 0.13.2__tar.gz

{vellum_ai-0.13.1 → vellum_ai-0.13.2}/PKG-INFO

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

{vellum_ai-0.13.1 → vellum_ai-0.13.2}/ee/vellum_cli/__init__.py

@@ -64,6 +64,11 @@ def workflows():
     is_flag=True,
     help="Check the Workflow for errors and expected changes, without updating its state in Vellum.",
 )
+@click.option(
+    "--strict",
+    is_flag=True,
+    help="Raises an error if we detect an unexpected discrepancy in the generated artifact.",
+)
 def workflows_push(
     module: Optional[str],
     deploy: Optional[bool],
@@ -72,6 +77,7 @@ def workflows_push(
     deployment_description: Optional[str],
     release_tag: Optional[List[str]],
     dry_run: Optional[bool],
+    strict: Optional[bool],
 ) -> None:
     """
     Push Workflows to Vellum. If a module is provided, only the Workflow for that module will be pushed.
@@ -86,6 +92,7 @@ def workflows_push(
         deployment_description=deployment_description,
         release_tags=release_tag,
         dry_run=dry_run,
+        strict=strict,
     )
 
 
@@ -101,6 +108,11 @@ def workflows_push(
     is_flag=True,
     help="Check the Workflow for errors and expected changes, without updating its state in Vellum.",
 )
+@click.option(
+    "--strict",
+    is_flag=True,
+    help="Raises an error if we detect an unexpected discrepancy in the generated artifact.",
+)
 def push_module(
     ctx: click.Context,
     deploy: Optional[bool],
@@ -109,6 +121,7 @@ def push_module(
     deployment_description: Optional[str],
     release_tag: Optional[List[str]],
     dry_run: Optional[bool],
+    strict: Optional[bool],
 ) -> None:
     """Push a specific module to Vellum"""
 
@@ -121,6 +134,7 @@ def push_module(
             deployment_description=deployment_description,
             release_tags=release_tag,
             dry_run=dry_run,
+            strict=strict,
         )
 
 

{vellum_ai-0.13.1 → vellum_ai-0.13.2}/ee/vellum_cli/push.py

@@ -9,6 +9,7 @@ from typing import List, Optional
 
 from dotenv import load_dotenv
 
+from vellum.client.core.api_error import ApiError
 from vellum.resources.workflows.client import OMIT
 from vellum.types import WorkflowPushDeploymentConfigRequest
 from vellum.workflows.utils.names import snake_to_title_case
@@ -28,6 +29,7 @@ def push_command(
     deployment_description: Optional[str] = None,
     release_tags: Optional[List[str]] = None,
     dry_run: Optional[bool] = None,
+    strict: Optional[bool] = None,
 ) -> None:
     load_dotenv()
     logger = load_cli_logger()
@@ -109,18 +111,66 @@ def push_command(
     artifact.seek(0)
     artifact.name = f"{workflow_config.module.replace('.', '__')}.tar.gz"
 
-    response = client.workflows.push(
-        # Remove this once we could serialize using the artifact in Vembda
-        # https://app.shortcut.com/vellum/story/5585
-        exec_config=json.dumps(exec_config),
-        label=label,
-        workflow_sandbox_id=workflow_config.workflow_sandbox_id,
-        artifact=artifact,
-        # We should check with fern if we could auto-serialize typed object fields for us
-        # https://app.shortcut.com/vellum/story/5568
-        deployment_config=deployment_config_serialized,  # type: ignore[arg-type]
-        dry_run=dry_run,
-    )
+    try:
+        response = client.workflows.push(
+            # Remove this once we could serialize using the artifact in Vembda
+            # https://app.shortcut.com/vellum/story/5585
+            exec_config=json.dumps(exec_config),
+            label=label,
+            workflow_sandbox_id=workflow_config.workflow_sandbox_id,
+            artifact=artifact,
+            # We should check with fern if we could auto-serialize typed object fields for us
+            # https://app.shortcut.com/vellum/story/5568
+            deployment_config=deployment_config_serialized,  # type: ignore[arg-type]
+            dry_run=dry_run,
+            strict=strict,
+        )
+    except ApiError as e:
+        if e.status_code != 400 or not isinstance(e.body, dict) or "diffs" not in e.body:
+            raise e
+
+        diffs: dict = e.body["diffs"]
+        generated_only = diffs.get("generated_only", [])
+        generated_only_str = (
+            "\n".join(
+                ["Files that were generated but not found in the original project:"]
+                + [f"- {file}" for file in generated_only]
+            )
+            if generated_only
+            else ""
+        )
+
+        original_only = diffs.get("original_only", [])
+        original_only_str = (
+            "\n".join(
+                ["Files that were found in the original project but not generated:"]
+                + [f"- {file}" for file in original_only]
+            )
+            if original_only
+            else ""
+        )
+
+        modified = diffs.get("modified", {})
+        modified_str = (
+            "\n\n".join(
+                ["Files that were different between the original project and the generated artifact:"]
+                + ["\n".join(line.strip() for line in lines) for lines in modified.values()]
+            )
+            if modified
+            else ""
+        )
+
+        reported_diffs = f"""\
+{e.body.get("detail")}
+
+{generated_only_str}
+
+{original_only_str}
+
+{modified_str}
+"""
+        logger.error(reported_diffs)
+        return
 
     if dry_run:
         error_messages = [str(e) for e in workflow_display.errors]

{vellum_ai-0.13.1 → vellum_ai-0.13.2}/ee/vellum_cli/tests/test_push.py

@@ -7,6 +7,7 @@ from uuid import uuid4
 
 from click.testing import CliRunner
 
+from vellum.client.core.api_error import ApiError
 from vellum.client.types.workflow_push_response import WorkflowPushResponse
 from vellum.utils.uuid import is_valid_uuid
 from vellum_cli import main as cli_main
@@ -242,3 +243,78 @@ class ExampleWorkflow(BaseWorkflow):
     assert "Serialization is not supported." in result.output
     assert "## Proposed Diffs" in result.output
     assert "iterable_item_added" in result.output
+
+
+def test_push__strict_option_returns_diffs(mock_module, vellum_client):
+    # GIVEN a single workflow configured
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+
+    # AND a workflow exists in the module successfully
+    base_dir = os.path.join(temp_dir, *module.split("."))
+    os.makedirs(base_dir, exist_ok=True)
+    workflow_py_file_content = """\
+from vellum.workflows import BaseWorkflow
+
+class ExampleWorkflow(BaseWorkflow):
+    pass
+"""
+    with open(os.path.join(temp_dir, *module.split("."), "workflow.py"), "w") as f:
+        f.write(workflow_py_file_content)
+
+    # AND the push API call returns a 4xx response with diffs
+    vellum_client.workflows.push.side_effect = ApiError(
+        status_code=400,
+        body={
+            "detail": "Failed to push workflow due to unexpected detected differences in the generated artifact.",
+            "diffs": {
+                "generated_only": ["state.py"],
+                "modified": {
+                    "workflow.py": [
+                        "--- a/workflow.py\n",
+                        "+++ b/workflow.py\n",
+                        "@@ -1 +1 @@\n",
+                        "-print('hello')",
+                        "+print('foo')",
+                    ]
+                },
+                "original_only": ["inputs.py"],
+            },
+        },
+    )
+
+    # WHEN calling `vellum push` on strict mode
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["push", module, "--strict"])
+
+    # THEN it should succeed
+    assert result.exit_code == 0
+
+    # AND we should have called the push API with the strict option
+    vellum_client.workflows.push.assert_called_once()
+    call_args = vellum_client.workflows.push.call_args.kwargs
+    assert call_args["strict"] is True
+
+    # AND the report should be in the output
+    assert (
+        result.output
+        == """\
+\x1b[38;20mLoading workflow from examples.mock.test_push__strict_option_returns_diffs\x1b[0m
+\x1b[31;20mFailed to push workflow due to unexpected detected differences in the generated artifact.
+
+Files that were generated but not found in the original project:
+- state.py
+
+Files that were found in the original project but not generated:
+- inputs.py
+
+Files that were different between the original project and the generated artifact:
+
+--- a/workflow.py
++++ b/workflow.py
+@@ -1 +1 @@
+-print('hello')
++print('foo')
+\x1b[0m
+"""
+    )

{vellum_ai-0.13.1 → vellum_ai-0.13.2}/ee/vellum_ee/workflows/display/nodes/vellum/base_node.py

@@ -1,5 +1,6 @@
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, TypeVar, cast
 
+from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.between import BetweenExpression
 from vellum.workflows.expressions.is_not_null import IsNotNullExpression
@@ -12,6 +13,7 @@ from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.references.workflow_input import WorkflowInputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.vellum.utils import convert_descriptor_to_operator
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -26,6 +28,18 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
         node = self._node
         node_id = self.node_id
 
+        attributes: JsonArray = []
+        for attribute in node:
+            id = str(uuid4_from_hash(f"{node_id}|{attribute.name}"))
+
+            attributes.append(
+                {
+                    "id": id,
+                    "name": attribute.name,
+                    "value": self.serialize_value(display_context, cast(BaseDescriptor, attribute.instance)),
+                }
+            )
+
         ports: JsonArray = []
         for idx, port in enumerate(node.Ports):
             id = str(uuid4_from_hash(f"{node_id}|{idx}"))
@@ -34,6 +48,7 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
                 ports.append(
                     {
                         "id": id,
+                        "name": port.name,
                         "type": port._condition_type.value,
                         "expression": (
                             self.serialize_condition(display_context, port._condition) if port._condition else None
@@ -44,10 +59,29 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
                 ports.append(
                     {
                         "id": id,
+                        "name": port.name,
                         "type": "DEFAULT",
                     }
                 )
 
+        outputs: JsonArray = []
+        for output in node.Outputs:
+            type = primitive_type_to_vellum_variable_type(output)
+            value = (
+                self.serialize_value(display_context, output.instance)
+                if output.instance is not None and output.instance != UNDEF
+                else None
+            )
+
+            outputs.append(
+                {
+                    "id": str(uuid4_from_hash(f"{node_id}|{output.name}")),
+                    "name": output.name,
+                    "type": type,
+                    "value": value,
+                }
+            )
+
         return {
             "id": str(node_id),
             "label": node.__qualname__,
@@ -61,7 +95,8 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
             },
             "ports": ports,
             "adornments": None,
-            "attributes": [],
+            "attributes": attributes,
+            "outputs": outputs,
         }
 
     def get_generic_node_display_data(self) -> GenericNodeDisplayData:

{vellum_ai-0.13.1 → vellum_ai-0.13.2}/ee/vellum_ee/workflows/display/tests/test_vellum_workflow_display.py

@@ -1,4 +1,10 @@
+from uuid import UUID
+
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.state import BaseState
 from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.vellum import WorkflowInputsVellumDisplayOverrides
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
 
@@ -40,3 +46,45 @@ def test_vellum_workflow_display__serialize_empty_workflow():
             ],
         },
     }
+
+
+def test_vellum_workflow_display__serialize_input_variables_with_capitalized_variable_override():
+    # GIVEN a workflow with input variables
+    class Inputs(BaseInputs):
+        foo: str
+
+    class StartNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            output = Inputs.foo
+
+    class ExampleWorkflow(BaseWorkflow[Inputs, BaseState]):
+        graph = StartNode
+
+    class ExampleWorkflowDisplay(VellumWorkflowDisplay[ExampleWorkflow]):
+        inputs_display = {
+            Inputs.foo: WorkflowInputsVellumDisplayOverrides(
+                id=UUID("97b63d71-5413-417f-9cf5-49e1b4fd56e4"), name="Foo", required=True
+            )
+        }
+
+    display = get_workflow_display(
+        base_display_class=ExampleWorkflowDisplay,
+        workflow_class=ExampleWorkflow,
+    )
+
+    # WHEN serializing the workflow
+    exec_config = display.serialize()
+
+    # THEN the input variables are what we expect
+    input_variables = exec_config["input_variables"]
+
+    assert input_variables == [
+        {
+            "id": "97b63d71-5413-417f-9cf5-49e1b4fd56e4",
+            "key": "Foo",
+            "type": "STRING",
+            "default": None,
+            "required": True,
+            "extensions": {"color": None},
+        }
+    ]

vellum_ai-0.13.2/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -0,0 +1,286 @@
+from uuid import uuid4
+
+from deepdiff import DeepDiff
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.references.vellum_secret import VellumSecretReference
+from vellum_ee.workflows.display.base import WorkflowInputsDisplay
+from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
+from vellum_ee.workflows.display.nodes.vellum.base_node import BaseNodeDisplay
+
+
+class Inputs(BaseInputs):
+    input: str
+
+
+class ConstantValueGenericNode(BaseNode):
+    attr: str = "hello"
+
+
+def test_serialize_node__constant_value(serialize_node):
+    input_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=ConstantValueGenericNode,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=input_id)},
+    )
+
+    assert not DeepDiff(
+        {
+            "id": "be892bc8-e4de-47ef-ab89-dc9d869af1fe",
+            "label": "ConstantValueGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "ConstantValueGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "279e8228-9b82-43a3-8c31-affc036e3a0b", "merge_behavior": "AWAIT_ANY"},
+            "ports": [{"id": "e6cf13b0-5590-421c-84f2-5a0b169677e1", "type": "DEFAULT", "name": "default"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "4cbbfd98-9ab6-41a8-bf4e-ae65f0eafe47",
+                    "name": "attr",
+                    "value": {
+                        "type": "CONSTANT_VALUE",
+                        "value": {
+                            "type": "STRING",
+                            "value": "hello",
+                        },
+                    },
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+class WorkflowInputGenericNode(BaseNode):
+    attr: str = Inputs.input
+
+
+def test_serialize_node__workflow_input(serialize_node):
+    input_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=WorkflowInputGenericNode,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=input_id)},
+    )
+    assert not DeepDiff(
+        {
+            "id": "ddfa947f-0830-476b-b07e-ac573968f9a7",
+            "label": "WorkflowInputGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "WorkflowInputGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "b1a5d749-bac0-4f11-8427-191febb2198e", "merge_behavior": "AWAIT_ANY"},
+            "ports": [{"id": "f013bf3f-49f6-41cd-ac13-7439b71a304a", "type": "DEFAULT", "name": "default"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "56d44313-cfdd-4d75-9b19-0beb94e59c4e",
+                    "name": "attr",
+                    "value": {
+                        "type": "WORKFLOW_INPUT",
+                        "input_variable_id": str(input_id),
+                    },
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+class NodeWithOutput(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        output = Inputs.input
+
+
+class NodeWithOutputDisplay(BaseNodeDisplay[NodeWithOutput]):
+    pass
+
+
+class GenericNodeReferencingOutput(BaseNode):
+    attr = NodeWithOutput.Outputs.output
+
+
+def test_serialize_node__node_output(serialize_node):
+    workflow_input_id = uuid4()
+    node_output_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=GenericNodeReferencingOutput,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=workflow_input_id)},
+        global_node_displays={NodeWithOutput: NodeWithOutputDisplay()},
+        global_node_output_displays={
+            NodeWithOutput.Outputs.output: (NodeWithOutput, NodeOutputDisplay(id=node_output_id, name="output"))
+        },
+    )
+
+    assert not DeepDiff(
+        {
+            "id": "c1e2ce60-ac3a-4b17-915e-abe861734e03",
+            "label": "GenericNodeReferencingOutput",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "GenericNodeReferencingOutput",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "449072ba-f7b6-4314-ac96-682123f225e5", "merge_behavior": "AWAIT_ANY"},
+            "ports": [{"id": "ec9a79b8-65c3-4de8-bd29-42c914d72d4f", "type": "DEFAULT", "name": "default"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "73e6a103-1339-41ec-a245-42d43b0637c1",
+                    "name": "attr",
+                    "value": {
+                        "type": "NODE_OUTPUT",
+                        "node_id": "cd954d76-0b0a-4d9b-9bdf-347179c38cb6",
+                        "node_output_id": str(node_output_id),
+                    },
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+class VellumSecretGenericNode(BaseNode):
+    attr = VellumSecretReference(name="hello")
+
+
+def test_serialize_node__vellum_secret(serialize_node):
+    input_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=VellumSecretGenericNode,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=input_id)},
+    )
+    assert not DeepDiff(
+        {
+            "id": "89aa6faa-b533-4179-8912-70a048bf0712",
+            "label": "VellumSecretGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "VellumSecretGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "3ea0305d-d8ea-45fe-8cf1-f6c1c85e6979", "merge_behavior": "AWAIT_ANY"},
+            "ports": [{"id": "69e49322-8f8a-42d2-b36f-3fbe53dad616", "type": "DEFAULT", "name": "default"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "8edd27da-eec1-4539-8bec-629b5ef7a9f9",
+                    "name": "attr",
+                    "value": {"type": "VELLUM_SECRET", "vellum_secret_name": "hello"},
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+class NodeWithExecutions(BaseNode):
+    pass
+
+
+class NodeWithExecutionsDisplay(BaseNodeDisplay[NodeWithExecutions]):
+    pass
+
+
+class GenericNodeReferencingExecutions(BaseNode):
+    attr: int = NodeWithExecutions.Execution.count
+
+
+def test_serialize_node__node_execution(serialize_node):
+    workflow_input_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=GenericNodeReferencingExecutions,
+        global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=workflow_input_id)},
+        global_node_displays={NodeWithExecutions: NodeWithExecutionsDisplay()},
+    )
+
+    assert not DeepDiff(
+        {
+            "id": "6e4d2fb7-891e-492e-97a1-adf44693f518",
+            "label": "GenericNodeReferencingExecutions",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "GenericNodeReferencingExecutions",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "68a91426-4c30-4194-a4c0-cff224d3c0f3", "merge_behavior": "AWAIT_ANY"},
+            "ports": [{"id": "1794c2eb-5cab-49fe-9354-dfc29f11b374", "type": "DEFAULT", "name": "default"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "090e18d7-d5b9-4d5f-9aec-0f562e4b33a8",
+                    "name": "attr",
+                    "value": {
+                        "type": "EXECUTION_COUNTER",
+                        "node_id": "c09bd5a6-dc04-4036-90d4-580acd43c71f",
+                    },
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )