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

lfx/components/processing/data_to_dataframe.py

@@ -0,0 +1,71 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import DataInput, Output
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+
+
+class DataToDataFrameComponent(Component):
+    display_name = "Data → DataFrame"
+    description = (
+        "Converts one or multiple Data objects into a DataFrame. "
+        "Each Data object corresponds to one row. Fields from `.data` become columns, "
+        "and the `.text` (if present) is placed in a 'text' column."
+    )
+    icon = "table"
+    name = "DataToDataFrame"
+    legacy = True
+    replacement = ["processing.DataOperations", "processing.TypeConverterComponent"]
+
+    inputs = [
+        DataInput(
+            name="data_list",
+            display_name="Data or Data List",
+            info="One or multiple Data objects to transform into a DataFrame.",
+            is_list=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="DataFrame",
+            name="dataframe",
+            method="build_dataframe",
+            info="A DataFrame built from each Data object's fields plus a 'text' column.",
+        ),
+    ]
+
+    def build_dataframe(self) -> DataFrame:
+        """Builds a DataFrame from Data objects by combining their fields.
+
+        For each Data object:
+          - Merge item.data (dictionary) as columns
+          - If item.text is present, add 'text' column
+
+        Returns a DataFrame with one row per Data object.
+        """
+        data_input = self.data_list
+
+        # If user passed a single Data, it might come in as a single object rather than a list
+        if not isinstance(data_input, list):
+            data_input = [data_input]
+
+        rows = []
+        for item in data_input:
+            if not isinstance(item, Data):
+                msg = f"Expected Data objects, got {type(item)} instead."
+                raise TypeError(msg)
+
+            # Start with a copy of item.data or an empty dict
+            row_dict = dict(item.data) if item.data else {}
+
+            # If the Data object has text, store it under 'text' col
+            text_val = item.get_text()
+            if text_val:
+                row_dict["text"] = text_val
+
+            rows.append(row_dict)
+
+        # Build a DataFrame from these row dictionaries
+        df_result = DataFrame(rows)
+        self.status = df_result  # store in self.status for logs
+        return df_result

lfx/components/processing/dataframe_operations.py

