vellum-ai 0.13.27__tar.gz → 0.14.0__tar.gz

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.13.27
+Version: 0.14.0
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0
@@ -37,6 +37,7 @@ Requires-Dist: pyyaml (==6.0.1)
 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">

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/ee/vellum_cli/push.py

@@ -53,7 +53,16 @@ def push_command(
         workflow_configs = [w for w in workflow_configs if w.workspace == workspace]
 
     if len(workflow_configs) == 0:
-        raise ValueError(f"No workflow config for '{module}' found in project to push.")
+        if module and module_exists(module):
+            new_config = WorkflowConfig(
+                module=module,
+                workflow_sandbox_id=workflow_sandbox_id,
+                workspace=workspace or DEFAULT_WORKSPACE_CONFIG.name,
+            )
+            config.workflows.append(new_config)
+            workflow_configs = [new_config]
+        else:
+            raise ValueError(f"No workflow config for '{module}' found in project to push.")
 
     if len(workflow_configs) > 1:
         raise ValueError("Multiple workflows found in project to push. Pushing only a single workflow is supported.")
@@ -241,3 +250,8 @@ Visit at: https://app.vellum.ai/workflow-sandboxes/{response.workflow_sandbox_id
 
     config.save()
     logger.info("Updated vellum.lock.json file.")
+
+
+def module_exists(module_name: str) -> bool:
+    module_path = os.path.join(os.getcwd(), *module_name.split("."))
+    return os.path.exists(module_path) and os.path.isdir(module_path)

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/ee/vellum_cli/tests/test_push.py

@@ -589,3 +589,47 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
         assert lock_file_content["workflows"][1]["module"] == module
         assert lock_file_content["workflows"][1]["workflow_sandbox_id"] == second_workflow_sandbox_id
         assert lock_file_content["workflows"][1]["workspace"] == "my_other_workspace"
+
+
+def test_push__create_new_config_for_existing_module(mock_module, vellum_client):
+    # GIVEN an empty config (no workflows configured)
+    temp_dir = mock_module.temp_dir
+    module = mock_module.module
+    # GIVEN multiple workflows configured
+    mock_module.set_pyproject_toml({"workflows": [{"module": "examples.mock"}, {"module": "examples.mock2"}]})
+
+    # AND a workflow exists in the module successfully
+    workflow_py_file_content = _ensure_workflow_py(temp_dir, module)
+
+    # AND the push API call returns successfully
+    new_workflow_sandbox_id = str(uuid4())
+    vellum_client.workflows.push.return_value = WorkflowPushResponse(
+        workflow_sandbox_id=new_workflow_sandbox_id,
+    )
+
+    # WHEN calling `vellum push` with a module that exists but isn't in config
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["workflows", "push", module])
+
+    # THEN it should succeed
+    assert result.exit_code == 0, result.output
+
+    # AND we should have called the push API with the correct args
+    vellum_client.workflows.push.assert_called_once()
+    call_args = vellum_client.workflows.push.call_args.kwargs
+    assert json.loads(call_args["exec_config"])["workflow_raw_data"]["definition"]["name"] == "ExampleWorkflow"
+    assert call_args["workflow_sandbox_id"] is None  # Should be None since it's a new config
+    assert call_args["artifact"].name == f"{module.replace('.', '__')}.tar.gz"
+
+    # AND the files in the artifact should be correct
+    extracted_files = _extract_tar_gz(call_args["artifact"].read())
+    assert extracted_files["workflow.py"] == workflow_py_file_content
+
+    # AND check that lockfile was updated with new config
+    with open(os.path.join(temp_dir, "vellum.lock.json")) as f:
+        lock_file_content = json.load(f)
+        new_configs = [w for w in lock_file_content["workflows"] if w["module"] == module]
+        assert len(new_configs) == 1  # Should only create one config
+        new_config = new_configs[0]
+        assert new_config["workflow_sandbox_id"] == new_workflow_sandbox_id
+        assert new_config["workspace"] == "default"

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -17,7 +17,7 @@ from typing import (
 )
 
 from vellum.workflows import BaseWorkflow
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.between import BetweenExpression
 from vellum.workflows.expressions.is_nil import IsNilExpression
