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

lfx/helpers/custom.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+
+def format_type(type_: Any) -> str:
+    if type_ is str:
+        type_ = "Text"
+    elif hasattr(type_, "__name__"):
+        type_ = type_.__name__
+    elif hasattr(type_, "__class__"):
+        type_ = type_.__class__.__name__
+    else:
+        type_ = str(type_)
+    return type_

lfx/helpers/data.py

@@ -0,0 +1,167 @@
+import re
+from collections import defaultdict
+from typing import Any
+
+import orjson
+from fastapi.encoders import jsonable_encoder
+from langchain_core.documents import Document
+
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.message import Message
+
+
+def docs_to_data(documents: list[Document]) -> list[Data]:
+    """Converts a list of Documents to a list of Data.
+
+    Args:
+        documents (list[Document]): The list of Documents to convert.
+
+    Returns:
+        list[Data]: The converted list of Data.
+    """
+    return [Data.from_document(document) for document in documents]
+
+
+def clean_string(s):
+    # Remove empty lines
+    s = re.sub(r"^\s*$", "", s, flags=re.MULTILINE)
+    # Replace three or more newlines with a double newline
+    return re.sub(r"\n{3,}", "\n\n", s)
+
+
+def _serialize_data(data: Data) -> str:
+    """Serialize Data object to JSON string."""
+    # Convert data.data to JSON-serializable format
+    serializable_data = jsonable_encoder(data.data)
+    # Serialize with orjson, enabling pretty printing with indentation
+    json_bytes = orjson.dumps(serializable_data, option=orjson.OPT_INDENT_2)
+    # Convert bytes to string and wrap in Markdown code blocks
+    return "```json\n" + json_bytes.decode("utf-8") + "\n```"
+
+
+def safe_convert(data: Any, *, clean_data: bool = False) -> str:
+    """Safely convert input data to string."""
+    try:
+        if isinstance(data, str):
+            return clean_string(data)
+        if isinstance(data, Message):
+            return data.get_text()
+        if isinstance(data, Data):
+            return clean_string(_serialize_data(data))
+        if isinstance(data, DataFrame):
+            if clean_data:
+                # Remove empty rows
+                data = data.dropna(how="all")
+                # Remove empty lines in each cell
+                data = data.replace(r"^\s*$", "", regex=True)
+                # Replace multiple newlines with a single newline
+                data = data.replace(r"\n+", "\n", regex=True)
+
+            # Replace pipe characters to avoid markdown table issues
+            processed_data = data.replace(r"\|", r"\\|", regex=True)
+
+            return processed_data.to_markdown(index=False)
+
+        return clean_string(str(data))
+    except (ValueError, TypeError, AttributeError) as e:
+        msg = f"Error converting data: {e!s}"
+        raise ValueError(msg) from e
+
+
+def data_to_text_list(template: str, data: Data | list[Data]) -> tuple[list[str], list[Data]]:
+    """Format text from Data objects using a template string.
+
+    This function processes Data objects and formats their content using a template string.
+    It handles various data structures and ensures consistent text formatting across different
+    input types.
+
+    Key Features:
+    - Supports single Data object or list of Data objects
+    - Handles nested dictionaries and extracts text from various locations
+    - Uses safe string formatting with fallback for missing keys
+    - Preserves original Data objects in output
+
+    Args:
+        template: Format string with placeholders (e.g., "Hello {text}")
+                 Placeholders are replaced with values from Data objects
+        data: Either a single Data object or a list of Data objects to format
+              Each object can contain text, dictionaries, or nested data
+
+    Returns:
+        A tuple containing:
+        - List[str]: Formatted strings based on the template
+        - List[Data]: Original Data objects in the same order
+
+    Raises:
+        ValueError: If template is None
+        TypeError: If template is not a string
+
+    Examples:
+        >>> result = data_to_text_list("Hello {text}", Data(text="world"))
+        >>> assert result == (["Hello world"], [Data(text="world")])
+
+        >>> result = data_to_text_list(
+        ...     "{name} is {age}",
+        ...     Data(data={"name": "Alice", "age": 25})
+        ... )
+        >>> assert result == (["Alice is 25"], [Data(data={"name": "Alice", "age": 25})])
+    """
+    if data is None:
+        return [], []
+
+    if template is None:
+        msg = "Template must be a string, but got None."
+        raise ValueError(msg)
+
+    if not isinstance(template, str):
+        msg = f"Template must be a string, but got {type(template)}"
+        raise TypeError(msg)
+
+    formatted_text: list[str] = []
+    processed_data: list[Data] = []
+
+    data_list = [data] if isinstance(data, Data) else data
+
+    data_objects = [item if isinstance(item, Data) else Data(text=str(item)) for item in data_list]
+
+    for data_obj in data_objects:
+        format_dict = {}
+
+        if isinstance(data_obj.data, dict):
+            format_dict.update(data_obj.data)
+
+            if isinstance(data_obj.data.get("data"), dict):
+                format_dict.update(data_obj.data["data"])
+
+            elif format_dict.get("error"):
+                format_dict["text"] = format_dict["error"]
+
+        format_dict["data"] = data_obj.data
+
+        safe_dict = defaultdict(str, format_dict)
+
+        try:
+            formatted_text.append(template.format_map(safe_dict))
+            processed_data.append(data_obj)
+        except ValueError as e:
+            msg = f"Error formatting template: {e!s}"
+            raise ValueError(msg) from e
+
+    return formatted_text, processed_data
+
+
+def data_to_text(template: str, data: Data | list[Data], sep: str = "\n") -> str:
+    r"""Converts data into a formatted text string based on a given template.
+
+    Args:
+        template (str): The template string used to format each data item.
+        data (Data | list[Data]): A single data item or a list of data items to be formatted.
+        sep (str, optional): The separator to use between formatted data items. Defaults to "\n".
+
+    Returns:
+        str: A string containing the formatted data items separated by the specified separator.
+    """
+    formatted_text, _ = data_to_text_list(template, data)
+    sep = "\n" if sep is None else sep
+    return sep.join(formatted_text)

