lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/processing/regex.py

@@ -0,0 +1,82 @@
+import re
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+
+
+class RegexExtractorComponent(Component):
+    display_name = "Regex Extractor"
+    description = "Extract patterns from text using regular expressions."
+    icon = "regex"
+    legacy = True
+
+    inputs = [
+        MessageTextInput(
+            name="input_text",
+            display_name="Input Text",
+            info="The text to analyze",
+            required=True,
+        ),
+        MessageTextInput(
+            name="pattern",
+            display_name="Regex Pattern",
+            info="The regular expression pattern to match",
+            value=r"",
+            required=True,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="data", method="extract_matches"),
+        Output(display_name="Message", name="text", method="get_matches_text"),
+    ]
+
+    def extract_matches(self) -> list[Data]:
+        if not self.pattern or not self.input_text:
+            self.status = []
+            return []
+
+        try:
+            # Compile regex pattern
+            pattern = re.compile(self.pattern)
+
+            # Find all matches in the input text
+            matches = pattern.findall(self.input_text)
+
+            # Filter out empty matches
+            filtered_matches = [match for match in matches if match]  # Remove empty matches
+
+            # Return empty list for no matches, or list of matches if found
+            result: list = [] if not filtered_matches else [Data(data={"match": match}) for match in filtered_matches]
+
+        except re.error as e:
+            error_message = f"Invalid regex pattern: {e!s}"
+            result = [Data(data={"error": error_message})]
+        except ValueError as e:
+            error_message = f"Error extracting matches: {e!s}"
+            result = [Data(data={"error": error_message})]
+
+        self.status = result
+        return result
+
+    def get_matches_text(self) -> Message:
+        """Get matches as a formatted text message."""
+        matches = self.extract_matches()
+
+        if not matches:
+            message = Message(text="No matches found")
+            self.status = message
+            return message
+
+        if "error" in matches[0].data:
+            message = Message(text=matches[0].data["error"])
+            self.status = message
+            return message
+
+        result = "\n".join(match.data["match"] for match in matches)
+        message = Message(text=result)
+        self.status = message
+        return message

lfx/components/processing/save_file.py

