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

langflow/components/datastax/run.py

@@ -1,89 +0,0 @@
-from typing import Any
-
-from openai.lib.streaming import AssistantEventHandler
-
-from langflow.base.astra_assistants.util import get_patched_openai_client
-from langflow.custom.custom_component.component_with_cache import ComponentWithCache
-from langflow.inputs.inputs import MultilineInput
-from langflow.schema.dotdict import dotdict
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class AssistantsRun(ComponentWithCache):
-    display_name = "Run Assistant"
-    description = "Executes an Assistant Run against a thread"
-    icon = "AstraDB"
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        self.client = get_patched_openai_client(self._shared_component_cache)
-        self.thread_id = None
-
-    def update_build_config(
-        self,
-        build_config: dotdict,
-        field_value: Any,
-        field_name: str | None = None,
-    ) -> None:
-        if field_name == "thread_id":
-            if field_value is None:
-                thread = self.client.beta.threads.create()
-                self.thread_id = thread.id
-            build_config["thread_id"] = field_value
-
-    inputs = [
-        MultilineInput(
-            name="assistant_id",
-            display_name="Assistant ID",
-            info=(
-                "The ID of the assistant to run. \n\n"
-                "Can be retrieved using the List Assistants component or created with the Create Assistant component."
-            ),
-        ),
-        MultilineInput(
-            name="user_message",
-            display_name="User Message",
-            info="User message to pass to the run.",
-        ),
-        MultilineInput(
-            name="thread_id",
-            display_name="Thread ID",
-            required=False,
-            info="Thread ID to use with the run. If not provided, a new thread will be created.",
-        ),
-        MultilineInput(
-            name="env_set",
-            display_name="Environment Set",
-            info="Dummy input to allow chaining with Dotenv Component.",
-        ),
-    ]
-
-    outputs = [Output(display_name="Assistant Response", name="assistant_response", method="process_inputs")]
-
-    def process_inputs(self) -> Message:
-        text = ""
-
-        if self.thread_id is None:
-            thread = self.client.beta.threads.create()
-            self.thread_id = thread.id
-
-        # add the user message
-        self.client.beta.threads.messages.create(thread_id=self.thread_id, role="user", content=self.user_message)
-
-        class EventHandler(AssistantEventHandler):
-            def __init__(self) -> None:
-                super().__init__()
-
-            def on_exception(self, exception: Exception) -> None:
-                raise exception
-
-        event_handler = EventHandler()
-        with self.client.beta.threads.runs.create_and_stream(
-            thread_id=self.thread_id,
-            assistant_id=self.assistant_id,
-            event_handler=event_handler,
-        ) as stream:
-            for part in stream.text_deltas:
-                text += part
-        return Message(text=text)

langflow/components/deactivated/__init__.py

@@ -1,19 +0,0 @@
-from .extract_key_from_data import ExtractKeyFromDataComponent
-from .list_flows import ListFlowsComponent
-from .merge_data import MergeDataComponent
-from .selective_passthrough import SelectivePassThroughComponent
-from .split_text import SplitTextComponent
-from .sub_flow import SubFlowComponent
-
-__all__ = [
-    "ExtractKeyFromDataComponent",
-    "FlowToolComponent",
-    "ListFlowsComponent",
-    "MergeDataComponent",
-    "PythonFunctionComponent",
-    "RunFlowComponent",
-    "SQLExecutorComponent",
-    "SelectivePassThroughComponent",
-    "SplitTextComponent",
-    "SubFlowComponent",
-]

langflow/components/deactivated/amazon_kendra.py

