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

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/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()))

lfx/components/processing/store_message.py

@@ -0,0 +1,91 @@
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import (
+    HandleInput,
+    MessageTextInput,
+)
+from lfx.memory import aget_messages, astore_message
+from lfx.schema.message import Message
+from lfx.template.field.base import Output
+from lfx.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_NAME_AI
+
+
+class MessageStoreComponent(Component):
+    display_name = "Message Store"
+    description = "Stores a chat message or text into Langflow tables or an external memory."
+    icon = "message-square-text"
+    name = "StoreMessage"
+    legacy = True
+    replacement = ["helpers.Memory"]
+
+    inputs = [
+        MessageTextInput(
+            name="message", display_name="Message", info="The chat message to be stored.", required=True, tool_mode=True
+        ),
+        HandleInput(
+            name="memory",
+            display_name="External Memory",
+            input_types=["Memory"],
+            info="The external memory to store the message. If empty, it will use the Langflow tables.",
+        ),
+        MessageTextInput(
+            name="sender",
+            display_name="Sender",
+            info="The sender of the message. Might be Machine or User. "
+            "If empty, the current sender parameter will be used.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="sender_name",
+            display_name="Sender Name",
+            info="The name of the sender. Might be AI or User. If empty, the current sender parameter will be used.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="session_id",
+            display_name="Session ID",
+            info="The session ID of the chat. If empty, the current session ID parameter will be used.",
+            value="",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Stored Messages", name="stored_messages", method="store_message", hidden=True),
+    ]
+
+    async def store_message(self) -> Message:
+        message = Message(text=self.message) if isinstance(self.message, str) else self.message
+
+        message.session_id = self.session_id or message.session_id
+        message.sender = self.sender or message.sender or MESSAGE_SENDER_AI
+        message.sender_name = self.sender_name or message.sender_name or MESSAGE_SENDER_NAME_AI
+
+        stored_messages: list[Message] = []
+
+        if self.memory:
+            self.memory.session_id = message.session_id
+            lc_message = message.to_lc_message()
+            await self.memory.aadd_messages([lc_message])
+
+            stored_messages = await self.memory.aget_messages() or []
+
+            stored_messages = [Message.from_lc_message(m) for m in stored_messages] if stored_messages else []
+
+            if message.sender:
+                stored_messages = [m for m in stored_messages if m.sender == message.sender]
+        else:
+            await astore_message(message, flow_id=self.graph.flow_id)
+            stored_messages = (
+                await aget_messages(
+                    session_id=message.session_id, sender_name=message.sender_name, sender=message.sender
+                )
+                or []
+            )
+
+        if not stored_messages:
+            msg = "No messages were stored. Please ensure that the session ID and sender are properly set."
+            raise ValueError(msg)
+
+        stored_message = stored_messages[0]
+        self.status = stored_message
+        return stored_message

lfx/components/processing/update_data.py

@@ -0,0 +1,161 @@
+from typing import Any
+
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import (
+    BoolInput,
+    DataInput,
+    DictInput,
+    IntInput,
+    MessageTextInput,
+)
+from lfx.io import Output
+from lfx.schema.data import Data
+from lfx.schema.dotdict import dotdict
+
+
+class UpdateDataComponent(Component):
+    display_name: str = "Update Data"
+    description: str = "Dynamically update or append data with the specified fields."
+    name: str = "UpdateData"
+    MAX_FIELDS = 15  # Define a constant for maximum number of fields
+    icon = "FolderSync"
+    legacy = True
+    replacement = ["processing.DataOperations"]
+
+    inputs = [
+        DataInput(
+            name="old_data",
+            display_name="Data",
+            info="The record to update.",
+            is_list=True,  # Changed to True to handle list of Data objects
+            required=True,
+        ),
+        IntInput(
+            name="number_of_fields",
+            display_name="Number of Fields",
+            info="Number of fields to be added to the record.",
+            real_time_refresh=True,
+            value=0,
+            range_spec=RangeSpec(min=1, max=MAX_FIELDS, step=1, step_type="int"),
+        ),
+        MessageTextInput(
+            name="text_key",
+            display_name="Text Key",
+            info="Key that identifies the field to be used as the text content.",
+            advanced=True,
+        ),
+        BoolInput(
+            name="text_key_validator",
+            display_name="Text Key Validator",
+            advanced=True,
+            info="If enabled, checks if the given 'Text Key' is present in the given 'Data'.",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="data", method="build_data"),
+    ]
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
+        """Update the build configuration when the number of fields changes.
+
+        Args:
+            build_config (dotdict): The current build configuration.
+            field_value (Any): The new value for the field.
+            field_name (Optional[str]): The name of the field being updated.
+        """
+        if field_name == "number_of_fields":
+            default_keys = {
+                "code",
+                "_type",
+                "number_of_fields",
+                "text_key",
+                "old_data",
+                "text_key_validator",
+            }
+            try:
+                field_value_int = int(field_value)
+            except ValueError:
+                return build_config
+
+            if field_value_int > self.MAX_FIELDS:
+                build_config["number_of_fields"]["value"] = self.MAX_FIELDS
+                msg = f"Number of fields cannot exceed {self.MAX_FIELDS}. Try using a Component to combine two Data."
+                raise ValueError(msg)
+
+            existing_fields = {}
+            # Back up the existing template fields
+            for key in list(build_config.keys()):
+                if key not in default_keys:
+                    existing_fields[key] = build_config.pop(key)
+
+            for i in range(1, field_value_int + 1):
+                key = f"field_{i}_key"
+                if key in existing_fields:
+                    field = existing_fields[key]
+                    build_config[key] = field
+                else:
+                    field = DictInput(
+                        display_name=f"Field {i}",
+                        name=key,
+                        info=f"Key for field {i}.",
+                        input_types=["Message", "Data"],
+                    )
+                    build_config[field.name] = field.to_dict()
+
+            build_config["number_of_fields"]["value"] = field_value_int
+        return build_config
+
+    async def build_data(self) -> Data | list[Data]:
+        """Build the updated data by combining the old data with new fields."""
+        new_data = self.get_data()
+        if isinstance(self.old_data, list):
+            for data_item in self.old_data:
+                if not isinstance(data_item, Data):
+                    continue  # Skip invalid items
+                data_item.data.update(new_data)
+                if self.text_key:
+                    data_item.text_key = self.text_key
+                self.validate_text_key(data_item)
+            self.status = self.old_data
+            return self.old_data  # Returns List[Data]
+        if isinstance(self.old_data, Data):
+            self.old_data.data.update(new_data)
+            if self.text_key:
+                self.old_data.text_key = self.text_key
+            self.status = self.old_data
+            self.validate_text_key(self.old_data)
+            return self.old_data  # Returns Data
+        msg = "old_data is not a Data object or list of Data objects."
+        raise ValueError(msg)
+
+    def get_data(self):
+        """Function to get the Data from the attributes."""
+        data = {}
+        default_keys = {
+            "code",
+            "_type",
+            "number_of_fields",
+            "text_key",
+            "old_data",
+            "text_key_validator",
+        }
+        for attr_name, attr_value in self._attributes.items():
+            if attr_name in default_keys:
+                continue  # Skip default attributes
+            if isinstance(attr_value, dict):
+                for key, value in attr_value.items():
+                    data[key] = value.get_text() if isinstance(value, Data) else value
+            elif isinstance(attr_value, Data):
+                data[attr_name] = attr_value.get_text()
+            else:
+                data[attr_name] = attr_value
+        return data
+
+    def validate_text_key(self, data: Data) -> None:
+        """This function validates that the Text Key is one of the keys in the Data."""
+        data_keys = data.data.keys()
+        if self.text_key and self.text_key not in data_keys:
+            msg = f"Text Key: '{self.text_key}' not found in the Data keys: {', '.join(data_keys)}"
+            raise ValueError(msg)

lfx/components/prototypes/__init__.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Any
+
+from lfx.components._importing import import_mod
+
+# _dynamic_imports = {
+#     "KnowledgeIngestionComponent": "ingestion",
+#     "KnowledgeRetrievalComponent": "retrieval",
+
+# }
+_dynamic_imports = {
+    "PythonFunctionComponent": "python_function",
+}
+
+# __all__ = ["KnowledgeIngestionComponent", "KnowledgeRetrievalComponent"]
+__all__ = ["PythonFunctionComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import input/output components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/prototypes/python_function.py

@@ -0,0 +1,73 @@
+from collections.abc import Callable
+
+from lfx.custom.custom_component.component import Component
+from lfx.custom.utils import get_function
+from lfx.io import CodeInput, Output
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dotdict import dotdict
+from lfx.schema.message import Message
+
+
+class PythonFunctionComponent(Component):
+    display_name = "Python Function"
+    description = "Define and execute a Python function that returns a Data object or a Message."
+    icon = "Python"
+    name = "PythonFunction"
+    legacy = True
+
+    inputs = [
+        CodeInput(
+            name="function_code",
+            display_name="Function Code",
+            info="The code for the function.",
+        ),
+    ]
+
+    outputs = [
+        Output(
+            name="function_output",
+            display_name="Function Callable",
+            method="get_function_callable",
+        ),
+        Output(
+            name="function_output_data",
+            display_name="Function Output (Data)",
+            method="execute_function_data",
+        ),
+        Output(
+            name="function_output_str",
+            display_name="Function Output (Message)",
+            method="execute_function_message",
+        ),
+    ]
+
+    def get_function_callable(self) -> Callable:
+        function_code = self.function_code
+        self.status = function_code
+        return get_function(function_code)
+
+    def execute_function(self) -> list[dotdict | str] | dotdict | str:
+        function_code = self.function_code
+
+        if not function_code:
+            return "No function code provided."
+
+        try:
+            func = get_function(function_code)
+            return func()
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Error executing function", exc_info=True)
+            return f"Error executing function: {e}"
+
+    def execute_function_data(self) -> list[Data]:
+        results = self.execute_function()
+        results = results if isinstance(results, list) else [results]
+        return [(Data(text=x) if isinstance(x, str) else Data(**x)) for x in results]
+
+    def execute_function_message(self) -> Message:
+        results = self.execute_function()
+        results = results if isinstance(results, list) else [results]
+        results_list = [str(x) for x in results]
+        results_str = "\n".join(results_list)
+        return Message(text=results_str)

lfx/components/qdrant/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .qdrant import QdrantVectorStoreComponent
+
+_dynamic_imports = {
+    "QdrantVectorStoreComponent": "qdrant",
+}
+
+__all__ = [
+    "QdrantVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Qdrant components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/qdrant/qdrant.py

@@ -0,0 +1,109 @@
+from langchain_community.vectorstores import Qdrant
+from langchain_core.embeddings import Embeddings
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import (
+    DropdownInput,
+    HandleInput,
+    IntInput,
+    SecretStrInput,
+    StrInput,
+)
+from lfx.schema.data import Data
+
+
+class QdrantVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "Qdrant"
+    description = "Qdrant Vector Store with search capabilities"
+    icon = "Qdrant"
+
+    inputs = [
+        StrInput(name="collection_name", display_name="Collection Name", required=True),
+        StrInput(name="host", display_name="Host", value="localhost", advanced=True),
+        IntInput(name="port", display_name="Port", value=6333, advanced=True),
+        IntInput(name="grpc_port", display_name="gRPC Port", value=6334, advanced=True),
+        SecretStrInput(name="api_key", display_name="Qdrant API Key", advanced=True),
+        StrInput(name="prefix", display_name="Prefix", advanced=True),
+        IntInput(name="timeout", display_name="Timeout", advanced=True),
+        StrInput(name="path", display_name="Path", advanced=True),
+        StrInput(name="url", display_name="URL", advanced=True),
+        DropdownInput(
+            name="distance_func",
+            display_name="Distance Function",
+            options=["Cosine", "Euclidean", "Dot Product"],
+            value="Cosine",
+            advanced=True,
+        ),
+        StrInput(name="content_payload_key", display_name="Content Payload Key", value="page_content", advanced=True),
+        StrInput(name="metadata_payload_key", display_name="Metadata Payload Key", value="metadata", advanced=True),
+        *LCVectorStoreComponent.inputs,
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            value=4,
+            advanced=True,
+        ),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> Qdrant:
+        qdrant_kwargs = {
+            "collection_name": self.collection_name,
+            "content_payload_key": self.content_payload_key,
+            "metadata_payload_key": self.metadata_payload_key,
+        }
+
+        server_kwargs = {
+            "host": self.host or None,
+            "port": int(self.port),  # Ensure port is an integer
+            "grpc_port": int(self.grpc_port),  # Ensure grpc_port is an integer
+            "api_key": self.api_key,
+            "prefix": self.prefix,
+            # Ensure timeout is an integer
+            "timeout": int(self.timeout) if self.timeout else None,
+            "path": self.path or None,
+            "url": self.url or None,
+        }
+
+        server_kwargs = {k: v for k, v in server_kwargs.items() if v is not None}
+
+        # Convert DataFrame to Data if needed using parent's method
+        self.ingest_data = self._prepare_ingest_data()
+
+        documents = []
+        for _input in self.ingest_data or []:
+            if isinstance(_input, Data):
+                documents.append(_input.to_lc_document())
+            else:
+                documents.append(_input)
+
+        if not isinstance(self.embedding, Embeddings):
+            msg = "Invalid embedding object"
+            raise TypeError(msg)
+
+        if documents:
+            qdrant = Qdrant.from_documents(documents, embedding=self.embedding, **qdrant_kwargs, **server_kwargs)
+        else:
+            from qdrant_client import QdrantClient
+
+            client = QdrantClient(**server_kwargs)
+            qdrant = Qdrant(embeddings=self.embedding, client=client, **qdrant_kwargs)
+
+        return qdrant
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            docs = vector_store.similarity_search(
+                query=self.search_query,
+                k=self.number_of_results,
+            )
+
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx/components/redis/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .redis import RedisVectorStoreComponent
+    from .redis_chat import RedisIndexChatMemory
+
+_dynamic_imports = {
+    "RedisVectorStoreComponent": "redis",
+    "RedisIndexChatMemory": "redis_chat",
+}
+
+__all__ = [
+    "RedisIndexChatMemory",
+    "RedisVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Redis components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)