lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/field_typing/__init__.py

@@ -0,0 +1,91 @@
+from typing import Any
+
+from .constants import (
+    AgentExecutor,
+    BaseChatMemory,
+    BaseChatModel,
+    BaseDocumentCompressor,
+    BaseLanguageModel,
+    BaseLLM,
+    BaseLoader,
+    BaseMemory,
+    BaseOutputParser,
+    BasePromptTemplate,
+    BaseRetriever,
+    Callable,
+    Chain,
+    ChatPromptTemplate,
+    Code,
+    Data,
+    Document,
+    Embeddings,
+    LanguageModel,
+    NestedDict,
+    Object,
+    PromptTemplate,
+    Retriever,
+    Text,
+    TextSplitter,
+    Tool,
+    VectorStore,
+)
+from .range_spec import RangeSpec
+
+
+def _import_input_class():
+    from lfx.template.field.base import Input
+
+    return Input
+
+
+def _import_output_class():
+    from lfx.template.field.base import Output
+
+    return Output
+
+
+def __getattr__(name: str) -> Any:
+    # This is to avoid circular imports
+    if name == "Input":
+        return _import_input_class()
+    if name == "Output":
+        return _import_output_class()
+    if name == "RangeSpec":
+        return RangeSpec
+    # The other names should work as if they were imported from constants
+    # Import the constants module langflow.field_typing.constants
+    from . import constants
+
+    return getattr(constants, name)
+
+
+__all__ = [
+    "AgentExecutor",
+    "BaseChatMemory",
+    "BaseChatModel",
+    "BaseDocumentCompressor",
+    "BaseLLM",
+    "BaseLanguageModel",
+    "BaseLoader",
+    "BaseMemory",
+    "BaseOutputParser",
+    "BasePromptTemplate",
+    "BaseRetriever",
+    "Callable",
+    "Chain",
+    "ChatPromptTemplate",
+    "Code",
+    "Data",
+    "Document",
+    "Embeddings",
+    "LanguageModel",
+    "NestedDict",
+    "Object",
+    "PromptTemplate",
+    "RangeSpec",
+    "Retriever",
+    "Text",
+    "TextSplitter",
+    "Tool",
+    "VectorStore",
+]

lfx/field_typing/constants.py

