lfx-nightly 0.1.11.dev0__py3-none-any.whl

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

lfx/components/deepseek/deepseek.py

@@ -0,0 +1,136 @@
+import requests
+from pydantic.v1 import SecretStr
+from typing_extensions import override
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import BoolInput, DictInput, DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
+
+DEEPSEEK_MODELS = ["deepseek-chat"]
+
+
+class DeepSeekModelComponent(LCModelComponent):
+    display_name = "DeepSeek"
+    description = "Generate text using DeepSeek LLMs."
+    icon = "DeepSeek"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            info="Maximum number of tokens to generate. Set to 0 for unlimited.",
+            range_spec=RangeSpec(min=0, max=128000),
+        ),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model Kwargs",
+            advanced=True,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+        BoolInput(
+            name="json_mode",
+            display_name="JSON Mode",
+            advanced=True,
+            info="If True, it will output JSON regardless of passing a schema.",
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            info="DeepSeek model to use",
+            options=DEEPSEEK_MODELS,
+            value="deepseek-chat",
+            refresh_button=True,
+        ),
+        StrInput(
+            name="api_base",
+            display_name="DeepSeek API Base",
+            advanced=True,
+            info="Base URL for API requests. Defaults to https://api.deepseek.com",
+            value="https://api.deepseek.com",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="DeepSeek API Key",
+            info="The DeepSeek API Key",
+            advanced=False,
+            required=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            info="Controls randomness in responses",
+            value=1.0,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
+            advanced=True,
+        ),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="The seed controls the reproducibility of the job.",
+            advanced=True,
+            value=1,
+        ),
+    ]
+
+    def get_models(self) -> list[str]:
+        if not self.api_key:
+            return DEEPSEEK_MODELS
+
+        url = f"{self.api_base}/models"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Accept": "application/json"}
+
+        try:
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            model_list = response.json()
+            return [model["id"] for model in model_list.get("data", [])]
+        except requests.RequestException as e:
+            self.status = f"Error fetching models: {e}"
+            return DEEPSEEK_MODELS
+
+    @override
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        if field_name in {"api_key", "api_base", "model_name"}:
+            models = self.get_models()
+            build_config["model_name"]["options"] = models
+        return build_config
+
+    def build_model(self) -> LanguageModel:
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError as e:
+            msg = "langchain-openai not installed. Please install with `pip install langchain-openai`"
+            raise ImportError(msg) from e
+
+        api_key = SecretStr(self.api_key).get_secret_value() if self.api_key else None
+        output = ChatOpenAI(
+            model=self.model_name,
+            temperature=self.temperature if self.temperature is not None else 0.1,
+            max_tokens=self.max_tokens or None,
+            model_kwargs=self.model_kwargs or {},
+            base_url=self.api_base,
+            api_key=api_key,
+            streaming=self.stream if hasattr(self, "stream") else False,
+            seed=self.seed,
+        )
+
+        if self.json_mode:
+            output = output.bind(response_format={"type": "json_object"})
+
+        return output
+
+    def _get_exception_message(self, e: Exception):
+        """Get message from DeepSeek API exception."""
+        try:
+            from openai import BadRequestError
+
+            if isinstance(e, BadRequestError):
+                message = e.body.get("message")
+                if message:
+                    return message
+        except ImportError:
+            pass
+        return None

lfx/components/docling/__init__.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .chunk_docling_document import ChunkDoclingDocumentComponent
+    from .docling_inline import DoclingInlineComponent
+    from .docling_remote import DoclingRemoteComponent
+    from .export_docling_document import ExportDoclingDocumentComponent
+
+_dynamic_imports = {
+    "ChunkDoclingDocumentComponent": "chunk_docling_document",
+    "DoclingInlineComponent": "docling_inline",
+    "DoclingRemoteComponent": "docling_remote",
+    "ExportDoclingDocumentComponent": "export_docling_document",
+}
+
+__all__ = [
+    "ChunkDoclingDocumentComponent",
+    "DoclingInlineComponent",
+    "DoclingRemoteComponent",
+    "ExportDoclingDocumentComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import docling 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__)