@@ -134,7 +134,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             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
+                if output.instance is not None and output.instance != undefined
                 else None
             )
 

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.13.27"
+version = "0.14.0"
 description = ""
 readme = "README.md"
 authors = []
@@ -24,15 +24,13 @@ classifiers = [
     "Typing :: Typed",
     "License :: OSI Approved :: MIT License"
 ]
+urls = { Repository = "https://github.com/vellum-ai/vellum-python-sdks" }
 packages = [
     { include = "vellum", from = "src" },
     { include = "vellum_cli", from = "ee" },
     { include = "vellum_ee", from = "ee" },
 ]
 
-[project.urls]
-Repository = 'https://github.com/vellum-ai/vellum-python-sdks'
-
 [tool.poetry.dependencies]
 python = "^3.9"
 Jinja2 = "^3.1.2"

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

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/constants.py

@@ -4,11 +4,11 @@ from typing import Any, cast
 
 class _UndefMeta(type):
     def __repr__(cls) -> str:
-        return "UNDEF"
+        return "undefined"
 
     def __getattribute__(cls, name: str) -> Any:
         if name == "__class__":
-            # ensures that UNDEF.__class__ == UNDEF
+            # ensures that undefined.__class__ == undefined
             return cls
 
         return super().__getattribute__(name)
@@ -17,7 +17,12 @@ class _UndefMeta(type):
         return False
 
 
-class UNDEF(metaclass=_UndefMeta):
+class undefined(metaclass=_UndefMeta):
+    """
+    A singleton class that represents an `undefined` value, mirroring the behavior of the `undefined`
+    value in TypeScript.
+    """
+
     pass
 
 

vellum_ai-0.14.0/src/vellum/workflows/descriptors/exceptions.py

@@ -0,0 +1,2 @@
+class InvalidExpressionException(Exception):
+    pass

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/descriptors/tests/test_utils.py

@@ -1,6 +1,7 @@
 import pytest
 
 from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.state.base import BaseState
@@ -77,6 +78,24 @@ class DummyNode(BaseNode[FixtureState]):
         (FixtureState.zeta["foo"], "bar"),
         (ConstantValueReference(1), 1),
         (FixtureState.theta[0], "baz"),
+        (
+            ConstantValueReference(
+                WorkflowError(
+                    message="This is a test",
+                    code=WorkflowErrorCode.USER_DEFINED_ERROR,
+                )
+            ).contains("test"),
+            True,
+        ),
+        (
+            ConstantValueReference(
+                WorkflowError(
+                    message="This is a test",
+                    code=WorkflowErrorCode.USER_DEFINED_ERROR,
+                )
+            ).does_not_contain("test"),
+            False,
+        ),
     ],
     ids=[
         "or",
@@ -122,6 +141,8 @@ class DummyNode(BaseNode[FixtureState]):
         "accessor",
         "constants",
         "list_index",
+        "error_contains",
+        "error_does_not_contain",
     ],
 )
 def test_resolve_value__happy_path(descriptor, expected_value):

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/descriptors/utils.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, Optional, Sequence, Set, TypeVar, Union, cast, ove
 
 from pydantic import BaseModel
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.state.base import BaseState
 
