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

langflow/components/processing/regex.py

@@ -1,82 +0,0 @@
-import re
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import MessageTextInput, Output
-from langflow.schema.data import Data
-from langflow.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

langflow/components/processing/save_file.py

@@ -1,208 +0,0 @@
-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 langflow.api.v2.files import upload_user_file
-from langflow.custom import Component
-from langflow.io import DropdownInput, HandleInput, StrInput
-from langflow.schema import Data, DataFrame, Message
-from langflow.services.database.models.user.crud import get_user_by_id
-from langflow.services.deps import get_settings_service, get_storage_service, session_scope
-from langflow.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."""
-        if not file_path.exists():
-            msg = f"File not found: {file_path}"
-            raise FileNotFoundError(msg)
-
-        with file_path.open("rb") as f:
-            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}'"

langflow/components/processing/select_data.py

@@ -1,48 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.inputs.inputs import DataInput, IntInput
-from langflow.io import Output
-from langflow.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

langflow/components/processing/split_text.py

@@ -1,141 +0,0 @@
-from langchain_text_splitters import CharacterTextSplitter
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import DropdownInput, HandleInput, IntInput, MessageTextInput, Output
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.schema.message import Message
-from langflow.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()))

langflow/components/processing/structured_output.py

@@ -1,202 +0,0 @@
-from pydantic import BaseModel, Field, create_model
-from trustcall import create_extractor
-
-from langflow.base.models.chat_result import get_chat_result
-from langflow.custom.custom_component.component import Component
-from langflow.helpers.base_model import build_model_from_schema
-from langflow.io import (
-    HandleInput,
-    MessageTextInput,
-    MultilineInput,
-    Output,
-    TableInput,
-)
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.schema.table import EditMode
-
-
-class StructuredOutputComponent(Component):
-    display_name = "Structured Output"
-    description = "Uses an LLM to generate structured data. Ideal for extraction and consistency."
-    documentation: str = "https://docs.langflow.org/components-processing#structured-output"
-    name = "StructuredOutput"
-    icon = "braces"
-
-    inputs = [
-        HandleInput(
-            name="llm",
-            display_name="Language Model",
-            info="The language model to use to generate the structured output.",
-            input_types=["LanguageModel"],
-            required=True,
-        ),
-        MultilineInput(
-            name="input_value",
-            display_name="Input Message",
-            info="The input message to the language model.",
-            tool_mode=True,
-            required=True,
-        ),
-        MultilineInput(
-            name="system_prompt",
-            display_name="Format Instructions",
-            info="The instructions to the language model for formatting the output.",
-            value=(
-                "You are an AI that extracts structured JSON objects from unstructured text. "
-                "Use a predefined schema with expected types (str, int, float, bool, dict). "
-                "Extract ALL relevant instances that match the schema - if multiple patterns exist, capture them all. "
-                "Fill missing or ambiguous values with defaults: null for missing values. "
-                "Remove exact duplicates but keep variations that have different field values. "
-                "Always return valid JSON in the expected format, never throw errors. "
-                "If multiple objects can be extracted, return them all in the structured format."
-            ),
-            required=True,
-            advanced=True,
-        ),
-        MessageTextInput(
-            name="schema_name",
-            display_name="Schema Name",
-            info="Provide a name for the output data schema.",
-            advanced=True,
-        ),
-        TableInput(
-            name="output_schema",
-            display_name="Output Schema",
-            info="Define the structure and data types for the model's output.",
-            required=True,
-            # TODO: remove deault value
-            table_schema=[
-                {
-                    "name": "name",
-                    "display_name": "Name",
-                    "type": "str",
-                    "description": "Specify the name of the output field.",
-                    "default": "field",
-                    "edit_mode": EditMode.INLINE,
-                },
-                {
-                    "name": "description",
-                    "display_name": "Description",
-                    "type": "str",
-                    "description": "Describe the purpose of the output field.",
-                    "default": "description of field",
-                    "edit_mode": EditMode.POPOVER,
-                },
-                {
-                    "name": "type",
-                    "display_name": "Type",
-                    "type": "str",
-                    "edit_mode": EditMode.INLINE,
-                    "description": ("Indicate the data type of the output field (e.g., str, int, float, bool, dict)."),
-                    "options": ["str", "int", "float", "bool", "dict"],
-                    "default": "str",
-                },
-                {
-                    "name": "multiple",
-                    "display_name": "As List",
-                    "type": "boolean",
-                    "description": "Set to True if this output field should be a list of the specified type.",
-                    "default": "False",
-                    "edit_mode": EditMode.INLINE,
-                },
-            ],
-            value=[
-                {
-                    "name": "field",
-                    "description": "description of field",
-                    "type": "str",
-                    "multiple": "False",
-                }
-            ],
-        ),
-    ]
-
-    outputs = [
-        Output(
-            name="structured_output",
-            display_name="Structured Output",
-            method="build_structured_output",
-        ),
-        Output(
-            name="dataframe_output",
-            display_name="Structured Output",
-            method="build_structured_dataframe",
-        ),
-    ]
-
-    def build_structured_output_base(self):
-        schema_name = self.schema_name or "OutputModel"
-
-        if not hasattr(self.llm, "with_structured_output"):
-            msg = "Language model does not support structured output."
-            raise TypeError(msg)
-        if not self.output_schema:
-            msg = "Output schema cannot be empty"
-            raise ValueError(msg)
-
-        output_model_ = build_model_from_schema(self.output_schema)
-
-        output_model = create_model(
-            schema_name,
-            __doc__=f"A list of {schema_name}.",
-            objects=(list[output_model_], Field(description=f"A list of {schema_name}.")),  # type: ignore[valid-type]
-        )
-
-        try:
-            llm_with_structured_output = create_extractor(self.llm, tools=[output_model])
-        except NotImplementedError as exc:
-            msg = f"{self.llm.__class__.__name__} does not support structured output."
-            raise TypeError(msg) from exc
-
-        config_dict = {
-            "run_name": self.display_name,
-            "project_name": self.get_project_name(),
-            "callbacks": self.get_langchain_callbacks(),
-        }
-        result = get_chat_result(
-            runnable=llm_with_structured_output,
-            system_message=self.system_prompt,
-            input_value=self.input_value,
-            config=config_dict,
-        )
-
-        # OPTIMIZATION NOTE: Simplified processing based on trustcall response structure
-        # Handle non-dict responses (shouldn't happen with trustcall, but defensive)
-        if not isinstance(result, dict):
-            return result
-
-        # Extract first response and convert BaseModel to dict
-        responses = result.get("responses", [])
-        if not responses:
-            return result
-
-        # Convert BaseModel to dict (creates the "objects" key)
-        first_response = responses[0]
-        structured_data = first_response.model_dump() if isinstance(first_response, BaseModel) else first_response
-
-        # Extract the objects array (guaranteed to exist due to our Pydantic model structure)
-        return structured_data.get("objects", structured_data)
-
-    def build_structured_output(self) -> Data:
-        output = self.build_structured_output_base()
-        if not isinstance(output, list) or not output:
-            # handle empty or unexpected type case
-            msg = "No structured output returned"
-            raise ValueError(msg)
-        if len(output) == 1:
-            return Data(data=output[0])
-        if len(output) > 1:
-            # Multiple outputs - wrap them in a results container
-            return Data(data={"results": output})
-        return Data()
-
-    def build_structured_dataframe(self) -> DataFrame:
-        output = self.build_structured_output_base()
-        if not isinstance(output, list) or not output:
-            # handle empty or unexpected type case
-            msg = "No structured output returned"
-            raise ValueError(msg)
-        data_list = [Data(data=output[0])] if len(output) == 1 else [Data(data=item) for item in output]
-
-        return DataFrame(data_list)