@@ -1,66 +0,0 @@
-# mypy: disable-error-code="attr-defined"
-from langchain_community.retrievers import AmazonKendraRetriever
-
-from langflow.base.vectorstores.model import check_cached_vector_store
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.io import DictInput, IntInput, StrInput
-
-
-class AmazonKendraRetrieverComponent(CustomComponent):
-    display_name: str = "Amazon Kendra Retriever"
-    description: str = "Retriever that uses the Amazon Kendra API."
-    name = "AmazonKendra"
-    icon = "Amazon"
-    legacy = True
-
-    inputs = [
-        StrInput(
-            name="index_id",
-            display_name="Index ID",
-        ),
-        StrInput(
-            name="region_name",
-            display_name="Region Name",
-        ),
-        StrInput(
-            name="credentials_profile_name",
-            display_name="Credentials Profile Name",
-        ),
-        DictInput(
-            name="attribute_filter",
-            display_name="Attribute Filter",
-        ),
-        IntInput(
-            name="top_k",
-            display_name="Top K",
-            value=3,
-        ),
-        DictInput(
-            name="user_context",
-            display_name="User Context",
-        ),
-    ]
-
-    @check_cached_vector_store
-    def build_vector_store(self) -> AmazonKendraRetriever:
-        """Builds the Amazon Kendra Retriever."""
-        try:
-            from langchain_community.retrievers import AmazonKendraRetriever
-        except ImportError as e:
-            msg = "Could not import AmazonKendraRetriever. Please install it with `pip install langchain-community`."
-            raise ImportError(msg) from e
-
-        try:
-            output = AmazonKendraRetriever(
-                index_id=self.index_id,
-                top_k=self.top_k,
-                region_name=self.region_name,
-                credentials_profile_name=self.credentials_profile_name,
-                attribute_filter=self.attribute_filter,
-                user_context=self.user_context,
-            )
-        except Exception as e:
-            msg = "Could not connect to AmazonKendra API."
-            raise ValueError(msg) from e
-
-        return output

langflow/components/deactivated/chat_litellm_model.py

@@ -1,158 +0,0 @@
-from langchain_community.chat_models.litellm import ChatLiteLLM, ChatLiteLLMException
-
-from langflow.base.constants import STREAM_INFO_TEXT
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import LanguageModel
-from langflow.io import (
-    BoolInput,
-    DictInput,
-    DropdownInput,
-    FloatInput,
-    IntInput,
-    MessageInput,
-    SecretStrInput,
-    StrInput,
-)
-
-
-class ChatLiteLLMModelComponent(LCModelComponent):
-    display_name = "LiteLLM"
-    description = "`LiteLLM` collection of large language models."
-    documentation = "https://python.langchain.com/docs/integrations/chat/litellm"
-    icon = "🚄"
-
-    inputs = [
-        MessageInput(name="input_value", display_name="Input"),
-        StrInput(
-            name="model",
-            display_name="Model name",
-            advanced=False,
-            required=True,
-            info="The name of the model to use. For example, `gpt-3.5-turbo`.",
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="API Key",
-            advanced=False,
-            required=False,
-        ),
-        DropdownInput(
-            name="provider",
-            display_name="Provider",
-            info="The provider of the API key.",
-            options=[
-                "OpenAI",
-                "Azure",
-                "Anthropic",
-                "Replicate",
-                "Cohere",
-                "OpenRouter",
-            ],
-        ),
-        FloatInput(
-            name="temperature",
-            display_name="Temperature",
-            advanced=False,
-            required=False,
-            value=0.7,
-        ),
-        DictInput(
-            name="kwargs",
-            display_name="Kwargs",
-            advanced=True,
-            required=False,
-            is_list=True,
-            value={},
-        ),
-        DictInput(
-            name="model_kwargs",
-            display_name="Model kwargs",
-            advanced=True,
-            required=False,
-            is_list=True,
-            value={},
-        ),
-        FloatInput(name="top_p", display_name="Top p", advanced=True, required=False, value=0.5),
-        IntInput(name="top_k", display_name="Top k", advanced=True, required=False, value=35),
-        IntInput(
-            name="n",
-            display_name="N",
-            advanced=True,
-            required=False,
-            info="Number of chat completions to generate for each prompt. "
-            "Note that the API may not return the full n completions if duplicates are generated.",
-            value=1,
-        ),
-        IntInput(
-            name="max_tokens",
-            display_name="Max tokens",
-            advanced=False,
-            value=256,
-            info="The maximum number of tokens to generate for each chat completion.",
-        ),
-        IntInput(
-            name="max_retries",
-            display_name="Max retries",
-            advanced=True,
-            required=False,
-            value=6,
-        ),
-        BoolInput(
-            name="verbose",
-            display_name="Verbose",
-            advanced=True,
-            required=False,
-            value=False,
-        ),
-        BoolInput(
-            name="stream",
-            display_name="Stream",
-            info=STREAM_INFO_TEXT,
-            advanced=True,
-        ),
-        StrInput(
-            name="system_message",
-            display_name="System Message",
-            info="System message to pass to the model.",
-            advanced=True,
-        ),
-    ]
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        try:
-            import litellm
-
-            litellm.drop_params = True
-            litellm.set_verbose = self.verbose
-        except ImportError as e:
-            msg = "Could not import litellm python package. Please install it with `pip install litellm`"
-            raise ChatLiteLLMException(msg) from e
-        # Remove empty keys
-        if "" in self.kwargs:
-            del self.kwargs[""]
-        if "" in self.model_kwargs:
-            del self.model_kwargs[""]
-        # Report missing fields for Azure provider
-        if self.provider == "Azure":
-            if "api_base" not in self.kwargs:
-                msg = "Missing api_base on kwargs"
-                raise ValueError(msg)
-            if "api_version" not in self.model_kwargs:
-                msg = "Missing api_version on model_kwargs"
-                raise ValueError(msg)
-        output = ChatLiteLLM(
-            model=f"{self.provider.lower()}/{self.model}",
-            client=None,
-            streaming=self.stream,
-            temperature=self.temperature,
-            model_kwargs=self.model_kwargs if self.model_kwargs is not None else {},
-            top_p=self.top_p,
-            top_k=self.top_k,
-            n=self.n,
-            max_tokens=self.max_tokens,
-            max_retries=self.max_retries,
-            **self.kwargs,
-        )
-        output.client.api_key = self.api_key
-
-        return output