lfx/helpers/flow.py

@@ -0,0 +1,308 @@
+"""Flow helper functions for lfx package."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from pydantic import BaseModel, Field, create_model
+
+from lfx.log.logger import logger
+from lfx.schema.schema import INPUT_FIELD_NAME
+
+if TYPE_CHECKING:
+    from lfx.graph.graph.base import Graph
+    from lfx.graph.schema import RunOutputs
+    from lfx.graph.vertex.base import Vertex
+    from lfx.schema.data import Data
+
+
+def get_flow_inputs(graph: Graph) -> list[Vertex]:
+    """Retrieves the flow inputs from the given graph.
+
+    Args:
+        graph (Graph): The graph object representing the flow.
+
+    Returns:
+        List[Vertex]: A list of input vertices.
+    """
+    return [vertex for vertex in graph.vertices if vertex.is_input]
+
+
+def build_schema_from_inputs(name: str, inputs: list[Vertex]) -> type[BaseModel]:
+    """Builds a schema from the given inputs.
+
+    Args:
+        name (str): The name of the schema.
+        inputs (List[Vertex]): A list of Vertex objects representing the inputs.
+
+    Returns:
+        BaseModel: The schema model.
+    """
+    fields = {}
+    for input_ in inputs:
+        field_name = input_.display_name.lower().replace(" ", "_")
+        description = input_.description
+        fields[field_name] = (str, Field(default="", description=description))
+    return create_model(name, **fields)
+
+
+def get_arg_names(inputs: list[Vertex]) -> list[dict[str, str]]:
+    """Returns a list of dictionaries containing the component name and its corresponding argument name.
+
+    Args:
+        inputs (List[Vertex]): A list of Vertex objects representing the inputs.
+
+    Returns:
+        List[dict[str, str]]: A list of dictionaries, where each dictionary contains the component name and its
+            argument name.
+    """
+    return [
+        {"component_name": input_.display_name, "arg_name": input_.display_name.lower().replace(" ", "_")}
+        for input_ in inputs
+    ]
+
+
+async def list_flows(*, user_id: str | None = None) -> list[Data]:
+    """List flows for a user.
+
+    In lfx, this is a stub that returns an empty list since we don't have
+    a database backend by default.
+
+    Args:
+        user_id: The user ID to list flows for.
+
+    Returns:
+        List of flow data objects.
+    """
+    if not user_id:
+        msg = "Session is invalid"
+        raise ValueError(msg)
+
+    # In lfx, we don't have a database backend by default
+    # This is a stub implementation
+    logger.warning("list_flows called but lfx doesn't have database backend by default")
+    return []
+
+
+async def list_flows_by_flow_folder(
+    *,
+    user_id: str | None = None,
+    flow_id: str | None = None,
+    order_params: dict | None = {"column": "updated_at", "direction": "desc"},  # noqa: B006, ARG001
+) -> list[Data]:
+    """Lists flows for the given user and in the same folder as the specified flow.
+
+    Retrieves all flows belonging to the given user and identified by user_id
+    that belong to the same folder as the flow identified by flow_id if the flow belongs to the user.
+
+    Optionally accepts a dictionary of order parameters
+    to order the flows by the specified column and direction.
+    Default order column is "updated_at" and default order direction is "desc".
+
+    In lfx, this is a stub that returns an empty list since we don't have
+    a database backend by default.
+
+    Args:
+        user_id (str | None, optional): The user ID to list flows for. Defaults to None.
+        flow_id (str | None, optional): The flow ID to list flows in the same folder as. Defaults to None.
+        order_params (dict | None, optional): Parameters for ordering the flows.
+        Defaults to {"column": "updated_at", "direction": "desc"}.
+            - column: The column to order by. Defaults to "updated_at".
+            - direction: The direction to order by. Defaults to "desc".
+
+    Returns:
+        list[Data]: List of flows in the same folder as the flow identified by flow_id.
+
+    Raises:
+        ValueError: If user_id is not provided.
+        ValueError: If Flow ID is not provided.
+    """
+    if not user_id:
+        msg = "Session is invalid"
+        raise ValueError(msg)
+    if not flow_id:
+        msg = "Flow ID is required"
+        raise ValueError(msg)
+
+    # In lfx, we don't have a database backend by default
+    # This is a stub implementation
+    logger.warning("list_flows_by_flow_folder called but lfx doesn't have database backend by default")
+    return []
+
+
+async def list_flows_by_folder_id(
+    *,
+    user_id: str | None = None,
+    folder_id: str | None = None,
+) -> list[Data]:
+    """Lists flows for the given user and in the same folder as the specified folder.
+
+    Retrieves all flows belonging to the user identified by user_id
+    that belong to the same folder as the folder identified by folder_id
+    if the folder belongs to the user.
+
+    In lfx, this is a stub that returns an empty list since we don't have
+    a database backend by default.
+
+    Args:
+        user_id (str | None, optional): The user ID to list flows for. Defaults to None.
+        folder_id (str | None, optional): The folder ID to list flows in the same folder as. Defaults to None.
+
+    Returns:
+        list[Data]: List of flows in the same folder as the folder identified by folder_id.
+
+    Raises:
+        ValueError: If user_id is not provided.
+        ValueError: If Folder ID is not provided.
+    """
+    if not user_id:
+        msg = "Session is invalid"
+        raise ValueError(msg)
+    if not folder_id:
+        msg = "Folder ID is required"
+        raise ValueError(msg)
+
+    # In lfx, we don't have a database backend by default
+    # This is a stub implementation
+    logger.warning("list_flows_by_folder_id called but lfx doesn't have database backend by default")
+    return []
+
+
+async def get_flow_by_id_or_name(
+    user_id: str,
+    flow_id: str | None = None,
+    flow_name: str | None = None,
+) -> Data | None:
+    """Get a flow by ID or name.
+
+    Retrieves a flow by ID or name. If both are provided, flow_id is used.
+
+    In lfx, this is a stub that returns None since we don't have
+    a database backend by default.
+
+    Args:
+        user_id (str): The user ID to get the flow for.
+        flow_id (str | None, optional): The flow ID. Defaults to None.
+        flow_name (str | None, optional): The flow name. Defaults to None.
+
+    Returns:
+        Data | None: The flow data or None if not found.
+    """
+    if not user_id:
+        msg = "Session is invalid"
+        raise ValueError(msg)
+    if not (flow_id or flow_name):
+        msg = "Flow ID or Flow Name is required"
+        raise ValueError(msg)
+
+    # In lfx, we don't have a database backend by default
+    # This is a stub implementation
+    logger.warning("get_flow_by_id_or_name called but lfx doesn't have database backend by default")
+    return None
+
+
+async def load_flow(
+    user_id: str,  # noqa: ARG001
+    flow_id: str | None = None,
+    flow_name: str | None = None,
+    tweaks: dict | None = None,  # noqa: ARG001
+) -> Graph:
+    """Load a flow by ID or name.
+
+    In lfx, this is a stub that raises an error since we don't have
+    a database backend by default.
+
+    Args:
+        user_id: The user ID.
+        flow_id: The flow ID to load.
+        flow_name: The flow name to load.
+        tweaks: Optional tweaks to apply to the flow.
+
+    Returns:
+        The loaded flow graph.
+    """
+    if not flow_id and not flow_name:
+        msg = "Flow ID or Flow Name is required"
+        raise ValueError(msg)
+
+    # In lfx, we don't have a database backend by default
+    # This is a stub implementation
+    msg = f"load_flow not implemented in lfx - cannot load flow {flow_id or flow_name}"
+    raise NotImplementedError(msg)
+
+
+async def run_flow(
+    inputs: dict | list[dict] | None = None,
+    tweaks: dict | None = None,  # noqa: ARG001
+    flow_id: str | None = None,  # noqa: ARG001
+    flow_name: str | None = None,  # noqa: ARG001
+    output_type: str | None = "chat",
+    user_id: str | None = None,
+    run_id: str | None = None,
+    session_id: str | None = None,
+    graph: Graph | None = None,
+) -> list[RunOutputs]:
+    """Run a flow with given inputs.
+
+    Args:
+        inputs: Input values for the flow.
+        tweaks: Optional tweaks to apply.
+        flow_id: The flow ID to run.
+        flow_name: The flow name to run.
+        output_type: The type of output to return.
+        user_id: The user ID.
+        run_id: Optional run ID.
+        session_id: Optional session ID.
+        graph: Optional pre-loaded graph.
+
+    Returns:
+        List of run outputs.
+    """
+    if user_id is None:
+        msg = "Session is invalid"
+        raise ValueError(msg)
+
+    if graph is None:
+        # In lfx, we can't load flows from database
+        msg = "run_flow requires a graph parameter in lfx"
+        raise ValueError(msg)
+
+    if run_id:
+        graph.set_run_id(UUID(run_id))
+    if session_id:
+        graph.session_id = session_id
+    if user_id:
+        graph.user_id = user_id
+
+    if inputs is None:
+        inputs = []
+    if isinstance(inputs, dict):
+        inputs = [inputs]
+
+    inputs_list = []
+    inputs_components = []
+    types = []
+
+    for input_dict in inputs:
+        inputs_list.append({INPUT_FIELD_NAME: input_dict.get("input_value", "")})
+        inputs_components.append(input_dict.get("components", []))
+        types.append(input_dict.get("type", "chat"))
+
+    outputs = [
+        vertex.id
+        for vertex in graph.vertices
+        if output_type == "debug"
+        or (vertex.is_output and (output_type == "any" or (output_type and output_type in str(vertex.id).lower())))
+    ]
+
+    # In lfx, we don't have settings service, so use False as default
+    fallback_to_env_vars = False
+
+    return await graph.arun(
+        inputs_list,
+        outputs=outputs,
+        inputs_components=inputs_components,
+        types=types,
+        fallback_to_env_vars=fallback_to_env_vars,
+    )

lfx/inputs/__init__.py

@@ -0,0 +1,68 @@
+from .inputs import (
+    AuthInput,
+    BoolInput,
+    CodeInput,
+    ConnectionInput,
+    DataFrameInput,
+    DataInput,
+    DefaultPromptField,
+    DictInput,
+    DropdownInput,
+    FileInput,
+    FloatInput,
+    HandleInput,
+    Input,
+    IntInput,
+    LinkInput,
+    McpInput,
+    MessageInput,
+    MessageTextInput,
+    MultilineInput,
+    MultilineSecretInput,
+    MultiselectInput,
+    NestedDictInput,
+    PromptInput,
+    QueryInput,
+    SecretStrInput,
+    SliderInput,
+    SortableListInput,
+    StrInput,
+    TabInput,
+    TableInput,
+    ToolsInput,
+)
+
+__all__ = [
+    "AuthInput",
+    "BoolInput",
+    "CodeInput",
+    "ConnectionInput",
+    "DataFrameInput",
+    "DataInput",
+    "DefaultPromptField",
+    "DefaultPromptField",
+    "DictInput",
+    "DropdownInput",
+    "FileInput",
+    "FloatInput",
+    "HandleInput",
+    "Input",
+    "IntInput",
+    "LinkInput",
+    "McpInput",
+    "MessageInput",
+    "MessageTextInput",
+    "MultilineInput",
+    "MultilineSecretInput",
+    "MultiselectInput",
+    "NestedDictInput",
+    "PromptInput",
+    "QueryInput",
+    "SecretStrInput",
+    "SliderInput",
+    "SortableListInput",
+    "StrInput",
+    "TabInput",
+    "TableInput",
+    "ToolsInput",
+]

lfx/inputs/constants.py

@@ -0,0 +1,2 @@
+MAX_TAB_OPTIONS = 3
+MAX_TAB_OPTION_LENGTH = 20