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

langflow/components/processing/merge_data.py

@@ -1,90 +0,0 @@
-from enum import Enum
-from typing import cast
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import DataInput, DropdownInput, Output
-from langflow.logging.logger import logger
-from langflow.schema.dataframe import DataFrame
-
-
-class DataOperation(str, Enum):
-    CONCATENATE = "Concatenate"
-    APPEND = "Append"
-    MERGE = "Merge"
-    JOIN = "Join"
-
-
-class MergeDataComponent(Component):
-    display_name = "Combine Data"
-    description = "Combines data using different operations"
-    icon = "merge"
-    MIN_INPUTS_REQUIRED = 2
-    legacy = True
-
-    inputs = [
-        DataInput(name="data_inputs", display_name="Data Inputs", info="Data to combine", is_list=True, required=True),
-        DropdownInput(
-            name="operation",
-            display_name="Operation Type",
-            options=[op.value for op in DataOperation],
-            value=DataOperation.CONCATENATE.value,
-        ),
-    ]
-    outputs = [Output(display_name="DataFrame", name="combined_data", method="combine_data")]
-
-    def combine_data(self) -> DataFrame:
-        if not self.data_inputs or len(self.data_inputs) < self.MIN_INPUTS_REQUIRED:
-            empty_dataframe = DataFrame()
-            self.status = empty_dataframe
-            return empty_dataframe
-
-        operation = DataOperation(self.operation)
-        try:
-            combined_dataframe = self._process_operation(operation)
-            self.status = combined_dataframe
-        except Exception as e:
-            logger.error(f"Error during operation {operation}: {e!s}")
-            raise
-        else:
-            return combined_dataframe
-
-    def _process_operation(self, operation: DataOperation) -> DataFrame:
-        if operation == DataOperation.CONCATENATE:
-            combined_data: dict[str, str | object] = {}
-            for data_input in self.data_inputs:
-                for key, value in data_input.data.items():
-                    if key in combined_data:
-                        if isinstance(combined_data[key], str) and isinstance(value, str):
-                            combined_data[key] = f"{combined_data[key]}\n{value}"
-                        else:
-                            combined_data[key] = value
-                    else:
-                        combined_data[key] = value
-            return DataFrame([combined_data])
-
-        if operation == DataOperation.APPEND:
-            rows = [data_input.data for data_input in self.data_inputs]
-            return DataFrame(rows)
-
-        if operation == DataOperation.MERGE:
-            result_data: dict[str, str | list[str] | object] = {}
-            for data_input in self.data_inputs:
-                for key, value in data_input.data.items():
-                    if key in result_data and isinstance(value, str):
-                        if isinstance(result_data[key], list):
-                            cast("list[str]", result_data[key]).append(value)
-                        else:
-                            result_data[key] = [result_data[key], value]
-                    else:
-                        result_data[key] = value
-            return DataFrame([result_data])
-
-        if operation == DataOperation.JOIN:
-            combined_data = {}
-            for idx, data_input in enumerate(self.data_inputs, 1):
-                for key, value in data_input.data.items():
-                    new_key = f"{key}_doc{idx}" if idx > 1 else key
-                    combined_data[new_key] = value
-            return DataFrame([combined_data])
-
-        return DataFrame()

langflow/components/processing/message_to_data.py

