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

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

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

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

@@ -4,6 +4,7 @@ import click
 
 from vellum_cli.aliased_group import ClickAliasedGroup
 from vellum_cli.image_push import image_push_command
+from vellum_cli.ping import ping_command
 from vellum_cli.pull import pull_command
 from vellum_cli.push import push_command
 
@@ -14,6 +15,15 @@ def main() -> None:
     pass
 
 
+@main.command
+def ping() -> None:
+    """
+    Ping Vellum to confirm that requests are correctly authenticated and to return information about the active
+    Workspace/Organization
+    """
+    ping_command()
+
+
 class PushGroup(ClickAliasedGroup):
     def get_command(self, ctx, cmd_name):
         # First try to get the command normally

vellum_ai-0.13.1/ee/vellum_cli/ping.py

@@ -0,0 +1,28 @@
+from dotenv import load_dotenv
+
+from vellum.workflows.vellum_client import create_vellum_client
+from vellum_cli.logger import load_cli_logger
+
+
+def ping_command():
+    load_dotenv()
+    logger = load_cli_logger()
+
+    client = create_vellum_client()
+
+    workspace = client.workspaces.workspace_identity()
+    organization = client.organizations.organization_identity()
+
+    logger.info(
+        f"""\
+Successfully authenticated with Vellum!
+
+Organization:
+    ID: {organization.id}
+    Name: {organization.name}
+
+Workspace:
+    ID: {workspace.id}
+    Name: {workspace.name}
+"""
+    )

vellum_ai-0.13.1/ee/vellum_cli/tests/test_ping.py

@@ -0,0 +1,47 @@
+from datetime import datetime
+
+from click.testing import CliRunner
+
+from vellum.client.types.organization_read import OrganizationRead
+from vellum.client.types.workspace_read import WorkspaceRead
+from vellum_cli import main as cli_main
+
+
+def test_ping__happy_path(vellum_client):
+    # GIVEN a cli
+    runner = CliRunner()
+
+    # AND a valid response from both the workflow and organization API calls
+    vellum_client.workspaces.workspace_identity.return_value = WorkspaceRead(
+        id="1234567890",
+        name="Test Workspace",
+        label="Test Workspace",
+        created=datetime.now(),
+    )
+    vellum_client.organizations.organization_identity.return_value = OrganizationRead(
+        id="1234567890",
+        name="Test Organization",
+        new_member_join_behavior="AUTO_ACCEPT_FROM_SHARED_DOMAIN",
+        allow_staff_access=True,
+    )
+
+    # WHEN calling `vellum ping`
+    result = runner.invoke(cli_main, ["ping"])
+
+    # THEN it should return Status information about the user's workspace
+    assert result.exit_code == 0
+    assert (
+        result.output
+        == """\x1b[38;20m\
+Successfully authenticated with Vellum!
+
+Organization:
+    ID: 1234567890
+    Name: Test Organization
+
+Workspace:
+    ID: 1234567890
+    Name: Test Workspace
+\x1b[0m
+"""
+    )

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

@@ -1,12 +1,10 @@
 from typing import Any, Generic, TypeVar
 
 from vellum.workflows.descriptors.base import BaseDescriptor
-from vellum.workflows.expressions.and_ import AndExpression
 from vellum.workflows.expressions.between import BetweenExpression
 from vellum.workflows.expressions.is_not_null import IsNotNullExpression
 from vellum.workflows.expressions.is_null import IsNullExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
-from vellum.workflows.expressions.or_ import OrExpression
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.execution_count import ExecutionCountReference
 from vellum.workflows.references.output import OutputReference
@@ -71,12 +69,25 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
         return explicit_value if explicit_value else GenericNodeDisplayData()
 
     def serialize_condition(self, display_context: WorkflowDisplayContext, condition: BaseDescriptor) -> JsonObject:
-        if isinstance(condition, (AndExpression, OrExpression)):
-            return {}
-        elif isinstance(condition, (IsNullExpression, IsNotNullExpression)):
-            return {}
+        if isinstance(condition, (IsNullExpression, IsNotNullExpression)):
+            lhs = self.serialize_value(display_context, condition._expression)  # type: ignore[attr-defined]
+            return {
+                "type": "UNARY_EXPRESSION",
+                "lhs": lhs,
+                "operator": convert_descriptor_to_operator(condition),
+            }
         elif isinstance(condition, (BetweenExpression, NotBetweenExpression)):