@@ -0,0 +1,216 @@
+"""Constants for field typing used throughout lfx package."""
+
+import importlib.util
+from collections.abc import Callable
+from typing import Text, TypeAlias, TypeVar
+
+# Safe imports that don't create circular dependencies
+try:
+    from langchain.agents.agent import AgentExecutor
+    from langchain.chains.base import Chain
+    from langchain.memory.chat_memory import BaseChatMemory
+    from langchain_core.chat_history import BaseChatMessageHistory
+    from langchain_core.document_loaders import BaseLoader
+    from langchain_core.documents import Document
+    from langchain_core.documents.compressor import BaseDocumentCompressor
+    from langchain_core.embeddings import Embeddings
+    from langchain_core.language_models import BaseLanguageModel, BaseLLM
+    from langchain_core.language_models.chat_models import BaseChatModel
+    from langchain_core.memory import BaseMemory
+    from langchain_core.output_parsers import BaseLLMOutputParser, BaseOutputParser
+    from langchain_core.prompts import BasePromptTemplate, ChatPromptTemplate, PromptTemplate
+    from langchain_core.retrievers import BaseRetriever
+    from langchain_core.tools import BaseTool, Tool
+    from langchain_core.vectorstores import VectorStore, VectorStoreRetriever
+    from langchain_text_splitters import TextSplitter
+except ImportError:
+    # Create stub types if langchain is not available
+    class AgentExecutor:
+        pass
+
+    class Chain:
+        pass
+
+    class BaseChatMemory:
+        pass
+
+    class BaseChatMessageHistory:
+        pass
+
+    class BaseLoader:
+        pass
+
+    class Document:
+        pass
+
+    class BaseDocumentCompressor:
+        pass
+
+    class Embeddings:
+        pass
+
+    class BaseLanguageModel:
+        pass
+
+    class BaseLLM:
+        pass
+
+    class BaseChatModel:
+        pass
+
+    class BaseMemory:
+        pass
+
+    class BaseLLMOutputParser:
+        pass
+
+    class BaseOutputParser:
+        pass
+
+    class BasePromptTemplate:
+        pass
+
+    class ChatPromptTemplate:
+        pass
+
+    class PromptTemplate:
+        pass
+
+    class BaseRetriever:
+        pass
+
+    class BaseTool:
+        pass
+
+    class Tool:
+        pass
+
+    class VectorStore:
+        pass
+
+    class VectorStoreRetriever:
+        pass
+
+    class TextSplitter:
+        pass
+
+
+# Import lfx schema types (avoid circular deps)
+from lfx.schema.data import Data
+
+# Type aliases
+NestedDict: TypeAlias = dict[str, str | dict]
+LanguageModel = TypeVar("LanguageModel", BaseLanguageModel, BaseLLM, BaseChatModel)
+ToolEnabledLanguageModel = TypeVar("ToolEnabledLanguageModel", BaseLanguageModel, BaseLLM, BaseChatModel)
+Memory = TypeVar("Memory", bound=BaseChatMessageHistory)
+
+Retriever = TypeVar(
+    "Retriever",
+    BaseRetriever,
+    VectorStoreRetriever,
+)
+OutputParser = TypeVar(
+    "OutputParser",
+    BaseOutputParser,
+    BaseLLMOutputParser,
+)
+
+
+class Object:
+    """Generic object type for custom components."""
+
+
+class Code:
+    """Code type for custom components."""
+
+
+# Langchain base types mapping
+LANGCHAIN_BASE_TYPES = {
+    "Chain": Chain,
+    "AgentExecutor": AgentExecutor,
+    "BaseTool": BaseTool,
+    "Tool": Tool,
+    "BaseLLM": BaseLLM,
+    "BaseLanguageModel": BaseLanguageModel,
+    "PromptTemplate": PromptTemplate,
+    "ChatPromptTemplate": ChatPromptTemplate,
+    "BasePromptTemplate": BasePromptTemplate,
+    "BaseLoader": BaseLoader,
+    "Document": Document,
+    "TextSplitter": TextSplitter,
+    "VectorStore": VectorStore,
+    "Embeddings": Embeddings,
+    "BaseRetriever": BaseRetriever,
+    "BaseOutputParser": BaseOutputParser,
+    "BaseMemory": BaseMemory,
+    "BaseChatMemory": BaseChatMemory,
+    "BaseChatModel": BaseChatModel,
+    "Memory": Memory,
+    "BaseDocumentCompressor": BaseDocumentCompressor,
+}
+
+# Langchain base types plus Python base types
+CUSTOM_COMPONENT_SUPPORTED_TYPES = {
+    **LANGCHAIN_BASE_TYPES,
+    "NestedDict": NestedDict,
+    "Data": Data,
+    "Text": Text,  # noqa: UP019
+    "Object": Object,
+    "Callable": Callable,
+    "LanguageModel": LanguageModel,
+    "Retriever": Retriever,
+}
+
+# Default import string for component code generation
+LANGCHAIN_IMPORT_STRING = """from langchain.agents.agent import AgentExecutor
+from langchain.chains.base import Chain
+from langchain.memory.chat_memory import BaseChatMemory
+from langchain_core.chat_history import BaseChatMessageHistory
+from langchain_core.document_loaders import BaseLoader
+from langchain_core.documents import Document
+from langchain_core.embeddings import Embeddings
+from langchain_core.language_models import BaseLanguageModel, BaseLLM
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.memory import BaseMemory
+from langchain_core.output_parsers import BaseLLMOutputParser, BaseOutputParser
+from langchain_core.prompts import BasePromptTemplate, ChatPromptTemplate, PromptTemplate
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.documents.compressor import BaseDocumentCompressor
+from langchain_core.tools import BaseTool, Tool
+from langchain_core.vectorstores import VectorStore, VectorStoreRetriever
+from langchain_text_splitters import TextSplitter
+"""
+
+
+DEFAULT_IMPORT_STRING = """
+
+from lfx.io import (
+    BoolInput,
+    CodeInput,
+    DataInput,
+    DictInput,
+    DropdownInput,
+    FileInput,
+    FloatInput,
+    HandleInput,
+    IntInput,
+    LinkInput,
+    MessageInput,
+    MessageTextInput,
+    MultilineInput,
+    MultilineSecretInput,
+    MultiselectInput,
+    NestedDictInput,
+    Output,
+    PromptInput,
+    SecretStrInput,
+    SliderInput,
+    StrInput,
+    TableInput,
+)
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+"""
+
+if importlib.util.find_spec("langchain") is not None:
+    DEFAULT_IMPORT_STRING = LANGCHAIN_IMPORT_STRING + DEFAULT_IMPORT_STRING

lfx/field_typing/range_spec.py