langflow/components/deactivated/code_block_extractor.py

@@ -1,26 +0,0 @@
-import re
-
-from langflow.custom.custom_component.component import Component
-from langflow.field_typing import Input, Output, Text
-
-
-class CodeBlockExtractor(Component):
-    display_name = "Code Block Extractor"
-    description = "Extracts code block from text."
-    name = "CodeBlockExtractor"
-
-    inputs = [Input(name="text", field_type=Text, description="Text to extract code blocks from.")]
-
-    outputs = [Output(name="code_block", display_name="Code Block", method="get_code_block")]
-
-    def get_code_block(self) -> Text:
-        text = self.text.strip()
-        # Extract code block
-        # It may start with ``` or ```language
-        # It may end with ```
-        pattern = r"^```(?:\w+)?\s*\n(.*?)(?=^```)```"
-        match = re.search(pattern, text, re.MULTILINE)
-        code_block = ""
-        if match:
-            code_block = match.group(1)
-        return code_block

langflow/components/deactivated/documents_to_data.py

@@ -1,22 +0,0 @@
-from langchain_core.documents import Document
-
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.schema.data import Data
-
-
-class DocumentsToDataComponent(CustomComponent):
-    display_name = "Documents ⇢ Data"
-    description = "Convert LangChain Documents into Data."
-    icon = "LangChain"
-    name = "DocumentsToData"
-
-    field_config = {
-        "documents": {"display_name": "Documents"},
-    }
-
-    def build(self, documents: list[Document]) -> list[Data]:
-        if isinstance(documents, Document):
-            documents = [documents]
-        data = [Data.from_document(document) for document in documents]
-        self.status = data
-        return data

langflow/components/deactivated/embed.py

