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

lfx/components/jigsawstack/nsfw.py

@@ -0,0 +1,60 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import Output, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class JigsawStackNSFWComponent(Component):
+    display_name = "NSFW Detection"
+    description = "Detect if image/video contains NSFW content"
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/nsfw"
+    icon = "JigsawStack"
+    name = "JigsawStackNSFW"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        StrInput(
+            name="url",
+            display_name="URL",
+            info="URL of the image or video to analyze",
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="NSFW Analysis", name="nsfw_result", method="detect_nsfw"),
+    ]
+
+    def detect_nsfw(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 parameters
+            params = {"url": self.url}
+
+            response = client.validate.nsfw(params)
+
+            api_error_msg = "JigsawStack API returned unsuccessful response"
+            if not response.get("success", False):
+                raise ValueError(api_error_msg)
+
+            return Data(data=response)
+
+        except ValueError:
+            raise
+        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/object_detection.py

@@ -0,0 +1,124 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import BoolInput, DropdownInput, MessageTextInput, Output, SecretStrInput
+from lfx.schema.data import Data
+
+
+class JigsawStackObjectDetectionComponent(Component):
+    display_name = "Object Detection"
+    description = "Perform object detection on images using JigsawStack's Object Detection Model, \
+        capable of image grounding, segmentation and computer use."
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/object-detection"
+    icon = "JigsawStack"
+    name = "JigsawStackObjectDetection"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        MessageTextInput(
+            name="prompts",
+            display_name="Prompts",
+            info="The prompts to ground the object detection model. \
+                You can pass a list of comma-separated prompts to extract different information from the image.",
+            required=False,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="url",
+            display_name="URL",
+            info="The image URL. Not required if file_store_key is specified.",
+            required=False,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="file_store_key",
+            display_name="File Store Key",
+            info="The key used to store the image on Jigsawstack File Storage. Not required if url is specified.",
+            required=False,
+            tool_mode=True,
+        ),
+        BoolInput(
+            name="annotated_image",
+            display_name="Return Annotated Image",
+            info="If true, will return an url for annotated image with detected objects.",
+            required=False,
+            value=True,
+        ),
+        DropdownInput(
+            name="features",
+            display_name="Features",
+            info="Select the features to enable for object detection",
+            required=False,
+            options=["object_detection", "gui"],
+            value=["object_detection", "gui"],
+        ),
+        DropdownInput(
+            name="return_type",
+            display_name="Return Type",
+            info="Select the return type for the object detection results such as masks or annotations.",
+            required=False,
+            options=["url", "base64"],
+            value="url",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Object Detection results", name="object_detection_results", method="detect_objects"),
+    ]
+
+    def detect_objects(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
+            params = {}
+            if self.prompts:
+                if isinstance(self.prompts, list):
+                    params["prompt"] = self.prompts
+                elif isinstance(self.prompts, str):
+                    if "," in self.prompts:
+                        # Split by comma and strip whitespace
+                        params["prompt"] = [p.strip() for p in self.prompts.split(",")]
+                    else:
+                        params["prompt"] = [self.prompts.strip()]
+                else:
+                    invalid_prompt_error = "Prompt must be a list of strings or a single string"
+                    raise ValueError(invalid_prompt_error)
+            if self.url:
+                params["url"] = self.url
+            if self.file_store_key:
+                params["file_store_key"] = self.file_store_key
+
+            # if both url and file_store_key are not provided, raise an error
+            if not self.url and not self.file_store_key:
+                missing_url_error = "Either URL or File Store Key must be provided to perform object detection"
+                raise ValueError(missing_url_error)
+
+            params["annotated_image"] = self.annotated_image
+            if self.features:
+                params["features"] = self.features
+
+            # Call web scraping
+            response = client.vision.object_detection(params)
+
+            if not response.get("success", False):
+                failed_response_error = "JigsawStack API returned unsuccessful response"
+                raise ValueError(failed_response_error)
+
+            return Data(data=response)
+
+        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/sentiment.py

@@ -0,0 +1,112 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output, SecretStrInput
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+
+
+class JigsawStackSentimentComponent(Component):
+    display_name = "Sentiment Analysis"
+    description = "Analyze sentiment of text using JigsawStack AI"
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/sentiment"
+    icon = "JigsawStack"
+    name = "JigsawStackSentiment"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        MessageTextInput(
+            name="text",
+            display_name="Text",
+            info="Text to analyze for sentiment",
+            required=True,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Sentiment Data", name="sentiment_data", method="analyze_sentiment"),
+        Output(display_name="Sentiment Text", name="sentiment_text", method="get_sentiment_text"),
+    ]
+
+    def analyze_sentiment(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)
+            response = client.sentiment({"text": self.text})
+
+            api_error_msg = "JigsawStack API returned unsuccessful response"
+            if not response.get("success", False):
+                raise ValueError(api_error_msg)
+
+            sentiment_data = response.get("sentiment", {})
+
+            result_data = {
+                "text_analyzed": self.text,
+                "sentiment": sentiment_data.get("sentiment", "Unknown"),
+                "emotion": sentiment_data.get("emotion", "Unknown"),
+                "score": sentiment_data.get("score", 0.0),
+                "sentences": response.get("sentences", []),
+                "success": True,
+            }
+
+            self.status = (
+                f"Sentiment: {sentiment_data.get('sentiment', 'Unknown')} | "
+                f"Emotion: {sentiment_data.get('emotion', 'Unknown')} | "
+                f"Score: {sentiment_data.get('score', 0.0):.3f}"
+            )
+
+            return Data(data=result_data)
+
+        except JigsawStackError as e:
+            error_data = {"error": str(e), "text_analyzed": self.text, "success": False}
+            self.status = f"Error: {e!s}"
+            return Data(data=error_data)
+
+    def get_sentiment_text(self) -> Message:
+        try:
+            from jigsawstack import JigsawStack, JigsawStackError
+        except ImportError:
+            return Message(text="Error: JigsawStack package not found. Please install it with: pip install jigsawstack")
+
+        try:
+            client = JigsawStack(api_key=self.api_key)
+            response = client.sentiment({"text": self.text})
+
+            sentiment_data = response.get("sentiment", {})
+            sentences = response.get("sentences", [])
+
+            # Format the output
+            formatted_output = f"""Sentiment Analysis Results:
+
+Text: {self.text}
+
+Overall Sentiment: {sentiment_data.get("sentiment", "Unknown")}
+Emotion: {sentiment_data.get("emotion", "Unknown")}
+Score: {sentiment_data.get("score", 0.0):.3f}
+
+Sentence-by-sentence Analysis:
+"""
+
+            for i, sentence in enumerate(sentences, 1):
+                formatted_output += (
+                    f"{i}. {sentence.get('text', '')}\n"
+                    f"   Sentiment: {sentence.get('sentiment', 'Unknown')} | "
+                    f"Emotion: {sentence.get('emotion', 'Unknown')} | "
+                    f"Score: {sentence.get('score', 0.0):.3f}\n"
+                )
+
+            return Message(text=formatted_output)
+
+        except JigsawStackError as e:
+            return Message(text=f"Error analyzing sentiment: {e!s}")

lfx/components/jigsawstack/text_to_sql.py

@@ -0,0 +1,90 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output, QueryInput, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class JigsawStackTextToSQLComponent(Component):
+    display_name = "Text to SQL"
+    description = "Convert natural language to SQL queries using JigsawStack AI"
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/text-to-sql"
+    icon = "JigsawStack"
+    name = "JigsawStackTextToSQL"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        QueryInput(
+            name="prompt",
+            display_name="Prompt",
+            info="Natural language description of the SQL query you want to generate",
+            required=True,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="sql_schema",
+            display_name="SQL Schema",
+            info=(
+                "The database schema information. Can be a CREATE TABLE statement or schema description. "
+                "Specifying this parameter improves SQL generation accuracy by applying "
+                "database-specific syntax and optimizations."
+            ),
+            required=False,
+            tool_mode=True,
+        ),
+        StrInput(
+            name="file_store_key",
+            display_name="File Store Key",
+            info=(
+                "The key used to store the database schema on Jigsawstack file Storage. "
+                "Not required if sql_schema is specified."
+            ),
+            required=False,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="SQL Query", name="sql_query", method="generate_sql"),
+    ]
+
+    def generate_sql(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:
+            schema_error = "Either 'sql_schema' or 'file_store_key' must be provided"
+            if not self.sql_schema and not self.file_store_key:
+                raise ValueError(schema_error)
+
+            # build request object
+            params = {"prompt": self.prompt}
+
+            if self.sql_schema:
+                params["sql_schema"] = self.sql_schema
+            if self.file_store_key:
+                params["file_store_key"] = self.file_store_key
+
+            client = JigsawStack(api_key=self.api_key)
+            response = client.text_to_sql(params)
+
+            api_error_msg = "JigsawStack API returned unsuccessful response"
+            if not response.get("success", False):
+                raise ValueError(api_error_msg)
+
+            return Data(data=response)
+
+        except ValueError:
+            raise
+        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/text_translate.py

@@ -0,0 +1,77 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class JigsawStackTextTranslateComponent(Component):
+    display_name = "Text Translate"
+    description = "Translate text from one language to another with support for multiple text formats."
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/translate"
+    icon = "JigsawStack"
+    name = "JigsawStackTextTranslate"
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        StrInput(
+            name="target_language",
+            display_name="Target Language",
+            info="The language code of the target language to translate to. \
+                Language code is identified by a unique ISO 639-1 two-letter code",
+            required=True,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="text",
+            display_name="Text",
+            info="The text to translate. This can be a single string or a list of strings. \
+                If a list is provided, each string will be translated separately.",
+            required=True,
+            is_list=True,
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Translation Results", name="translation_results", method="translation"),
+    ]
+
+    def translation(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
+            params = {}
+            if self.target_language:
+                params["target_language"] = self.target_language
+
+            if self.text:
+                if isinstance(self.text, list):
+                    params["text"] = self.text
+                else:
+                    params["text"] = [self.text]
+
+            # Call web scraping
+            response = client.translate.text(params)
+
+            if not response.get("success", False):
+                failed_response_error = "JigsawStack API returned unsuccessful response"
+                raise ValueError(failed_response_error)
+
+            return Data(data=response)
+
+        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/vocr.py

@@ -0,0 +1,107 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import IntInput, MessageTextInput, Output, SecretStrInput, StrInput
+from lfx.schema.data import Data
+
+
+class JigsawStackVOCRComponent(Component):
+    display_name = "VOCR"
+    description = "Extract data from any document type in a consistent structure with fine-tuned \
+        vLLMs for the highest accuracy"
+    documentation = "https://jigsawstack.com/docs/api-reference/ai/vocr"
+    icon = "JigsawStack"
+    name = "JigsawStackVOCR"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="JigsawStack API Key",
+            info="Your JigsawStack API key for authentication",
+            required=True,
+        ),
+        MessageTextInput(
+            name="prompts",
+            display_name="Prompts",
+            info="The prompts used to describe the image. Default prompt is Describe the image in detail. \
+                You can pass a list of comma-separated prompts to extract different information from the image.",
+            required=False,
+            tool_mode=True,
+        ),
+        StrInput(
+            name="url",
+            display_name="URL",
+            info="The image or document url. Not required if file_store_key is specified.",
+            required=False,
+            tool_mode=True,
+        ),
+        StrInput(
+            name="file_store_key",
+            display_name="File Store Key",
+            info="The key used to store the image on Jigsawstack File Storage. Not required if url is specified.",
+            required=False,
+            tool_mode=True,
+        ),
+        IntInput(
+            name="page_range_start",
+            display_name="Page Range",
+            info="Page range start limit for the document. If not specified, all pages will be processed.",
+            required=False,
+        ),
+        IntInput(
+            name="page_range_end",
+            display_name="Page Range End",
+            info="Page range end limit for the document. If not specified, all pages will be processed.",
+            required=False,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="VOCR results", name="vocr_results", method="vocr"),
+    ]
+
+    def vocr(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
+            params = {}
+            if self.prompts:
+                if isinstance(self.prompts, list):
+                    params["prompt"] = self.prompts
+                elif isinstance(self.prompts, str):
+                    if "," in self.prompts:
+                        # Split by comma and strip whitespace
+                        params["prompt"] = [p.strip() for p in self.prompts.split(",")]
+                    else:
+                        params["prompt"] = [self.prompts.strip()]
+                else:
+                    invalid_prompt_error = "Prompt must be a list of strings or a single string"
+                    raise ValueError(invalid_prompt_error)
+            if self.url:
+                params["url"] = self.url
+            if self.file_store_key:
+                params["file_store_key"] = self.file_store_key
+
+            if self.page_range_start and self.page_range_end:
+                params["page_range"] = [self.page_range_start, self.page_range_end]
+
+            # Call VOCR
+            response = client.vision.vocr(params)
+
+            if not response.get("success", False):
+                failed_response_error = "JigsawStack API returned unsuccessful response"
+                raise ValueError(failed_response_error)
+
+            return Data(data=response)
+
+        except JigsawStackError as e:
+            error_data = {"error": str(e), "success": False}
+            self.status = f"Error: {e!s}"
+            return Data(data=error_data)

lfx/components/langchain_utilities/__init__.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .character import CharacterTextSplitterComponent
+    from .conversation import ConversationChainComponent
+    from .csv_agent import CSVAgentComponent
+    from .fake_embeddings import FakeEmbeddingsComponent
+    from .html_link_extractor import HtmlLinkExtractorComponent
+    from .json_agent import JsonAgentComponent
+    from .langchain_hub import LangChainHubPromptComponent
+    from .language_recursive import LanguageRecursiveTextSplitterComponent
+    from .language_semantic import SemanticTextSplitterComponent
+    from .llm_checker import LLMCheckerChainComponent
+    from .llm_math import LLMMathChainComponent
+    from .natural_language import NaturalLanguageTextSplitterComponent
+    from .openai_tools import OpenAIToolsAgentComponent
+    from .openapi import OpenAPIAgentComponent
+    from .recursive_character import RecursiveCharacterTextSplitterComponent
+    from .retrieval_qa import RetrievalQAComponent
+    from .runnable_executor import RunnableExecComponent
+    from .self_query import SelfQueryRetrieverComponent
+    from .spider import SpiderTool
+    from .sql import SQLAgentComponent
+    from .sql_database import SQLDatabaseComponent
+    from .sql_generator import SQLGeneratorComponent
+    from .tool_calling import ToolCallingAgentComponent
+    from .vector_store_info import VectorStoreInfoComponent
+    from .vector_store_router import VectorStoreRouterAgentComponent
+    from .xml_agent import XMLAgentComponent
+
+_dynamic_imports = {
+    "CharacterTextSplitterComponent": "character",
+    "ConversationChainComponent": "conversation",
+    "CSVAgentComponent": "csv_agent",
+    "FakeEmbeddingsComponent": "fake_embeddings",
+    "HtmlLinkExtractorComponent": "html_link_extractor",
+    "JsonAgentComponent": "json_agent",
+    "LangChainHubPromptComponent": "langchain_hub",
+    "LanguageRecursiveTextSplitterComponent": "language_recursive",
+    "LLMCheckerChainComponent": "llm_checker",
+    "LLMMathChainComponent": "llm_math",
+    "NaturalLanguageTextSplitterComponent": "natural_language",
+    "OpenAIToolsAgentComponent": "openai_tools",
+    "OpenAPIAgentComponent": "openapi",
+    "RecursiveCharacterTextSplitterComponent": "recursive_character",
+    "RetrievalQAComponent": "retrieval_qa",
+    "RunnableExecComponent": "runnable_executor",
+    "SelfQueryRetrieverComponent": "self_query",
+    "SemanticTextSplitterComponent": "language_semantic",
+    "SpiderTool": "spider",
+    "SQLAgentComponent": "sql",
+    "SQLDatabaseComponent": "sql_database",
+    "SQLGeneratorComponent": "sql_generator",
+    "ToolCallingAgentComponent": "tool_calling",
+    "VectorStoreInfoComponent": "vector_store_info",
+    "VectorStoreRouterAgentComponent": "vector_store_router",
+    "XMLAgentComponent": "xml_agent",
+}
+
+__all__ = [
+    "CSVAgentComponent",
+    "CharacterTextSplitterComponent",
+    "ConversationChainComponent",
+    "FakeEmbeddingsComponent",
+    "HtmlLinkExtractorComponent",
+    "JsonAgentComponent",
+    "LLMCheckerChainComponent",
+    "LLMMathChainComponent",
+    "LangChainHubPromptComponent",
+    "LanguageRecursiveTextSplitterComponent",
+    "NaturalLanguageTextSplitterComponent",
+    "OpenAIToolsAgentComponent",
+    "OpenAPIAgentComponent",
+    "RecursiveCharacterTextSplitterComponent",
+    "RetrievalQAComponent",
+    "RunnableExecComponent",
+    "SQLAgentComponent",
+    "SQLDatabaseComponent",
+    "SQLGeneratorComponent",
+    "SelfQueryRetrieverComponent",
+    "SemanticTextSplitterComponent",
+    "SpiderTool",
+    "ToolCallingAgentComponent",
+    "VectorStoreInfoComponent",
+    "VectorStoreRouterAgentComponent",
+    "XMLAgentComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import langchain 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__)