vellum-ai 0.13.11__tar.gz → 0.13.12__tar.gz

{vellum_ai-0.13.11 → vellum_ai-0.13.12}/PKG-INFO

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

{vellum_ai-0.13.11 → vellum_ai-0.13.12}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -31,7 +31,9 @@ from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.utils import get_wrapped_node
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference
+from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
+from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.references.workflow_input import WorkflowInputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
@@ -337,6 +339,12 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             }
 
     def serialize_value(self, display_context: "WorkflowDisplayContext", value: BaseDescriptor) -> JsonObject:
+        if isinstance(value, ConstantValueReference):
+            return self.serialize_value(display_context, value._value)
+
+        if isinstance(value, LazyReference):
+            return self.serialize_value(display_context, value._get())
+
         if isinstance(value, WorkflowInputReference):
             workflow_input_display = display_context.global_workflow_input_displays[value]
             return {

{vellum_ai-0.13.11 → vellum_ai-0.13.12}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -4,6 +4,8 @@ from deepdiff import DeepDiff
 
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum_ee.workflows.display.base import WorkflowInputsDisplay
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
@@ -19,11 +21,7 @@ class ConstantValueGenericNode(BaseNode):
 
 
 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)},
-    )
+    serialized_node = serialize_node(ConstantValueGenericNode)
 
     assert not DeepDiff(
         {
@@ -67,6 +65,92 @@ def test_serialize_node__constant_value(serialize_node):
     )
 
 
+class ConstantValueReferenceGenericNode(BaseNode):
+    attr: str = ConstantValueReference("hello")
+
+
+def test_serialize_node__constant_value_reference(serialize_node):
+    serialized_node = serialize_node(ConstantValueReferenceGenericNode)
+
+    assert not DeepDiff(
+        {
+            "id": "9271e2b1-f47e-47a4-95ae-51299dedb62f",
+            "label": "ConstantValueReferenceGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "ConstantValueReferenceGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "8cc0b4c4-4ae4-4248-8fd5-bfb2e658eb51", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "fe696d84-47c2-4325-8020-34a1c586a759", "name": "default", "type": "DEFAULT"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "460aeb68-7369-43d2-9d3d-37caa425611f",
+                    "name": "attr",
+                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "hello"}},
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
+class LazyReferenceGenericNode(BaseNode):
+    attr: str = LazyReference(lambda: ConstantValueReference("hello"))
+
+
+def test_serialize_node__lazy_reference(serialize_node):
+    serialized_node = serialize_node(LazyReferenceGenericNode)
+
+    assert not DeepDiff(
+        {
+            "id": "29563b11-bd4d-47b0-b017-372f78aeaef5",
+            "label": "LazyReferenceGenericNode",
+            "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": "56e9791a-078a-4bb7-90bc-a26c3991c70f", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "acb761a0-fcc2-4d21-bc8c-d0d560912c04", "name": "default", "type": "DEFAULT"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "4370b381-9165-4fb4-881e-480507abe069",
+                    "name": "attr",
+                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "hello"}},
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )
+
+
 class WorkflowInputGenericNode(BaseNode):
     attr: str = Inputs.input
 
@@ -284,3 +368,100 @@ def test_serialize_node__node_execution(serialize_node):
         serialized_node,
         ignore_order=True,
     )