-            return {}
+            base = self.serialize_value(display_context, condition._value)  # type: ignore[attr-defined]
+            lhs = self.serialize_value(display_context, condition._start)  # type: ignore[attr-defined]
+            rhs = self.serialize_value(display_context, condition._end)  # type: ignore[attr-defined]
+
+            return {
+                "type": "TERNARY_EXPRESSION",
+                "base": base,
+                "operator": convert_descriptor_to_operator(condition),
+                "lhs": lhs,
+                "rhs": rhs,
+            }
         else:
             lhs = self.serialize_value(display_context, condition._lhs)  # type: ignore[attr-defined]
             rhs = self.serialize_value(display_context, condition._rhs)  # type: ignore[attr-defined]
@@ -113,7 +124,7 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
             }
 
         if isinstance(value, ExecutionCountReference):
-            node_class_display = display_context.node_displays[value.node_class]
+            node_class_display = display_context.global_node_displays[value.node_class]
 
             return {
                 "type": "EXECUTION_COUNTER",
@@ -127,4 +138,6 @@ class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeTyp
                 "value": vellum_value.dict(),
             }
 
-        raise ValueError(f"Unsupported descriptor type: {value.__class__.__name__}")
+        # If it's not any of the references we know about,
+        # then try to serialize it as a nested value
+        return self.serialize_condition(display_context, value)

{vellum_ai-0.13.0 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -74,6 +74,9 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
         node_inputs: List[NodeInput] = []
         prompt_inputs: List[VellumVariable] = []
 
+        if not value:
+            return node_inputs, prompt_inputs
+
         for variable_name, variable_value in value.items():
             node_input = create_node_input(
                 node_id=node_id,

{vellum_ai-0.13.0 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/map_node.py

@@ -69,7 +69,7 @@ class BaseMapNodeDisplay(BaseNodeVellumDisplay[_MapNodeType], Generic[_MapNodeTy
                 "workflow_raw_data": serialized_subworkflow["workflow_raw_data"],
                 "input_variables": cast(JsonObject, renamed_input_variables),
                 "output_variables": serialized_subworkflow["output_variables"],
-                "concurrency": raise_if_descriptor(node.concurrency),
+                "concurrency": raise_if_descriptor(node.max_concurrency),
                 "items_input_id": items_workflow_input_id,
                 "item_input_id": item_workflow_input_id,
                 "index_input_id": index_workflow_input_id,

{vellum_ai-0.13.0 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py

@@ -27,16 +27,20 @@ class BasePromptDeploymentNodeDisplay(
         node_id = self.node_id
 
         prompt_inputs = raise_if_descriptor(node.prompt_inputs)
-        node_inputs = [
-            create_node_input(
-                node_id=node_id,
-                input_name=variable_name,
-                value=variable_value,
-                display_context=display_context,
-                input_id=self.prompt_input_ids_by_name.get(variable_name),
-            )
-            for variable_name, variable_value in prompt_inputs.items()
-        ]
+        node_inputs = (
+            [
+                create_node_input(
+                    node_id=node_id,
+                    input_name=variable_name,
+                    value=variable_value,
+                    display_context=display_context,
+                    input_id=self.prompt_input_ids_by_name.get(variable_name),
+                )
+                for variable_name, variable_value in prompt_inputs.items()
+            ]
+            if prompt_inputs
+            else []
+        )
 
         _, output_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.text)]
         _, array_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.results)]

{vellum_ai-0.13.0 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_utils.py

@@ -2,6 +2,7 @@ import pytest
 from uuid import UUID, uuid4
 from typing import List, cast
 
+from vellum.client.types.string_vellum_value import StringVellumValue
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
@@ -19,7 +20,6 @@ from vellum_ee.workflows.display.vellum import (
     NodeInputValuePointerRule,
     NodeOutputData,
     NodeOutputPointer,
-    StringVellumValue,
     WorkflowInputsVellumDisplayOverrides,
     WorkflowMetaVellumDisplay,
 )
@@ -74,7 +74,7 @@ class MyNodeB(BaseNode):
                     type="INPUT_VARIABLE",
                     data=InputVariableData(input_variable_id="a154c29d-fac0-4cd0-ba88-bc52034f5470"),
                 ),
-                ConstantValuePointer(type="CONSTANT_VALUE", data=StringVellumValue(type="STRING", value="fallback")),
+                ConstantValuePointer(type="CONSTANT_VALUE", data=StringVellumValue(value="fallback")),
             ],
         ),
     ],

