vellum-ai 0.9.16rc2__py3-none-any.whl → 0.10.0__py3-none-any.whl

vellum/workflows/expressions/accessor.py

@@ -0,0 +1,52 @@
+from collections.abc import Mapping
+import dataclasses
+from typing import Any, Sequence, Type, TypeVar
+
+from pydantic import BaseModel, GetCoreSchemaHandler
+from pydantic_core import core_schema
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+
+
+class AccessorExpression(BaseDescriptor[Any]):
+    def __init__(
+        self,
+        *,
+        base: BaseDescriptor[LHS],
+        field: str,
+    ) -> None:
+        super().__init__(
+            name=f"{base.name}.{field}",
+            types=(),
+            instance=None,
+        )
+        self._base = base
+        self._field = field
+
+    def resolve(self, state: "BaseState") -> Any:
+        base = resolve_value(self._base, state)
+
+        if dataclasses.is_dataclass(base):
+            return getattr(base, self._field)
+
+        if isinstance(base, BaseModel):
+            return getattr(base, self._field)
+
+        if isinstance(base, Mapping):
+            return base[self._field]
+
+        if isinstance(base, Sequence):
+            index = int(self._field)
+            return base[index]
+
+        raise ValueError(f"Cannot get field {self._field} from {base}")
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Type[Any], handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        return core_schema.is_instance_schema(cls)

vellum/workflows/expressions/and_.py

@@ -0,0 +1,32 @@
+from typing import TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.types.utils import resolve_combined_types
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class AndExpression(BaseDescriptor[Union[LHS, RHS]]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(
+            name=f"{lhs} and {rhs}",
+            types=resolve_combined_types(lhs, rhs),
+            instance=None,
+        )
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> Union[LHS, RHS]:
+        lhs = resolve_value(self._lhs, state)
+        if lhs:
+            return resolve_value(self._rhs, state)
+
+        return lhs

vellum/workflows/expressions/begins_with.py

@@ -0,0 +1,31 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class BeginsWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} begins with {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        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)}")
+
+        if not isinstance(rhs, str):
+            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+
+        return lhs.startswith(rhs)

vellum/workflows/expressions/between.py

@@ -0,0 +1,38 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_V = TypeVar("_V")
+_S = TypeVar("_S")
+_E = TypeVar("_E")
+
+
+class BetweenExpression(BaseDescriptor[bool], Generic[_V, _S, _E]):
+    def __init__(
+        self,
+        *,
+        value: Union[BaseDescriptor[_V], _V],
+        start: Union[BaseDescriptor[_S], _S],
+        end: Union[BaseDescriptor[_E], _E],
+    ) -> None:
+        super().__init__(name=f"{value} is between {start} and {end}", types=(bool,))
+        self._value = value
+        self._start = start
+        self._end = end
+
+    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__}")
+
+        start = resolve_value(self._start, state)
+        if not isinstance(start, (int, float)):
+            raise ValueError(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__}")
+
+        return start <= value <= end

vellum/workflows/expressions/coalesce_expression.py

@@ -0,0 +1,41 @@
+from typing import TypeVar, Union
+
+from vellum.workflows.constants import UNDEF
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.types.utils import resolve_combined_types
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class CoalesceExpression(BaseDescriptor[Union[LHS, RHS]]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(
+            name=f"{lhs} ?? {rhs}",
+            types=resolve_combined_types(lhs, rhs),
+            instance=None,
+        )
+        self._lhs = lhs
+        self._rhs = 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:
+            return lhs
+
+        return resolve_value(self._rhs, state)
+
+    @property
+    def lhs(self) -> Union[BaseDescriptor[LHS], LHS]:
+        return self._lhs
+
+    @property
+    def rhs(self) -> Union[BaseDescriptor[RHS], RHS]:
+        return self._rhs

vellum/workflows/expressions/contains.py

@@ -0,0 +1,30 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class ContainsExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} contains {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        # 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__}")
+
+        rhs = resolve_value(self._rhs, state)
+        return rhs in lhs

vellum/workflows/expressions/does_not_begin_with.py

@@ -0,0 +1,31 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class DoesNotBeginWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} not begins with {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        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)}")
+
+        if not isinstance(rhs, str):
+            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+
+        return not lhs.startswith(rhs)

vellum/workflows/expressions/does_not_contain.py

@@ -0,0 +1,30 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class DoesNotContainExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} does not contain {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        # 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__}")
+
+        rhs = resolve_value(self._rhs, state)
+        return rhs not in lhs

vellum/workflows/expressions/does_not_end_with.py

@@ -0,0 +1,31 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class DoesNotEndWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} not ends with {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        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)}")
+
+        if not isinstance(rhs, str):
+            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+
+        return not lhs.endswith(rhs)

vellum/workflows/expressions/does_not_equal.py

