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

langflow/components/lmstudio/lmstudioembeddings.py

@@ -1,89 +0,0 @@
-from typing import Any
-from urllib.parse import urljoin
-
-import httpx
-
-from langflow.base.embeddings.model import LCEmbeddingsModel
-from langflow.field_typing import Embeddings
-from langflow.inputs.inputs import DropdownInput, SecretStrInput
-from langflow.io import FloatInput, MessageTextInput
-
-
-class LMStudioEmbeddingsComponent(LCEmbeddingsModel):
-    display_name: str = "LM Studio Embeddings"
-    description: str = "Generate embeddings using LM Studio."
-    icon = "LMStudio"
-
-    async def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None):  # noqa: ARG002
-        if field_name == "model":
-            base_url_dict = build_config.get("base_url", {})
-            base_url_load_from_db = base_url_dict.get("load_from_db", False)
-            base_url_value = base_url_dict.get("value")
-            if base_url_load_from_db:
-                base_url_value = await self.get_variables(base_url_value, field_name)
-            elif not base_url_value:
-                base_url_value = "http://localhost:1234/v1"
-            build_config["model"]["options"] = await self.get_model(base_url_value)
-
-        return build_config
-
-    @staticmethod
-    async def get_model(base_url_value: str) -> list[str]:
-        try:
-            url = urljoin(base_url_value, "/v1/models")
-            async with httpx.AsyncClient() as client:
-                response = await client.get(url)
-                response.raise_for_status()
-                data = response.json()
-
-                return [model["id"] for model in data.get("data", [])]
-        except Exception as e:
-            msg = "Could not retrieve models. Please, make sure the LM Studio server is running."
-            raise ValueError(msg) from e
-
-    inputs = [
-        DropdownInput(
-            name="model",
-            display_name="Model",
-            advanced=False,
-            refresh_button=True,
-            required=True,
-        ),
-        MessageTextInput(
-            name="base_url",
-            display_name="LM Studio Base URL",
-            refresh_button=True,
-            value="http://localhost:1234/v1",
-            required=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="LM Studio API Key",
-            advanced=True,
-            value="LMSTUDIO_API_KEY",
-        ),
-        FloatInput(
-            name="temperature",
-            display_name="Model Temperature",
-            value=0.1,
-            advanced=True,
-        ),
-    ]
-
-    def build_embeddings(self) -> Embeddings:
-        try:
-            from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings
-        except ImportError as e:
-            msg = "Please install langchain-nvidia-ai-endpoints to use LM Studio Embeddings."
-            raise ImportError(msg) from e
-        try:
-            output = NVIDIAEmbeddings(
-                model=self.model,
-                base_url=self.base_url,
-                temperature=self.temperature,
-                nvidia_api_key=self.api_key,
-            )
-        except Exception as e:
-            msg = f"Could not connect to LM Studio API. Error: {e}"
-            raise ValueError(msg) from e
-        return output

langflow/components/lmstudio/lmstudiomodel.py