@@ -1,16 +0,0 @@
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.field_typing import Embeddings
-from langflow.schema.data import Data
-
-
-class EmbedComponent(CustomComponent):
-    display_name = "Embed Texts"
-    name = "Embed"
-
-    def build_config(self):
-        return {"texts": {"display_name": "Texts"}, "embbedings": {"display_name": "Embeddings"}}
-
-    def build(self, texts: list[str], embbedings: Embeddings) -> Data:
-        vectors = Data(vector=embbedings.embed_documents(texts))
-        self.status = vectors
-        return vectors

langflow/components/deactivated/extract_key_from_data.py

@@ -1,46 +0,0 @@
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.schema.data import Data
-
-
-class ExtractKeyFromDataComponent(CustomComponent):
-    display_name = "Extract Key From Data"
-    description = "Extracts a key from a data."
-    beta: bool = True
-    name = "ExtractKeyFromData"
-
-    field_config = {
-        "data": {"display_name": "Data"},
-        "keys": {
-            "display_name": "Keys",
-            "info": "The keys to extract from the data.",
-            "input_types": [],
-        },
-        "silent_error": {
-            "display_name": "Silent Errors",
-            "info": "If True, errors will not be raised.",
-            "advanced": True,
-        },
-    }
-
-    def build(self, data: Data, keys: list[str], *, silent_error: bool = True) -> Data:
-        """Extracts the keys from a data.
-
-        Args:
-            data (Data): The data from which to extract the keys.
-            keys (list[str]): The keys to extract from the data.
-            silent_error (bool): If True, errors will not be raised.
-
-        Returns:
-            dict: The extracted keys.
-        """
-        extracted_keys = {}
-        for key in keys:
-            try:
-                extracted_keys[key] = getattr(data, key)
-            except AttributeError as e:
-                if not silent_error:
-                    msg = f"The key '{key}' does not exist in the data."
-                    raise KeyError(msg) from e
-        return_data = Data(data=extracted_keys)
-        self.status = return_data
-        return return_data

langflow/components/deactivated/json_document_builder.py

@@ -1,59 +0,0 @@
-# JSON Document Builder
-
-# Build a Document containing a JSON object using a key and another Document page content.
-
-# **Params**
-
-# - **Key:** The key to use for the JSON object.
-# - **Document:** The Document page to use for the JSON object.
-
-# **Output**
-
-# - **Document:** The Document containing the JSON object.
-
-
-from langchain_core.documents import Document
-
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.io import HandleInput, StrInput
-from langflow.services.database.models.base import orjson_dumps
-
-
-class JSONDocumentBuilder(CustomComponent):
-    display_name: str = "JSON Document Builder"
-    description: str = "Build a Document containing a JSON object using a key and another Document page content."
-    name = "JSONDocumentBuilder"
-    documentation: str = "https://docs.langflow.org/components/utilities#json-document-builder"
-    legacy = True
-
-    inputs = [
-        StrInput(
-            name="key",
-            display_name="Key",
-            required=True,
-        ),
-        HandleInput(
-            name="document",
-            display_name="Document",
-            required=True,
-        ),
-    ]
-
-    def build(
-        self,
-        key: str,
-        document: Document,
-    ) -> Document:
-        documents = None
-        if isinstance(document, list):
-            documents = [
-                Document(page_content=orjson_dumps({key: doc.page_content}, indent_2=False)) for doc in document
-            ]
-        elif isinstance(document, Document):
-            documents = Document(page_content=orjson_dumps({key: document.page_content}, indent_2=False))
-        else:
-            msg = f"Expected Document or list of Documents, got {type(document)}"
-            raise TypeError(msg)
-
-        self.repr_value = documents
-        return documents

langflow/components/deactivated/list_flows.py

@@ -1,20 +0,0 @@
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.schema.data import Data
-
-
-class ListFlowsComponent(CustomComponent):
-    display_name = "List Flows"
-    description = "A component to list all available flows."
-    icon = "ListFlows"
-    beta: bool = True
-    name = "ListFlows"
-
-    def build_config(self):
-        return {}
-
-    async def build(
-        self,
-    ) -> list[Data]:
-        flows = await self.alist_flows()
-        self.status = flows
-        return flows

