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

lfx/components/deactivated/metal.py

@@ -0,0 +1,54 @@
+# mypy: disable-error-code="attr-defined"
+from langchain_community.retrievers import MetalRetriever
+
+from lfx.base.vectorstores.model import check_cached_vector_store
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.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="Metal Retriever 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 {})

lfx/components/deactivated/multi_query.py

@@ -0,0 +1,59 @@
+from langchain.prompts import PromptTemplate
+from langchain.retrievers import MultiQueryRetriever
+
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.field_typing import BaseRetriever, LanguageModel, Text
+from lfx.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)

lfx/components/deactivated/retriever.py

@@ -0,0 +1,43 @@
+from langchain_core.tools import create_retriever_tool
+
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.field_typing import BaseRetriever, Tool
+from lfx.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,
+        )

lfx/components/deactivated/selective_passthrough.py

@@ -0,0 +1,77 @@
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing import Text
+from lfx.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 ""

lfx/components/deactivated/should_run_next.py

@@ -0,0 +1,40 @@
+from langchain_core.messages import BaseMessage
+from langchain_core.prompts import PromptTemplate
+
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.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

lfx/components/deactivated/split_text.py

@@ -0,0 +1,63 @@
+from langchain_text_splitters import CharacterTextSplitter
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import HandleInput, IntInput, MessageTextInput, Output
+from lfx.schema.data import Data
+from lfx.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

lfx/components/deactivated/store_message.py

@@ -0,0 +1,24 @@
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.memory import aget_messages, astore_message
+from lfx.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

lfx/components/deactivated/sub_flow.py

@@ -0,0 +1,124 @@
+from typing import TYPE_CHECKING, Any
+
+from lfx.base.flow_processing.utils import build_data_from_result_data
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.graph.graph.base import Graph
+from lfx.graph.vertex.base import Vertex
+from lfx.helpers import get_flow_inputs
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dotdict import dotdict
+from lfx.template.field.base import Input
+
+if TYPE_CHECKING:
+    from lfx.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

lfx/components/deactivated/vectara_self_query.py

@@ -0,0 +1,76 @@
+# mypy: disable-error-code="attr-defined"
+import json
+
+from langchain.chains.query_constructor.base import AttributeInfo
+from langchain.retrievers.self_query.base import SelfQueryRetriever
+
+from lfx.base.vectorstores.model import check_cached_vector_store
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.io import HandleInput, StrInput
+
+
+class VectaraSelfQueryRetriverComponent(CustomComponent):
+    """A custom component for implementing Vectara Self Query Retriever using a vector store."""
+
+    display_name: str = "Vectara Self Query Retriever"
+    description: str = "Implementation of Vectara Self Query Retriever"
+    name = "VectaraSelfQueryRetriver"
+    icon = "Vectara"
+    legacy = True
+
+    inputs = [
+        HandleInput(
+            name="vectorstore",
+            display_name="Vector Store",
+            info="Input Vectara Vector Store",
+        ),
+        HandleInput(
+            name="llm",
+            display_name="LLM",
+            info="For self query retriever",
+        ),
+        StrInput(
+            name="document_content_description",
+            display_name="Document Content Description",
+            info="For self query retriever",
+        ),
+        StrInput(
+            name="metadata_field_info",
+            display_name="Metadata Field Info",
+            info="Each metadata field info is a string in the form of key value pair dictionary containing "
+            "additional search metadata.\n"
+            'Example input: {"name":"speech","description":"what name of the speech","type":'
+            '"string or list[string]"}.\n'
+            "The keys should remain constant(name, description, type)",
+        ),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self):
+        """Builds the Vectara Self Query Retriever."""
+        try:
+            from langchain_community.vectorstores import Vectara  # noqa: F401
+        except ImportError as e:
+            msg = "Could not import Vectara. Please install it with `pip install langchain-community`."
+            raise ImportError(msg) from e
+
+        metadata_field_obj = []
+        for meta in self.metadata_field_info:
+            meta_obj = json.loads(meta)
+            if "name" not in meta_obj or "description" not in meta_obj or "type" not in meta_obj:
+                msg = "Incorrect metadata field info format."
+                raise ValueError(msg)
+            attribute_info = AttributeInfo(
+                name=meta_obj["name"],
+                description=meta_obj["description"],
+                type=meta_obj["type"],
+            )
+            metadata_field_obj.append(attribute_info)
+
+        return SelfQueryRetriever.from_llm(
+            self.llm,  # type: ignore[attr-defined]
+            self.vectorstore,  # type: ignore[attr-defined]
+            self.document_content_description,  # type: ignore[attr-defined]
+            metadata_field_obj,
+            verbose=True,
+        )

lfx/components/deactivated/vector_store.py

@@ -0,0 +1,24 @@
+from langchain_core.vectorstores import VectorStoreRetriever
+
+from lfx.custom.custom_component.custom_component import CustomComponent
+from lfx.field_typing import VectorStore
+from lfx.inputs.inputs import HandleInput
+
+
+class VectorStoreRetrieverComponent(CustomComponent):
+    display_name = "VectorStore Retriever"
+    description = "A vector store retriever"
+    name = "VectorStoreRetriever"
+    icon = "LangChain"
+
+    inputs = [
+        HandleInput(
+            name="vectorstore",
+            display_name="Vector Store",
+            input_types=["VectorStore"],
+            required=True,
+        ),
+    ]
+
+    def build(self, vectorstore: VectorStore) -> VectorStoreRetriever:
+        return vectorstore.as_retriever()

lfx/components/deepseek/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .deepseek import DeepSeekModelComponent
+
+_dynamic_imports = {
+    "DeepSeekModelComponent": "deepseek",
+}
+
+__all__ = [
+    "DeepSeekModelComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import deepseek 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__)