langflow-base-nightly 0.5.1.dev2__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/graph/graph/constants.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from langflow.graph.schema import CHAT_COMPONENTS
-from langflow.utils.lazy_load import LazyLoadDictBase
-
-if TYPE_CHECKING:
-    from langflow.graph.vertex.base import Vertex
-    from langflow.graph.vertex.vertex_types import CustomComponentVertex
-
-
-class Finish:
-    def __bool__(self) -> bool:
-        return True
-
-    def __eq__(self, /, other):
-        return isinstance(other, Finish)
-
-    def __hash__(self) -> int:
-        return hash(type(self))
-
-
-def _import_vertex_types():
-    from langflow.graph.vertex import vertex_types
-
-    return vertex_types
-
-
-class VertexTypesDict(LazyLoadDictBase):
-    def __init__(self) -> None:
-        self._all_types_dict = None
-        self._types = _import_vertex_types
-
-    @property
-    def vertex_type_map(self) -> dict[str, type[Vertex]]:
-        return self.all_types_dict
-
-    def _build_dict(self):
-        langchain_types_dict = self.get_type_dict()
-        return {
-            **langchain_types_dict,
-            "Custom": ["Custom Tool", "Python Function"],
-        }
-
-    def get_type_dict(self) -> dict[str, type[Vertex]]:
-        types = self._types()
-        return {
-            "CustomComponent": types.CustomComponentVertex,
-            "Component": types.ComponentVertex,
-            **dict.fromkeys(CHAT_COMPONENTS, types.InterfaceVertex),
-        }
-
-    def get_custom_component_vertex_type(self) -> type[CustomComponentVertex]:
-        return self._types().CustomComponentVertex
-
-
-lazy_load_vertex_dict = VertexTypesDict()

langflow/graph/graph/runnable_vertices_manager.py

