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

vellum/workflows/expressions/less_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 LessThanExpression(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/less_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 LessThanOrEqualToExpression(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/not_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 NotBetweenExpression(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 not 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 value < start or value > end

vellum/workflows/expressions/not_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 NotInExpression(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 in {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)
+
+        rhs = resolve_value(self._rhs, state)
+        if not isinstance(rhs, (list, tuple, set, dict, str)):
+            raise ValueError(f"Expected a RHS that supported contains, got: {rhs.__class__.__name__}")
+
+        return lhs not in rhs

vellum/workflows/expressions/or_.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 OrExpression(BaseDescriptor[Union[LHS, RHS]]):
+    def __init__(
+        self,
+        *,
+        lhs: Union[BaseDescriptor[LHS], LHS],
+        rhs: Union[BaseDescriptor[RHS], RHS],
+    ) -> None:
+        super().__init__(
+            name=f"{lhs} or {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 lhs
+
+        return resolve_value(self._rhs, state)

vellum/workflows/graph/__init__.py

@@ -0,0 +1,3 @@
+from .graph import Graph, GraphTarget
+
+__all__ = ["Graph", "GraphTarget"]

vellum/workflows/graph/graph.py

@@ -0,0 +1,131 @@
+from typing import TYPE_CHECKING, Iterator, List, Set, Type, Union
+
+from orderly_set import OrderedSet
+
+from vellum.workflows.edges.edge import Edge
+from vellum.workflows.types.generics import NodeType
+
+if TYPE_CHECKING:
+    from vellum.workflows.nodes.bases.base import BaseNode
+    from vellum.workflows.ports.port import Port
+
+GraphTargetOfSets = Union[
+    Set[NodeType],
+    Set["Graph"],
+    Set[Union[Type["BaseNode"], "Graph"]],
+]
+
+GraphTarget = Union[
+    Type["BaseNode"],
+    "Graph",
+    GraphTargetOfSets,
+]
+
+
+class Graph:
+    _entrypoints: Set["Port"]
+    _edges: List[Edge]
+    _terminals: Set["Port"]
+
+    def __init__(self, entrypoints: Set["Port"], edges: List[Edge], terminals: Set["Port"]):
+        self._edges = edges
+        self._entrypoints = entrypoints
+        self._terminals = terminals
+
+    @staticmethod
+    def from_port(port: "Port") -> "Graph":
+        ports = {port}
+        return Graph(entrypoints=ports, edges=[], terminals=ports)
+
+    @staticmethod
+    def from_node(node: Type["BaseNode"]) -> "Graph":
+        ports = {port for port in node.Ports}
+        return Graph(entrypoints=ports, edges=[], terminals=ports)
+
+    @staticmethod
+    def from_set(targets: GraphTargetOfSets) -> "Graph":
+        entrypoints = set()
+        edges = OrderedSet[Edge]()
+        terminals = set()
+
+        for target in targets:
+            if isinstance(target, Graph):
+                entrypoints.update(target._entrypoints)
+                edges.update(target._edges)
+                terminals.update(target._terminals)
+            else:
+                entrypoints.update({port for port in target.Ports})
+                terminals.update({port for port in target.Ports})
+
+        return Graph(entrypoints=entrypoints, edges=list(edges), terminals=terminals)
+
+    @staticmethod
+    def from_edge(edge: Edge) -> "Graph":
+        return Graph(entrypoints={edge.from_port}, edges=[edge], terminals={port for port in edge.to_node.Ports})
+
+    def __rshift__(self, other: GraphTarget) -> "Graph":
+        if not self._edges and not self._entrypoints:
+            raise ValueError("Graph instance can only create new edges from nodes within existing edges")
+
+        if isinstance(other, set):
+            new_terminals = set()
+            for elem in other:
+                for final_output_node in self._terminals:
+                    if isinstance(elem, Graph):
+                        midgraph = final_output_node >> set(elem.entrypoints)
+                        self._extend_edges(midgraph.edges)
+                        self._extend_edges(elem.edges)
+                        for other_terminal in elem._terminals:
+                            new_terminals.add(other_terminal)
+                    else:
+                        midgraph = final_output_node >> elem
+                        self._extend_edges(midgraph.edges)
+                        for other_terminal in elem.Ports:
+                            new_terminals.add(other_terminal)
+            self._terminals = new_terminals
+            return self
+
+        if isinstance(other, Graph):
+            for final_output_node in self._terminals:
+                midgraph = final_output_node >> set(other.entrypoints)
+                self._extend_edges(midgraph.edges)
+                self._extend_edges(other.edges)
+            self._terminals = other._terminals
+            return self
+
+        for final_output_node in self._terminals:
+            subgraph = final_output_node >> other
+            self._extend_edges(subgraph.edges)
+        self._terminals = {port for port in other.Ports}
+        return self
+
+    @property
+    def entrypoints(self) -> Iterator[Type["BaseNode"]]:
+        return iter(e.node_class for e in self._entrypoints)
+
+    @property
+    def edges(self) -> Iterator[Edge]:
+        return iter(self._edges)
+
+    @property
+    def nodes(self) -> Iterator[Type["BaseNode"]]:
+        nodes = set()
+        if not self._edges:
+            for node in self.entrypoints:
+                if node not in nodes:
+                    nodes.add(node)
+                    yield node
+            return
+
+        for edge in self._edges:
+            if edge.from_port.node_class not in nodes:
+                nodes.add(edge.from_port.node_class)
+                yield edge.from_port.node_class
+            if edge.to_node not in nodes:
+                nodes.add(edge.to_node)
+                yield edge.to_node
+
+    def _extend_edges(self, edges: Iterator[Edge]) -> None:
+        for edge in edges:
+            if edge not in self._edges:
+                self._edges.append(edge)