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

langflow/components/deactivated/merge_data.py

@@ -1,93 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import DataInput, Output
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-
-
-class MergeDataComponent(Component):
-    """MergeDataComponent is responsible for combining multiple Data objects into a unified list of Data objects.
-
-    It ensures that all keys across the input Data objects are present in each merged Data object.
-    Missing keys are filled with empty strings to maintain consistency.
-    """
-
-    display_name = "Merge Data"
-    description = (
-        "Combines multiple Data objects into a unified list, ensuring all keys are present in each Data object."
-    )
-    icon = "merge"
-
-    inputs = [
-        DataInput(
-            name="data_inputs",
-            display_name="Data Inputs",
-            is_list=True,
-            info="A list of Data inputs objects to be merged.",
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Merged Data",
-            name="merged_data",
-            method="merge_data",
-        ),
-    ]
-
-    def merge_data(self) -> list[Data]:
-        """Merges multiple Data objects into a single list of Data objects.
-
-        Ensures that all keys from the input Data objects are present in each merged Data object.
-        Missing keys are filled with empty strings.
-
-        Returns:
-            List[Data]: A list of merged Data objects with consistent keys.
-        """
-        logger.info("Initiating the data merging process.")
-
-        data_inputs: list[Data] = self.data_inputs
-        logger.debug(f"Received {len(data_inputs)} data input(s) for merging.")
-
-        if not data_inputs:
-            logger.warning("No data inputs provided. Returning an empty list.")
-            return []
-
-        # Collect all unique keys from all Data objects
-        all_keys: set[str] = set()
-        for idx, data_input in enumerate(data_inputs):
-            if not isinstance(data_input, Data):
-                error_message = f"Data input at index {idx} is not of type Data."
-                logger.error(error_message)
-                type_error_message = (
-                    f"All items in data_inputs must be of type Data. Item at index {idx} is {type(data_input)}"
-                )
-                raise TypeError(type_error_message)
-            all_keys.update(data_input.data.keys())
-        logger.debug(f"Collected {len(all_keys)} unique key(s) from input data.")
-
-        try:
-            # Create new list of Data objects with missing keys filled with empty strings
-            merged_data_list = []
-            for idx, data_input in enumerate(data_inputs):
-                merged_data_dict = {}
-
-                for key in all_keys:
-                    # Use the existing value if the key exists, otherwise use an empty string
-                    value = data_input.data.get(key, "")
-                    if key not in data_input.data:
-                        log_message = f"Key '{key}' missing in data input at index {idx}. Assigning empty string."
-                        logger.debug(log_message)
-                    merged_data_dict[key] = value
-
-                merged_data = Data(
-                    text_key=data_input.text_key, data=merged_data_dict, default_value=data_input.default_value
-                )
-                merged_data_list.append(merged_data)
-                logger.debug(f"Merged Data object created for input at index {idx}.")
-
-        except Exception:
-            logger.exception("An error occurred during the data merging process.")
-            raise
-
-        logger.info("Data merging process completed successfully.")
-        return merged_data_list

langflow/components/deactivated/message.py

@@ -1,37 +0,0 @@
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.schema.message import Message
-from langflow.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_USER
-
-
-class MessageComponent(CustomComponent):
-    display_name = "Message"
-    description = "Creates a Message object given a Session ID."
-    name = "Message"
-
-    def build_config(self):
-        return {
-            "sender": {
-                "options": [MESSAGE_SENDER_AI, MESSAGE_SENDER_USER],
-                "display_name": "Sender Type",
-            },
-            "sender_name": {"display_name": "Sender Name"},
-            "text": {"display_name": "Text"},
-            "session_id": {
-                "display_name": "Session ID",
-                "info": "Session ID of the chat history.",
-                "input_types": ["Message"],
-            },
-        }
-
-    def build(
-        self,
-        sender: str = MESSAGE_SENDER_USER,
-        sender_name: str | None = None,
-        session_id: str | None = None,
-        text: str = "",
-    ) -> Message:
-        flow_id = self.graph.flow_id if hasattr(self, "graph") else None
-        message = Message(text=text, sender=sender, sender_name=sender_name, flow_id=flow_id, session_id=session_id)
-
-        self.status = message
-        return message