@@ -1,129 +0,0 @@
-from typing import Any
-from urllib.parse import urljoin
-
-import httpx
-from langchain_openai import ChatOpenAI
-from typing_extensions import override
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import LanguageModel
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.inputs.inputs import DictInput, DropdownInput, FloatInput, IntInput, SecretStrInput, StrInput
-
-
-class LMStudioModelComponent(LCModelComponent):
-    display_name = "LM Studio"
-    description = "Generate text using LM Studio Local LLMs."
-    icon = "LMStudio"
-    name = "LMStudioModel"
-
-    @override
-    async def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None):
-        if field_name == "model_name":
-            base_url_dict = build_config.get("base_url", {})
-            base_url_load_from_db = base_url_dict.get("load_from_db", False)
-            base_url_value = base_url_dict.get("value")
-            if base_url_load_from_db:
-                base_url_value = await self.get_variables(base_url_value, field_name)
-            elif not base_url_value:
-                base_url_value = "http://localhost:1234/v1"
-            build_config["model_name"]["options"] = await self.get_model(base_url_value)
-
-        return build_config
-
-    @staticmethod
-    async def get_model(base_url_value: str) -> list[str]:
-        try:
-            url = urljoin(base_url_value, "/v1/models")
-            async with httpx.AsyncClient() as client:
-                response = await client.get(url)
-                response.raise_for_status()
-                data = response.json()
-
-                return [model["id"] for model in data.get("data", [])]
-        except Exception as e:
-            msg = "Could not retrieve models. Please, make sure the LM Studio server is running."
-            raise ValueError(msg) from e
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        IntInput(
-            name="max_tokens",
-            display_name="Max Tokens",
-            advanced=True,
-            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
-            range_spec=RangeSpec(min=0, max=128000),
-        ),
-        DictInput(name="model_kwargs", display_name="Model Kwargs", advanced=True),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            advanced=False,
-            refresh_button=True,
-        ),
-        StrInput(
-            name="base_url",
-            display_name="Base URL",
-            advanced=False,
-            info="Endpoint of the LM Studio API. Defaults to 'http://localhost:1234/v1' if not specified.",
-            value="http://localhost:1234/v1",
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="LM Studio API Key",
-            info="The LM Studio API Key to use for LM Studio.",
-            advanced=True,
-            value="LMSTUDIO_API_KEY",
-        ),
-        FloatInput(
-            name="temperature",
-            display_name="Temperature",
-            value=0.1,
-            advanced=True,
-        ),
-        IntInput(
-            name="seed",
-            display_name="Seed",
-            info="The seed controls the reproducibility of the job.",
-            advanced=True,
-            value=1,
-        ),
-    ]
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        lmstudio_api_key = self.api_key
-        temperature = self.temperature
-        model_name: str = self.model_name
-        max_tokens = self.max_tokens
-        model_kwargs = self.model_kwargs or {}
-        base_url = self.base_url or "http://localhost:1234/v1"
-        seed = self.seed
-
-        return ChatOpenAI(
-            max_tokens=max_tokens or None,
-            model_kwargs=model_kwargs,
-            model=model_name,
-            base_url=base_url,
-            api_key=lmstudio_api_key,
-            temperature=temperature if temperature is not None else 0.1,
-            seed=seed,
-        )
-
-    def _get_exception_message(self, e: Exception):
-        """Get a message from an LM Studio exception.
-
-        Args:
-            e (Exception): The exception to get the message from.
-
-        Returns:
-            str: The message from the exception.
-        """
-        try:
-            from openai import BadRequestError
-        except ImportError:
-            return None
-        if isinstance(e, BadRequestError):
-            message = e.body.get("message")
-            if message:
-                return message
-        return None

