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

lfx/components/input_output/chat_output.py

@@ -0,0 +1,184 @@
+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/chat-input-and-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="context_id",
+            display_name="Context ID",
+            info="The context ID of the chat. Adds an extra layer to the local memory.",
+            value="",
+            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.",
+        ),
+        BoolInput(
+            name="clean_data",
+            display_name="Basic Clean Data",
+            value=True,
+            advanced=True,
+            info="Whether to clean data before converting to string.",
+        ),
+    ]
+    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, _, display_name, source_id = self.get_properties_from_source_component()
+
+        # Create or use existing Message object
+        if isinstance(self.input_value, Message) and not self.is_connected_to_chat_input():
+            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 or self.graph.session_id or ""
+        message.context_id = self.context_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)
+
+        # Store message if needed
+        if message.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):
+            clean_data: bool = getattr(self, "clean_data", False)
+            return "\n".join([safe_convert(item, clean_data=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/text-input-and-output"
+    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/text-input-and-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/input_output/webhook.py

@@ -0,0 +1,56 @@
+import json
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import MultilineInput, Output
+from lfx.schema.data import Data
+
+
+class WebhookComponent(Component):
+    display_name = "Webhook"
+    documentation: str = "https://docs.langflow.org/component-webhook"
+    name = "Webhook"
+    icon = "webhook"
+
+    inputs = [
+        MultilineInput(
+            name="data",
+            display_name="Payload",
+            info="Receives a payload from external systems via HTTP POST.",
+            advanced=True,
+        ),
+        MultilineInput(
+            name="curl",
+            display_name="cURL",
+            value="CURL_WEBHOOK",
+            advanced=True,
+            input_types=[],
+        ),
+        MultilineInput(
+            name="endpoint",
+            display_name="Endpoint",
+            value="BACKEND_URL",
+            advanced=False,
+            copy_field=True,
+            input_types=[],
+        ),
+    ]
+    outputs = [
+        Output(display_name="Data", name="output_data", method="build_data"),
+    ]
+
+    def build_data(self) -> Data:
+        message: str | Data = ""
+        if not self.data:
+            self.status = "No data provided."
+            return Data(data={})
+        try:
+            my_data = self.data.replace('"\n"', '"\\n"')
+            body = json.loads(my_data or "{}")
+        except json.JSONDecodeError:
+            body = {"payload": self.data}
+            message = f"Invalid JSON payload. Please check the format.\n\n{self.data}"
+        data = Data(data=body)
+        if not message:
+            message = data
+        self.status = message
+        return data

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",
+]

lfx/components/jigsawstack/ai_scrape.py

@@ -0,0 +1,126 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output, SecretStrInput
+from lfx.schema.data import Data
+
+MAX_ELEMENT_PROMPTS = 5
+
+
+class JigsawStackAIScraperComponent(Component):
+    display_name = "AI Scraper"
+    description = "Scrape any website instantly and get consistent structured data \
+        in seconds without writing any css selector code"
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/scrape"
+    icon = "JigsawStack"
+    name = "JigsawStackAIScraper"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        MessageTextInput(
+            name="url",
+            display_name="URL",
+            info="URL of the page to scrape. Either url or html is required, but not both.",
+            required=False,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="html",
+            display_name="HTML",
+            info="HTML content to scrape. Either url or html is required, but not both.",
+            required=False,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="element_prompts",
+            display_name="Element Prompts",
+            info="Items on the page to be scraped (maximum 5). E.g. 'Plan price', 'Plan title'",
+            required=True,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="root_element_selector",
+            display_name="Root Element Selector",
+            info="CSS selector to limit the scope of scraping to a specific element and its children",
+            required=False,
+            value="main",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="AI Scraper Results", name="scrape_results", method="scrape"),
+    ]
+
+    def scrape(self) -> Data:
+        try:
+            from jigsawstack import JigsawStack, JigsawStackError
+        except ImportError as e:
+            jigsawstack_import_error = (
+                "JigsawStack package not found. Please install it using: pip install jigsawstack>=0.2.7"
+            )
+            raise ImportError(jigsawstack_import_error) from e
+
+        try:
+            client = JigsawStack(api_key=self.api_key)
+
+            # Build request object
+            scrape_params: dict = {}
+            if self.url:
+                scrape_params["url"] = self.url
+            if self.html:
+                scrape_params["html"] = self.html
+
+            url_value = scrape_params.get("url", "")
+            html_value = scrape_params.get("html", "")
+            if (not url_value or not url_value.strip()) and (not html_value or not html_value.strip()):
+                url_or_html_error = "Either 'url' or 'html' must be provided for scraping"
+                raise ValueError(url_or_html_error)
+
+            # Process element_prompts with proper type handling
+            element_prompts_list: list[str] = []
+            if self.element_prompts:
+                element_prompts_value: str | list[str] = self.element_prompts
+
+                if isinstance(element_prompts_value, str):
+                    if "," not in element_prompts_value:
+                        element_prompts_list = [element_prompts_value]
+                    else:
+                        element_prompts_list = element_prompts_value.split(",")
+                elif isinstance(element_prompts_value, list):
+                    element_prompts_list = element_prompts_value
+                else:
+                    # Fallback for other types
+                    element_prompts_list = str(element_prompts_value).split(",")
+
+                if len(element_prompts_list) > MAX_ELEMENT_PROMPTS:
+                    max_elements_error = "Maximum of 5 element prompts allowed"
+                    raise ValueError(max_elements_error)
+                if len(element_prompts_list) == 0:
+                    invalid_elements_error = "Element prompts cannot be empty"
+                    raise ValueError(invalid_elements_error)
+
+                scrape_params["element_prompts"] = element_prompts_list
+
+            if self.root_element_selector:
+                scrape_params["root_element_selector"] = self.root_element_selector
+
+            # Call web scraping
+            response = client.web.ai_scrape(scrape_params)
+
+            if not response.get("success", False):
+                fail_error = "JigsawStack API request failed."
+                raise ValueError(fail_error)
+
+            result_data = response
+
+            self.status = "AI scrape process is now complete."
+
+            return Data(data=result_data)
+
+        except JigsawStackError as e:
+            error_data = {"error": str(e), "success": False}
+            self.status = f"Error: {e!s}"
+            return Data(data=error_data)

lfx/components/jigsawstack/ai_web_search.py

@@ -0,0 +1,136 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import BoolInput, DropdownInput, Output, QueryInput, SecretStrInput
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+
+
+class JigsawStackAIWebSearchComponent(Component):
+    display_name = "AI Web Search"
+    description = "Effortlessly search the Web and get access to high-quality results powered with AI."
+    documentation = "https://jigsawstack.com/docs/api-reference/web/ai-search"
+    icon = "JigsawStack"
+    name = "JigsawStackAISearch"
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        QueryInput(
+            name="query",
+            display_name="Query",
+            info="The search value. The maximum query character length is 400",
+            required=True,
+            tool_mode=True,
+        ),
+        BoolInput(
+            name="ai_overview",
+            display_name="AI Overview",
+            info="Include AI powered overview in the search results",
+            required=False,
+            value=True,
+        ),
+        DropdownInput(
+            name="safe_search",
+            display_name="Safe Search",
+            info="Enable safe search to filter out adult content",
+            required=False,
+            options=["moderate", "strict", "off"],
+            value="off",
+        ),
+        BoolInput(
+            name="spell_check",
+            display_name="Spell Check",
+            info="Spell check the search query",
+            required=False,
+            value=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="AI Search Results", name="search_results", method="search"),
+        Output(display_name="Content Text", name="content_text", method="get_content_text"),
+    ]
+
+    def search(self) -> Data:
+        try:
+            from jigsawstack import JigsawStack, JigsawStackError
+        except ImportError as e:
+            jigsawstack_import_error = (
+                "JigsawStack package not found. Please install it using: pip install jigsawstack>=0.2.7"
+            )
+            raise ImportError(jigsawstack_import_error) from e
+
+        try:
+            client = JigsawStack(api_key=self.api_key)
+
+            # build request object
+            search_params = {}
+            if self.query:
+                search_params["query"] = self.query
+            if self.ai_overview is not None:
+                search_params["ai_overview"] = self.ai_overview
+            if self.safe_search:
+                search_params["safe_search"] = self.safe_search
+            if self.spell_check is not None:
+                search_params["spell_check"] = self.spell_check
+
+            # Call web scraping
+            response = client.web.search(search_params)
+
+            api_error_msg = "JigsawStack API returned unsuccessful response"
+            if not response.get("success", False):
+                raise ValueError(api_error_msg)
+
+            # Create comprehensive data object
+            result_data = {
+                "query": self.query,
+                "ai_overview": response.get("ai_overview", ""),
+                "spell_fixed": response.get("spell_fixed", False),
+                "is_safe": response.get("is_safe", True),
+                "results": response.get("results", []),
+                "success": True,
+            }
+
+            self.status = f"Search complete for: {response.get('query', '')}"
+
+            return Data(data=result_data)
+
+        except JigsawStackError as e:
+            error_data = {"error": str(e), "success": False}
+            self.status = f"Error: {e!s}"
+            return Data(data=error_data)
+
+    def get_content_text(self) -> Message:
+        try:
+            from jigsawstack import JigsawStack, JigsawStackError
+        except ImportError:
+            return Message(text="Error: JigsawStack package not found.")
+
+        try:
+            # Initialize JigsawStack client
+            client = JigsawStack(api_key=self.api_key)
+            search_params = {}
+            if self.query:
+                search_params["query"] = self.query
+            if self.ai_overview is not None:
+                search_params["ai_overview"] = self.ai_overview
+            if self.safe_search:
+                search_params["safe_search"] = self.safe_search
+            if self.spell_check is not None:
+                search_params["spell_check"] = self.spell_check
+
+            # Call web scraping
+            response = client.web.search(search_params)
+
+            request_failed_msg = "Request Failed"
+            if not response.get("success", False):
+                raise JigsawStackError(request_failed_msg)
+
+            # Return the content as text
+            content = response.get("ai_overview", "")
+            return Message(text=content)
+
+        except JigsawStackError as e:
+            return Message(text=f"Error while using AI Search: {e!s}")