@@ -1,36 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import MessageInput, Output
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.schema.message import Message
-
-
-class MessageToDataComponent(Component):
-    display_name = "Message to Data"
-    description = "Convert a Message object to a Data object"
-    icon = "message-square-share"
-    beta = True
-    name = "MessagetoData"
-    legacy = True
-
-    inputs = [
-        MessageInput(
-            name="message",
-            display_name="Message",
-            info="The Message object to convert to a Data object",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Data", name="data", method="convert_message_to_data"),
-    ]
-
-    def convert_message_to_data(self) -> Data:
-        if isinstance(self.message, Message):
-            # Convert Message to Data
-            return Data(data=self.message.data)
-
-        msg = "Error converting Message to Data: Input must be a Message object"
-        logger.debug(msg, exc_info=True)
-        self.status = msg
-        return Data(data={"error": msg})

langflow/components/processing/parse_data.py

@@ -1,70 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.helpers.data import data_to_text, data_to_text_list
-from langflow.io import DataInput, MultilineInput, Output, StrInput
-from langflow.schema.data import Data
-from langflow.schema.message import Message
-
-
-class ParseDataComponent(Component):
-    display_name = "Data to Message"
-    description = "Convert Data objects into Messages using any {field_name} from input data."
-    icon = "message-square"
-    name = "ParseData"
-    legacy = True
-    metadata = {
-        "legacy_name": "Parse Data",
-    }
-
-    inputs = [
-        DataInput(
-            name="data",
-            display_name="Data",
-            info="The data to convert to text.",
-            is_list=True,
-            required=True,
-        ),
-        MultilineInput(
-            name="template",
-            display_name="Template",
-            info="The template to use for formatting the data. "
-            "It can contain the keys {text}, {data} or any other key in the Data.",
-            value="{text}",
-            required=True,
-        ),
-        StrInput(name="sep", display_name="Separator", advanced=True, value="\n"),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Message",
-            name="text",
-            info="Data as a single Message, with each input Data separated by Separator",
-            method="parse_data",
-        ),
-        Output(
-            display_name="Data List",
-            name="data_list",
-            info="Data as a list of new Data, each having `text` formatted by Template",
-            method="parse_data_as_list",
-        ),
-    ]
-
-    def _clean_args(self) -> tuple[list[Data], str, str]:
-        data = self.data if isinstance(self.data, list) else [self.data]
-        template = self.template
-        sep = self.sep
-        return data, template, sep
-
-    def parse_data(self) -> Message:
-        data, template, sep = self._clean_args()
-        result_string = data_to_text(template, data, sep)
-        self.status = result_string
-        return Message(text=result_string)
-
-    def parse_data_as_list(self) -> list[Data]:
-        data, template, _ = self._clean_args()
-        text_list, data_list = data_to_text_list(template, data)
-        for item, text in zip(data_list, text_list, strict=True):
-            item.set_text(text)
-        self.status = data_list
-        return data_list

langflow/components/processing/parse_dataframe.py

@@ -1,68 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import DataFrameInput, MultilineInput, Output, StrInput
-from langflow.schema.message import Message
-
-
-class ParseDataFrameComponent(Component):
-    display_name = "Parse DataFrame"
-    description = (
-        "Convert a DataFrame into plain text following a specified template. "
-        "Each column in the DataFrame is treated as a possible template key, e.g. {col_name}."
-    )
-    icon = "braces"
-    name = "ParseDataFrame"
-    legacy = True
-
-    inputs = [
-        DataFrameInput(name="df", display_name="DataFrame", info="The DataFrame to convert to text rows."),
-        MultilineInput(
-            name="template",
-            display_name="Template",
-            info=(
-                "The template for formatting each row. "
-                "Use placeholders matching column names in the DataFrame, for example '{col1}', '{col2}'."
-            ),
-            value="{text}",
-        ),
-        StrInput(
-            name="sep",
-            display_name="Separator",
-            advanced=True,
-            value="\n",
-            info="String that joins all row texts when building the single Text output.",
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Text",
-            name="text",
-            info="All rows combined into a single text, each row formatted by the template and separated by `sep`.",
-            method="parse_data",
-        ),
-    ]
-
-    def _clean_args(self):
-        dataframe = self.df
-        template = self.template or "{text}"
-        sep = self.sep or "\n"
-        return dataframe, template, sep
-
-    def parse_data(self) -> Message:
-        """Converts each row of the DataFrame into a formatted string using the template.
-
-        then joins them with `sep`. Returns a single combined string as a Message.
-        """
-        dataframe, template, sep = self._clean_args()
-
-        lines = []
-        # For each row in the DataFrame, build a dict and format
-        for _, row in dataframe.iterrows():
-            row_dict = row.to_dict()
-            text_line = template.format(**row_dict)  # e.g. template="{text}", row_dict={"text": "Hello"}
-            lines.append(text_line)
-
-        # Join all lines with the provided separator
-        result_string = sep.join(lines)
-        self.status = result_string  # store in self.status for UI logs
-        return Message(text=result_string)

langflow/components/processing/parse_json_data.py