@@ -0,0 +1,35 @@
+"""Range specification for field types copied from langflow for lfx package."""
+
+from typing import Literal
+
+from pydantic import BaseModel, field_validator
+
+
+class RangeSpec(BaseModel):
+    step_type: Literal["int", "float"] = "float"
+    min: float = -1.0
+    max: float = 1.0
+    step: float = 0.1
+
+    @field_validator("max")
+    @classmethod
+    def max_must_be_greater_than_min(cls, v, values):
+        if "min" in values.data and v <= values.data["min"]:
+            msg = "Max must be greater than min"
+            raise ValueError(msg)
+        return v
+
+    @field_validator("step")
+    @classmethod
+    def step_must_be_positive(cls, v, values):
+        if v <= 0:
+            msg = "Step must be positive"
+            raise ValueError(msg)
+        if values.data["step_type"] == "int" and isinstance(v, float) and not v.is_integer():
+            msg = "When step_type is int, step must be an integer"
+            raise ValueError(msg)
+        return v
+
+    @classmethod
+    def set_step_type(cls, step_type: Literal["int", "float"], range_spec: "RangeSpec") -> "RangeSpec":
+        return cls(min=range_spec.min, max=range_spec.max, step=range_spec.step, step_type=step_type)

lfx/graph/__init__.py

@@ -0,0 +1,6 @@
+from lfx.graph.edge.base import Edge
+from lfx.graph.graph.base import Graph
+from lfx.graph.vertex.base import Vertex
+from lfx.graph.vertex.vertex_types import CustomComponentVertex, InterfaceVertex, StateVertex
+
+__all__ = ["CustomComponentVertex", "Edge", "Graph", "InterfaceVertex", "StateVertex", "Vertex"]