@@ -0,0 +1,313 @@
+import pandas as pd
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs import SortableListInput
+from lfx.io import BoolInput, DataFrameInput, DropdownInput, IntInput, MessageTextInput, Output, StrInput
+from lfx.log.logger import logger
+from lfx.schema.dataframe import DataFrame
+
+
+class DataFrameOperationsComponent(Component):
+    display_name = "DataFrame Operations"
+    description = "Perform various operations on a DataFrame."
+    documentation: str = "https://docs.langflow.org/dataframe-operations"
+    icon = "table"
+    name = "DataFrameOperations"
+
+    OPERATION_CHOICES = [
+        "Add Column",
+        "Drop Column",
+        "Filter",
+        "Head",
+        "Rename Column",
+        "Replace Value",
+        "Select Columns",
+        "Sort",
+        "Tail",
+        "Drop Duplicates",
+    ]
+
+    inputs = [
+        DataFrameInput(
+            name="df",
+            display_name="DataFrame",
+            info="The input DataFrame to operate on.",
+            required=True,
+        ),
+        SortableListInput(
+            name="operation",
+            display_name="Operation",
+            placeholder="Select Operation",
+            info="Select the DataFrame operation to perform.",
+            options=[
+                {"name": "Add Column", "icon": "plus"},
+                {"name": "Drop Column", "icon": "minus"},
+                {"name": "Filter", "icon": "filter"},
+                {"name": "Head", "icon": "arrow-up"},
+                {"name": "Rename Column", "icon": "pencil"},
+                {"name": "Replace Value", "icon": "replace"},
+                {"name": "Select Columns", "icon": "columns"},
+                {"name": "Sort", "icon": "arrow-up-down"},
+                {"name": "Tail", "icon": "arrow-down"},
+                {"name": "Drop Duplicates", "icon": "copy-x"},
+            ],
+            real_time_refresh=True,
+            limit=1,
+        ),
+        StrInput(
+            name="column_name",
+            display_name="Column Name",
+            info="The column name to use for the operation.",
+            dynamic=True,
+            show=False,
+        ),
+        MessageTextInput(
+            name="filter_value",
+            display_name="Filter Value",
+            info="The value to filter rows by.",
+            dynamic=True,
+            show=False,
+        ),
+        DropdownInput(
+            name="filter_operator",
+            display_name="Filter Operator",
+            options=[
+                "equals",
+                "not equals",
+                "contains",
+                "not contains",
+                "starts with",
+                "ends with",
+                "greater than",
+                "less than",
+            ],
+            value="equals",
+            info="The operator to apply for filtering rows.",
+            advanced=False,
+            dynamic=True,
+            show=False,
+        ),
+        BoolInput(
+            name="ascending",
+            display_name="Sort Ascending",
+            info="Whether to sort in ascending order.",
+            dynamic=True,
+            show=False,
+            value=True,
+        ),
+        StrInput(
+            name="new_column_name",
+            display_name="New Column Name",
+            info="The new column name when renaming or adding a column.",
+            dynamic=True,
+            show=False,
+        ),
+        MessageTextInput(
+            name="new_column_value",
+            display_name="New Column Value",
+            info="The value to populate the new column with.",
+            dynamic=True,
+            show=False,
+        ),
+        StrInput(
+            name="columns_to_select",
+            display_name="Columns to Select",
+            dynamic=True,
+            is_list=True,
+            show=False,
+        ),
+        IntInput(
+            name="num_rows",
+            display_name="Number of Rows",
+            info="Number of rows to return (for head/tail).",
+            dynamic=True,
+            show=False,
+            value=5,
+        ),
+        MessageTextInput(
+            name="replace_value",
+            display_name="Value to Replace",
+            info="The value to replace in the column.",
+            dynamic=True,
+            show=False,
+        ),
+        MessageTextInput(
+            name="replacement_value",
+            display_name="Replacement Value",
+            info="The value to replace with.",
+            dynamic=True,
+            show=False,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="DataFrame",
+            name="output",
+            method="perform_operation",
+            info="The resulting DataFrame after the operation.",
+        )
+    ]
+
+    def update_build_config(self, build_config, field_value, field_name=None):
+        dynamic_fields = [
+            "column_name",
+            "filter_value",
+            "filter_operator",
+            "ascending",
+            "new_column_name",
+            "new_column_value",
+            "columns_to_select",
+            "num_rows",
+            "replace_value",
+            "replacement_value",
+        ]
+        for field in dynamic_fields:
+            build_config[field]["show"] = False
+
+        if field_name == "operation":
+            # Handle SortableListInput format
+            if isinstance(field_value, list):
+                operation_name = field_value[0].get("name", "") if field_value else ""
+            else:
+                operation_name = field_value or ""
+
+            # If no operation selected, all dynamic fields stay hidden (already set to False above)
+            if not operation_name:
+                return build_config
+
+            if operation_name == "Filter":
+                build_config["column_name"]["show"] = True
+                build_config["filter_value"]["show"] = True
+                build_config["filter_operator"]["show"] = True
+            elif operation_name == "Sort":
+                build_config["column_name"]["show"] = True
+                build_config["ascending"]["show"] = True
+            elif operation_name == "Drop Column":
+                build_config["column_name"]["show"] = True
+            elif operation_name == "Rename Column":
+                build_config["column_name"]["show"] = True
+                build_config["new_column_name"]["show"] = True
+            elif operation_name == "Add Column":
+                build_config["new_column_name"]["show"] = True
+                build_config["new_column_value"]["show"] = True
+            elif operation_name == "Select Columns":
+                build_config["columns_to_select"]["show"] = True
+            elif operation_name in {"Head", "Tail"}:
+                build_config["num_rows"]["show"] = True
+            elif operation_name == "Replace Value":
+                build_config["column_name"]["show"] = True
+                build_config["replace_value"]["show"] = True
+                build_config["replacement_value"]["show"] = True
+            elif operation_name == "Drop Duplicates":
+                build_config["column_name"]["show"] = True
+
+        return build_config
+
+    def perform_operation(self) -> DataFrame:
+        df_copy = self.df.copy()
+
+        # Handle SortableListInput format for operation
+        operation_input = getattr(self, "operation", [])
+        if isinstance(operation_input, list) and len(operation_input) > 0:
+            op = operation_input[0].get("name", "")
+        else:
+            op = ""
+
+        # If no operation selected, return original DataFrame
+        if not op:
+            return df_copy
+
+        if op == "Filter":
+            return self.filter_rows_by_value(df_copy)
+        if op == "Sort":
+            return self.sort_by_column(df_copy)
+        if op == "Drop Column":
+            return self.drop_column(df_copy)
+        if op == "Rename Column":
+            return self.rename_column(df_copy)
+        if op == "Add Column":
+            return self.add_column(df_copy)
+        if op == "Select Columns":
+            return self.select_columns(df_copy)
+        if op == "Head":
+            return self.head(df_copy)
+        if op == "Tail":
+            return self.tail(df_copy)
+        if op == "Replace Value":
+            return self.replace_values(df_copy)
+        if op == "Drop Duplicates":
+            return self.drop_duplicates(df_copy)
+        msg = f"Unsupported operation: {op}"
+        logger.error(msg)
+        raise ValueError(msg)
+
+    def filter_rows_by_value(self, df: DataFrame) -> DataFrame:
+        column = df[self.column_name]
+        filter_value = self.filter_value
+
+        # Handle regular DropdownInput format (just a string value)
+        operator = getattr(self, "filter_operator", "equals")  # Default to equals for backward compatibility
+
+        if operator == "equals":
+            mask = column == filter_value
+        elif operator == "not equals":
+            mask = column != filter_value
+        elif operator == "contains":
+            mask = column.astype(str).str.contains(str(filter_value), na=False)
+        elif operator == "not contains":
+            mask = ~column.astype(str).str.contains(str(filter_value), na=False)
+        elif operator == "starts with":
+            mask = column.astype(str).str.startswith(str(filter_value), na=False)
+        elif operator == "ends with":
+            mask = column.astype(str).str.endswith(str(filter_value), na=False)
+        elif operator == "greater than":
+            try:
+                # Try to convert filter_value to numeric for comparison
+                numeric_value = pd.to_numeric(filter_value)
+                mask = column > numeric_value
+            except (ValueError, TypeError):
+                # If conversion fails, compare as strings
+                mask = column.astype(str) > str(filter_value)
+        elif operator == "less than":
+            try:
+                # Try to convert filter_value to numeric for comparison
+                numeric_value = pd.to_numeric(filter_value)
+                mask = column < numeric_value
+            except (ValueError, TypeError):
+                # If conversion fails, compare as strings
+                mask = column.astype(str) < str(filter_value)
+        else:
+            mask = column == filter_value  # Fallback to equals
+
+        return DataFrame(df[mask])
+
+    def sort_by_column(self, df: DataFrame) -> DataFrame:
+        return DataFrame(df.sort_values(by=self.column_name, ascending=self.ascending))
+
+    def drop_column(self, df: DataFrame) -> DataFrame:
+        return DataFrame(df.drop(columns=[self.column_name]))
+
+    def rename_column(self, df: DataFrame) -> DataFrame:
+        return DataFrame(df.rename(columns={self.column_name: self.new_column_name}))
+
+    def add_column(self, df: DataFrame) -> DataFrame:
+        df[self.new_column_name] = [self.new_column_value] * len(df)
+        return DataFrame(df)
+
+    def select_columns(self, df: DataFrame) -> DataFrame:
+        columns = [col.strip() for col in self.columns_to_select]
+        return DataFrame(df[columns])
+
+    def head(self, df: DataFrame) -> DataFrame:
+        return DataFrame(df.head(self.num_rows))
+
+    def tail(self, df: DataFrame) -> DataFrame:
+        return DataFrame(df.tail(self.num_rows))
+
+    def replace_values(self, df: DataFrame) -> DataFrame:
+        df[self.column_name] = df[self.column_name].replace(self.replace_value, self.replacement_value)
+        return DataFrame(df)
+
+    def drop_duplicates(self, df: DataFrame) -> DataFrame:
+        return DataFrame(df.drop_duplicates(subset=self.column_name))