@@ -0,0 +1,25 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class DoesNotEqualExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} != {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        lhs = resolve_value(self._lhs, state)
+        rhs = resolve_value(self._rhs, state)
+        return lhs != rhs

vellum/workflows/expressions/ends_with.py

@@ -0,0 +1,31 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class EndsWithExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} ends with {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        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)}")
+
+        if not isinstance(rhs, str):
+            raise ValueError(f"Expected RHS to be a string, got {type(rhs)}")
+
+        return lhs.endswith(rhs)

vellum/workflows/expressions/equals.py

@@ -0,0 +1,25 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class EqualsExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} == {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        lhs = resolve_value(self._lhs, state)
+        rhs = resolve_value(self._rhs, state)
+        return lhs == rhs

vellum/workflows/expressions/greater_than.py

@@ -0,0 +1,33 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class GreaterThanExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} > {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        # Support any type that implements the > operator
+        # 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__}")
+
+        rhs = resolve_value(self._rhs, state)
+        if not isinstance(rhs, (int, float)):
+            raise ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+
+        return lhs > rhs

vellum/workflows/expressions/greater_than_or_equal_to.py

@@ -0,0 +1,33 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class GreaterThanOrEqualToExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} >= {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        # Support any type that implements the >= operator
+        # 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__}")
+
+        rhs = resolve_value(self._rhs, state)
+        if not isinstance(rhs, (int, float)):
+            raise ValueError(f"Expected a numeric rhs value, got: {rhs.__class__.__name__}")
+
+        return lhs >= rhs

vellum/workflows/expressions/in_.py

@@ -0,0 +1,31 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+LHS = TypeVar("LHS")
+RHS = TypeVar("RHS")
+
+
+class InExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(name=f"{lhs} in {rhs}", types=(bool,))
+        self._lhs = lhs
+        self._rhs = rhs
+
+    def resolve(self, state: "BaseState") -> bool:
+        # Support any type that implements the in operator
+        # https://app.shortcut.com/vellum/story/4658
+        lhs = resolve_value(self._lhs, state)
+
+        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__}")
+
+        return lhs in rhs

vellum/workflows/expressions/is_blank.py

@@ -0,0 +1,24 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class IsBlankExpression(BaseDescriptor[bool], Generic[_T]):
+    def __init__(
+        self,
+        *,
+        expression: Union[BaseDescriptor[_T], _T],
+    ) -> None:
+        super().__init__(name=f"{expression} is blank", types=(bool,))
+        self._expression = expression
+
+    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__}")
+
+        return len(expression) == 0

vellum/workflows/expressions/is_not_blank.py

@@ -0,0 +1,24 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class IsNotBlankExpression(BaseDescriptor[bool], Generic[_T]):
+    def __init__(
+        self,
+        *,
+        expression: Union[BaseDescriptor[_T], _T],
+    ) -> None:
+        super().__init__(name=f"{expression} is not blank", types=(bool,))
+        self._expression = expression
+
+    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__}")
+
+        return len(expression) != 0

vellum/workflows/expressions/is_not_null.py

@@ -0,0 +1,21 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class IsNotNullExpression(BaseDescriptor[bool], Generic[_T]):
+    def __init__(
+        self,
+        *,
+        expression: Union[BaseDescriptor[_T], _T],
+    ) -> None:
+        super().__init__(name=f"{expression} is not None", types=(bool,))
+        self._expression = expression
+
+    def resolve(self, state: "BaseState") -> bool:
+        expression = resolve_value(self._expression, state)
+        return expression is not None

vellum/workflows/expressions/is_not_undefined.py

@@ -0,0 +1,22 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.constants import UNDEF
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class IsNotUndefinedExpression(BaseDescriptor[bool], Generic[_T]):
+    def __init__(
+        self,
+        *,
+        expression: Union[BaseDescriptor[_T], _T],
+    ) -> None:
+        super().__init__(name=f"{expression} is not undefined", types=(bool,))
+        self._expression = expression
+
+    def resolve(self, state: "BaseState") -> bool:
+        expression = resolve_value(self._expression, state)
+        return expression is not UNDEF

vellum/workflows/expressions/is_null.py

@@ -0,0 +1,21 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class IsNullExpression(BaseDescriptor[bool], Generic[_T]):
+    def __init__(
+        self,
+        *,
+        expression: Union[BaseDescriptor[_T], _T],
+    ) -> None:
+        super().__init__(name=f"{expression} is None", types=(bool,))
+        self._expression = expression
+
+    def resolve(self, state: "BaseState") -> bool:
+        expression = resolve_value(self._expression, state)
+        return expression is None

vellum/workflows/expressions/is_undefined.py

@@ -0,0 +1,22 @@
+from typing import Generic, TypeVar, Union
+
+from vellum.workflows.constants import UNDEF
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class IsUndefinedExpression(BaseDescriptor[bool], Generic[_T]):
+    def __init__(
+        self,
+        *,
+        expression: Union[BaseDescriptor[_T], _T],
+    ) -> None:
+        super().__init__(name=f"{expression} is undefined", types=(bool,))
+        self._expression = expression
+
+    def resolve(self, state: "BaseState") -> bool:
+        expression = resolve_value(self._expression, state)
+        return expression is UNDEF