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

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/knowledge_bases/__init__.py

@@ -0,0 +1,89 @@
+"""Knowledge bases module - backwards compatibility alias for files_and_knowledge.
+
+This module provides backwards compatibility by forwarding all imports
+to files_and_knowledge where the actual knowledge base components are located.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.files_and_knowledge.ingestion import KnowledgeIngestionComponent
+    from lfx.components.files_and_knowledge.retrieval import KnowledgeRetrievalComponent
+
+_dynamic_imports = {
+    "KnowledgeIngestionComponent": "ingestion",
+    "KnowledgeRetrievalComponent": "retrieval",
+}
+
+__all__ = ["KnowledgeIngestionComponent", "KnowledgeRetrievalComponent"]
+
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.knowledge_bases.ingestion
+_redirected_submodules = {
+    "lfx.components.knowledge_bases.ingestion": "lfx.components.files_and_knowledge.ingestion",
+    "lfx.components.knowledge_bases.retrieval": "lfx.components.files_and_knowledge.retrieval",
+}
+
+for old_path, new_path in _redirected_submodules.items():
+    if old_path not in sys.modules:
+        # Use a lazy loader that imports the actual module when accessed
+        class _RedirectedModule:
+            def __init__(self, target_path: str, original_path: str):
+                self._target_path = target_path
+                self._original_path = original_path
+                self._module = None
+
+            def __getattr__(self, name: str) -> Any:
+                if self._module is None:
+                    from importlib import import_module
+
+                    self._module = import_module(self._target_path)
+                    # Also register under the original path for future imports
+                    sys.modules[self._original_path] = self._module
+                return getattr(self._module, name)
+
+            def __repr__(self) -> str:
+                return f"<redirected module '{self._original_path}' -> '{self._target_path}'>"
+
+        sys.modules[old_path] = _RedirectedModule(new_path, old_path)
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Forward attribute access to files_and_knowledge components."""
+    # Handle submodule access for backwards compatibility
+    if attr_name == "ingestion":
+        from importlib import import_module
+
+        result = import_module("lfx.components.files_and_knowledge.ingestion")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "retrieval":
+        from importlib import import_module
+
+        result = import_module("lfx.components.files_and_knowledge.retrieval")
+        globals()[attr_name] = result
+        return result
+
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+
+    # Import from files_and_knowledge using the correct package path
+    package = "lfx.components.files_and_knowledge"
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], package)
+    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 directory of available components."""
+    return list(__all__)

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__)

lfx/components/langchain_utilities/character.py

@@ -0,0 +1,53 @@
+from typing import Any
+
+from langchain_text_splitters import CharacterTextSplitter, TextSplitter
+
+from lfx.base.textsplitters.model import LCTextSplitterComponent
+from lfx.inputs.inputs import DataInput, IntInput, MessageTextInput
+from lfx.utils.util import unescape_string
+
+
+class CharacterTextSplitterComponent(LCTextSplitterComponent):
+    display_name = "Character Text Splitter"
+    description = "Split text by number of characters."
+    documentation = "https://docs.langflow.org/bundles-langchain"
+    name = "CharacterTextSplitter"
+    icon = "LangChain"
+
+    inputs = [
+        IntInput(
+            name="chunk_size",
+            display_name="Chunk Size",
+            info="The maximum length of each chunk.",
+            value=1000,
+        ),
+        IntInput(
+            name="chunk_overlap",
+            display_name="Chunk Overlap",
+            info="The amount of overlap between chunks.",
+            value=200,
+        ),
+        DataInput(
+            name="data_input",
+            display_name="Input",
+            info="The texts to split.",
+            input_types=["Document", "Data"],
+            required=True,
+        ),
+        MessageTextInput(
+            name="separator",
+            display_name="Separator",
+            info='The characters to split on.\nIf left empty defaults to "\\n\\n".',
+        ),
+    ]
+
+    def get_data_input(self) -> Any:
+        return self.data_input
+
+    def build_text_splitter(self) -> TextSplitter:
+        separator = unescape_string(self.separator) if self.separator else "\n\n"
+        return CharacterTextSplitter(
+            chunk_overlap=self.chunk_overlap,
+            chunk_size=self.chunk_size,
+            separator=separator,
+        )