@@ -93,10 +93,10 @@ def resolve_value(
 
 def is_unresolved(value: Any) -> bool:
     """
-    Recursively checks if a value has an unresolved value, represented by UNDEF.
+    Recursively checks if a value has an unresolved value, represented by undefined.
     """
 
-    if value is UNDEF:
+    if value is undefined:
         return True
 
     if dataclasses.is_dataclass(value):

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/errors/types.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from enum import Enum
-from typing import Dict
+from typing import Any, Dict
 
 from vellum.client.types.vellum_error import VellumError
 from vellum.client.types.vellum_error_code_enum import VellumErrorCodeEnum
@@ -26,6 +26,9 @@ class WorkflowError:
     message: str
     code: WorkflowErrorCode
 
+    def __contains__(self, item: Any) -> bool:
+        return item in self.message
+
 
 _VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[VellumErrorCodeEnum, WorkflowErrorCode] = {
     "INVALID_REQUEST": WorkflowErrorCode.INVALID_INPUTS,

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/accessor.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, GetCoreSchemaHandler
 from pydantic_core import core_schema
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -32,13 +33,13 @@ class AccessorExpression(BaseDescriptor[Any]):
 
         if dataclasses.is_dataclass(base):
             if isinstance(self._field, int):
-                raise ValueError("Cannot access field by index on a dataclass")
+                raise InvalidExpressionException("Cannot access field by index on a dataclass")
 
             return getattr(base, self._field)
 
         if isinstance(base, BaseModel):
             if isinstance(self._field, int):
-                raise ValueError("Cannot access field by index on a BaseModel")
+                raise InvalidExpressionException("Cannot access field by index on a BaseModel")
 
             return getattr(base, self._field)
 
@@ -49,7 +50,7 @@ class AccessorExpression(BaseDescriptor[Any]):
             index = int(self._field)
             return base[index]
 
-        raise ValueError(f"Cannot get field {self._field} from {base}")
+        raise InvalidExpressionException(f"Cannot get field {self._field} from {base}")
 
     @classmethod
     def __get_pydantic_core_schema__(

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/begins_with.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -23,9 +24,9 @@ class BeginsWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return lhs.startswith(rhs)

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/between.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -25,14 +26,14 @@ class BetweenExpression(BaseDescriptor[bool], Generic[_V, _S, _E]):
     def resolve(self, state: "BaseState") -> bool:
         value = resolve_value(self._value, state)
         if not isinstance(value, (int, float)):
-            raise ValueError(f"Expected a numeric value, got: {value.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric value, got: {value.__class__.__name__}")
 
         start = resolve_value(self._start, state)
         if not isinstance(start, (int, float)):
-            raise ValueError(f"Expected a numeric start value, got: {start.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric start value, got: {start.__class__.__name__}")
 
         end = resolve_value(self._end, state)
         if not isinstance(end, (int, float)):
-            raise ValueError(f"Expected a numeric end value, got: {end.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric end value, got: {end.__class__.__name__}")
 
         return start <= value <= end

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/coalesce_expression.py

@@ -1,6 +1,6 @@
 from typing import TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -27,7 +27,7 @@ class CoalesceExpression(BaseDescriptor[Union[LHS, RHS]]):
 
     def resolve(self, state: "BaseState") -> Union[LHS, RHS]:
         lhs = resolve_value(self._lhs, state)
-        if lhs is not UNDEF and lhs is not None:
+        if lhs is not undefined and lhs is not None:
             return lhs
 
         return resolve_value(self._rhs, state)

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/contains.py

@@ -1,7 +1,10 @@
 from typing import Generic, TypeVar, Union
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.errors.types import WorkflowError
 from vellum.workflows.state.base import BaseState
 
 LHS = TypeVar("LHS")
@@ -23,8 +26,13 @@ class ContainsExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # Support any type that implements the in operator
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
-        if not isinstance(lhs, (list, tuple, set, dict, str)):
-            raise ValueError(f"Expected a LHS that supported contains, got: {lhs.__class__.__name__}")
+        # assumes that lack of is also false
+        if lhs is undefined:
+            return False
+        if not isinstance(lhs, (list, tuple, set, dict, str, WorkflowError)):
+            raise InvalidExpressionException(
+                f"Expected a LHS that supported `contains`, got `{lhs.__class__.__name__}`"
+            )
 
         rhs = resolve_value(self._rhs, state)
         return rhs in lhs

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/does_not_begin_with.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -23,9 +24,9 @@ class DoesNotBeginWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return not lhs.startswith(rhs)

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/does_not_contain.py

@@ -1,7 +1,9 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.errors.types import WorkflowError
 from vellum.workflows.state.base import BaseState
 
 LHS = TypeVar("LHS")
@@ -23,8 +25,10 @@ class DoesNotContainExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # Support any type that implements the not in operator
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
-        if not isinstance(lhs, (list, tuple, set, dict, str)):
-            raise ValueError(f"Expected a LHS that supported contains, got: {lhs.__class__.__name__}")
+        if not isinstance(lhs, (list, tuple, set, dict, str, WorkflowError)):
+            raise InvalidExpressionException(
+                f"Expected a LHS that supported `contains`, got `{lhs.__class__.__name__}`"
+            )
 
         rhs = resolve_value(self._rhs, state)
         return rhs not in lhs

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/does_not_end_with.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -23,9 +24,9 @@ class DoesNotEndWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return not lhs.endswith(rhs)

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/ends_with.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -23,9 +24,9 @@ class EndsWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         lhs = resolve_value(self._lhs, state)
         rhs = resolve_value(self._rhs, state)
         if not isinstance(lhs, str):
-            raise ValueError(f"Expected LHS to be a string, got {type(lhs)}")
+            raise InvalidExpressionException(f"Expected LHS to be a string, got {type(lhs)}")
 
         if not isinstance(rhs, str):
-            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+            raise InvalidExpressionException(f"Expected RHS to be a string, got {type(rhs)}")
 
         return lhs.endswith(rhs)

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/greater_than.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -24,10 +25,10 @@ class GreaterThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (int, float)):
-            raise ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs > rhs

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/greater_than_or_equal_to.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -24,10 +25,10 @@ class GreaterThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (int, float)):
-            raise ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs >= rhs

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/in_.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -26,6 +27,6 @@ class InExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (list, tuple, set, dict, str)):
-            raise ValueError(f"Expected a RHS that supported in, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a RHS that supported in, got: {rhs.__class__.__name__}")
 
         return lhs in rhs

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/is_blank.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -19,6 +20,6 @@ class IsBlankExpression(BaseDescriptor[bool], Generic[_T]):
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
         if not isinstance(expression, str):