langflow/components/deactivated/mcp_sse.py

@@ -1,61 +0,0 @@
-# from langflow.field_typing import Data
-
-from langchain_core.tools import StructuredTool
-from mcp import types
-
-from langflow.base.mcp.util import (
-    MCPSseClient,
-    create_input_schema_from_json_schema,
-    create_tool_coroutine,
-    create_tool_func,
-)
-from langflow.custom.custom_component.component import Component
-from langflow.field_typing import Tool
-from langflow.io import MessageTextInput, Output
-
-
-class MCPSse(Component):
-    client = MCPSseClient()
-    tools = types.ListToolsResult
-    tool_names = [str]
-    display_name = "MCP Tools (SSE) [DEPRECATED]"
-    description = "Connects to an MCP server over SSE and exposes it's tools as langflow tools to be used by an Agent."
-    documentation: str = "https://docs.langflow.org/components-custom-components"
-    icon = "code"
-    name = "MCPSse"
-    legacy = True
-
-    inputs = [
-        MessageTextInput(
-            name="url",
-            display_name="mcp sse url",
-            info="sse url",
-            value="http://localhost:7860/api/v1/mcp/sse",
-            tool_mode=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Tools", name="tools", method="build_output"),
-    ]
-
-    async def build_output(self) -> list[Tool]:
-        if self.client.session is None:
-            self.tools = await self.client.connect_to_server(self.url, {})
-
-        tool_list = []
-
-        for tool in self.tools:
-            args_schema = create_input_schema_from_json_schema(tool.inputSchema)
-            tool_list.append(
-                StructuredTool(
-                    name=tool.name,  # maybe format this
-                    description=tool.description,
-                    args_schema=args_schema,
-                    func=create_tool_func(tool.name, args_schema, self.client.session),
-                    coroutine=create_tool_coroutine(tool.name, args_schema, self.client.session),
-                )
-            )
-
-        self.tool_names = [tool.name for tool in self.tools]
-        return tool_list

langflow/components/deactivated/mcp_stdio.py

@@ -1,62 +0,0 @@
-# from langflow.field_typing import Data
-
-from langchain_core.tools import StructuredTool
-from mcp import types
-
-from langflow.base.mcp.util import (
-    MCPStdioClient,
-    create_input_schema_from_json_schema,
-    create_tool_coroutine,
-    create_tool_func,
-)
-from langflow.custom.custom_component.component import Component
-from langflow.field_typing import Tool
-from langflow.io import MessageTextInput, Output
-
-
-class MCPStdio(Component):
-    client = MCPStdioClient()
-    tools = types.ListToolsResult
-    tool_names = [str]
-    display_name = "MCP Tools (stdio) [DEPRECATED]"
-    description = (
-        "Connects to an MCP server over stdio and exposes it's tools as langflow tools to be used by an Agent."
-    )
-    documentation: str = "https://docs.langflow.org/components-custom-components"
-    icon = "code"
-    name = "MCPStdio"
-    legacy = True
-
-    inputs = [
-        MessageTextInput(
-            name="command",
-            display_name="mcp command",
-            info="mcp command",
-            value="uvx mcp-sse-shim@latest",
-            tool_mode=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Tools", name="tools", method="build_output"),
-    ]
-
-    async def build_output(self) -> list[Tool]:
-        if self.client.session is None:
-            self.tools = await self.client.connect_to_server(self.command)
-
-        tool_list = []
-
-        for tool in self.tools:
-            args_schema = create_input_schema_from_json_schema(tool.inputSchema)
-            tool_list.append(
-                StructuredTool(
-                    name=tool.name,
-                    description=tool.description,
-                    args_schema=args_schema,
-                    func=create_tool_func(tool.name, args_schema, self.client.session),
-                    coroutine=create_tool_coroutine(tool.name, args_schema, self.client.session),
-                )
-            )
-        self.tool_names = [tool.name for tool in self.tools]
-        return tool_list