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

lfx/components/ibm/watsonx_embeddings.py

@@ -0,0 +1,135 @@
+from typing import Any
+
+import requests
+from ibm_watsonx_ai import APIClient, Credentials
+from ibm_watsonx_ai.metanames import EmbedTextParamsMetaNames
+from langchain_ibm import WatsonxEmbeddings
+from pydantic.v1 import SecretStr
+
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.field_typing import Embeddings
+from lfx.io import BoolInput, DropdownInput, IntInput, SecretStrInput, StrInput
+from lfx.log.logger import logger
+from lfx.schema.dotdict import dotdict
+
+
+class WatsonxEmbeddingsComponent(LCEmbeddingsModel):
+    display_name = "IBM watsonx.ai Embeddings"
+    description = "Generate embeddings using IBM watsonx.ai models."
+    icon = "WatsonxAI"
+    name = "WatsonxEmbeddingsComponent"
+
+    # models present in all the regions
+    _default_models = [
+        "sentence-transformers/all-minilm-l12-v2",
+        "ibm/slate-125m-english-rtrvr-v2",
+        "ibm/slate-30m-english-rtrvr-v2",
+        "intfloat/multilingual-e5-large",
+    ]
+
+    inputs = [
+        DropdownInput(
+            name="url",
+            display_name="watsonx API Endpoint",
+            info="The base URL of the API.",
+            value=None,
+            options=[
+                "https://us-south.ml.cloud.ibm.com",
+                "https://eu-de.ml.cloud.ibm.com",
+                "https://eu-gb.ml.cloud.ibm.com",
+                "https://au-syd.ml.cloud.ibm.com",
+                "https://jp-tok.ml.cloud.ibm.com",
+                "https://ca-tor.ml.cloud.ibm.com",
+            ],
+            real_time_refresh=True,
+        ),
+        StrInput(
+            name="project_id",
+            display_name="watsonx project id",
+            info="The project ID or deployment space ID that is associated with the foundation model.",
+            required=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="The API Key to use for the model.",
+            required=True,
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            options=[],
+            value=None,
+            dynamic=True,
+            required=True,
+        ),
+        IntInput(
+            name="truncate_input_tokens",
+            display_name="Truncate Input Tokens",
+            advanced=True,
+            value=200,
+        ),
+        BoolInput(
+            name="input_text",
+            display_name="Include the original text in the output",
+            value=True,
+            advanced=True,
+        ),
+    ]
+
+    @staticmethod
+    def fetch_models(base_url: str) -> list[str]:
+        """Fetch available models from the watsonx.ai API."""
+        try:
+            endpoint = f"{base_url}/ml/v1/foundation_model_specs"
+            params = {
+                "version": "2024-09-16",
+                "filters": "function_embedding,!lifecycle_withdrawn:and",
+            }
+            response = requests.get(endpoint, params=params, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            models = [model["model_id"] for model in data.get("resources", [])]
+            return sorted(models)
+        except Exception:  # noqa: BLE001
+            logger.exception("Error fetching models")
+            return WatsonxEmbeddingsComponent._default_models
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
+        """Update model options when URL or API key changes."""
+        logger.debug(
+            "Updating build config. Field name: %s, Field value: %s",
+            field_name,
+            field_value,
+        )
+
+        if field_name == "url" and field_value:
+            try:
+                models = self.fetch_models(base_url=build_config.url.value)
+                build_config.model_name.options = models
+                if build_config.model_name.value:
+                    build_config.model_name.value = models[0]
+                info_message = f"Updated model options: {len(models)} models found in {build_config.url.value}"
+                logger.info(info_message)
+            except Exception:  # noqa: BLE001
+                logger.exception("Error updating model options.")
+
+    def build_embeddings(self) -> Embeddings:
+        credentials = Credentials(
+            api_key=SecretStr(self.api_key).get_secret_value(),
+            url=self.url,
+        )
+
+        api_client = APIClient(credentials)
+
+        params = {
+            EmbedTextParamsMetaNames.TRUNCATE_INPUT_TOKENS: self.truncate_input_tokens,
+            EmbedTextParamsMetaNames.RETURN_OPTIONS: {"input_text": self.input_text},
+        }
+
+        return WatsonxEmbeddings(
+            model_id=self.model_name,
+            params=params,
+            watsonx_client=api_client,
+            project_id=self.project_id,
+        )

lfx/components/icosacomputing/__init__.py

@@ -0,0 +1,5 @@
+from .combinatorial_reasoner import CombinatorialReasonerComponent
+
+__all__ = [
+    "CombinatorialReasonerComponent",
+]

lfx/components/icosacomputing/combinatorial_reasoner.py

@@ -0,0 +1,84 @@
+import requests
+from requests.auth import HTTPBasicAuth
+
+from lfx.base.models.openai_constants import OPENAI_CHAT_MODEL_NAMES
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import DropdownInput, SecretStrInput, StrInput
+from lfx.io import MessageTextInput, Output
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+
+
+class CombinatorialReasonerComponent(Component):
+    display_name = "Combinatorial Reasoner"
+    description = "Uses Combinatorial Optimization to construct an optimal prompt with embedded reasons. Sign up here:\nhttps://forms.gle/oWNv2NKjBNaqqvCx6"
+    icon = "Icosa"
+    name = "Combinatorial Reasoner"
+
+    inputs = [
+        MessageTextInput(name="prompt", display_name="Prompt", required=True),
+        SecretStrInput(
+            name="openai_api_key",
+            display_name="OpenAI API Key",
+            info="The OpenAI API Key to use for the OpenAI model.",
+            advanced=False,
+            value="OPENAI_API_KEY",
+            required=True,
+        ),
+        StrInput(
+            name="username",
+            display_name="Username",
+            info="Username to authenticate access to Icosa CR API",
+            advanced=False,
+            required=True,
+        ),
+        SecretStrInput(
+            name="password",
+            display_name="Password",
+            info="Password to authenticate access to Icosa CR API.",
+            advanced=False,
+            required=True,
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            options=OPENAI_CHAT_MODEL_NAMES,
+            value=OPENAI_CHAT_MODEL_NAMES[0],
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Optimized Prompt",
+            name="optimized_prompt",
+            method="build_prompt",
+        ),
+        Output(display_name="Selected Reasons", name="reasons", method="build_reasons"),
+    ]
+
+    def build_prompt(self) -> Message:
+        params = {
+            "prompt": self.prompt,
+            "apiKey": self.openai_api_key,
+            "model": self.model_name,
+        }
+
+        creds = HTTPBasicAuth(self.username, password=self.password)
+        response = requests.post(
+            "https://cr-api.icosacomputing.com/cr/langflow",
+            json=params,
+            auth=creds,
+            timeout=100,
+        )
+        response.raise_for_status()
+
+        prompt = response.json()["prompt"]
+
+        self.reasons = response.json()["finalReasons"]
+        return prompt
+
+    def build_reasons(self) -> Data:
+        # list of selected reasons
+        final_reasons = [reason[0] for reason in self.reasons]
+        return Data(value=final_reasons)

lfx/components/input_output/__init__.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.input_output.chat import ChatInput
+    from lfx.components.input_output.chat_output import ChatOutput
+    from lfx.components.input_output.text import TextInputComponent
+    from lfx.components.input_output.text_output import TextOutputComponent
+
+_dynamic_imports = {
+    "ChatInput": "chat",
+    "ChatOutput": "chat_output",
+    "TextInputComponent": "text",
+    "TextOutputComponent": "text_output",
+}
+
+__all__ = ["ChatInput", "ChatOutput", "TextInputComponent", "TextOutputComponent"]
+
+
+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/input_output/chat.py

@@ -0,0 +1,120 @@
+from lfx.base.data.utils import IMG_FILE_TYPES, TEXT_FILE_TYPES
+from lfx.base.io.chat import ChatComponent
+from lfx.inputs.inputs import BoolInput
+from lfx.io import (
+    DropdownInput,
+    FileInput,
+    MessageTextInput,
+    MultilineInput,
+    Output,
+)
+from lfx.schema.message import Message
+from lfx.utils.constants import (
+    MESSAGE_SENDER_AI,
+    MESSAGE_SENDER_NAME_USER,
+    MESSAGE_SENDER_USER,
+)
+
+
+class ChatInput(ChatComponent):
+    display_name = "Chat Input"
+    description = "Get chat inputs from the Playground."
+    documentation: str = "https://docs.langflow.org/components-io#chat-input"
+    icon = "MessagesSquare"
+    name = "ChatInput"
+    minimized = True
+
+    inputs = [
+        MultilineInput(
+            name="input_value",
+            display_name="Input Text",
+            value="",
+            info="Message to be passed as input.",
+            input_types=[],
+        ),
+        BoolInput(
+            name="should_store_message",
+            display_name="Store Messages",
+            info="Store the message in the history.",
+            value=True,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="sender",
+            display_name="Sender Type",
+            options=[MESSAGE_SENDER_AI, MESSAGE_SENDER_USER],
+            value=MESSAGE_SENDER_USER,
+            info="Type of sender.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="sender_name",
+            display_name="Sender Name",
+            info="Name of the sender.",
+            value=MESSAGE_SENDER_NAME_USER,
+            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.",
+            advanced=True,
+        ),
+        FileInput(
+            name="files",
+            display_name="Files",
+            file_types=TEXT_FILE_TYPES + IMG_FILE_TYPES,
+            info="Files to be sent with the message.",
+            advanced=True,
+            is_list=True,
+            temp_file=True,
+        ),
+        MessageTextInput(
+            name="background_color",
+            display_name="Background Color",
+            info="The background color of the icon.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="chat_icon",
+            display_name="Icon",
+            info="The icon of the message.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="text_color",
+            display_name="Text Color",
+            info="The text color of the name",
+            advanced=True,
+        ),
+    ]
+    outputs = [
+        Output(display_name="Chat Message", name="message", method="message_response"),
+    ]
+
+    async def message_response(self) -> Message:
+        background_color = self.background_color
+        text_color = self.text_color
+        icon = self.chat_icon
+
+        message = await Message.create(
+            text=self.input_value,
+            sender=self.sender,
+            sender_name=self.sender_name,
+            session_id=self.session_id,
+            files=self.files,
+            properties={
+                "background_color": background_color,
+                "text_color": text_color,
+                "icon": icon,
+            },
+        )
+        if self.session_id and isinstance(message, Message) and self.should_store_message:
+            stored_message = await self.send_message(
+                message,
+            )
+            self.message.value = stored_message
+            message = stored_message
+
+        self.status = message
+        return message

lfx/components/input_output/chat_output.py

@@ -0,0 +1,200 @@
+from collections.abc import Generator
+from typing import Any
+
+import orjson
+from fastapi.encoders import jsonable_encoder
+
+from lfx.base.io.chat import ChatComponent
+from lfx.helpers.data import safe_convert
+from lfx.inputs.inputs import BoolInput, DropdownInput, HandleInput, MessageTextInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.message import Message
+from lfx.schema.properties import Source
+from lfx.template.field.base import Output
+from lfx.utils.constants import (
+    MESSAGE_SENDER_AI,
+    MESSAGE_SENDER_NAME_AI,
+    MESSAGE_SENDER_USER,
+)
+
+
+class ChatOutput(ChatComponent):
+    display_name = "Chat Output"
+    description = "Display a chat message in the Playground."
+    documentation: str = "https://docs.langflow.org/components-io#chat-output"
+    icon = "MessagesSquare"
+    name = "ChatOutput"
+    minimized = True
+
+    inputs = [
+        HandleInput(
+            name="input_value",
+            display_name="Inputs",
+            info="Message to be passed as output.",
+            input_types=["Data", "DataFrame", "Message"],
+            required=True,
+        ),
+        BoolInput(
+            name="should_store_message",
+            display_name="Store Messages",
+            info="Store the message in the history.",
+            value=True,
+            advanced=True,
+        ),
+        DropdownInput(
+            name="sender",
+            display_name="Sender Type",
+            options=[MESSAGE_SENDER_AI, MESSAGE_SENDER_USER],
+            value=MESSAGE_SENDER_AI,
+            advanced=True,
+            info="Type of sender.",
+        ),
+        MessageTextInput(
+            name="sender_name",
+            display_name="Sender Name",
+            info="Name of the sender.",
+            value=MESSAGE_SENDER_NAME_AI,
+            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.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="data_template",
+            display_name="Data Template",
+            value="{text}",
+            advanced=True,
+            info="Template to convert Data to Text. If left empty, it will be dynamically set to the Data's text key.",
+        ),
+        MessageTextInput(
+            name="background_color",
+            display_name="Background Color",
+            info="The background color of the icon.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="chat_icon",
+            display_name="Icon",
+            info="The icon of the message.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="text_color",
+            display_name="Text Color",
+            info="The text color of the name",
+            advanced=True,
+        ),
+        BoolInput(
+            name="clean_data",
+            display_name="Basic Clean Data",
+            value=True,
+            info="Whether to clean the data",
+            advanced=True,
+        ),
+    ]
+    outputs = [
+        Output(
+            display_name="Output Message",
+            name="message",
+            method="message_response",
+        ),
+    ]
+
+    def _build_source(self, id_: str | None, display_name: str | None, source: str | None) -> Source:
+        source_dict = {}
+        if id_:
+            source_dict["id"] = id_
+        if display_name:
+            source_dict["display_name"] = display_name
+        if source:
+            # Handle case where source is a ChatOpenAI object
+            if hasattr(source, "model_name"):
+                source_dict["source"] = source.model_name
+            elif hasattr(source, "model"):
+                source_dict["source"] = str(source.model)
+            else:
+                source_dict["source"] = str(source)
+        return Source(**source_dict)
+
+    async def message_response(self) -> Message:
+        # First convert the input to string if needed
+        text = self.convert_to_string()
+
+        # Get source properties
+        source, icon, display_name, source_id = self.get_properties_from_source_component()
+        background_color = self.background_color
+        text_color = self.text_color
+        if self.chat_icon:
+            icon = self.chat_icon
+
+        # Create or use existing Message object
+        if isinstance(self.input_value, Message):
+            message = self.input_value
+            # Update message properties
+            message.text = text
+        else:
+            message = Message(text=text)
+
+        # Set message properties
+        message.sender = self.sender
+        message.sender_name = self.sender_name
+        message.session_id = self.session_id
+        message.flow_id = self.graph.flow_id if hasattr(self, "graph") else None
+        message.properties.source = self._build_source(source_id, display_name, source)
+        message.properties.icon = icon
+        message.properties.background_color = background_color
+        message.properties.text_color = text_color
+
+        # Store message if needed
+        if self.session_id and self.should_store_message:
+            stored_message = await self.send_message(message)
+            self.message.value = stored_message
+            message = stored_message
+
+        self.status = message
+        return message
+
+    def _serialize_data(self, data: Data) -> str:
+        """Serialize Data object to JSON string."""
+        # Convert data.data to JSON-serializable format
+        serializable_data = jsonable_encoder(data.data)
+        # Serialize with orjson, enabling pretty printing with indentation
+        json_bytes = orjson.dumps(serializable_data, option=orjson.OPT_INDENT_2)
+        # Convert bytes to string and wrap in Markdown code blocks
+        return "```json\n" + json_bytes.decode("utf-8") + "\n```"
+
+    def _validate_input(self) -> None:
+        """Validate the input data and raise ValueError if invalid."""
+        if self.input_value is None:
+            msg = "Input data cannot be None"
+            raise ValueError(msg)
+        if isinstance(self.input_value, list) and not all(
+            isinstance(item, Message | Data | DataFrame | str) for item in self.input_value
+        ):
+            invalid_types = [
+                type(item).__name__
+                for item in self.input_value
+                if not isinstance(item, Message | Data | DataFrame | str)
+            ]
+            msg = f"Expected Data or DataFrame or Message or str, got {invalid_types}"
+            raise TypeError(msg)
+        if not isinstance(
+            self.input_value,
+            Message | Data | DataFrame | str | list | Generator | type(None),
+        ):
+            type_name = type(self.input_value).__name__
+            msg = f"Expected Data or DataFrame or Message or str, Generator or None, got {type_name}"
+            raise TypeError(msg)
+
+    def convert_to_string(self) -> str | Generator[Any, None, None]:
+        """Convert input data to string with proper error handling."""
+        self._validate_input()
+        if isinstance(self.input_value, list):
+            return "\n".join([safe_convert(item, clean_data=self.clean_data) for item in self.input_value])
+        if isinstance(self.input_value, Generator):
+            return self.input_value
+        return safe_convert(self.input_value)

lfx/components/input_output/text.py

@@ -0,0 +1,27 @@
+from lfx.base.io.text import TextComponent
+from lfx.io import MultilineInput, Output
+from lfx.schema.message import Message
+
+
+class TextInputComponent(TextComponent):
+    display_name = "Text Input"
+    description = "Get user text inputs."
+    documentation: str = "https://docs.langflow.org/components-io#text-input"
+    icon = "type"
+    name = "TextInput"
+
+    inputs = [
+        MultilineInput(
+            name="input_value",
+            display_name="Text",
+            info="Text to be passed as input.",
+        ),
+    ]
+    outputs = [
+        Output(display_name="Output Text", name="text", method="text_response"),
+    ]
+
+    def text_response(self) -> Message:
+        return Message(
+            text=self.input_value,
+        )

lfx/components/input_output/text_output.py

@@ -0,0 +1,29 @@
+from lfx.base.io.text import TextComponent
+from lfx.io import MultilineInput, Output
+from lfx.schema.message import Message
+
+
+class TextOutputComponent(TextComponent):
+    display_name = "Text Output"
+    description = "Sends text output via API."
+    documentation: str = "https://docs.langflow.org/components-io#text-output"
+    icon = "type"
+    name = "TextOutput"
+
+    inputs = [
+        MultilineInput(
+            name="input_value",
+            display_name="Inputs",
+            info="Text to be passed as output.",
+        ),
+    ]
+    outputs = [
+        Output(display_name="Output Text", name="text", method="text_response"),
+    ]
+
+    def text_response(self) -> Message:
+        message = Message(
+            text=self.input_value,
+        )
+        self.status = self.input_value
+        return message

lfx/components/jigsawstack/__init__.py

@@ -0,0 +1,23 @@
+from .ai_scrape import JigsawStackAIScraperComponent
+from .ai_web_search import JigsawStackAIWebSearchComponent
+from .file_read import JigsawStackFileReadComponent
+from .file_upload import JigsawStackFileUploadComponent
+from .image_generation import JigsawStackImageGenerationComponent
+from .nsfw import JigsawStackNSFWComponent
+from .object_detection import JigsawStackObjectDetectionComponent
+from .sentiment import JigsawStackSentimentComponent
+from .text_to_sql import JigsawStackTextToSQLComponent
+from .vocr import JigsawStackVOCRComponent
+
+__all__ = [
+    "JigsawStackAIScraperComponent",
+    "JigsawStackAIWebSearchComponent",
+    "JigsawStackFileReadComponent",
+    "JigsawStackFileUploadComponent",
+    "JigsawStackImageGenerationComponent",
+    "JigsawStackNSFWComponent",
+    "JigsawStackObjectDetectionComponent",
+    "JigsawStackSentimentComponent",
+    "JigsawStackTextToSQLComponent",
+    "JigsawStackVOCRComponent",
+]