-            raise ValueError(f"Expected a string expression, got: {expression.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a string expression, got: {expression.__class__.__name__}")
 
         return len(expression) == 0

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/is_nil.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsNilExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is None or expression is UNDEF
+        return expression is None or expression is undefined

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/is_not_blank.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -19,6 +20,6 @@ class IsNotBlankExpression(BaseDescriptor[bool], Generic[_T]):
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
         if not isinstance(expression, str):
-            raise ValueError(f"Expected a string expression, got: {expression.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a string expression, got: {expression.__class__.__name__}")
 
         return len(expression) != 0

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/is_not_nil.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsNotNilExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is not None and expression is not UNDEF
+        return expression is not None and expression is not undefined

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/is_not_undefined.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsNotUndefinedExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is not UNDEF
+        return expression is not undefined

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/is_undefined.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsUndefinedExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is UNDEF
+        return expression is undefined

{vellum_ai-0.13.27 → vellum_ai-0.14.0}/src/vellum/workflows/expressions/less_than.py

@@ -1,6 +1,7 @@
 from typing import Generic, TypeVar, Union
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
 
@@ -24,10 +25,10 @@ class LessThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         if not isinstance(lhs, (int, float)):
-            raise ValueError(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric lhs value, got: {lhs.__class__.__name__}")
 
         rhs = resolve_value(self._rhs, state)
         if not isinstance(rhs, (int, float)):
-            raise ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+            raise InvalidExpressionException(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
 
         return lhs < rhs