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

lfx/components/unstructured/__init__.py

@@ -0,0 +1,3 @@
+from .unstructured import UnstructuredComponent
+
+__all__ = ["UnstructuredComponent"]

lfx/components/unstructured/unstructured.py

@@ -0,0 +1,121 @@
+from langchain_unstructured import UnstructuredLoader
+
+from lfx.base.data.base_file import BaseFileComponent
+from lfx.inputs.inputs import DropdownInput, MessageTextInput, NestedDictInput, SecretStrInput
+from lfx.schema.data import Data
+
+
+class UnstructuredComponent(BaseFileComponent):
+    display_name = "Unstructured API"
+    description = (
+        "Uses Unstructured.io API to extract clean text from raw source documents. Supports a wide range of file types."
+    )
+    documentation = (
+        "https://python.langchain.com/api_reference/unstructured/document_loaders/"
+        "langchain_unstructured.document_loaders.UnstructuredLoader.html"
+    )
+    trace_type = "tool"
+    icon = "Unstructured"
+    name = "Unstructured"
+
+    # https://docs.unstructured.io/api-reference/api-services/overview#supported-file-types
+    VALID_EXTENSIONS = [
+        "bmp",
+        "csv",
+        "doc",
+        "docx",
+        "eml",
+        "epub",
+        "heic",
+        "html",
+        "jpeg",
+        "png",
+        "md",
+        "msg",
+        "odt",
+        "org",
+        "p7s",
+        "pdf",
+        "png",
+        "ppt",
+        "pptx",
+        "rst",
+        "rtf",
+        "tiff",
+        "txt",
+        "tsv",
+        "xls",
+        "xlsx",
+        "xml",
+    ]
+
+    inputs = [
+        *BaseFileComponent.get_base_inputs(),
+        SecretStrInput(
+            name="api_key",
+            display_name="Unstructured.io Serverless API Key",
+            required=True,
+            info="Unstructured API Key. Create at: https://app.unstructured.io/",
+        ),
+        MessageTextInput(
+            name="api_url",
+            display_name="Unstructured.io API URL",
+            required=False,
+            info="Unstructured API URL.",
+        ),
+        DropdownInput(
+            name="chunking_strategy",
+            display_name="Chunking Strategy",
+            info="Chunking strategy to use, see https://docs.unstructured.io/api-reference/api-services/chunking",
+            options=["", "basic", "by_title", "by_page", "by_similarity"],
+            real_time_refresh=False,
+            value="",
+        ),
+        NestedDictInput(
+            name="unstructured_args",
+            display_name="Additional Arguments",
+            required=False,
+            info=(
+                "Optional dictionary of additional arguments to the Loader. "
+                "See https://docs.unstructured.io/api-reference/api-services/api-parameters for more information."
+            ),
+        ),
+    ]
+
+    outputs = [
+        *BaseFileComponent.get_base_outputs(),
+    ]
+
+    def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
+        file_paths = [str(file.path) for file in file_list if file.path]
+
+        if not file_paths:
+            self.log("No files to process.")
+            return file_list
+
+        # https://docs.unstructured.io/api-reference/api-services/api-parameters
+        args = self.unstructured_args or {}
+
+        if self.chunking_strategy:
+            args["chunking_strategy"] = self.chunking_strategy
+
+        args["api_key"] = self.api_key
+        args["partition_via_api"] = True
+        if self.api_url:
+            args["url"] = self.api_url
+
+        loader = UnstructuredLoader(
+            file_paths,
+            **args,
+        )
+
+        documents = loader.load()
+
+        processed_data: list[Data | None] = [Data.from_document(doc) if doc else None for doc in documents]
+
+        # Rename the `source` field to `self.SERVER_FILE_PATH_FIELDNAME`, to avoid conflicts with the `source` field
+        for data in processed_data:
+            if data and "source" in data.data:
+                data.data[self.SERVER_FILE_PATH_FIELDNAME] = data.data.pop("source")
+
+        return self.rollup_data(file_list, processed_data)

