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

lfx/components/flow_controls/conditional_router.py

@@ -0,0 +1,208 @@
+import re
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import BoolInput, DropdownInput, IntInput, MessageInput, MessageTextInput, Output
+from lfx.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/if-else"
+    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):
+        """Handles cycle iteration counting and branch exclusion.
+
+        Uses two complementary mechanisms:
+        1. stop() - ACTIVE/INACTIVE state for cycle management (gets reset each iteration)
+        2. exclude_branch_conditionally() - Persistent exclusion for conditional routing
+
+        When max_iterations is reached, breaks the cycle by allowing the default_route to execute.
+        """
+        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
+            current_iteration = self.ctx.get(f"{self._id}_iteration", 0)
+
+            # Check if max iterations reached and we're trying to stop the default route
+            if current_iteration >= self.max_iterations and route_to_stop == self.default_route:
+                # Clear ALL conditional exclusions to allow default route to execute
+                if self._id in self.graph.conditional_exclusion_sources:
+                    previous_exclusions = self.graph.conditional_exclusion_sources[self._id]
+                    self.graph.conditionally_excluded_vertices -= previous_exclusions
+                    del self.graph.conditional_exclusion_sources[self._id]
+
+                # Switch which route to stop - stop the NON-default route to break the cycle
+                route_to_stop = "true_result" if route_to_stop == "false_result" else "false_result"
+
+                # Call stop to break the cycle
+                self.stop(route_to_stop)
+                # Don't apply conditional exclusion when breaking cycle
+                return
+
+            # Normal case: Use BOTH mechanisms
+            # 1. stop() for cycle management (marks INACTIVE, updates run manager, gets reset)
+            self.stop(route_to_stop)
+
+            # 2. Conditional exclusion for persistent routing (doesn't get reset except by this router)
+            self.graph.exclude_branch_conditionally(self._id, output_name=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
+        )
+
+        # Check if we should force output due to max_iterations on default route
+        current_iteration = self.ctx.get(f"{self._id}_iteration", 0)
+        force_output = current_iteration >= self.max_iterations and self.default_route == "true_result"
+
+        if result or force_output:
+            self.status = self.true_case_message
+            if not force_output:  # Only stop the other branch if not forcing due to max iterations
+                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

lfx/components/flow_controls/data_conditional_router.py

@@ -0,0 +1,126 @@
+from typing import Any
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import DataInput, DropdownInput, MessageTextInput, Output
+from lfx.schema.data import Data
+from lfx.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
+    replacement = ["logic.ConditionalRouter"]
+
+    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

lfx/components/flow_controls/flow_tool.py

@@ -0,0 +1,111 @@
+from typing import Any
+
+from typing_extensions import override
+
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.base.tools.flow_tool import FlowTool
+from lfx.field_typing import Tool
+from lfx.graph.graph.base import Graph
+from lfx.helpers import get_flow_inputs
+from lfx.io import BoolInput, DropdownInput, Output, StrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dotdict import dotdict
+
+
+class FlowToolComponent(LCToolComponent):
+    display_name = "Flow as Tool"
+    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
+    replacement = ["logic.RunFlow"]
+    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

lfx/components/flow_controls/listen.py

@@ -0,0 +1,29 @@
+from lfx.custom import Component
+from lfx.io import Output, StrInput
+from lfx.schema.data import Data
+
+
+class ListenComponent(Component):
+    display_name = "Listen"
+    description = "A component to listen for a notification."
+    name = "Listen"
+    beta: bool = True
+    icon = "Radio"
+    inputs = [
+        StrInput(
+            name="context_key",
+            display_name="Context Key",
+            info="The key of the context to listen for.",
+            input_types=["Message"],
+            required=True,
+        )
+    ]
+
+    outputs = [Output(name="data", display_name="Data", method="listen_for_data", cache=False)]
+
+    def listen_for_data(self) -> Data:
+        """Retrieves a Data object from the component context using the provided context key.
+
+        If the specified context key does not exist in the context, returns an empty Data object.
+        """
+        return self.ctx.get(self.context_key, Data(text=""))

lfx/components/flow_controls/loop.py