lfx/graph/edge/base.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+from lfx.graph.edge.schema import EdgeData, LoopTargetHandleDict, SourceHandle, TargetHandle, TargetHandleDict
+from lfx.log.logger import logger
+from lfx.schema.schema import INPUT_FIELD_NAME
+
+if TYPE_CHECKING:
+    from lfx.graph.vertex.base import Vertex
+
+
+class Edge:
+    def __init__(self, source: Vertex, target: Vertex, edge: EdgeData):
+        self.source_id: str = source.id if source else ""
+        self.target_id: str = target.id if target else ""
+        self.valid_handles: bool = False
+        self.target_param: str | None = None
+        self._target_handle: TargetHandleDict | str | None = None
+        self._data = edge.copy()
+        self.is_cycle = False
+        if data := edge.get("data", {}):
+            self._source_handle = data.get("sourceHandle", {})
+            self._target_handle = cast("TargetHandleDict", data.get("targetHandle", {}))
+            self.source_handle: SourceHandle = SourceHandle(**self._source_handle)
+            if isinstance(self._target_handle, dict):
+                try:
+                    if "name" in self._target_handle:
+                        self.target_handle: TargetHandle = TargetHandle.from_loop_target_handle(
+                            cast("LoopTargetHandleDict", self._target_handle)
+                        )
+                    else:
+                        self.target_handle = TargetHandle(**self._target_handle)
+                except Exception as e:
+                    if "inputTypes" in self._target_handle and self._target_handle["inputTypes"] is None:
+                        # Check if self._target_handle['fieldName']
+                        if hasattr(target, "custom_component"):
+                            display_name = getattr(target.custom_component, "display_name", "")
+                            msg = (
+                                f"Component {display_name} field '{self._target_handle['fieldName']}' "
+                                "might not be a valid input."
+                            )
+                            raise ValueError(msg) from e
+                        msg = (
+                            f"Field '{self._target_handle['fieldName']}' on {target.display_name} "
+                            "might not be a valid input."
+                        )
+                        raise ValueError(msg) from e
+                    raise
+
+            else:
+                msg = "Target handle is not a dictionary"
+                raise ValueError(msg)
+            self.target_param = self.target_handle.field_name
+            # validate handles
+            self.validate_handles(source, target)
+        else:
+            # Logging here because this is a breaking change
+            logger.error("Edge data is empty")
+            self._source_handle = edge.get("sourceHandle", "")  # type: ignore[assignment]
+            self._target_handle = edge.get("targetHandle", "")  # type: ignore[assignment]
+            # 'BaseLoader;BaseOutputParser|documents|PromptTemplate-zmTlD'
+            # target_param is documents
+            if isinstance(self._target_handle, str):
+                self.target_param = self._target_handle.split("|")[1]
+                self.source_handle = None  # type: ignore[assignment]
+                self.target_handle = None  # type: ignore[assignment]
+            else:
+                msg = "Target handle is not a string"
+                raise ValueError(msg)
+        # Validate in __init__ to fail fast
+        self.validate_edge(source, target)
+
+    def to_data(self):
+        return self._data
+
+    def validate_handles(self, source, target) -> None:
+        if isinstance(self._source_handle, str) or self.source_handle.base_classes:
+            self._legacy_validate_handles(source, target)
+        else:
+            self._validate_handles(source, target)
+
+    def _validate_handles(self, source, target) -> None:
+        if self.target_handle.input_types is None:
+            self.valid_handles = self.target_handle.type in self.source_handle.output_types
+        elif self.target_handle.type is None:
+            # ! This is not a good solution
+            # This is a loop edge
+            # If the target_handle.type is None, it means it's a loop edge
+            # and we should check if the source_handle.output_types is not empty
+            # and if the target_handle.input_types is empty or if any of the source_handle.output_types
+            # is in the target_handle.input_types
+            self.valid_handles = bool(self.source_handle.output_types) and (
+                not self.target_handle.input_types
+                or any(output_type in self.target_handle.input_types for output_type in self.source_handle.output_types)
+            )
+
+        elif self.source_handle.output_types is not None:
+            self.valid_handles = (
+                any(output_type in self.target_handle.input_types for output_type in self.source_handle.output_types)
+                or self.target_handle.type in self.source_handle.output_types
+            )
+
+        if not self.valid_handles:
+            logger.debug(self.source_handle)
+            logger.debug(self.target_handle)
+            msg = f"Edge between {source.display_name} and {target.display_name} has invalid handles"
+            raise ValueError(msg)
+
+    def _legacy_validate_handles(self, source, target) -> None:
+        if self.target_handle.input_types is None:
+            self.valid_handles = self.target_handle.type in self.source_handle.base_classes
+        else:
+            self.valid_handles = (
+                any(baseClass in self.target_handle.input_types for baseClass in self.source_handle.base_classes)
+                or self.target_handle.type in self.source_handle.base_classes
+            )
+        if not self.valid_handles:
+            logger.debug(self.source_handle)
+            logger.debug(self.target_handle)
+            msg = f"Edge between {source.vertex_type} and {target.vertex_type} has invalid handles"
+            raise ValueError(msg)
+
+    def __setstate__(self, state):
+        self.source_id = state["source_id"]
+        self.target_id = state["target_id"]
+        self.target_param = state["target_param"]
+        self.source_handle = state.get("source_handle")
+        self.target_handle = state.get("target_handle")
+        self._source_handle = state.get("_source_handle")
+        self._target_handle = state.get("_target_handle")
+        self._data = state.get("_data")
+        self.valid_handles = state.get("valid_handles")
+        self.source_types = state.get("source_types")
+        self.target_reqs = state.get("target_reqs")
+        self.matched_type = state.get("matched_type")
+
+    def validate_edge(self, source, target) -> None:
+        # If the self.source_handle has base_classes, then we are using the legacy
+        # way of defining the source and target handles
+        if isinstance(self._source_handle, str) or self.source_handle.base_classes:
+            self._legacy_validate_edge(source, target)
+        else:
+            self._validate_edge(source, target)
+
+    def _validate_edge(self, source, target) -> None:
+        # Validate that the outputs of the source node are valid inputs
+        # for the target node
+        # .outputs is a list of Output objects as dictionaries
+        # meaning: check for "types" key in each dictionary
+        self.source_types = [output for output in source.outputs if output["name"] == self.source_handle.name]
+
+        # Check if this is an loop input (loop target handle with output_types)
+        is_loop_input = hasattr(self.target_handle, "input_types") and self.target_handle.input_types
+        loop_input_types = []
+
+        if is_loop_input:
+            # For loop inputs, use the configured input_types
+            # (which already includes original type + loop_types from frontend)
+            loop_input_types = list(self.target_handle.input_types)
+            self.valid = any(
+                any(output_type in loop_input_types for output_type in output["types"]) for output in self.source_types
+            )
+            # Find the first matching type
+            self.matched_type = next(
+                (
+                    output_type
+                    for output in self.source_types
+                    for output_type in output["types"]
+                    if output_type in loop_input_types
+                ),
+                None,
+            )
+        else:
+            # Standard validation for regular inputs
+            self.target_reqs = target.required_inputs + target.optional_inputs
+            # Both lists contain strings and sometimes a string contains the value we are
+            # looking for e.g. comgin_out=["Chain"] and target_reqs=["LLMChain"]
+            # so we need to check if any of the strings in source_types is in target_reqs
+            self.valid = any(
+                any(output_type in target_req for output_type in output["types"])
+                for output in self.source_types
+                for target_req in self.target_reqs
+            )
+            # Update the matched type to be the first found match
+            self.matched_type = next(
+                (
+                    output_type
+                    for output in self.source_types
+                    for output_type in output["types"]
+                    for target_req in self.target_reqs
+                    if output_type in target_req
+                ),
+                None,
+            )
+
+        no_matched_type = self.matched_type is None
+        if no_matched_type:
+            logger.debug(self.source_types)
+            logger.debug(self.target_reqs if not is_loop_input else loop_input_types)
+            msg = f"Edge between {source.vertex_type} and {target.vertex_type} has no matched type."
+            raise ValueError(msg)
+
+    def _legacy_validate_edge(self, source, target) -> None:
+        # Validate that the outputs of the source node are valid inputs
+        # for the target node
+        self.source_types = source.output
+        self.target_reqs = target.required_inputs + target.optional_inputs
+        # Both lists contain strings and sometimes a string contains the value we are
+        # looking for e.g. comgin_out=["Chain"] and target_reqs=["LLMChain"]
+        # so we need to check if any of the strings in source_types is in target_reqs
+        self.valid = any(output in target_req for output in self.source_types for target_req in self.target_reqs)
+        # Get what type of input the target node is expecting
+
+        self.matched_type = next(
+            (output for output in self.source_types if output in self.target_reqs),
+            None,
+        )
+        no_matched_type = self.matched_type is None
+        if no_matched_type:
+            logger.debug(self.source_types)
+            logger.debug(self.target_reqs)
+            msg = f"Edge between {source.vertex_type} and {target.vertex_type} has no matched type"
+            raise ValueError(msg)
+
+    def __repr__(self) -> str:
+        if (hasattr(self, "source_handle") and self.source_handle) and (
+            hasattr(self, "target_handle") and self.target_handle
+        ):
+            return f"{self.source_id} -[{self.source_handle.name}->{self.target_handle.field_name}]-> {self.target_id}"
+        return f"{self.source_id} -[{self.target_param}]-> {self.target_id}"
+
+    def __hash__(self) -> int:
+        return hash(self.__repr__())
+
+    def __eq__(self, /, other: object) -> bool:
+        if not isinstance(other, Edge):
+            return False
+        return (
+            self._source_handle == other._source_handle
+            and self._target_handle == other._target_handle
+            and self.target_param == other.target_param
+        )
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+
+class CycleEdge(Edge):
+    def __init__(self, source: Vertex, target: Vertex, raw_edge: EdgeData):
+        super().__init__(source, target, raw_edge)
+        self.is_fulfilled = False  # Whether the contract has been fulfilled.
+        self.result: Any = None
+        self.is_cycle = True
+        source.has_cycle_edges = True
+        target.has_cycle_edges = True
+
+    async def honor(self, source: Vertex, target: Vertex) -> None:
+        """Fulfills the contract by setting the result of the source vertex to the target vertex's parameter.
+
+        If the edge is runnable, the source vertex is run with the message text and the target vertex's
+        root_field param is set to the
+        result. If the edge is not runnable, the target vertex's parameter is set to the result.
+        :param message: The message object to be processed if the edge is runnable.
+        """
+        if self.is_fulfilled:
+            return
+
+        if not source.built:
+            # The system should be read-only, so we should not be building vertices
+            # that are not already built.
+            msg = f"Source vertex {source.id} is not built."
+            raise ValueError(msg)
+
+        if self.matched_type == "Text":
+            self.result = source.built_result
+        else:
+            self.result = source.built_object
+
+        target.params[self.target_param] = self.result
+        self.is_fulfilled = True
+
+    async def get_result_from_source(self, source: Vertex, target: Vertex):
+        # Fulfill the contract if it has not been fulfilled.
+        if not self.is_fulfilled:
+            await self.honor(source, target)
+
+        # If the target vertex is a power component we log messages
+        if (
+            target.vertex_type == "ChatOutput"
+            and isinstance(target.params.get(INPUT_FIELD_NAME), str | dict)
+            and target.params.get("message") == ""
+        ):
+            return self.result
+        return self.result
+
+    def __repr__(self) -> str:
+        str_repr = super().__repr__()
+        # Add a symbol to show this is a cycle edge
+        return f"{str_repr} 🔄"