@@ -1,133 +0,0 @@
-from collections import defaultdict
-
-
-class RunnableVerticesManager:
-    def __init__(self) -> None:
-        self.run_map: dict[str, list[str]] = defaultdict(list)  # Tracks successors of each vertex
-        self.run_predecessors: dict[str, list[str]] = defaultdict(list)  # Tracks predecessors for each vertex
-        self.vertices_to_run: set[str] = set()  # Set of vertices that are ready to run
-        self.vertices_being_run: set[str] = set()  # Set of vertices that are currently running
-        self.cycle_vertices: set[str] = set()  # Set of vertices that are in a cycle
-        self.ran_at_least_once: set[str] = set()  # Set of vertices that have been run at least once
-
-    def to_dict(self) -> dict:
-        return {
-            "run_map": self.run_map,
-            "run_predecessors": self.run_predecessors,
-            "vertices_to_run": self.vertices_to_run,
-            "vertices_being_run": self.vertices_being_run,
-            "ran_at_least_once": self.ran_at_least_once,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "RunnableVerticesManager":
-        instance = cls()
-        instance.run_map = data["run_map"]
-        instance.run_predecessors = data["run_predecessors"]
-        instance.vertices_to_run = data["vertices_to_run"]
-        instance.vertices_being_run = data["vertices_being_run"]
-        instance.ran_at_least_once = data.get("ran_at_least_once", set())
-        return instance
-
-    def __getstate__(self) -> object:
-        return {
-            "run_map": self.run_map,
-            "run_predecessors": self.run_predecessors,
-            "vertices_to_run": self.vertices_to_run,
-            "vertices_being_run": self.vertices_being_run,
-            "ran_at_least_once": self.ran_at_least_once,
-        }
-
-    def __setstate__(self, state: dict) -> None:
-        self.run_map = state["run_map"]
-        self.run_predecessors = state["run_predecessors"]
-        self.vertices_to_run = state["vertices_to_run"]
-        self.vertices_being_run = state["vertices_being_run"]
-        self.ran_at_least_once = state["ran_at_least_once"]
-
-    def all_predecessors_are_fulfilled(self) -> bool:
-        return all(not value for value in self.run_predecessors.values())
-
-    def update_run_state(self, run_predecessors: dict, vertices_to_run: set) -> None:
-        self.run_predecessors.update(run_predecessors)
-        self.vertices_to_run.update(vertices_to_run)
-        self.build_run_map(self.run_predecessors, self.vertices_to_run)
-
-    def is_vertex_runnable(self, vertex_id: str, *, is_active: bool, is_loop: bool = False) -> bool:
-        """Determines if a vertex is runnable based on its active state and predecessor fulfillment."""
-        if not is_active:
-            return False
-        if vertex_id in self.vertices_being_run:
-            return False
-        if vertex_id not in self.vertices_to_run:
-            return False
-
-        return self.are_all_predecessors_fulfilled(vertex_id, is_loop=is_loop)
-
-    def are_all_predecessors_fulfilled(self, vertex_id: str, *, is_loop: bool) -> bool:
-        """Determines if all predecessors for a vertex have been fulfilled.
-
-        This method checks if a vertex is ready to run by verifying that either:
-        1. It has no pending predecessors that need to complete first
-        2. For vertices in cycles, none of its pending predecessors are also cycle vertices
-           (which would create a circular dependency)
-
-        Args:
-            vertex_id (str): The ID of the vertex to check
-            is_loop (bool): Whether the vertex is a loop
-        Returns:
-            bool: True if all predecessor conditions are met, False otherwise
-        """
-        # Get pending predecessors, return True if none exist
-        pending = self.run_predecessors.get(vertex_id, [])
-        if not pending:
-            return True
-
-        # For cycle vertices, check if any pending predecessors are also in cycle
-        # Using set intersection is faster than iteration
-        if vertex_id in self.cycle_vertices:
-            pending_set = set(pending)
-            running_predecessors = pending_set & self.vertices_being_run
-
-            # If this vertex has already run at least once, be strict: wait until NOTHING is pending or running
-            if vertex_id in self.ran_at_least_once:
-                # Wait if there are still pending or running predecessors; otherwise allow.
-                return not (pending_set or running_predecessors)
-
-            # FIRST execution of a cycle vertex
-            # Allow running **only** if it's a loop AND *all* pending predecessors are cycle vertices
-            return is_loop and pending_set <= self.cycle_vertices
-        return False
-
-    def remove_from_predecessors(self, vertex_id: str) -> None:
-        """Removes a vertex from the predecessor list of its successors."""
-        predecessors = self.run_map.get(vertex_id, [])
-        for predecessor in predecessors:
-            if vertex_id in self.run_predecessors[predecessor]:
-                self.run_predecessors[predecessor].remove(vertex_id)
-
-    def build_run_map(self, predecessor_map, vertices_to_run) -> None:
-        """Builds a map of vertices and their runnable successors."""
-        self.run_map = defaultdict(list)
-        for vertex_id, predecessors in predecessor_map.items():
-            for predecessor in predecessors:
-                self.run_map[predecessor].append(vertex_id)
-        self.run_predecessors = predecessor_map.copy()
-        self.vertices_to_run = vertices_to_run
-
-    def update_vertex_run_state(self, vertex_id: str, *, is_runnable: bool) -> None:
-        """Updates the runnable state of a vertex."""
-        if is_runnable:
-            self.vertices_to_run.add(vertex_id)
-        else:
-            self.vertices_being_run.discard(vertex_id)
-
-    def remove_vertex_from_runnables(self, v_id) -> None:
-        self.update_vertex_run_state(v_id, is_runnable=False)
-        self.remove_from_predecessors(v_id)
-
-    def add_to_vertices_being_run(self, v_id) -> None:
-        self.vertices_being_run.add(v_id)
-
-    def add_to_cycle_vertices(self, v_id):
-        self.cycle_vertices.add(v_id)

langflow/graph/graph/schema.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, NamedTuple, Protocol
-
-from typing_extensions import NotRequired, TypedDict
-
-from langflow.graph.edge.schema import EdgeData
-from langflow.graph.vertex.schema import NodeData
-
-if TYPE_CHECKING:
-    from langflow.graph.schema import ResultData
-    from langflow.graph.vertex.base import Vertex
-    from langflow.schema.log import LoggableType
-
-
-class ViewPort(TypedDict):
-    x: float
-    y: float
-    zoom: float
-
-
-class GraphData(TypedDict):
-    nodes: list[NodeData]
-    edges: list[EdgeData]
-    viewport: NotRequired[ViewPort]
-
-
-class GraphDump(TypedDict, total=False):
-    data: GraphData
-    is_component: bool
-    name: str
-    description: str
-    endpoint_name: str
-
-
-class VertexBuildResult(NamedTuple):
-    result_dict: ResultData
-    params: str
-    valid: bool
-    artifacts: dict
-    vertex: Vertex
-
-
-class OutputConfigDict(TypedDict):
-    cache: bool
-
-
-class StartConfigDict(TypedDict):
-    output: OutputConfigDict
-
-
-class LogCallbackFunction(Protocol):
-    def __call__(self, event_name: str, log: LoggableType) -> None: ...

langflow/graph/graph/state_model.py

@@ -1,66 +0,0 @@
-import re
-
-from langflow.graph.state.model import create_state_model
-from langflow.helpers.base_model import BaseModel
-
-
-def camel_to_snake(camel_str: str) -> str:
-    return re.sub(r"(?<!^)(?=[A-Z])", "_", camel_str).lower()
-
-
-def create_state_model_from_graph(graph: BaseModel) -> type[BaseModel]:
-    """Create a Pydantic state model from a graph representation.
-
-    This function generates a Pydantic model that represents the state of an entire graph.
-    It creates getter methods for each vertex in the graph, allowing access to the state
-    of individual components within the graph structure.
-
-    Args:
-        graph (BaseModel): The graph object from which to create the state model.
-            This should be a Pydantic model representing the graph structure,
-            with a 'vertices' attribute containing all graph vertices.
-
-    Returns:
-        type[BaseModel]: A dynamically created Pydantic model class representing
-            the state of the entire graph. This model will have properties
-            corresponding to each vertex in the graph, with names converted from
-            the vertex IDs to snake case.
-
-    Raises:
-        ValueError: If any vertex in the graph does not have a properly initialized
-            component instance (i.e., if vertex.custom_component is None).
-
-    Notes:
-        - Each vertex in the graph must have a 'custom_component' attribute.
-        - The 'custom_component' must have a 'get_state_model_instance_getter' method.
-        - Vertex IDs are converted from camel case to snake case for the resulting model's field names.
-        - The resulting model uses the 'create_state_model' function with validation disabled.
-
-    Example:
-        >>> class Vertex(BaseModel):
-        ...     id: str
-        ...     custom_component: Any
-        >>> class Graph(BaseModel):
-        ...     vertices: List[Vertex]
-        >>> # Assume proper setup of vertices and components
-        >>> graph = Graph(vertices=[...])
-        >>> GraphStateModel = create_state_model_from_graph(graph)
-        >>> graph_state = GraphStateModel()
-        >>> # Access component states, e.g.:
-        >>> print(graph_state.some_component_name)
-    """
-    for vertex in graph.vertices:
-        if hasattr(vertex, "custom_component") and vertex.custom_component is None:
-            msg = f"Vertex {vertex.id} does not have a component instance."
-            raise ValueError(msg)
-
-    state_model_getters = [
-        vertex.custom_component.get_state_model_instance_getter()
-        for vertex in graph.vertices
-        if hasattr(vertex, "custom_component") and hasattr(vertex.custom_component, "get_state_model_instance_getter")
-    ]
-    fields = {
-        camel_to_snake(vertex.id): state_model_getter
-        for vertex, state_model_getter in zip(graph.vertices, state_model_getters, strict=False)
-    }
-    return create_state_model(model_name="GraphStateModel", validate=False, **fields)