@@ -1,90 +0,0 @@
-import json
-from json import JSONDecodeError
-
-import jq
-from json_repair import repair_json
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import HandleInput, MessageTextInput
-from langflow.io import Output
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.schema.message import Message
-
-
-class ParseJSONDataComponent(Component):
-    display_name = "Parse JSON"
-    description = "Convert and extract JSON fields."
-    icon = "braces"
-    name = "ParseJSONData"
-    legacy: bool = True
-
-    inputs = [
-        HandleInput(
-            name="input_value",
-            display_name="Input",
-            info="Data object to filter.",
-            required=True,
-            input_types=["Message", "Data"],
-        ),
-        MessageTextInput(
-            name="query",
-            display_name="JQ Query",
-            info="JQ Query to filter the data. The input is always a JSON list.",
-            required=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Filtered Data", name="filtered_data", method="filter_data"),
-    ]
-
-    def _parse_data(self, input_value) -> str:
-        if isinstance(input_value, Message) and isinstance(input_value.text, str):
-            return input_value.text
-        if isinstance(input_value, Data):
-            return json.dumps(input_value.data)
-        return str(input_value)
-
-    def filter_data(self) -> list[Data]:
-        to_filter = self.input_value
-        if not to_filter:
-            return []
-        # Check if input is a list
-        if isinstance(to_filter, list):
-            to_filter = [self._parse_data(f) for f in to_filter]
-        else:
-            to_filter = self._parse_data(to_filter)
-
-        # If input is not a list, don't wrap it in a list
-        if not isinstance(to_filter, list):
-            to_filter = repair_json(to_filter)
-            try:
-                to_filter_as_dict = json.loads(to_filter)
-            except JSONDecodeError:
-                try:
-                    to_filter_as_dict = json.loads(repair_json(to_filter))
-                except JSONDecodeError as e:
-                    msg = f"Invalid JSON: {e}"
-                    raise ValueError(msg) from e
-        else:
-            to_filter = [repair_json(f) for f in to_filter]
-            to_filter_as_dict = []
-            for f in to_filter:
-                try:
-                    to_filter_as_dict.append(json.loads(f))
-                except JSONDecodeError:
-                    try:
-                        to_filter_as_dict.append(json.loads(repair_json(f)))
-                    except JSONDecodeError as e:
-                        msg = f"Invalid JSON: {e}"
-                        raise ValueError(msg) from e
-            to_filter = to_filter_as_dict
-
-        full_filter_str = json.dumps(to_filter_as_dict)
-
-        logger.info("to_filter: ", to_filter)
-
-        results = jq.compile(self.query).input_text(full_filter_str).all()
-        logger.info("results: ", results)
-        return [Data(data=value) if isinstance(value, dict) else Data(text=str(value)) for value in results]

langflow/components/processing/parser.py

@@ -1,143 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.helpers.data import safe_convert
-from langflow.inputs.inputs import BoolInput, HandleInput, MessageTextInput, MultilineInput, TabInput
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class ParserComponent(Component):
-    display_name = "Parser"
-    description = "Extracts text using a template."
-    documentation: str = "https://docs.langflow.org/components-processing#parser"
-    icon = "braces"
-
-    inputs = [
-        HandleInput(
-            name="input_data",
-            display_name="Data or DataFrame",
-            input_types=["DataFrame", "Data"],
-            info="Accepts either a DataFrame or a Data object.",
-            required=True,
-        ),
-        TabInput(
-            name="mode",
-            display_name="Mode",
-            options=["Parser", "Stringify"],
-            value="Parser",
-            info="Convert into raw string instead of using a template.",
-            real_time_refresh=True,
-        ),
-        MultilineInput(
-            name="pattern",
-            display_name="Template",
-            info=(
-                "Use variables within curly brackets to extract column values for DataFrames "
-                "or key values for Data."
-                "For example: `Name: {Name}, Age: {Age}, Country: {Country}`"
-            ),
-            value="Text: {text}",  # Example default
-            dynamic=True,
-            show=True,
-            required=True,
-        ),
-        MessageTextInput(
-            name="sep",
-            display_name="Separator",
-            advanced=True,
-            value="\n",
-            info="String used to separate rows/items.",
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Parsed Text",
-            name="parsed_text",
-            info="Formatted text output.",
-            method="parse_combined_text",
-        ),
-    ]
-
-    def update_build_config(self, build_config, field_value, field_name=None):
-        """Dynamically hide/show `template` and enforce requirement based on `stringify`."""
-        if field_name == "mode":
-            build_config["pattern"]["show"] = self.mode == "Parser"
-            build_config["pattern"]["required"] = self.mode == "Parser"
-            if field_value:
-                clean_data = BoolInput(
-                    name="clean_data",
-                    display_name="Clean Data",
-                    info=(
-                        "Enable to clean the data by removing empty rows and lines "
-                        "in each cell of the DataFrame/ Data object."
-                    ),
-                    value=True,
-                    advanced=True,
-                    required=False,
-                )
-                build_config["clean_data"] = clean_data.to_dict()
-            else:
-                build_config.pop("clean_data", None)
-
-        return build_config
-
-    def _clean_args(self):
-        """Prepare arguments based on input type."""
-        input_data = self.input_data
-
-        match input_data:
-            case list() if all(isinstance(item, Data) for item in input_data):
-                msg = "List of Data objects is not supported."
-                raise ValueError(msg)
-            case DataFrame():
-                return input_data, None
-            case Data():
-                return None, input_data
-            case dict() if "data" in input_data:
-                try:
-                    if "columns" in input_data:  # Likely a DataFrame
-                        return DataFrame.from_dict(input_data), None
-                    # Likely a Data object
-                    return None, Data(**input_data)
-                except (TypeError, ValueError, KeyError) as e:
-                    msg = f"Invalid structured input provided: {e!s}"
-                    raise ValueError(msg) from e
-            case _:
-                msg = f"Unsupported input type: {type(input_data)}. Expected DataFrame or Data."
-                raise ValueError(msg)
-
-    def parse_combined_text(self) -> Message:
-        """Parse all rows/items into a single text or convert input to string if `stringify` is enabled."""
-        # Early return for stringify option
-        if self.mode == "Stringify":
-            return self.convert_to_string()
-
-        df, data = self._clean_args()
-
-        lines = []
-        if df is not None:
-            for _, row in df.iterrows():
-                formatted_text = self.pattern.format(**row.to_dict())
-                lines.append(formatted_text)
-        elif data is not None:
-            formatted_text = self.pattern.format(**data.data)
-            lines.append(formatted_text)
-
-        combined_text = self.sep.join(lines)
-        self.status = combined_text
-        return Message(text=combined_text)
-
-    def convert_to_string(self) -> Message:
-        """Convert input data to string with proper error handling."""
-        result = ""
-        if isinstance(self.input_data, list):
-            result = "\n".join([safe_convert(item, clean_data=self.clean_data or False) for item in self.input_data])
-        else:
-            result = safe_convert(self.input_data or False)
-        self.log(f"Converted to string with length: {len(result)}")
-
-        message = Message(text=result)
-        self.status = message
-        return message

langflow/components/processing/prompt.py

@@ -1,67 +0,0 @@
-from langflow.base.prompts.api_utils import process_prompt_template
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import DefaultPromptField
-from langflow.io import MessageTextInput, Output, PromptInput
-from langflow.schema.message import Message
-from langflow.template.utils import update_template_values
-
-
-class PromptComponent(Component):
-    display_name: str = "Prompt Template"
-    description: str = "Create a prompt template with dynamic variables."
-    documentation: str = "https://docs.langflow.org/components-prompts"
-    icon = "braces"
-    trace_type = "prompt"
-    name = "Prompt Template"
-    priority = 0  # Set priority to 0 to make it appear first
-
-    inputs = [
-        PromptInput(name="template", display_name="Template"),
-        MessageTextInput(
-            name="tool_placeholder",
-            display_name="Tool Placeholder",
-            tool_mode=True,
-            advanced=True,
-            info="A placeholder input for tool mode.",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Prompt", name="prompt", method="build_prompt"),
-    ]
-
-    async def build_prompt(self) -> Message:
-        prompt = Message.from_template(**self._attributes)
-        self.status = prompt.text
-        return prompt
-
-    def _update_template(self, frontend_node: dict):
-        prompt_template = frontend_node["template"]["template"]["value"]
-        custom_fields = frontend_node["custom_fields"]
-        frontend_node_template = frontend_node["template"]
-        _ = process_prompt_template(
-            template=prompt_template,
-            name="template",
-            custom_fields=custom_fields,
-            frontend_node_template=frontend_node_template,
-        )
-        return frontend_node
-
-    async def update_frontend_node(self, new_frontend_node: dict, current_frontend_node: dict):
-        """This function is called after the code validation is done."""
-        frontend_node = await super().update_frontend_node(new_frontend_node, current_frontend_node)
-        template = frontend_node["template"]["template"]["value"]
-        # Kept it duplicated for backwards compatibility
-        _ = process_prompt_template(
-            template=template,
-            name="template",
-            custom_fields=frontend_node["custom_fields"],
-            frontend_node_template=frontend_node["template"],
-        )
-        # Now that template is updated, we need to grab any values that were set in the current_frontend_node
-        # and update the frontend_node with those values
-        update_template_values(new_template=frontend_node, previous_template=current_frontend_node["template"])
-        return frontend_node
-
-    def _get_fallback_input(self, **kwargs):
-        return DefaultPromptField(**kwargs)

langflow/components/processing/python_repl_core.py

@@ -1,98 +0,0 @@
-import importlib
-
-from langchain_experimental.utilities import PythonREPL
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import CodeInput, Output, StrInput
-from langflow.schema.data import Data
-
-
-class PythonREPLComponent(Component):
-    display_name = "Python Interpreter"
-    description = "Run Python code with optional imports. Use print() to see the output."
-    documentation: str = "https://docs.langflow.org/components-processing#python-interpreter"
-    icon = "square-terminal"
-
-    inputs = [
-        StrInput(
-            name="global_imports",
-            display_name="Global Imports",
-            info="A comma-separated list of modules to import globally, e.g. 'math,numpy,pandas'.",
-            value="math,pandas",
-            required=True,
-        ),
-        CodeInput(
-            name="python_code",
-            display_name="Python Code",
-            info="The Python code to execute. Only modules specified in Global Imports can be used.",
-            value="print('Hello, World!')",
-            input_types=["Message"],
-            tool_mode=True,
-            required=True,
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Results",
-            name="results",
-            type_=Data,
-            method="run_python_repl",
-        ),
-    ]
-
-    def get_globals(self, global_imports: str | list[str]) -> dict:
-        """Create a globals dictionary with only the specified allowed imports."""
-        global_dict = {}
-
-        try:
-            if isinstance(global_imports, str):
-                modules = [module.strip() for module in global_imports.split(",")]
-            elif isinstance(global_imports, list):
-                modules = global_imports
-            else:
-                msg = "global_imports must be either a string or a list"
-                raise TypeError(msg)
-
-            for module in modules:
-                try:
-                    imported_module = importlib.import_module(module)
-                    global_dict[imported_module.__name__] = imported_module
-                except ImportError as e:
-                    msg = f"Could not import module {module}: {e!s}"
-                    raise ImportError(msg) from e
-
-        except Exception as e:
-            self.log(f"Error in global imports: {e!s}")
-            raise
-        else:
-            self.log(f"Successfully imported modules: {list(global_dict.keys())}")
-            return global_dict
-
-    def run_python_repl(self) -> Data:
-        try:
-            globals_ = self.get_globals(self.global_imports)
-            python_repl = PythonREPL(_globals=globals_)
-            result = python_repl.run(self.python_code)
-            result = result.strip() if result else ""
-
-            self.log("Code execution completed successfully")
-            return Data(data={"result": result})
-
-        except ImportError as e:
-            error_message = f"Import Error: {e!s}"
-            self.log(error_message)
-            return Data(data={"error": error_message})
-
-        except SyntaxError as e:
-            error_message = f"Syntax Error: {e!s}"
-            self.log(error_message)
-            return Data(data={"error": error_message})
-
-        except (NameError, TypeError, ValueError) as e:
-            error_message = f"Error during execution: {e!s}"
-            self.log(error_message)
-            return Data(data={"error": error_message})
-
-    def build(self):
-        return self.run_python_repl