langflow/components/deactivated/metal.py

@@ -1,54 +0,0 @@
-# mypy: disable-error-code="attr-defined"
-from langchain_community.retrievers import MetalRetriever
-
-from langflow.base.vectorstores.model import check_cached_vector_store
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.io import DictInput, SecretStrInput, StrInput
-
-
-class MetalRetrieverComponent(CustomComponent):
-    display_name: str = "Metal Retriever"
-    description: str = "Retriever that uses the Metal API."
-    name = "MetalRetriever"
-    legacy = True
-
-    inputs = [
-        SecretStrInput(
-            name="api_key",
-            display_name="API Key",
-            required=True,
-        ),
-        SecretStrInput(
-            name="client_id",
-            display_name="Client ID",
-            required=True,
-        ),
-        StrInput(
-            name="index_id",
-            display_name="Index ID",
-            required=True,
-        ),
-        DictInput(
-            name="params",
-            display_name="Parameters",
-            required=False,
-        ),
-    ]
-
-    @check_cached_vector_store
-    def build_vector_store(self) -> MetalRetriever:
-        """Builds the Metal Retriever."""
-        try:
-            from langchain_community.retrievers import MetalRetriever
-            from metal_sdk.metal import Metal
-        except ImportError as e:
-            msg = "Could not import Metal. Please install it with `pip install metal-sdk langchain-community`."
-            raise ImportError(msg) from e
-
-        try:
-            metal = Metal(api_key=self.api_key, client_id=self.client_id, index_id=self.index_id)
-        except Exception as e:
-            msg = "Could not connect to Metal API."
-            raise ValueError(msg) from e
-
-        return MetalRetriever(client=metal, params=self.params or {})

langflow/components/deactivated/multi_query.py

@@ -1,59 +0,0 @@
-from langchain.prompts import PromptTemplate
-from langchain.retrievers import MultiQueryRetriever
-
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.field_typing import BaseRetriever, LanguageModel, Text
-from langflow.inputs.inputs import HandleInput, StrInput
-
-
-class MultiQueryRetrieverComponent(CustomComponent):
-    display_name = "MultiQueryRetriever"
-    description = "Initialize from llm using default template."
-    documentation = "https://python.langchain.com/docs/modules/data_connection/retrievers/how_to/MultiQueryRetriever"
-    name = "MultiQueryRetriever"
-    legacy = True
-
-    inputs = [
-        HandleInput(
-            name="llm",
-            display_name="LLM",
-            input_types=["LanguageModel"],
-            required=True,
-        ),
-        HandleInput(
-            name="retriever",
-            display_name="Retriever",
-            input_types=["BaseRetriever"],
-            required=True,
-        ),
-        StrInput(
-            name="prompt",
-            display_name="Prompt",
-            value="You are an AI language model assistant. Your task is \n"
-            "to generate 3 different versions of the given user \n"
-            "question to retrieve relevant documents from a vector database. \n"
-            "By generating multiple perspectives on the user question, \n"
-            "your goal is to help the user overcome some of the limitations \n"
-            "of distance-based similarity search. Provide these alternative \n"
-            "questions separated by newlines. Original question: {question}",
-            required=False,
-        ),
-        StrInput(
-            name="parser_key",
-            display_name="Parser Key",
-            value="lines",
-            required=False,
-        ),
-    ]
-
-    def build(
-        self,
-        llm: LanguageModel,
-        retriever: BaseRetriever,
-        prompt: Text | None = None,
-        parser_key: str = "lines",
-    ) -> MultiQueryRetriever:
-        if not prompt:
-            return MultiQueryRetriever.from_llm(llm=llm, retriever=retriever, parser_key=parser_key)
-        prompt_template = PromptTemplate.from_template(prompt)
-        return MultiQueryRetriever.from_llm(llm=llm, retriever=retriever, prompt=prompt_template, parser_key=parser_key)