langflow/components/logic/__init__.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from langflow.components.logic.conditional_router import ConditionalRouterComponent
-    from langflow.components.logic.data_conditional_router import DataConditionalRouterComponent
-    from langflow.components.logic.flow_tool import FlowToolComponent
-    from langflow.components.logic.loop import LoopComponent
-    from langflow.components.logic.pass_message import PassMessageComponent
-    from langflow.components.logic.run_flow import RunFlowComponent
-    from langflow.components.logic.sub_flow import SubFlowComponent
-
-_dynamic_imports = {
-    "ConditionalRouterComponent": "conditional_router",
-    "DataConditionalRouterComponent": "data_conditional_router",
-    "FlowToolComponent": "flow_tool",
-    "LoopComponent": "loop",
-    "PassMessageComponent": "pass_message",
-    "RunFlowComponent": "run_flow",
-    "SubFlowComponent": "sub_flow",
-}
-
-__all__ = [
-    "ConditionalRouterComponent",
-    "DataConditionalRouterComponent",
-    "FlowToolComponent",
-    "LoopComponent",
-    "PassMessageComponent",
-    "RunFlowComponent",
-    "SubFlowComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import logic 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/logic/conditional_router.py

@@ -1,171 +0,0 @@
-import re
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import BoolInput, DropdownInput, IntInput, MessageInput, MessageTextInput, Output
-from langflow.schema.message import Message
-
-
-class ConditionalRouterComponent(Component):
-    display_name = "If-Else"
-    description = "Routes an input message to a corresponding output based on text comparison."
-    documentation: str = "https://docs.langflow.org/components-logic#conditional-router-if-else-component"
-    icon = "split"
-    name = "ConditionalRouter"
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.__iteration_updated = False
-
-    inputs = [
-        MessageTextInput(
-            name="input_text",
-            display_name="Text Input",
-            info="The primary text input for the operation.",
-            required=True,
-        ),
-        DropdownInput(
-            name="operator",
-            display_name="Operator",
-            options=[
-                "equals",
-                "not equals",
-                "contains",
-                "starts with",
-                "ends with",
-                "regex",
-                "less than",
-                "less than or equal",
-                "greater than",
-                "greater than or equal",
-            ],
-            info="The operator to apply for comparing the texts.",
-            value="equals",
-            real_time_refresh=True,
-        ),
-        MessageTextInput(
-            name="match_text",
-            display_name="Match Text",
-            info="The text input to compare against.",
-            required=True,
-        ),
-        BoolInput(
-            name="case_sensitive",
-            display_name="Case Sensitive",
-            info="If true, the comparison will be case sensitive.",
-            value=True,
-            advanced=True,
-        ),
-        MessageInput(
-            name="true_case_message",
-            display_name="Case True",
-            info="The message to pass if the condition is True.",
-            advanced=True,
-        ),
-        MessageInput(
-            name="false_case_message",
-            display_name="Case False",
-            info="The message to pass if the condition is False.",
-            advanced=True,
-        ),
-        IntInput(
-            name="max_iterations",
-            display_name="Max Iterations",
-            info="The maximum number of iterations for the conditional router.",
-            value=10,
-            advanced=True,
-        ),
-        DropdownInput(
-            name="default_route",
-            display_name="Default Route",
-            options=["true_result", "false_result"],
-            info="The default route to take when max iterations are reached.",
-            value="false_result",
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="True", name="true_result", method="true_response", group_outputs=True),
-        Output(display_name="False", name="false_result", method="false_response", group_outputs=True),
-    ]
-
-    def _pre_run_setup(self):
-        self.__iteration_updated = False
-
-    def evaluate_condition(self, input_text: str, match_text: str, operator: str, *, case_sensitive: bool) -> bool:
-        if not case_sensitive and operator != "regex":
-            input_text = input_text.lower()
-            match_text = match_text.lower()
-
-        if operator == "equals":
-            return input_text == match_text
-        if operator == "not equals":
-            return input_text != match_text
-        if operator == "contains":
-            return match_text in input_text
-        if operator == "starts with":
-            return input_text.startswith(match_text)
-        if operator == "ends with":
-            return input_text.endswith(match_text)
-        if operator == "regex":
-            try:
-                return bool(re.match(match_text, input_text))
-            except re.error:
-                return False  # Return False if the regex is invalid
-        if operator in ["less than", "less than or equal", "greater than", "greater than or equal"]:
-            try:
-                input_num = float(input_text)
-                match_num = float(match_text)
-                if operator == "less than":
-                    return input_num < match_num
-                if operator == "less than or equal":
-                    return input_num <= match_num
-                if operator == "greater than":
-                    return input_num > match_num
-                if operator == "greater than or equal":
-                    return input_num >= match_num
-            except ValueError:
-                return False  # Invalid number format for comparison
-        return False
-
-    def iterate_and_stop_once(self, route_to_stop: str):
-        if not self.__iteration_updated:
-            self.update_ctx({f"{self._id}_iteration": self.ctx.get(f"{self._id}_iteration", 0) + 1})
-            self.__iteration_updated = True
-            if self.ctx.get(f"{self._id}_iteration", 0) >= self.max_iterations and route_to_stop == self.default_route:
-                route_to_stop = "true_result" if route_to_stop == "false_result" else "false_result"
-            self.stop(route_to_stop)
-
-    def true_response(self) -> Message:
-        result = self.evaluate_condition(
-            self.input_text, self.match_text, self.operator, case_sensitive=self.case_sensitive
-        )
-        if result:
-            self.status = self.true_case_message
-            self.iterate_and_stop_once("false_result")
-            return self.true_case_message
-        self.iterate_and_stop_once("true_result")
-        return Message(content="")
-
-    def false_response(self) -> Message:
-        result = self.evaluate_condition(
-            self.input_text, self.match_text, self.operator, case_sensitive=self.case_sensitive
-        )
-        if not result:
-            self.status = self.false_case_message
-            self.iterate_and_stop_once("true_result")
-            return self.false_case_message
-        self.iterate_and_stop_once("false_result")
-        return Message(content="")
-
-    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
-        if field_name == "operator":
-            if field_value == "regex":
-                build_config.pop("case_sensitive", None)
-            elif "case_sensitive" not in build_config:
-                case_sensitive_input = next(
-                    (input_field for input_field in self.inputs if input_field.name == "case_sensitive"), None
-                )
-                if case_sensitive_input:
-                    build_config["case_sensitive"] = case_sensitive_input.to_dict()
-        return build_config

langflow/components/logic/data_conditional_router.py

@@ -1,125 +0,0 @@
-from typing import Any
-
-from langflow.custom.custom_component.component import Component
-from langflow.io import DataInput, DropdownInput, MessageTextInput, Output
-from langflow.schema.data import Data
-from langflow.schema.dotdict import dotdict
-
-
-class DataConditionalRouterComponent(Component):
-    display_name = "Condition"
-    description = "Route Data object(s) based on a condition applied to a specified key, including boolean validation."
-    icon = "split"
-    name = "DataConditionalRouter"
-    legacy = True
-
-    inputs = [
-        DataInput(
-            name="data_input",
-            display_name="Data Input",
-            info="The Data object or list of Data objects to process",
-            is_list=True,
-        ),
-        MessageTextInput(
-            name="key_name",
-            display_name="Key Name",
-            info="The name of the key in the Data object(s) to check",
-        ),
-        DropdownInput(
-            name="operator",
-            display_name="Operator",
-            options=["equals", "not equals", "contains", "starts with", "ends with", "boolean validator"],
-            info="The operator to apply for comparing the values. 'boolean validator' treats the value as a boolean.",
-            value="equals",
-        ),
-        MessageTextInput(
-            name="compare_value",
-            display_name="Match Text",
-            info="The value to compare against (not used for boolean validator)",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="True Output", name="true_output", method="process_data"),
-        Output(display_name="False Output", name="false_output", method="process_data"),
-    ]
-
-    def compare_values(self, item_value: str, compare_value: str, operator: str) -> bool:
-        if operator == "equals":
-            return item_value == compare_value
-        if operator == "not equals":
-            return item_value != compare_value
-        if operator == "contains":
-            return compare_value in item_value
-        if operator == "starts with":
-            return item_value.startswith(compare_value)
-        if operator == "ends with":
-            return item_value.endswith(compare_value)
-        if operator == "boolean validator":
-            return self.parse_boolean(item_value)
-        return False
-
-    def parse_boolean(self, value):
-        if isinstance(value, bool):
-            return value
-        if isinstance(value, str):
-            return value.lower() in {"true", "1", "yes", "y", "on"}
-        return bool(value)
-
-    def validate_input(self, data_item: Data) -> bool:
-        if not isinstance(data_item, Data):
-            self.status = "Input is not a Data object"
-            return False
-        if self.key_name not in data_item.data:
-            self.status = f"Key '{self.key_name}' not found in Data"
-            return False
-        return True
-
-    def process_data(self) -> Data | list[Data]:
-        if isinstance(self.data_input, list):
-            true_output = []
-            false_output = []
-            for item in self.data_input:
-                if self.validate_input(item):
-                    result = self.process_single_data(item)
-                    if result:
-                        true_output.append(item)
-                    else:
-                        false_output.append(item)
-            self.stop("false_output" if true_output else "true_output")
-            return true_output or false_output
-        if not self.validate_input(self.data_input):
-            return Data(data={"error": self.status})
-        result = self.process_single_data(self.data_input)
-        self.stop("false_output" if result else "true_output")
-        return self.data_input
-
-    def process_single_data(self, data_item: Data) -> bool:
-        item_value = data_item.data[self.key_name]
-        operator = self.operator
-
-        if operator == "boolean validator":
-            condition_met = self.parse_boolean(item_value)
-            condition_description = f"Boolean validation of '{self.key_name}'"
-        else:
-            compare_value = self.compare_value
-            condition_met = self.compare_values(str(item_value), compare_value, operator)
-            condition_description = f"{self.key_name} {operator} {compare_value}"
-
-        if condition_met:
-            self.status = f"Condition met: {condition_description}"
-            return True
-        self.status = f"Condition not met: {condition_description}"
-        return False
-
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        if field_name == "operator":
-            if field_value == "boolean validator":
-                build_config["compare_value"]["show"] = False
-                build_config["compare_value"]["advanced"] = True
-                build_config["compare_value"]["value"] = None
-            else:
-                build_config["compare_value"]["show"] = True
-                build_config["compare_value"]["advanced"] = False
-
-        return build_config

langflow/components/logic/flow_tool.py

@@ -1,110 +0,0 @@
-from typing import Any
-
-from typing_extensions import override
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.base.tools.flow_tool import FlowTool
-from langflow.field_typing import Tool
-from langflow.graph.graph.base import Graph
-from langflow.helpers.flow import get_flow_inputs
-from langflow.io import BoolInput, DropdownInput, Output, StrInput
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.schema.dotdict import dotdict
-
-
-class FlowToolComponent(LCToolComponent):
-    display_name = "Flow as Tool [Deprecated]"
-    description = "Construct a Tool from a function that runs the loaded Flow."
-    field_order = ["flow_name", "name", "description", "return_direct"]
-    trace_type = "tool"
-    name = "FlowTool"
-    legacy: bool = True
-    icon = "hammer"
-
-    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:
-        """Retrieves a flow by its name.
-
-        Args:
-            flow_name (str): The name of the flow to retrieve.
-
-        Returns:
-            Optional[Text]: The flow record if found, None otherwise.
-        """
-        flow_datas = await self.alist_flows()
-        for flow_data in flow_datas:
-            if flow_data.data["name"] == flow_name:
-                return flow_data
-        return None
-
-    @override
-    async def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        if field_name == "flow_name":
-            build_config["flow_name"]["options"] = self.get_flow_names()
-
-        return build_config
-
-    inputs = [
-        DropdownInput(
-            name="flow_name", display_name="Flow Name", info="The name of the flow to run.", refresh_button=True
-        ),
-        StrInput(
-            name="tool_name",
-            display_name="Name",
-            info="The name of the tool.",
-        ),
-        StrInput(
-            name="tool_description",
-            display_name="Description",
-            info="The description of the tool; defaults to the Flow's description.",
-        ),
-        BoolInput(
-            name="return_direct",
-            display_name="Return Direct",
-            info="Return the result directly from the Tool.",
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(name="api_build_tool", display_name="Tool", method="build_tool"),
-    ]
-
-    async def build_tool(self) -> Tool:
-        FlowTool.model_rebuild()
-        if "flow_name" not in self._attributes or not self._attributes["flow_name"]:
-            msg = "Flow name is required"
-            raise ValueError(msg)
-        flow_name = self._attributes["flow_name"]
-        flow_data = await self.get_flow(flow_name)
-        if not flow_data:
-            msg = "Flow not found."
-            raise ValueError(msg)
-        graph = Graph.from_payload(
-            flow_data.data["data"],
-            user_id=str(self.user_id),
-        )
-        try:
-            graph.set_run_id(self.graph.run_id)
-        except Exception:  # noqa: BLE001
-            logger.warning("Failed to set run_id", exc_info=True)
-        inputs = get_flow_inputs(graph)
-        tool_description = self.tool_description.strip() or flow_data.description
-        tool = FlowTool(
-            name=self.tool_name,
-            description=tool_description,
-            graph=graph,
-            return_direct=self.return_direct,
-            inputs=inputs,
-            flow_id=str(flow_data.id),
-            user_id=str(self.user_id),
-            session_id=self.graph.session_id if hasattr(self, "graph") else None,
-        )
-        description_repr = repr(tool.description).strip("'")
-        args_str = "\n".join([f"- {arg_name}: {arg_data['description']}" for arg_name, arg_data in tool.args.items()])
-        self.status = f"{description_repr}\nArguments:\n{args_str}"
-        return tool