vellum-ai 0.14.63__py3-none-any.whl → 1.13.5__py3-none-any.whl

vellum/workflows/expressions/tests/test_contains.py

@@ -0,0 +1,175 @@
+import pytest
+
+from vellum.workflows.constants import undefined
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.contains import ContainsExpression
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    dict_value: dict = {"key": "value"}
+    list_value: list = [1, 2, 3]
+    string_value: str = "hello world"
+
+
+def test_dict_contains_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for dict-contains-dict scenarios.
+    """
+    state = TestState()
+    lhs_dict = {"foo": "bar"}
+    rhs_dict = {"foo": "bar"}
+
+    expression = ContainsExpression(lhs=lhs_dict, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_dict_contains_different_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for different dict-contains-dict scenarios.
+    """
+    state = TestState()
+    lhs_dict = {"foo": "bar"}
+    rhs_dict = {"hello": "world"}
+
+    expression = ContainsExpression(lhs=lhs_dict, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_string_contains_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for string-contains-dict scenarios.
+    """
+    state = TestState()
+    lhs_string = 'Response: {"status": "success"} was returned'
+    rhs_dict = {"status": "success"}
+
+    expression = ContainsExpression(lhs=lhs_string, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_nested_dict_contains_dict_raises_error():
+    """
+    Tests that ContainsExpression raises clear error for nested dict scenarios.
+    """
+    state = TestState()
+    lhs_dict = {"user": {"name": "john", "age": 30}}
+    rhs_dict = {"age": 30, "name": "john"}
+
+    expression = ContainsExpression(lhs=lhs_dict, rhs=rhs_dict)
+
+    with pytest.raises(InvalidExpressionException, match="Cannot use dict as right-hand side"):
+        expression.resolve(state)
+
+
+def test_list_contains_string():
+    """
+    Tests that ContainsExpression preserves original list functionality.
+    """
+    state = TestState()
+
+    expression = TestState.list_value.contains(2)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_string_contains_substring():
+    """
+    Tests that ContainsExpression preserves original string functionality.
+    """
+    state = TestState()
+
+    expression = TestState.string_value.contains("world")
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_set_contains_item():
+    """
+    Tests that ContainsExpression works with sets.
+    """
+    state = TestState()
+    lhs_set = {1, 2, 3}
+    rhs_item = 2
+
+    expression = ContainsExpression(lhs=lhs_set, rhs=rhs_item)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_tuple_contains_item():
+    """
+    Tests that ContainsExpression works with tuples.
+    """
+    state = TestState()
+    lhs_tuple = (1, 2, 3)
+    rhs_item = 2
+
+    expression = ContainsExpression(lhs=lhs_tuple, rhs=rhs_item)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_invalid_lhs_type():
+    """
+    Tests that ContainsExpression raises exception for invalid LHS types.
+    """
+
+    class NoContainsSupport:
+        pass
+
+    state = TestState()
+    no_contains_obj = NoContainsSupport()
+    expression = ContainsExpression(lhs=no_contains_obj, rhs="test")
+
+    with pytest.raises(
+        InvalidExpressionException, match="Expected a LHS that supported `contains`, got `NoContainsSupport`"
+    ):
+        expression.resolve(state)
+
+
+def test_undefined_lhs_returns_false():
+    """
+    Tests that ContainsExpression returns False for undefined LHS.
+    """
+    state = TestState()
+    expression = ContainsExpression(lhs=undefined, rhs="test")
+
+    result = expression.resolve(state)
+
+    assert result is False
+
+
+def test_contains_with_constant_value_reference():
+    """
+    Tests ContainsExpression with ConstantValueReference for valid operations.
+    """
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2, 3])
+    rhs_ref = ConstantValueReference(2)
+
+    expression: ContainsExpression = ContainsExpression(lhs=lhs_ref, rhs=rhs_ref)
+    result = expression.resolve(state)
+
+    assert result is True
+
+
+def test_expression_metadata():
+    """
+    Tests that ContainsExpression has correct name and types properties.
+    """
+    expression = ContainsExpression(lhs=[1, 2, 3], rhs=2)
+
+    assert expression.name == "[1, 2, 3] contains 2"
+    assert expression.types == (bool,)

vellum/workflows/expressions/tests/test_expressions.py

@@ -1,5 +1,6 @@
 import pytest
 
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.expressions.greater_than import GreaterThanExpression
 from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
 from vellum.workflows.expressions.less_than import LessThanExpression
@@ -85,18 +86,18 @@ def test_greater_than_or_equal_to_invalid():
     state = TestState()
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'>=' not supported between instances of 'Comparable' and 'str'"
+    assert "not supported between instances of 'Comparable' and 'str'" in str(exc_info.value)
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         GreaterThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'>=' not supported between instances of 'str' and 'Comparable'"
+    assert "not supported between instances of 'str' and 'Comparable'" in str(exc_info.value)
 
 
 def test_greater_than_or_equal_to_non_comparable():
@@ -107,18 +108,18 @@ def test_greater_than_or_equal_to_non_comparable():
     state = TestState()
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'>=' not supported between instances of 'Comparable' and 'NonComparable'"
+    assert "not supported between instances of 'Comparable' and 'NonComparable'" in str(exc_info.value)
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         GreaterThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'>=' not supported between instances of 'NonComparable' and 'Comparable'"
+    assert "not supported between instances of 'NonComparable' and 'Comparable'" in str(exc_info.value)
 
 
 def test_greater_than():
@@ -148,18 +149,18 @@ def test_greater_than_invalid():
     state = TestState()
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'>' not supported between instances of 'Comparable' and 'str'"
+    assert "not supported between instances of 'Comparable' and 'str'" in str(exc_info.value)
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         GreaterThanExpression(lhs=obj2, rhs=obj1).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'>' not supported between instances of 'str' and 'Comparable'"
+    assert "not supported between instances of 'str' and 'Comparable'" in str(exc_info.value)
 
 
 def test_greater_than_non_comparable():
@@ -170,18 +171,18 @@ def test_greater_than_non_comparable():
     state = TestState()
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'>' not supported between instances of 'Comparable' and 'NonComparable'"
+    assert "not supported between instances of 'Comparable' and 'NonComparable'" in str(exc_info.value)
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         GreaterThanExpression(lhs=obj2, rhs=obj1).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'>' not supported between instances of 'NonComparable' and 'Comparable'"
+    assert "not supported between instances of 'NonComparable' and 'Comparable'" in str(exc_info.value)
 
 
 def test_less_than_or_equal_to():
@@ -211,18 +212,18 @@ def test_less_than_or_equal_to_invalid():
     state = TestState()
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'<=' not supported between instances of 'Comparable' and 'str'"
+    assert "not supported between instances of 'Comparable' and 'str'" in str(exc_info.value)
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         LessThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'<=' not supported between instances of 'str' and 'Comparable'"
+    assert "not supported between instances of 'str' and 'Comparable'" in str(exc_info.value)
 
 
 def test_less_than_or_equal_to_non_comparable():
@@ -233,18 +234,18 @@ def test_less_than_or_equal_to_non_comparable():
     state = TestState()
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'<=' not supported between instances of 'Comparable' and 'NonComparable'"
+    assert "not supported between instances of 'Comparable' and 'NonComparable'" in str(exc_info.value)
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         LessThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'<=' not supported between instances of 'NonComparable' and 'Comparable'"
+    assert "not supported between instances of 'NonComparable' and 'Comparable'" in str(exc_info.value)
 
 
 def test_less_than():
@@ -274,18 +275,18 @@ def test_less_than_invalid():
     state = TestState()
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         LessThanExpression(lhs=obj1, rhs=obj2).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'<' not supported between instances of 'Comparable' and 'str'"
+    assert "not supported between instances of 'Comparable' and 'str'" in str(exc_info.value)
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         LessThanExpression(lhs=obj2, rhs=obj1).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'<' not supported between instances of 'str' and 'Comparable'"
+    assert "not supported between instances of 'str' and 'Comparable'" in str(exc_info.value)
 
 
 def test_less_than_non_comparable():
@@ -296,15 +297,127 @@ def test_less_than_non_comparable():
     state = TestState()
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         LessThanExpression(lhs=obj1, rhs=obj2).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'<' not supported between instances of 'Comparable' and 'NonComparable'"
+    assert "not supported between instances of 'Comparable' and 'NonComparable'" in str(exc_info.value)
 
     # WHEN comparing objects with incompatible types
-    with pytest.raises(TypeError) as exc_info:
+    with pytest.raises(InvalidExpressionException) as exc_info:
         LessThanExpression(lhs=obj2, rhs=obj1).resolve(state)
 
     # THEN the expected error is raised
-    assert str(exc_info.value) == "'<' not supported between instances of 'NonComparable' and 'Comparable'"
+    assert "not supported between instances of 'NonComparable' and 'Comparable'" in str(exc_info.value)
+
+
+def test_greater_than_or_equal_to_with_numeric_string():
+    """
+    Test that numeric strings are parsed and compared correctly with numbers.
+    """
+
+    state = TestState()
+
+    # WHEN comparing a numeric string to an int
+    assert GreaterThanOrEqualToExpression(lhs="50", rhs=42).resolve(state) is True
+    assert GreaterThanOrEqualToExpression(lhs="42", rhs=42).resolve(state) is True
+    assert GreaterThanOrEqualToExpression(lhs="30", rhs=42).resolve(state) is False
+
+    # WHEN comparing a numeric string to a float
+    assert GreaterThanOrEqualToExpression(lhs="50.5", rhs=42.0).resolve(state) is True
+    assert GreaterThanOrEqualToExpression(lhs="42.0", rhs=42.0).resolve(state) is True
+    assert GreaterThanOrEqualToExpression(lhs="30.5", rhs=42.0).resolve(state) is False
+
+    # WHEN comparing an int to a numeric string
+    assert GreaterThanOrEqualToExpression(lhs=50, rhs="42").resolve(state) is True
+    assert GreaterThanOrEqualToExpression(lhs=42, rhs="42").resolve(state) is True
+    assert GreaterThanOrEqualToExpression(lhs=30, rhs="42").resolve(state) is False
+
+    # WHEN comparing a float to a numeric string
+    assert GreaterThanOrEqualToExpression(lhs=50.5, rhs="42.0").resolve(state) is True
+    assert GreaterThanOrEqualToExpression(lhs=42.0, rhs="42.0").resolve(state) is True
+    assert GreaterThanOrEqualToExpression(lhs=30.5, rhs="42.0").resolve(state) is False
+
+
+def test_greater_than_with_numeric_string():
+    """
+    Test that numeric strings are parsed and compared correctly with numbers.
+    """
+
+    state = TestState()
+
+    # WHEN comparing a numeric string to an int
+    assert GreaterThanExpression(lhs="50", rhs=42).resolve(state) is True
+    assert GreaterThanExpression(lhs="42", rhs=42).resolve(state) is False
+    assert GreaterThanExpression(lhs="30", rhs=42).resolve(state) is False
+
+    # WHEN comparing a numeric string to a float
+    assert GreaterThanExpression(lhs="50.5", rhs=42.0).resolve(state) is True
+    assert GreaterThanExpression(lhs="42.0", rhs=42.0).resolve(state) is False
+    assert GreaterThanExpression(lhs="30.5", rhs=42.0).resolve(state) is False
+
+    # WHEN comparing an int to a numeric string
+    assert GreaterThanExpression(lhs=50, rhs="42").resolve(state) is True
+    assert GreaterThanExpression(lhs=42, rhs="42").resolve(state) is False
+    assert GreaterThanExpression(lhs=30, rhs="42").resolve(state) is False
+
+    # WHEN comparing a float to a numeric string
+    assert GreaterThanExpression(lhs=50.5, rhs="42.0").resolve(state) is True
+    assert GreaterThanExpression(lhs=42.0, rhs="42.0").resolve(state) is False
+    assert GreaterThanExpression(lhs=30.5, rhs="42.0").resolve(state) is False
+
+
+def test_less_than_or_equal_to_with_numeric_string():
+    """
+    Test that numeric strings are parsed and compared correctly with numbers.
+    """
+
+    state = TestState()
+
+    # WHEN comparing a numeric string to an int
+    assert LessThanOrEqualToExpression(lhs="30", rhs=42).resolve(state) is True
+    assert LessThanOrEqualToExpression(lhs="42", rhs=42).resolve(state) is True
+    assert LessThanOrEqualToExpression(lhs="50", rhs=42).resolve(state) is False
+
+    # WHEN comparing a numeric string to a float
+    assert LessThanOrEqualToExpression(lhs="30.5", rhs=42.0).resolve(state) is True
+    assert LessThanOrEqualToExpression(lhs="42.0", rhs=42.0).resolve(state) is True
+    assert LessThanOrEqualToExpression(lhs="50.5", rhs=42.0).resolve(state) is False
+
+    # WHEN comparing an int to a numeric string
+    assert LessThanOrEqualToExpression(lhs=30, rhs="42").resolve(state) is True
+    assert LessThanOrEqualToExpression(lhs=42, rhs="42").resolve(state) is True
+    assert LessThanOrEqualToExpression(lhs=50, rhs="42").resolve(state) is False
+
+    # WHEN comparing a float to a numeric string
+    assert LessThanOrEqualToExpression(lhs=30.5, rhs="42.0").resolve(state) is True
+    assert LessThanOrEqualToExpression(lhs=42.0, rhs="42.0").resolve(state) is True
+    assert LessThanOrEqualToExpression(lhs=50.5, rhs="42.0").resolve(state) is False
+
+
+def test_less_than_with_numeric_string():
+    """
+    Test that numeric strings are parsed and compared correctly with numbers.
+    """
+
+    state = TestState()
+
+    # WHEN comparing a numeric string to an int
+    assert LessThanExpression(lhs="30", rhs=42).resolve(state) is True
+    assert LessThanExpression(lhs="42", rhs=42).resolve(state) is False
+    assert LessThanExpression(lhs="50", rhs=42).resolve(state) is False
+
+    # WHEN comparing a numeric string to a float
+    assert LessThanExpression(lhs="30.5", rhs=42.0).resolve(state) is True
+    assert LessThanExpression(lhs="42.0", rhs=42.0).resolve(state) is False
+    assert LessThanExpression(lhs="50.5", rhs=42.0).resolve(state) is False
+
+    # WHEN comparing an int to a numeric string
+    assert LessThanExpression(lhs=30, rhs="42").resolve(state) is True
+    assert LessThanExpression(lhs=42, rhs="42").resolve(state) is False
+    assert LessThanExpression(lhs=50, rhs="42").resolve(state) is False
+
+    # WHEN comparing a float to a numeric string
+    assert LessThanExpression(lhs=30.5, rhs="42.0").resolve(state) is True
+    assert LessThanExpression(lhs=42.0, rhs="42.0").resolve(state) is False
+    assert LessThanExpression(lhs=50.5, rhs="42.0").resolve(state) is False

vellum/workflows/expressions/tests/test_length.py

@@ -0,0 +1,38 @@
+import pytest
+
+from vellum.workflows.constants import undefined
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.length import LengthExpression
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    string_value: str = "hello world"
+
+
+def test_length_expression_string():
+    """
+    Tests that LengthExpression correctly returns the length of a string.
+    """
+
+    state = TestState()
+
+    expression = TestState.string_value.length()
+    result = expression.resolve(state)
+
+    assert result == 11
+
+
+def test_length_expression_undefined():
+    """
+    Tests that LengthExpression raises an exception for undefined values.
+    """
+
+    expression = LengthExpression(expression=undefined)
+    state = TestState()
+
+    # THEN we should get an InvalidExpressionException
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        expression.resolve(state)
+
+    assert "Cannot get length of undefined value" in str(exc_info.value)

vellum/workflows/expressions/tests/test_minus.py

@@ -0,0 +1,109 @@
+import pytest
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.expressions.minus import MinusExpression
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    number_value: int = 10
+    float_value: float = 15.5
+
+
+def test_minus_expression_numbers():
+    """
+    Tests that MinusExpression correctly subtracts two numbers.
+    """
+
+    state = TestState()
+
+    expression = TestState.number_value.minus(3)
+
+    result = expression.resolve(state)
+    assert result == 7
+
+
+def test_minus_expression_floats():
+    """
+    Tests that MinusExpression correctly subtracts two floats.
+    """
+
+    state = TestState()
+
+    expression = TestState.float_value.minus(5.5)
+
+    result = expression.resolve(state)
+    assert result == 10.0
+
+
+def test_minus_expression_unsupported_type():
+    """
+    Tests that MinusExpression raises an exception for unsupported types.
+    """
+
+    class NoSubSupport:
+        pass
+
+    no_sub_obj = NoSubSupport()
+    expression = MinusExpression(lhs=no_sub_obj, rhs=5)
+    state = TestState()
+
+    with pytest.raises(InvalidExpressionException, match="'NoSubSupport' must support the '-' operator"):
+        expression.resolve(state)
+
+
+def test_minus_expression_name():
+    """
+    Tests that MinusExpression has the correct name.
+    """
+
+    expression = MinusExpression(lhs=10, rhs=3)
+
+    assert expression.name == "10 - 3"
+
+
+def test_minus_expression_types():
+    """
+    Tests that MinusExpression has the correct types.
+    """
+
+    expression = MinusExpression(lhs=10, rhs=3)
+
+    assert expression.types == (object,)
+
+
+def test_sub_operator_numbers():
+    """
+    Tests that __sub__ operator correctly subtracts two numbers.
+    """
+
+    state = TestState()
+
+    expression = TestState.number_value - 3
+
+    result = expression.resolve(state)
+    assert result == 7
+
+
+def test_sub_operator_floats():
+    """
+    Tests that __sub__ operator correctly subtracts two floats.
+    """
+
+    state = TestState()
+
+    expression = TestState.float_value - 5.5
+
+    result = expression.resolve(state)
+    assert result == 10.0
+
+
+def test_sub_operator_returns_minus_expression():
+    """
+    Tests that __sub__ operator returns a MinusExpression.
+    """
+
+    expression = TestState.number_value - 3
+
+    # THEN it should return a MinusExpression
+    assert isinstance(expression, MinusExpression)