{vellum_ai-0.13.0 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/utils.py

@@ -2,6 +2,7 @@ from uuid import UUID
 from typing import Any, List, Optional, Type, Union, cast
 
 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
@@ -25,11 +26,13 @@ from vellum.workflows.expressions.less_than import LessThanExpression
 from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
 from vellum.workflows.expressions.not_in import NotInExpression
+from vellum.workflows.expressions.or_ import OrExpression
+from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.nodes.utils import get_wrapped_node, has_wrapped_node
 from vellum.workflows.references import NodeReference, OutputReference
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
-from vellum_ee.workflows.display.utils.vellum import create_node_input_value_pointer_rule, primitive_to_vellum_value
+from vellum_ee.workflows.display.utils.vellum import create_node_input_value_pointer_rule
 from vellum_ee.workflows.display.vellum import (
     ConstantValuePointer,
     ExecutionCounterData,
@@ -170,5 +173,9 @@ def convert_descriptor_to_operator(descriptor: BaseDescriptor) -> str:
         return "between"
     elif isinstance(descriptor, NotBetweenExpression):
         return "notBetween"
+    elif isinstance(descriptor, AndExpression):
+        return "and"
+    elif isinstance(descriptor, OrExpression):
+        return "or"
     else:
         raise ValueError(f"Unsupported descriptor type: {descriptor}")

vellum_ai-0.13.1/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py

@@ -0,0 +1,67 @@
+import pytest
+
+from deepdiff import DeepDiff
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.map_node.node import MapNode
+from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.state.base import BaseState
+
+
+class Inputs(BaseInputs):
+    foo: str
+
+
+class State(BaseState):
+    bar: str
+
+
+@MapNode.wrap(items=[1, 2, 3])
+class MapGenericNode(BaseNode):
+    item = MapNode.SubworkflowInputs.item
+    foo = Inputs.foo
+    bar = State.bar
+
+    class Outputs(BaseOutputs):
+        value: str
+
+    def run(self) -> Outputs:
+        return self.Outputs(value=f"{self.foo} {self.bar} {self.item}")
+
+
+@pytest.mark.skip(reason="not implemented")
+def test_serialize_node__try(serialize_node):
+    serialized_node = serialize_node(MapGenericNode)
+    assert not DeepDiff(
+        {
+            "id": "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f",
+            "label": "BasicGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "BasicGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_adornments_serialization",
+                ],
+            },
+            "trigger": {"id": "9d3a1b3d-4a38-4f2e-bbf1-dd8be152bce8", "merge_behavior": "AWAIT_ANY"},
+            "ports": [
+                {
+                    "id": "4fbf0fff-a42e-4410-852a-238b5059198e",
+                    "type": "DEFAULT",
+                }
+            ],
+            "adornments": None,
+            "attributes": [],
+        },
+        serialized_node,
+        ignore_order=True,
+    )

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

@@ -0,0 +1,66 @@
+import pytest
+
+from deepdiff import DeepDiff
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+
+
+class Inputs(BaseInputs):
+    input: str
+
+
+class BasicGenericNode(BaseNode):
+    attr: str = "hello"
+
+    class Outputs(BaseNode.Outputs):
+        output = Inputs.input
+
+
+@pytest.mark.skip(reason="not implemented")
+def test_serialize_node__try(serialize_node):
+    serialized_node = serialize_node(BasicGenericNode)
+    assert not DeepDiff(
+        {
+            "id": "c2ed23f7-f6cb-4a56-a91c-2e5f9d8fda7f",
+            "label": "BasicGenericNode",
+            "type": "GENERIC",
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "base": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"]},
+            "definition": {
+                "name": "BasicGenericNode",
+                "module": [
+                    "vellum_ee",
+                    "workflows",
+                    "display",
+                    "tests",
+                    "workflow_serialization",
+                    "generic_nodes",
+                    "test_attributes_serialization",
+                ],
+            },
+            "trigger": {"id": "9d3a1b3d-4a38-4f2e-bbf1-dd8be152bce8", "merge_behavior": "AWAIT_ANY"},
+            "ports": [
+                {
+                    "id": "4fbf0fff-a42e-4410-852a-238b5059198e",
+                    "type": "DEFAULT",
+                }
+            ],
+            "adornments": None,
+            "attributes": [
+                {
+                    "id": "e3c8b6e4-4b7d-4e3c-8a5c-6e5f4e3c8b6e",
+                    "name": "attr",
+                    "value": {
+                        "type": "CONSTANT_VALUE",
+                        "value": {
+                            "type": "STRING",
+                            "value": "hello",
+                        },
+                    },
+                }
+            ],
+        },
+        serialized_node,
+        ignore_order=True,
+    )