langflow-base-nightly 0.5.1.dev3__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/components/jigsawstack/sentiment.py

@@ -1,112 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import MessageTextInput, Output, SecretStrInput
-from langflow.schema.data import Data
-from langflow.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}")

langflow/components/jigsawstack/text_to_sql.py

@@ -1,90 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import MessageTextInput, Output, QueryInput, SecretStrInput, StrInput
-from langflow.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)

langflow/components/jigsawstack/text_translate.py

@@ -1,77 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import MessageTextInput, Output, SecretStrInput, StrInput
-from langflow.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)

langflow/components/jigsawstack/vocr.py

@@ -1,107 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import IntInput, MessageTextInput, Output, SecretStrInput, StrInput
-from langflow.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)

langflow/components/langchain_utilities/__init__.py

@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.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__)

langflow/components/langchain_utilities/character.py

@@ -1,53 +0,0 @@
-from typing import Any
-
-from langchain_text_splitters import CharacterTextSplitter, TextSplitter
-
-from langflow.base.textsplitters.model import LCTextSplitterComponent
-from langflow.inputs.inputs import DataInput, IntInput, MessageTextInput
-from langflow.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/components/text-splitters#charactertextsplitter"
-    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,
-        )

langflow/components/langchain_utilities/conversation.py

@@ -1,52 +0,0 @@
-from langchain.chains import ConversationChain
-
-from langflow.base.chains.model import LCChainComponent
-from langflow.inputs.inputs import HandleInput, MultilineInput
-from langflow.schema.message import Message
-
-
-class ConversationChainComponent(LCChainComponent):
-    display_name = "ConversationChain"
-    description = "Chain to have a conversation and load context from memory."
-    name = "ConversationChain"
-    legacy: bool = True
-    icon = "LangChain"
-
-    inputs = [
-        MultilineInput(
-            name="input_value",
-            display_name="Input",
-            info="The input value to pass to the chain.",
-            required=True,
-        ),
-        HandleInput(
-            name="llm",
-            display_name="Language Model",
-            input_types=["LanguageModel"],
-            required=True,
-        ),
-        HandleInput(
-            name="memory",
-            display_name="Memory",
-            input_types=["BaseChatMemory"],
-        ),
-    ]
-
-    def invoke_chain(self) -> Message:
-        if not self.memory:
-            chain = ConversationChain(llm=self.llm)
-        else:
-            chain = ConversationChain(llm=self.llm, memory=self.memory)
-
-        result = chain.invoke(
-            {"input": self.input_value},
-            config={"callbacks": self.get_langchain_callbacks()},
-        )
-        if isinstance(result, dict):
-            result = result.get(chain.output_key, "")
-
-        elif not isinstance(result, str):
-            result = result.get("response")
-        result = str(result)
-        self.status = result
-        return Message(text=result)