langflow/components/deactivated/retriever.py

@@ -1,43 +0,0 @@
-from langchain_core.tools import create_retriever_tool
-
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.field_typing import BaseRetriever, Tool
-from langflow.io import HandleInput, StrInput
-
-
-class RetrieverToolComponent(CustomComponent):
-    display_name = "RetrieverTool"
-    description = "Tool for interacting with retriever"
-    name = "RetrieverTool"
-    icon = "LangChain"
-    legacy = True
-
-    inputs = [
-        HandleInput(
-            name="retriever",
-            display_name="Retriever",
-            info="Retriever to interact with",
-            input_types=["Retriever"],
-            required=True,
-        ),
-        StrInput(
-            name="name",
-            display_name="Name",
-            info="Name of the tool",
-            required=True,
-        ),
-        StrInput(
-            name="description",
-            display_name="Description",
-            info="Description of the tool",
-            required=True,
-        ),
-    ]
-
-    def build(self, retriever: BaseRetriever, name: str, description: str, **kwargs) -> Tool:
-        _ = kwargs
-        return create_retriever_tool(
-            retriever=retriever,
-            name=name,
-            description=description,
-        )

langflow/components/deactivated/selective_passthrough.py

@@ -1,77 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.field_typing import Text
-from langflow.io import BoolInput, DropdownInput, MessageTextInput, Output
-
-
-class SelectivePassThroughComponent(Component):
-    display_name = "Selective Pass Through"
-    description = "Passes the specified value if a specified condition is met."
-    icon = "filter"
-    name = "SelectivePassThrough"
-
-    inputs = [
-        MessageTextInput(
-            name="input_value",
-            display_name="Input Value",
-            info="The primary input value to evaluate.",
-        ),
-        MessageTextInput(
-            name="comparison_value",
-            display_name="Comparison Value",
-            info="The value to compare against the input value.",
-        ),
-        DropdownInput(
-            name="operator",
-            display_name="Operator",
-            options=["equals", "not equals", "contains", "starts with", "ends with"],
-            info="Condition to evaluate the input value.",
-        ),
-        MessageTextInput(
-            name="value_to_pass",
-            display_name="Value to Pass",
-            info="The value to pass if the condition is met.",
-        ),
-        BoolInput(
-            name="case_sensitive",
-            display_name="Case Sensitive",
-            info="If true, the comparison will be case sensitive.",
-            value=False,
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Passed Output", name="passed_output", method="pass_through"),
-    ]
-
-    def evaluate_condition(
-        self, input_value: str, comparison_value: str, operator: str, *, case_sensitive: bool
-    ) -> bool:
-        if not case_sensitive:
-            input_value = input_value.lower()
-            comparison_value = comparison_value.lower()
-
-        if operator == "equals":
-            return input_value == comparison_value
-        if operator == "not equals":
-            return input_value != comparison_value
-        if operator == "contains":
-            return comparison_value in input_value
-        if operator == "starts with":
-            return input_value.startswith(comparison_value)
-        if operator == "ends with":
-            return input_value.endswith(comparison_value)
-        return False
-
-    def pass_through(self) -> Text:
-        input_value = self.input_value
-        comparison_value = self.comparison_value
-        operator = self.operator
-        value_to_pass = self.value_to_pass
-        case_sensitive = self.case_sensitive
-
-        if self.evaluate_condition(input_value, comparison_value, operator, case_sensitive=case_sensitive):
-            self.status = value_to_pass
-            return value_to_pass
-        self.status = ""
-        return ""

langflow/components/deactivated/should_run_next.py

@@ -1,40 +0,0 @@
-from langchain_core.messages import BaseMessage
-from langchain_core.prompts import PromptTemplate
-
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.field_typing import LanguageModel, Text
-
-
-class ShouldRunNextComponent(CustomComponent):
-    display_name = "Should Run Next"
-    description = "Determines if a vertex is runnable."
-    name = "ShouldRunNext"
-
-    def build(self, llm: LanguageModel, question: str, context: str, retries: int = 3) -> Text:
-        template = (
-            "Given the following question and the context below, answer with a yes or no.\n\n"
-            "{error_message}\n\n"
-            "Question: {question}\n\n"  # noqa: RUF100, RUF027
-            "Context: {context}\n\n"  # noqa: RUF100, RUF027
-            "Answer:"
-        )
-
-        prompt = PromptTemplate.from_template(template)
-        chain = prompt | llm
-        error_message = ""
-        for _i in range(retries):
-            result = chain.invoke(
-                {"question": question, "context": context, "error_message": error_message},
-                config={"callbacks": self.get_langchain_callbacks()},
-            )
-            if isinstance(result, BaseMessage):
-                content = result.content
-            elif isinstance(result, str):
-                content = result
-            if isinstance(content, str) and content.lower().strip() in {"yes", "no"}:
-                break
-        condition = str(content).lower().strip() == "yes"
-        self.status = f"Should Run Next: {condition}"
-        if condition is False:
-            self.stop()
-        return context

langflow/components/deactivated/split_text.py

@@ -1,63 +0,0 @@
-from langchain_text_splitters import CharacterTextSplitter
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import HandleInput, IntInput, MessageTextInput, Output
-from langflow.schema.data import Data
-from langflow.utils.util import unescape_string
-
-
-class SplitTextComponent(Component):
-    display_name: str = "Split Text"
-    description: str = "Split text into chunks based on specified criteria."
-    icon = "scissors-line-dashed"
-    name = "SplitText"
-
-    inputs = [
-        HandleInput(
-            name="data_inputs",
-            display_name="Data Inputs",
-            info="The data to split.",
-            input_types=["Data"],
-            is_list=True,
-        ),
-        IntInput(
-            name="chunk_overlap",
-            display_name="Chunk Overlap",
-            info="Number of characters to overlap between chunks.",
-            value=200,
-        ),
-        IntInput(
-            name="chunk_size",
-            display_name="Chunk Size",
-            info="The maximum number of characters in each chunk.",
-            value=1000,
-        ),
-        MessageTextInput(
-            name="separator",
-            display_name="Separator",
-            info="The character to split on. Defaults to newline.",
-            value="\n",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Chunks", name="chunks", method="split_text"),
-    ]
-
-    def _docs_to_data(self, docs):
-        return [Data(text=doc.page_content, data=doc.metadata) for doc in docs]
-
-    def split_text(self) -> list[Data]:
-        separator = unescape_string(self.separator)
-
-        documents = [_input.to_lc_document() for _input in self.data_inputs if isinstance(_input, Data)]
-
-        splitter = CharacterTextSplitter(
-            chunk_overlap=self.chunk_overlap,
-            chunk_size=self.chunk_size,
-            separator=separator,
-        )
-        docs = splitter.split_documents(documents)
-        data = self._docs_to_data(docs)
-        self.status = data
-        return data

langflow/components/deactivated/store_message.py

@@ -1,24 +0,0 @@
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.memory import aget_messages, astore_message
-from langflow.schema.message import Message
-
-
-class StoreMessageComponent(CustomComponent):
-    display_name = "Store Message"
-    description = "Stores a chat message."
-    name = "StoreMessage"
-
-    def build_config(self):
-        return {
-            "message": {"display_name": "Message"},
-        }
-
-    async def build(
-        self,
-        message: Message,
-    ) -> Message:
-        flow_id = self.graph.flow_id if hasattr(self, "graph") else None
-        await astore_message(message, flow_id=flow_id)
-        self.status = await aget_messages()
-
-        return message

langflow/components/deactivated/sub_flow.py

@@ -1,124 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langflow.base.flow_processing.utils import build_data_from_result_data
-from langflow.custom.custom_component.custom_component import CustomComponent
-from langflow.graph.graph.base import Graph
-from langflow.graph.vertex.base import Vertex
-from langflow.helpers.flow import get_flow_inputs
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.schema.dotdict import dotdict
-from langflow.template.field.base import Input
-
-if TYPE_CHECKING:
-    from langflow.graph.schema import RunOutputs
-
-
-class SubFlowComponent(CustomComponent):
-    display_name = "Sub Flow"
-    description = (
-        "Dynamically Generates a Component from a Flow. The output is a list of data with keys 'result' and 'message'."
-    )
-    beta: bool = True
-    field_order = ["flow_name"]
-    name = "SubFlow"
-
-    async def get_flow_names(self) -> list[str]:
-        flow_datas = await self.alist_flows()
-        return [flow_data.data["name"] for flow_data in flow_datas]
-
-    async def get_flow(self, flow_name: str) -> Data | None:
-        flow_datas = await self.alist_flows()
-        for flow_data in flow_datas:
-            if flow_data.data["name"] == flow_name:
-                return flow_data
-        return None
-
-    async def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        await logger.adebug(f"Updating build config with field value {field_value} and field name {field_name}")
-        if field_name == "flow_name":
-            build_config["flow_name"]["options"] = await self.get_flow_names()
-        # Clean up the build config
-        for key in list(build_config.keys()):
-            if key not in {*self.field_order, "code", "_type", "get_final_results_only"}:
-                del build_config[key]
-        if field_value is not None and field_name == "flow_name":
-            try:
-                flow_data = await self.get_flow(field_value)
-            except Exception:  # noqa: BLE001
-                await logger.aexception(f"Error getting flow {field_value}")
-            else:
-                if not flow_data:
-                    msg = f"Flow {field_value} not found."
-                    await logger.aerror(msg)
-                else:
-                    try:
-                        graph = Graph.from_payload(flow_data.data["data"])
-                        # Get all inputs from the graph
-                        inputs = get_flow_inputs(graph)
-                        # Add inputs to the build config
-                        build_config = self.add_inputs_to_build_config(inputs, build_config)
-                    except Exception:  # noqa: BLE001
-                        await logger.aexception(f"Error building graph for flow {field_value}")
-
-        return build_config
-
-    def add_inputs_to_build_config(self, inputs: list[Vertex], build_config: dotdict):
-        new_fields: list[Input] = []
-        for vertex in inputs:
-            field = Input(
-                display_name=vertex.display_name,
-                name=vertex.id,
-                info=vertex.description,
-                field_type="str",
-                value=None,
-            )
-            new_fields.append(field)
-        logger.debug(new_fields)
-        for field in new_fields:
-            build_config[field.name] = field.to_dict()
-        return build_config
-
-    def build_config(self):
-        return {
-            "input_value": {
-                "display_name": "Input Value",
-                "multiline": True,
-            },
-            "flow_name": {
-                "display_name": "Flow Name",
-                "info": "The name of the flow to run.",
-                "options": [],
-                "real_time_refresh": True,
-                "refresh_button": True,
-            },
-            "tweaks": {
-                "display_name": "Tweaks",
-                "info": "Tweaks to apply to the flow.",
-            },
-            "get_final_results_only": {
-                "display_name": "Get Final Results Only",
-                "info": "If False, the output will contain all outputs from the flow.",
-                "advanced": True,
-            },
-        }
-
-    async def build(self, flow_name: str, **kwargs) -> list[Data]:
-        tweaks = {key: {"input_value": value} for key, value in kwargs.items()}
-        run_outputs: list[RunOutputs | None] = await self.run_flow(
-            tweaks=tweaks,
-            flow_name=flow_name,
-        )
-        if not run_outputs:
-            return []
-        run_output = run_outputs[0]
-
-        data = []
-        if run_output is not None:
-            for output in run_output.outputs:
-                if output:
-                    data.extend(build_data_from_result_data(output))
-
-        self.status = data
-        await logger.adebug(data)
-        return data