lfx/components/upstash/__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 .upstash import UpstashVectorStoreComponent
+
+_dynamic_imports = {
+    "UpstashVectorStoreComponent": "upstash",
+}
+
+__all__ = [
+    "UpstashVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Upstash 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/upstash/upstash.py

@@ -0,0 +1,124 @@
+from langchain_community.vectorstores import UpstashVectorStore
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import (
+    HandleInput,
+    IntInput,
+    MultilineInput,
+    SecretStrInput,
+    StrInput,
+)
+from lfx.schema.data import Data
+
+
+class UpstashVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "Upstash"
+    description = "Upstash Vector Store with search capabilities"
+    name = "Upstash"
+    icon = "Upstash"
+
+    inputs = [
+        StrInput(
+            name="index_url",
+            display_name="Index URL",
+            info="The URL of the Upstash index.",
+            required=True,
+        ),
+        SecretStrInput(
+            name="index_token",
+            display_name="Upstash Index Token",
+            info="The token for the Upstash index.",
+            required=True,
+        ),
+        StrInput(
+            name="text_key",
+            display_name="Text Key",
+            info="The key in the record to use as text.",
+            value="text",
+            advanced=True,
+        ),
+        StrInput(
+            name="namespace",
+            display_name="Namespace",
+            info="Leave empty for default namespace.",
+        ),
+        *LCVectorStoreComponent.inputs,
+        MultilineInput(
+            name="metadata_filter",
+            display_name="Metadata Filter",
+            info="Filters documents by metadata. Look at the documentation for more information.",
+        ),
+        HandleInput(
+            name="embedding",
+            display_name="Embedding",
+            input_types=["Embeddings"],
+            info="To use Upstash's embeddings, don't provide an embedding.",
+        ),
+        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) -> UpstashVectorStore:
+        use_upstash_embedding = self.embedding is 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 documents:
+            if use_upstash_embedding:
+                upstash_vs = UpstashVectorStore(
+                    embedding=use_upstash_embedding,
+                    text_key=self.text_key,
+                    index_url=self.index_url,
+                    index_token=self.index_token,
+                    namespace=self.namespace,
+                )
+                upstash_vs.add_documents(documents)
+            else:
+                upstash_vs = UpstashVectorStore.from_documents(
+                    documents=documents,
+                    embedding=self.embedding,
+                    text_key=self.text_key,
+                    index_url=self.index_url,
+                    index_token=self.index_token,
+                    namespace=self.namespace,
+                )
+        else:
+            upstash_vs = UpstashVectorStore(
+                embedding=self.embedding or use_upstash_embedding,
+                text_key=self.text_key,
+                index_url=self.index_url,
+                index_token=self.index_token,
+                namespace=self.namespace,
+            )
+
+        return upstash_vs
+
+    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,
+                filter=self.metadata_filter,
+            )
+
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx/components/utilities/__init__.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.utilities.calculator_core import CalculatorComponent
+    from lfx.components.utilities.current_date import CurrentDateComponent
+    from lfx.components.utilities.id_generator import IDGeneratorComponent
+    from lfx.components.utilities.python_repl_core import PythonREPLComponent
+
+_dynamic_imports = {
+    "CalculatorComponent": "calculator_core",
+    "CurrentDateComponent": "current_date",
+    "IDGeneratorComponent": "id_generator",
+    "PythonREPLComponent": "python_repl_core",
+}
+
+__all__ = [
+    "CalculatorComponent",
+    "CurrentDateComponent",
+    "IDGeneratorComponent",
+    "PythonREPLComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import utility 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/utilities/calculator_core.py

@@ -0,0 +1,89 @@
+import ast
+import operator
+from collections.abc import Callable
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import MessageTextInput
+from lfx.io import Output
+from lfx.schema.data import Data
+
+
+class CalculatorComponent(Component):
+    display_name = "Calculator"
+    description = "Perform basic arithmetic operations on a given expression."
+    documentation: str = "https://docs.langflow.org/calculator"
+    icon = "calculator"
+
+    # Cache operators dictionary as a class variable
+    OPERATORS: dict[type[ast.operator], Callable] = {
+        ast.Add: operator.add,
+        ast.Sub: operator.sub,
+        ast.Mult: operator.mul,
+        ast.Div: operator.truediv,
+        ast.Pow: operator.pow,
+    }
+
+    inputs = [
+        MessageTextInput(
+            name="expression",
+            display_name="Expression",
+            info="The arithmetic expression to evaluate (e.g., '4*4*(33/22)+12-20').",
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="result", type_=Data, method="evaluate_expression"),
+    ]
+
+    def _eval_expr(self, node: ast.AST) -> float:
+        """Evaluate an AST node recursively."""
+        if isinstance(node, ast.Constant):
+            if isinstance(node.value, int | float):
+                return float(node.value)
+            error_msg = f"Unsupported constant type: {type(node.value).__name__}"
+            raise TypeError(error_msg)
+        if isinstance(node, ast.Num):  # For backwards compatibility
+            if isinstance(node.n, int | float):
+                return float(node.n)
+            error_msg = f"Unsupported number type: {type(node.n).__name__}"
+            raise TypeError(error_msg)
+
+        if isinstance(node, ast.BinOp):
+            op_type = type(node.op)
+            if op_type not in self.OPERATORS:
+                error_msg = f"Unsupported binary operator: {op_type.__name__}"
+                raise TypeError(error_msg)
+
+            left = self._eval_expr(node.left)
+            right = self._eval_expr(node.right)
+            return self.OPERATORS[op_type](left, right)
+
+        error_msg = f"Unsupported operation or expression type: {type(node).__name__}"
+        raise TypeError(error_msg)
+
+    def evaluate_expression(self) -> Data:
+        """Evaluate the mathematical expression and return the result."""
+        try:
+            tree = ast.parse(self.expression, mode="eval")
+            result = self._eval_expr(tree.body)
+
+            formatted_result = f"{float(result):.6f}".rstrip("0").rstrip(".")
+            self.log(f"Calculation result: {formatted_result}")
+
+            self.status = formatted_result
+            return Data(data={"result": formatted_result})
+
+        except ZeroDivisionError:
+            error_message = "Error: Division by zero"
+            self.status = error_message
+            return Data(data={"error": error_message, "input": self.expression})
+
+        except (SyntaxError, TypeError, KeyError, ValueError, AttributeError, OverflowError) as e:
+            error_message = f"Invalid expression: {e!s}"
+            self.status = error_message
+            return Data(data={"error": error_message, "input": self.expression})
+
+    def build(self):
+        """Return the main evaluation function."""
+        return self.evaluate_expression

lfx/components/utilities/current_date.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+from zoneinfo import ZoneInfo, available_timezones
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import DropdownInput, Output
+from lfx.log.logger import logger
+from lfx.schema.message import Message
+
+
+class CurrentDateComponent(Component):
+    display_name = "Current Date"
+    description = "Returns the current date and time in the selected timezone."
+    documentation: str = "https://docs.langflow.org/current-date"
+    icon = "clock"
+    name = "CurrentDate"
+
+    inputs = [
+        DropdownInput(
+            name="timezone",
+            display_name="Timezone",
+            options=sorted(tz for tz in available_timezones() if tz != "localtime"),
+            value="UTC",
+            info="Select the timezone for the current date and time.",
+            tool_mode=True,
+        ),
+    ]
+    outputs = [
+        Output(display_name="Current Date", name="current_date", method="get_current_date"),
+    ]
+
+    def get_current_date(self) -> Message:
+        try:
+            tz = ZoneInfo(self.timezone)
+            current_date = datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S %Z")
+            result = f"Current date and time in {self.timezone}: {current_date}"
+            self.status = result
+            return Message(text=result)
+        except Exception as e:  # noqa: BLE001
+            logger.debug("Error getting current date", exc_info=True)
+            error_message = f"Error: {e}"
+            self.status = error_message
+            return Message(text=error_message)

lfx/components/utilities/id_generator.py

@@ -0,0 +1,42 @@
+import uuid
+from typing import Any
+
+from typing_extensions import override
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output
+from lfx.schema.dotdict import dotdict
+from lfx.schema.message import Message
+
+
+class IDGeneratorComponent(Component):
+    display_name = "ID Generator"
+    description = "Generates a unique ID."
+    icon = "fingerprint"
+    name = "IDGenerator"
+    legacy = True
+
+    inputs = [
+        MessageTextInput(
+            name="unique_id",
+            display_name="Value",
+            info="The generated unique ID.",
+            refresh_button=True,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="ID", name="id", method="generate_id"),
+    ]
+
+    @override
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
+        if field_name == "unique_id":
+            build_config[field_name]["value"] = str(uuid.uuid4())
+        return build_config
+
+    def generate_id(self) -> Message:
+        unique_id = self.unique_id or str(uuid.uuid4())
+        self.status = f"Generated ID: {unique_id}"
+        return Message(text=unique_id)

lfx/components/utilities/python_repl_core.py

@@ -0,0 +1,98 @@
+import importlib
+
+from langchain_experimental.utilities import PythonREPL
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import MultilineInput, Output, StrInput
+from lfx.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/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,
+        ),
+        MultilineInput(
+            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

lfx/components/vectara/__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 .vectara import VectaraVectorStoreComponent
+    from .vectara_rag import VectaraRagComponent
+
+_dynamic_imports = {
+    "VectaraVectorStoreComponent": "vectara",
+    "VectaraRagComponent": "vectara_rag",
+}
+
+__all__ = [
+    "VectaraRagComponent",
+    "VectaraVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Vectara 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__)