@@ -0,0 +1,225 @@
+import json
+from collections.abc import AsyncIterator, Iterator
+from pathlib import Path
+
+import orjson
+import pandas as pd
+from fastapi import UploadFile
+from fastapi.encoders import jsonable_encoder
+
+from lfx.custom import Component
+from lfx.io import DropdownInput, HandleInput, StrInput
+from lfx.schema import Data, DataFrame, Message
+from lfx.services.deps import get_settings_service, get_storage_service
+from lfx.template.field.base import Output
+
+
+class SaveToFileComponent(Component):
+    display_name = "Save File"
+    description = "Save data to a local file in the selected format."
+    documentation: str = "https://docs.langflow.org/components-processing#save-file"
+    icon = "save"
+    name = "SaveToFile"
+
+    # File format options for different types
+    DATA_FORMAT_CHOICES = ["csv", "excel", "json", "markdown"]
+    MESSAGE_FORMAT_CHOICES = ["txt", "json", "markdown"]
+
+    inputs = [
+        HandleInput(
+            name="input",
+            display_name="Input",
+            info="The input to save.",
+            dynamic=True,
+            input_types=["Data", "DataFrame", "Message"],
+            required=True,
+        ),
+        StrInput(
+            name="file_name",
+            display_name="File Name",
+            info="Name file will be saved as (without extension).",
+            required=True,
+        ),
+        DropdownInput(
+            name="file_format",
+            display_name="File Format",
+            options=list(dict.fromkeys(DATA_FORMAT_CHOICES + MESSAGE_FORMAT_CHOICES)),
+            info="Select the file format to save the input. If not provided, the default format will be used.",
+            value="",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [Output(display_name="File Path", name="message", method="save_to_file")]
+
+    async def save_to_file(self) -> Message:
+        """Save the input to a file and upload it, returning a confirmation message."""
+        # Validate inputs
+        if not self.file_name:
+            msg = "File name must be provided."
+            raise ValueError(msg)
+        if not self._get_input_type():
+            msg = "Input type is not set."
+            raise ValueError(msg)
+
+        # Validate file format based on input type
+        file_format = self.file_format or self._get_default_format()
+        allowed_formats = (
+            self.MESSAGE_FORMAT_CHOICES if self._get_input_type() == "Message" else self.DATA_FORMAT_CHOICES
+        )
+        if file_format not in allowed_formats:
+            msg = f"Invalid file format '{file_format}' for {self._get_input_type()}. Allowed: {allowed_formats}"
+            raise ValueError(msg)
+
+        # Prepare file path
+        file_path = Path(self.file_name).expanduser()
+        if not file_path.parent.exists():
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_path = self._adjust_file_path_with_format(file_path, file_format)
+
+        # Save the input to file based on type
+        if self._get_input_type() == "DataFrame":
+            confirmation = self._save_dataframe(self.input, file_path, file_format)
+        elif self._get_input_type() == "Data":
+            confirmation = self._save_data(self.input, file_path, file_format)
+        elif self._get_input_type() == "Message":
+            confirmation = await self._save_message(self.input, file_path, file_format)
+        else:
+            msg = f"Unsupported input type: {self._get_input_type()}"
+            raise ValueError(msg)
+
+        # Upload the saved file
+        await self._upload_file(file_path)
+
+        # Return the final file path and confirmation message
+        final_path = Path.cwd() / file_path if not file_path.is_absolute() else file_path
+
+        return Message(text=f"{confirmation} at {final_path}")
+
+    def _get_input_type(self) -> str:
+        """Determine the input type based on the provided input."""
+        # Use exact type checking (type() is) instead of isinstance() to avoid inheritance issues.
+        # Since Message inherits from Data, isinstance(message, Data) would return True for Message objects,
+        # causing Message inputs to be incorrectly identified as Data type.
+        if type(self.input) is DataFrame:
+            return "DataFrame"
+        if type(self.input) is Message:
+            return "Message"
+        if type(self.input) is Data:
+            return "Data"
+        msg = f"Unsupported input type: {type(self.input)}"
+        raise ValueError(msg)
+
+    def _get_default_format(self) -> str:
+        """Return the default file format based on input type."""
+        if self._get_input_type() == "DataFrame":
+            return "csv"
+        if self._get_input_type() == "Data":
+            return "json"
+        if self._get_input_type() == "Message":
+            return "json"
+        return "json"  # Fallback
+
+    def _adjust_file_path_with_format(self, path: Path, fmt: str) -> Path:
+        """Adjust the file path to include the correct extension."""
+        file_extension = path.suffix.lower().lstrip(".")
+        if fmt == "excel":
+            return Path(f"{path}.xlsx").expanduser() if file_extension not in ["xlsx", "xls"] else path
+        return Path(f"{path}.{fmt}").expanduser() if file_extension != fmt else path
+
+    async def _upload_file(self, file_path: Path) -> None:
+        """Upload the saved file using the upload_user_file service."""
+        try:
+            from langflow.api.v2.files import upload_user_file
+            from langflow.services.database.models.user.crud import get_user_by_id
+        except ImportError as e:
+            msg = (
+                "Langflow file upload functionality is not available. "
+                "This feature requires the full Langflow installation. "
+            )
+            raise ImportError(msg) from e
+
+        if not file_path.exists():
+            msg = f"File not found: {file_path}"
+            raise FileNotFoundError(msg)
+
+        with file_path.open("rb") as f:
+            try:
+                from langflow.services.database.models.user.crud import get_user_by_id
+                from langflow.services.deps import session_scope
+            except ImportError as e:
+                msg = (
+                    "Langflow MCP server functionality is not available. "
+                    "This feature requires the full Langflow installation."
+                )
+                raise ImportError(msg) from e
+            async with session_scope() as db:
+                if not self.user_id:
+                    msg = "User ID is required for file saving."
+                    raise ValueError(msg)
+                current_user = await get_user_by_id(db, self.user_id)
+
+                await upload_user_file(
+                    file=UploadFile(filename=file_path.name, file=f, size=file_path.stat().st_size),
+                    session=db,
+                    current_user=current_user,
+                    storage_service=get_storage_service(),
+                    settings_service=get_settings_service(),
+                )
+
+    def _save_dataframe(self, dataframe: DataFrame, path: Path, fmt: str) -> str:
+        """Save a DataFrame to the specified file format."""
+        if fmt == "csv":
+            dataframe.to_csv(path, index=False)
+        elif fmt == "excel":
+            dataframe.to_excel(path, index=False, engine="openpyxl")
+        elif fmt == "json":
+            dataframe.to_json(path, orient="records", indent=2)
+        elif fmt == "markdown":
+            path.write_text(dataframe.to_markdown(index=False), encoding="utf-8")
+        else:
+            msg = f"Unsupported DataFrame format: {fmt}"
+            raise ValueError(msg)
+        return f"DataFrame saved successfully as '{path}'"
+
+    def _save_data(self, data: Data, path: Path, fmt: str) -> str:
+        """Save a Data object to the specified file format."""
+        if fmt == "csv":
+            pd.DataFrame(data.data).to_csv(path, index=False)
+        elif fmt == "excel":
+            pd.DataFrame(data.data).to_excel(path, index=False, engine="openpyxl")
+        elif fmt == "json":
+            path.write_text(
+                orjson.dumps(jsonable_encoder(data.data), option=orjson.OPT_INDENT_2).decode("utf-8"), encoding="utf-8"
+            )
+        elif fmt == "markdown":
+            path.write_text(pd.DataFrame(data.data).to_markdown(index=False), encoding="utf-8")
+        else:
+            msg = f"Unsupported Data format: {fmt}"
+            raise ValueError(msg)
+        return f"Data saved successfully as '{path}'"
+
+    async def _save_message(self, message: Message, path: Path, fmt: str) -> str:
+        """Save a Message to the specified file format, handling async iterators."""
+        content = ""
+        if message.text is None:
+            content = ""
+        elif isinstance(message.text, AsyncIterator):
+            async for item in message.text:
+                content += str(item) + " "
+            content = content.strip()
+        elif isinstance(message.text, Iterator):
+            content = " ".join(str(item) for item in message.text)
+        else:
+            content = str(message.text)
+
+        if fmt == "txt":
+            path.write_text(content, encoding="utf-8")
+        elif fmt == "json":
+            path.write_text(json.dumps({"message": content}, indent=2), encoding="utf-8")
+        elif fmt == "markdown":
+            path.write_text(f"**Message:**\n\n{content}", encoding="utf-8")
+        else:
+            msg = f"Unsupported Message format: {fmt}"
+            raise ValueError(msg)
+        return f"Message saved successfully as '{path}'"

lfx/components/processing/select_data.py

@@ -0,0 +1,48 @@
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import DataInput, IntInput
+from lfx.io import Output
+from lfx.schema.data import Data
+
+
+class SelectDataComponent(Component):
+    display_name: str = "Select Data"
+    description: str = "Select a single data from a list of data."
+    name: str = "SelectData"
+    icon = "prototypes"
+    legacy = True
+
+    inputs = [
+        DataInput(
+            name="data_list",
+            display_name="Data List",
+            info="List of data to select from.",
+            is_list=True,  # Specify that this input takes a list of Data objects
+        ),
+        IntInput(
+            name="data_index",
+            display_name="Data Index",
+            info="Index of the data to select.",
+            value=0,  # Will be populated dynamically based on the length of data_list
+            range_spec=RangeSpec(min=0, max=15, step=1, step_type="int"),
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Selected Data", name="selected_data", method="select_data"),
+    ]
+
+    async def select_data(self) -> Data:
+        # Retrieve the selected index from the dropdown
+        selected_index = int(self.data_index)
+        # Get the data list
+
+        # Validate that the selected index is within bounds
+        if selected_index < 0 or selected_index >= len(self.data_list):
+            msg = f"Selected index {selected_index} is out of range."
+            raise ValueError(msg)
+
+        # Return the selected Data object
+        selected_data = self.data_list[selected_index]
+        self.status = selected_data  # Update the component status to reflect the selected data
+        return selected_data

lfx/components/processing/split_text.py

@@ -0,0 +1,141 @@
+from langchain_text_splitters import CharacterTextSplitter
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import DropdownInput, HandleInput, IntInput, MessageTextInput, Output
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.message import Message
+from lfx.utils.util import unescape_string
+
+
+class SplitTextComponent(Component):
+    display_name: str = "Split Text"
+    description: str = "Split text into chunks based on specified criteria."
+    documentation: str = "https://docs.langflow.org/components-processing#split-text"
+    icon = "scissors-line-dashed"
+    name = "SplitText"
+
+    inputs = [
+        HandleInput(
+            name="data_inputs",
+            display_name="Input",
+            info="The data with texts to split in chunks.",
+            input_types=["Data", "DataFrame", "Message"],
+            required=True,
+        ),
+        IntInput(
+            name="chunk_overlap",
+            display_name="Chunk Overlap",
+            info="Number of characters to overlap between chunks.",
+            value=200,
+        ),
+        IntInput(
+            name="chunk_size",
+            display_name="Chunk Size",
+            info=(
+                "The maximum length of each chunk. Text is first split by separator, "
+                "then chunks are merged up to this size. "
+                "Individual splits larger than this won't be further divided."
+            ),
+            value=1000,
+        ),
+        MessageTextInput(
+            name="separator",
+            display_name="Separator",
+            info=(
+                "The character to split on. Use \\n for newline. "
+                "Examples: \\n\\n for paragraphs, \\n for lines, . for sentences"
+            ),
+            value="\n",
+        ),
+        MessageTextInput(
+            name="text_key",
+            display_name="Text Key",
+            info="The key to use for the text column.",
+            value="text",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="keep_separator",
+            display_name="Keep Separator",
+            info="Whether to keep the separator in the output chunks and where to place it.",
+            options=["False", "True", "Start", "End"],
+            value="False",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Chunks", name="dataframe", method="split_text"),
+    ]
+
+    def _docs_to_data(self, docs) -> list[Data]:
+        return [Data(text=doc.page_content, data=doc.metadata) for doc in docs]
+
+    def _fix_separator(self, separator: str) -> str:
+        """Fix common separator issues and convert to proper format."""
+        if separator == "/n":
+            return "\n"
+        if separator == "/t":
+            return "\t"
+        return separator
+
+    def split_text_base(self):
+        separator = self._fix_separator(self.separator)
+        separator = unescape_string(separator)
+
+        if isinstance(self.data_inputs, DataFrame):
+            if not len(self.data_inputs):
+                msg = "DataFrame is empty"
+                raise TypeError(msg)
+
+            self.data_inputs.text_key = self.text_key
+            try:
+                documents = self.data_inputs.to_lc_documents()
+            except Exception as e:
+                msg = f"Error converting DataFrame to documents: {e}"
+                raise TypeError(msg) from e
+        elif isinstance(self.data_inputs, Message):
+            self.data_inputs = [self.data_inputs.to_data()]
+            return self.split_text_base()
+        else:
+            if not self.data_inputs:
+                msg = "No data inputs provided"
+                raise TypeError(msg)
+
+            documents = []
+            if isinstance(self.data_inputs, Data):
+                self.data_inputs.text_key = self.text_key
+                documents = [self.data_inputs.to_lc_document()]
+            else:
+                try:
+                    documents = [input_.to_lc_document() for input_ in self.data_inputs if isinstance(input_, Data)]
+                    if not documents:
+                        msg = f"No valid Data inputs found in {type(self.data_inputs)}"
+                        raise TypeError(msg)
+                except AttributeError as e:
+                    msg = f"Invalid input type in collection: {e}"
+                    raise TypeError(msg) from e
+        try:
+            # Convert string 'False'/'True' to boolean
+            keep_sep = self.keep_separator
+            if isinstance(keep_sep, str):
+                if keep_sep.lower() == "false":
+                    keep_sep = False
+                elif keep_sep.lower() == "true":
+                    keep_sep = True
+                # 'start' and 'end' are kept as strings
+
+            splitter = CharacterTextSplitter(
+                chunk_overlap=self.chunk_overlap,
+                chunk_size=self.chunk_size,
+                separator=separator,
+                keep_separator=keep_sep,
+            )
+            return splitter.split_documents(documents)
+        except Exception as e:
+            msg = f"Error splitting text: {e}"
+            raise TypeError(msg) from e
+
+    def split_text(self) -> DataFrame:
+        return DataFrame(self._docs_to_data(self.split_text_base()))