vellum-ai 1.2.5__py3-none-any.whl → 1.3.1__py3-none-any.whl

vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -142,41 +142,15 @@ def test_serialize_node__lazy_reference(serialize_node):
         attr: str = LazyReference(lambda: ConstantValueReference("hello"))
 
     serialized_node = serialize_node(LazyReferenceGenericNode)
+    attributes = serialized_node["attributes"]
 
-    assert not DeepDiff(
+    assert attributes == [
         {
-            "id": "3d6bfe3b-263a-40a6-8a05-98288e9559a4",
-            "label": "Lazy Reference Generic Node",
-            "type": "GENERIC",
-            "display_data": {"position": {"x": 0.0, "y": 0.0}},
-            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
-            "definition": {
-                "name": "LazyReferenceGenericNode",
-                "module": [
-                    "vellum_ee",
-                    "workflows",
-                    "display",
-                    "tests",
-                    "workflow_serialization",
-                    "generic_nodes",
-                    "test_attributes_serialization",
-                ],
-            },
-            "trigger": {"id": "14ec4d19-13e5-4db3-94fa-4e15274bffc7", "merge_behavior": "AWAIT_ATTRIBUTES"},
-            "ports": [{"id": "2dba7224-a376-4780-8414-2b50601f9283", "name": "default", "type": "DEFAULT"}],
-            "adornments": None,
-            "attributes": [
-                {
-                    "id": "7ae37eb4-18c8-49e1-b5ac-6369ce7ed5dd",
-                    "name": "attr",
-                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "hello"}},
-                }
-            ],
-            "outputs": [],
-        },
-        serialized_node,
-        ignore_order=True,
-    )
+            "id": "7ae37eb4-18c8-49e1-b5ac-6369ce7ed5dd",
+            "name": "attr",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "hello"}},
+        }
+    ]
 
 
 def test_serialize_node__lazy_reference_with_string():

vellum_ee/workflows/display/utils/events.py

@@ -26,6 +26,9 @@ def _should_mark_workflow_dynamic(event: WorkflowExecutionInitiatedEvent) -> boo
 
 
 def event_enricher(event: WorkflowExecutionInitiatedEvent) -> WorkflowExecutionInitiatedEvent:
+    if event.name != "workflow.execution.initiated":
+        return event
+
     workflow_definition = event.body.workflow_definition
     workflow_display = get_workflow_display(
         workflow_class=workflow_definition,

vellum_ee/workflows/tests/test_server.py

@@ -9,6 +9,7 @@ from vellum.workflows import BaseWorkflow
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.utils.uuids import generate_workflow_deployment_prefix
+from vellum.workflows.utils.zip import zip_file_map
 from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 from vellum_ee.workflows.server.virtual_file_loader import VirtualFileFinder
 
@@ -661,3 +662,117 @@ __all__ = ["TestNode"]
 
     # AND the method should return a workflow (not None) - this will pass once implemented
     assert event.name == "workflow.execution.fulfilled"
+
+
+def test_resolve_workflow_deployment__uses_pull_api_with_inputs_deployment_name(vellum_client):
+    """
+    Test that resolve_workflow_deployment uses the pull API to fetch subworkflow files
+    when the deployment name comes from Inputs.deployment_name.
+    """
+    # GIVEN a deployment name and release tag
+    deployment_name = "test_deployment"
+    release_tag = "LATEST"
+
+    test_node_code = """
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.outputs import BaseOutputs
+
+class TestNode(BaseNode):
+    template = "Hello"
+
+    class Outputs(BaseOutputs):
+        result: str
+
+    def run(self):
+        return self.Outputs(result="Hello, {template}")
+"""
+
+    mock_workflow_code = """
+from vellum.workflows import BaseWorkflow
+from .nodes.test_node import TestNode
+
+class ResolvedWorkflow(BaseWorkflow):
+    graph = TestNode
+"""
+
+    inputs_code = """
+from vellum.workflows.inputs import BaseInputs
+
+class Inputs(BaseInputs):
+    deployment_name: str
+"""
+
+    parent_workflow_code = """
+from vellum.workflows import BaseWorkflow
+from .inputs import Inputs
+from .nodes.subworkflow_deployment_node import TestSubworkflowDeploymentNode
+from vellum.workflows.state import BaseState
+
+class ParentWorkflow(BaseWorkflow[Inputs, BaseState]):
+    graph = TestSubworkflowDeploymentNode
+"""
+
+    parent_node_code = """
+from vellum.workflows.nodes import SubworkflowDeploymentNode
+from vellum.workflows.outputs import BaseOutputs
+from ..inputs import Inputs
+
+class TestSubworkflowDeploymentNode(SubworkflowDeploymentNode):
+    deployment = Inputs.deployment_name
+
+    class Outputs(BaseOutputs):
+        result: str
+
+    subworkflow_inputs = {"message": "test"}
+"""
+
+    subworkflow_files = {
+        "__init__.py": "",
+        "workflow.py": mock_workflow_code,
+        "nodes/__init__.py": """
+from .test_node import TestNode
+
+__all__ = ["TestNode"]
+""",
+        "nodes/test_node.py": test_node_code,
+    }
+
+    parent_files = {
+        "__init__.py": "",
+        "inputs.py": inputs_code,
+        "workflow.py": parent_workflow_code,
+        "nodes/__init__.py": """
+from .subworkflow_deployment_node import TestSubworkflowDeploymentNode
+
+__all__ = ["TestSubworkflowDeploymentNode"]
+""",
+        "nodes/subworkflow_deployment_node.py": parent_node_code,
+    }
+
+    namespace = str(uuid4())
+
+    # AND the virtual file loader is registered for the parent workflow
+    finder = VirtualFileFinder(parent_files, namespace)
+    sys.meta_path.append(finder)
+
+    vellum_client.workflows.pull.return_value = iter([zip_file_map(subworkflow_files)])
+
+    # WHEN we execute the root workflow with the mocked client
+    Workflow = BaseWorkflow.load_from_module(namespace)
+    Inputs = Workflow.get_inputs_class()
+
+    workflow = Workflow(context=WorkflowContext(namespace=namespace, generated_files=parent_files))
+    final_event = workflow.run(inputs=Inputs(deployment_name=deployment_name))
+
+    # THEN the method should return a workflow (not None) - this will pass once implemented
+    assert final_event.name == "workflow.execution.fulfilled", final_event
+
+    # AND the pull API should have been called with the correct deployment name, release tag, and version
+    args, kwargs = vellum_client.workflows.pull.call_args
+    assert args[0] == deployment_name
+    assert kwargs["release_tag"] == release_tag
+    assert kwargs["version"].startswith(">=")
+    assert ".0.0,<=" in kwargs["version"]
+
+    # AND the X-Vellum-Always-Success header should be included for graceful error handling
+    assert kwargs["request_options"]["additional_headers"]["X-Vellum-Always-Success"] == "true"