+
+
+class CoalesceNodeA(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        output: str
+
+
+class CoalesceNodeADisplay(BaseNodeDisplay[CoalesceNodeA]):
+    pass
+
+
+class CoalesceNodeB(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        output: str
+
+
+class CoalesceNodeBDisplay(BaseNodeDisplay[CoalesceNodeB]):
+    pass
+
+
+class CoalesceNodeFinal(BaseNode):
+    attr = CoalesceNodeA.Outputs.output.coalesce(CoalesceNodeB.Outputs.output)
+
+
+class CoalesceNodeFinalDisplay(BaseNodeDisplay[CoalesceNodeFinal]):
+    pass
+
+
+def test_serialize_node__coalesce(serialize_node):
+    coalesce_node_a_output_id = uuid4()
+    coalesce_node_b_output_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=CoalesceNodeFinal,
+        global_node_displays={
+            CoalesceNodeA: CoalesceNodeADisplay(),
+            CoalesceNodeB: CoalesceNodeBDisplay(),
+            CoalesceNodeFinal: CoalesceNodeFinalDisplay(),
+        },
+        global_node_output_displays={
+            CoalesceNodeA.Outputs.output: (
+                CoalesceNodeA,
+                NodeOutputDisplay(id=coalesce_node_a_output_id, name="output"),
+            ),
+            CoalesceNodeB.Outputs.output: (
+                CoalesceNodeB,
+                NodeOutputDisplay(id=coalesce_node_b_output_id, name="output"),
+            ),
+        },
+    )
+
+    assert not DeepDiff(
+        {
+            "id": "84d0ce62-afd1-4186-b0e3-5dd8e5ca8b65",
+            "label": "CoalesceNodeFinal",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "CoalesceNodeFinal",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "5165f887-153b-4ecd-9219-1beb3cf4f906", "merge_behavior": "AWAIT_ATTRIBUTES"},
+            "ports": [{"id": "08ab456d-f541-4400-8305-e97f30cbe745", "name": "default", "type": "DEFAULT"}],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "5a22dd48-9ef3-456b-85b8-7662cf7823eb",
+                    "name": "attr",
+                    "value": {
+                        "type": "BINARY_EXPRESSION",
+                        "lhs": {
+                            "type": "NODE_OUTPUT",
+                            "node_id": "20c340f2-409c-4d31-b44b-eeffd76938d5",
+                            "node_output_id": str(coalesce_node_a_output_id),
+                        },
+                        "operator": "coalesce",
+                        "rhs": {
+                            "type": "NODE_OUTPUT",
+                            "node_id": "9fac3c54-4e75-46ca-a1f2-a80fc6d8ad3f",
+                            "node_output_id": str(coalesce_node_b_output_id),
+                        },
+                    },
+                }
+            ],
+            "outputs": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )

{vellum_ai-0.13.11 → vellum_ai-0.13.12}/ee/vellum_ee/workflows/display/utils/vellum.py

@@ -6,6 +6,7 @@ from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.and_ import AndExpression
 from vellum.workflows.expressions.begins_with import BeginsWithExpression
 from vellum.workflows.expressions.between import BetweenExpression
+from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
 from vellum.workflows.expressions.contains import ContainsExpression
 from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
 from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
@@ -150,5 +151,7 @@ def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> LogicalOperato
         return "and"
     elif isinstance(descriptor, OrExpression):
         return "or"
+    elif isinstance(descriptor, CoalesceExpression):
+        return "coalesce"
     else:
         raise ValueError(f"Unsupported descriptor type: {descriptor}")

{vellum_ai-0.13.11 → vellum_ai-0.13.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.13.11"
+version = "0.13.12"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.13.11 → vellum_ai-0.13.12}/src/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.11",
+            "X-Fern-SDK-Version": "0.13.12",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.13.11 → vellum_ai-0.13.12}/src/vellum/workflows/nodes/bases/base.py

@@ -250,11 +250,10 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
             Determines whether a Node's execution should be initiated. Override this method to define custom
             trigger criteria.
             """
+            if state.meta.node_execution_cache.is_node_execution_initiated(cls.node_class, node_span_id):
+                return False
 
             if cls.merge_behavior == MergeBehavior.AWAIT_ATTRIBUTES:
-                if state.meta.node_execution_cache.is_node_execution_initiated(cls.node_class, node_span_id):
-                    return False
-
                 is_ready = True
                 for descriptor in cls.node_class:
                     if not descriptor.instance:
@@ -268,15 +267,9 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                 return is_ready
 
             if cls.merge_behavior == MergeBehavior.AWAIT_ANY:
-                if state.meta.node_execution_cache.is_node_execution_initiated(cls.node_class, node_span_id):
-                    return False
-
                 return True
 
             if cls.merge_behavior == MergeBehavior.AWAIT_ALL:
-                if state.meta.node_execution_cache.is_node_execution_initiated(cls.node_class, node_span_id):
-                    return False
-
                 """
                 A node utilizing an AWAIT_ALL merge strategy will only be considered ready for the Nth time
                 when all of its dependencies have been executed N times.