@@ -0,0 +1,163 @@
+from lfx.components.processing.converter import convert_to_data
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import HandleInput
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.message import Message
+from lfx.template.field.base import Output
+
+
+class LoopComponent(Component):
+    display_name = "Loop"
+    description = (
+        "Iterates over a list of Data or Message objects, outputting one item at a time and "
+        "aggregating results from loop inputs. Message objects are automatically converted to "
+        "Data objects for consistent processing."
+    )
+    documentation: str = "https://docs.langflow.org/loop"
+    icon = "infinity"
+
+    inputs = [
+        HandleInput(
+            name="data",
+            display_name="Inputs",
+            info="The initial DataFrame to iterate over.",
+            input_types=["DataFrame"],
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Item",
+            name="item",
+            method="item_output",
+            allows_loop=True,
+            loop_types=["Message"],
+            group_outputs=True,
+        ),
+        Output(display_name="Done", name="done", method="done_output", group_outputs=True),
+    ]
+
+    def initialize_data(self) -> None:
+        """Initialize the data list, context index, and aggregated list."""
+        if self.ctx.get(f"{self._id}_initialized", False):
+            return
+
+        # Ensure data is a list of Data objects
+        data_list = self._validate_data(self.data)
+
+        # Store the initial data and context variables
+        self.update_ctx(
+            {
+                f"{self._id}_data": data_list,
+                f"{self._id}_index": 0,
+                f"{self._id}_aggregated": [],
+                f"{self._id}_initialized": True,
+            }
+        )
+
+    def _convert_message_to_data(self, message: Message) -> Data:
+        """Convert a Message object to a Data object using Type Convert logic."""
+        return convert_to_data(message, auto_parse=False)
+
+    def _validate_data(self, data):
+        """Validate and return a list of Data objects. Message objects are auto-converted to Data."""
+        if isinstance(data, DataFrame):
+            return data.to_data_list()
+        if isinstance(data, Data):
+            return [data]
+        if isinstance(data, Message):
+            # Auto-convert Message to Data
+            converted_data = self._convert_message_to_data(data)
+            return [converted_data]
+        if isinstance(data, list) and all(isinstance(item, (Data, Message)) for item in data):
+            # Convert any Message objects in the list to Data objects
+            converted_list = []
+            for item in data:
+                if isinstance(item, Message):
+                    converted_list.append(self._convert_message_to_data(item))
+                else:
+                    converted_list.append(item)
+            return converted_list
+        msg = "The 'data' input must be a DataFrame, a list of Data/Message objects, or a single Data/Message object."
+        raise TypeError(msg)
+
+    def evaluate_stop_loop(self) -> bool:
+        """Evaluate whether to stop item or done output."""
+        current_index = self.ctx.get(f"{self._id}_index", 0)
+        data_length = len(self.ctx.get(f"{self._id}_data", []))
+        return current_index > data_length
+
+    def item_output(self) -> Data:
+        """Output the next item in the list or stop if done."""
+        self.initialize_data()
+        current_item = Data(text="")
+
+        if self.evaluate_stop_loop():
+            self.stop("item")
+        else:
+            # Get data list and current index
+            data_list, current_index = self.loop_variables()
+            if current_index < len(data_list):
+                # Output current item and increment index
+                try:
+                    current_item = data_list[current_index]
+                except IndexError:
+                    current_item = Data(text="")
+            self.aggregated_output()
+            self.update_ctx({f"{self._id}_index": current_index + 1})
+
+        # Now we need to update the dependencies for the next run
+        self.update_dependency()
+        return current_item
+
+    def update_dependency(self):
+        item_dependency_id = self.get_incoming_edge_by_target_param("item")
+        if item_dependency_id not in self.graph.run_manager.run_predecessors[self._id]:
+            self.graph.run_manager.run_predecessors[self._id].append(item_dependency_id)
+            # CRITICAL: Also update run_map so remove_from_predecessors() works correctly
+            # run_map[predecessor] = list of vertices that depend on predecessor
+            if self._id not in self.graph.run_manager.run_map[item_dependency_id]:
+                self.graph.run_manager.run_map[item_dependency_id].append(self._id)
+
+    def done_output(self) -> DataFrame:
+        """Trigger the done output when iteration is complete."""
+        self.initialize_data()
+
+        if self.evaluate_stop_loop():
+            self.stop("item")
+            self.start("done")
+
+            aggregated = self.ctx.get(f"{self._id}_aggregated", [])
+
+            return DataFrame(aggregated)
+        self.stop("done")
+        return DataFrame([])
+
+    def loop_variables(self):
+        """Retrieve loop variables from context."""
+        return (
+            self.ctx.get(f"{self._id}_data", []),
+            self.ctx.get(f"{self._id}_index", 0),
+        )
+
+    def aggregated_output(self) -> list[Data]:
+        """Return the aggregated list once all items are processed.
+
+        Returns Data or Message objects depending on loop input types.
+        """
+        self.initialize_data()
+
+        # Get data list and aggregated list
+        data_list = self.ctx.get(f"{self._id}_data", [])
+        aggregated = self.ctx.get(f"{self._id}_aggregated", [])
+        loop_input = self.item
+
+        # Append the current loop input to aggregated if it's not already included
+        if loop_input is not None and not isinstance(loop_input, str) and len(aggregated) <= len(data_list):
+            # If the loop input is a Message, convert it to Data for consistency
+            if isinstance(loop_input, Message):
+                loop_input = self._convert_message_to_data(loop_input)
+            aggregated.append(loop_input)
+            self.update_ctx({f"{self._id}_aggregated": aggregated})
+        return aggregated