lfx/components/processing/dataframe_to_toolset.py

@@ -0,0 +1,259 @@
+"""DataFrame to Toolset Component.
+
+This component converts each row of a DataFrame into a callable tool/action within a toolset.
+Each row becomes a tool where the action name comes from one column and the content/response
+comes from another column.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from langchain.tools import StructuredTool
+from pydantic import BaseModel, create_model
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.field_typing.constants import Tool
+from lfx.io import HandleInput, Output, StrInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.message import Message
+
+if TYPE_CHECKING:
+    from lfx.field_typing.constants import Tool
+
+
+class DataFrameToToolsetComponent(LCToolComponent):
+    """Component that converts DataFrame rows into a toolset with multiple callable actions."""
+
+    display_name = "DataFrame to Toolset"
+    description = "Convert each row of a DataFrame into a callable tool/action in a toolset."
+    icon = "wrench"
+    name = "DataFrameToToolset"
+
+    inputs = [
+        HandleInput(
+            name="dataframe",
+            display_name="DataFrame",
+            input_types=["DataFrame"],
+            info="DataFrame where each row will become a tool/action",
+            required=True,
+        ),
+        StrInput(
+            name="tool_name_column",
+            display_name="Tool Name Column",
+            info="Column with tool names",
+            required=True,
+        ),
+        StrInput(
+            name="tool_output_column",
+            display_name="Tool Output Column",
+            info="Column with tool outputs/responses",
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Tools", name="tools", method="build_tools"),
+        Output(display_name="Message", name="message", method="get_message"),
+    ]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._tools_cache: list[Tool] = []
+        self._action_data: dict[str, dict[str, str]] = {}
+
+    def _sanitize_tool_name(self, name: str) -> str:
+        """Sanitize tool name to match required format '^[a-zA-Z0-9_-]+$'."""
+        # Replace any non-alphanumeric characters (except _ and -) with underscores
+        sanitized = re.sub(r"[^a-zA-Z0-9_-]", "_", str(name))
+        # Ensure it starts with a letter or underscore
+        if sanitized and not sanitized[0].isalpha() and sanitized[0] != "_":
+            sanitized = f"tool_{sanitized}"
+        return sanitized or "unnamed_tool"
+
+    def _prepare_action_data(self) -> None:
+        """Prepare action data from DataFrame."""
+        # Check if dataframe exists and is valid
+        if not hasattr(self, "dataframe") or self.dataframe is None:
+            self._action_data = {}
+            return
+
+        if not isinstance(self.dataframe, DataFrame):
+            self._action_data = {}
+            return
+
+        if not hasattr(self.dataframe, "columns"):
+            self._action_data = {}
+            return
+
+        # Check if column names are provided
+        if not self.tool_name_column or not self.tool_output_column:
+            self._action_data = {}
+            return
+
+        if self.tool_name_column not in self.dataframe.columns:
+            msg = (
+                f"Tool name column '{self.tool_name_column}' not found in DataFrame columns: "
+                f"{list(self.dataframe.columns)}"
+            )
+            raise ValueError(msg)
+
+        if self.tool_output_column not in self.dataframe.columns:
+            msg = (
+                f"Tool output column '{self.tool_output_column}' not found in DataFrame columns: "
+                f"{list(self.dataframe.columns)}"
+            )
+            raise ValueError(msg)
+
+        # Clear previous data
+        self._action_data = {}
+
+        # Process each row to create action mappings
+        for _, row in self.dataframe.iterrows():
+            action_name = str(row[self.tool_name_column]).strip()
+            content = str(row[self.tool_output_column]).strip()
+
+            if action_name and content:
+                sanitized_name = self._sanitize_tool_name(action_name)
+                self._action_data[sanitized_name] = {
+                    "original_name": action_name,
+                    "content": content,
+                    "sanitized_name": sanitized_name,
+                }
+
+    def _create_action_function(self, action_name: str, content: str):
+        """Create a function for a specific action that returns the content."""
+
+        def action_function(**kwargs) -> str:
+            # You could extend this to use kwargs to modify the content
+            # For now, just return the stored content
+            self.log(kwargs)  # TODO: Coming soon: implement arguments to modify content
+            return content
+
+        action_function.__name__ = f"execute_{action_name}"
+        action_function.__doc__ = f"Execute {action_name} action and return the associated content."
+        return action_function
+
+    def build_tools(self) -> list[Tool]:
+        """Build the toolset from DataFrame data."""
+        # Handle case where inputs are not ready
+        if not hasattr(self, "dataframe") or self.dataframe is None:
+            return []
+
+        self._prepare_action_data()
+
+        if not self._action_data:
+            return []
+
+        tools_description_preview_length = 100
+        tools_description_content_length = 200
+
+        tools = []
+
+        for sanitized_name, action_info in self._action_data.items():
+            original_name = action_info["original_name"]
+            content = action_info["content"]
+
+            # Create a simple schema for this tool (no parameters needed)
+            # But we could extend this to accept parameters if needed
+            tool_schema = create_model(
+                f"{sanitized_name}Schema",
+                __base__=BaseModel,
+                # Add parameters here if you want the tools to accept inputs
+                # For now, keeping it simple with no parameters
+            )
+
+            # Create the tool function
+            tool_function = self._create_action_function(sanitized_name, content)
+
+            # Create the StructuredTool
+            tool = StructuredTool(
+                name=sanitized_name,
+                description=(
+                    f"Execute {original_name} action. Returns: "
+                    f"{content[:tools_description_preview_length]}"
+                    f"{'...' if len(content) > tools_description_preview_length else ''}"
+                ),
+                func=tool_function,
+                args_schema=tool_schema,
+                handle_tool_error=True,
+                tags=[sanitized_name],
+                metadata={
+                    "display_name": original_name,
+                    "display_description": f"Action: {original_name}",
+                    "original_name": original_name,
+                    "content_preview": content[:tools_description_content_length],
+                },
+            )
+
+            tools.append(tool)
+
+        self._tools_cache = tools
+        return tools
+
+    def build_tool(self) -> Tool:
+        """Build a single tool (for compatibility with LCToolComponent)."""
+        tools = self.build_tools()
+        if not tools:
+            # Return a placeholder tool when no data is available
+            def placeholder_function(**kwargs) -> str:
+                self.log(kwargs)  # TODO: Coming soon: implement arguments to modify content
+                return "No tools available. Please connect a DataFrame with appropriate columns."
+
+            return StructuredTool(
+                name="placeholder_tool",
+                description="Placeholder tool - waiting for DataFrame input",
+                func=placeholder_function,
+                args_schema=create_model("PlaceholderSchema", __base__=BaseModel),
+            )
+
+        # Return the first tool, or create a composite tool
+        return tools[0]
+
+    def get_message(self) -> Message:
+        """Get a message describing the created toolset."""
+        # Handle case where inputs are not ready
+        if not hasattr(self, "dataframe") or self.dataframe is None:
+            return Message(text="Waiting for DataFrame input...")
+
+        self._prepare_action_data()
+
+        if not self._action_data:
+            return Message(text="No tools were created. Please check your DataFrame and column selections.")
+
+        tool_count = len(self._action_data)
+        tool_names = [info["original_name"] for info in self._action_data.values()]
+
+        message_text = f"Created toolset with {tool_count} tools:\n"
+        for i, name in enumerate(tool_names, 1):
+            message_text += f"{i}. {name}\n"
+
+        return Message(text=message_text)
+
+    def run_model(self) -> list[Data]:
+        """Run the model and return tool information as Data objects."""
+        # Handle case where inputs are not ready
+        if not hasattr(self, "dataframe") or self.dataframe is None:
+            return [Data(data={"status": "Waiting for DataFrame input"})]
+
+        tools = self.build_tools()
+
+        if not tools:
+            return [Data(data={"status": "No tools created. Check DataFrame and column selections."})]
+
+        results = []
+        for tool in tools:
+            tool_data = {
+                "tool_name": tool.name,
+                "display_name": tool.metadata.get("display_name", tool.name)
+                if hasattr(tool, "metadata")
+                else tool.name,
+                "description": tool.description,
+                "original_name": tool.metadata.get("original_name", "") if hasattr(tool, "metadata") else "",
+                "content_preview": tool.metadata.get("content_preview", "") if hasattr(tool, "metadata") else "",
+            }
+            results.append(Data(data=tool_data))
+
+        return results