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

langflow/components/logic/listen.py

@@ -1,29 +0,0 @@
-from langflow.custom import Component
-from langflow.io import Output, StrInput
-from langflow.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=""))

langflow/components/logic/loop.py

@@ -1,125 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import HandleInput
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.template.field.base import Output
-
-
-class LoopComponent(Component):
-    display_name = "Loop"
-    description = (
-        "Iterates over a list of Data objects, outputting one item at a time and aggregating results from loop inputs."
-    )
-    documentation: str = "https://docs.langflow.org/components-logic#loop"
-    icon = "infinity"
-
-    inputs = [
-        HandleInput(
-            name="data",
-            display_name="Inputs",
-            info="The initial list of Data objects or DataFrame to iterate over.",
-            input_types=["DataFrame"],
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Item", name="item", method="item_output", allows_loop=True, 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 _validate_data(self, data):
-        """Validate and return a list of Data objects."""
-        if isinstance(data, DataFrame):
-            return data.to_data_list()
-        if isinstance(data, Data):
-            return [data]
-        if isinstance(data, list) and all(isinstance(item, Data) for item in data):
-            return data
-        msg = "The 'data' input must be a DataFrame, a list of Data objects, or a single Data 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)
-
-    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."""
-        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
-        if loop_input is not None and not isinstance(loop_input, str) and len(aggregated) <= len(data_list):
-            aggregated.append(loop_input)
-            self.update_ctx({f"{self._id}_aggregated": aggregated})
-        return aggregated

langflow/components/logic/notify.py

@@ -1,88 +0,0 @@
-from typing import cast
-
-from langflow.custom import Component
-from langflow.io import BoolInput, HandleInput, Output, StrInput
-from langflow.schema.data import Data
-
-
-class NotifyComponent(Component):
-    display_name = "Notify"
-    description = "A component to generate a notification to Get Notified component."
-    icon = "Notify"
-    name = "Notify"
-    beta: bool = True
-
-    inputs = [
-        StrInput(
-            name="context_key",
-            display_name="Context Key",
-            info="The key of the context to store the notification.",
-            required=True,
-        ),
-        HandleInput(
-            name="input_value",
-            display_name="Input Data",
-            info="The data to store.",
-            required=False,
-            input_types=["Data", "Message", "DataFrame"],
-        ),
-        BoolInput(
-            name="append",
-            display_name="Append",
-            info="If True, the record will be appended to the notification.",
-            value=False,
-            required=False,
-        ),
-    ]
-
-    outputs = [
-        Output(
-            display_name="Data",
-            name="result",
-            method="notify_components",
-            cache=False,
-        ),
-    ]
-
-    async def notify_components(self) -> Data:
-        """Processes and stores a notification in the component's context.
-
-        Normalizes the input value to a `Data` object and stores it under the
-        specified context key. If `append` is True, adds the value to a list
-        of notifications; otherwise, replaces the existing value. Updates the
-        component's status and activates related state vertices in the graph.
-
-        Returns:
-            The processed `Data` object stored in the context.
-
-        Raises:
-            ValueError: If the component is not part of a graph.
-        """
-        if not self._vertex:
-            msg = "Notify component must be used in a graph."
-            raise ValueError(msg)
-        input_value: Data | str | dict | None = self.input_value
-        if input_value is None:
-            input_value = Data(text="")
-        elif not isinstance(input_value, Data):
-            if isinstance(input_value, str):
-                input_value = Data(text=input_value)
-            elif isinstance(input_value, dict):
-                input_value = Data(data=input_value)
-            else:
-                input_value = Data(text=str(input_value))
-        if input_value:
-            if self.append:
-                current_data = self.ctx.get(self.context_key, [])
-                if not isinstance(current_data, list):
-                    current_data = [current_data]
-                current_data.append(input_value)
-                self.update_ctx({self.context_key: current_data})
-            else:
-                self.update_ctx({self.context_key: input_value})
-            self.status = input_value
-        else:
-            self.status = "No record provided."
-        self._vertex.is_state = True
-        self.graph.activate_state_vertices(name=self.context_key, caller=self._id)
-        return cast("Data", input_value)

langflow/components/logic/pass_message.py

@@ -1,35 +0,0 @@
-from langflow.custom.custom_component.component import Component
-from langflow.io import MessageInput
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class PassMessageComponent(Component):
-    display_name = "Pass"
-    description = "Forwards the input message, unchanged."
-    name = "Pass"
-    icon = "arrow-right"
-    legacy: bool = True
-
-    inputs = [
-        MessageInput(
-            name="input_message",
-            display_name="Input Message",
-            info="The message to be passed forward.",
-            required=True,
-        ),
-        MessageInput(
-            name="ignored_message",
-            display_name="Ignored Message",
-            info="A second message to be ignored. Used as a workaround for continuity.",
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Output Message", name="output_message", method="pass_message"),
-    ]
-
-    def pass_message(self) -> Message:
-        self.status = self.input_message
-        return self.input_message

langflow/components/logic/run_flow.py

@@ -1,71 +0,0 @@
-from typing import Any
-
-from langflow.base.tools.run_flow import RunFlowBaseComponent
-from langflow.helpers.flow import run_flow
-from langflow.logging.logger import logger
-from langflow.schema.dotdict import dotdict
-
-
-class RunFlowComponent(RunFlowBaseComponent):
-    display_name = "Run Flow"
-    description = (
-        "Creates a tool component from a Flow that takes all its inputs and runs it. "
-        " \n **Select a Flow to use the tool mode**"
-    )
-    documentation: str = "https://docs.langflow.org/components-logic#run-flow"
-    beta = True
-    name = "RunFlow"
-    icon = "Workflow"
-
-    inputs = RunFlowBaseComponent._base_inputs
-    outputs = RunFlowBaseComponent._base_outputs
-
-    async def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
-        if field_name == "flow_name_selected":
-            build_config["flow_name_selected"]["options"] = await self.get_flow_names()
-            missing_keys = [key for key in self.default_keys if key not in build_config]
-            if missing_keys:
-                msg = f"Missing required keys in build_config: {missing_keys}"
-                raise ValueError(msg)
-            if field_value is not None:
-                try:
-                    graph = await self.get_graph(field_value)
-                    build_config = self.update_build_config_from_graph(build_config, graph)
-                except Exception as e:
-                    msg = f"Error building graph for flow {field_value}"
-                    await logger.aexception(msg)
-                    raise RuntimeError(msg) from e
-        return build_config
-
-    async def run_flow_with_tweaks(self):
-        tweaks: dict = {}
-
-        flow_name_selected = self._attributes.get("flow_name_selected")
-        parsed_flow_tweak_data = self._attributes.get("flow_tweak_data", {})
-        if not isinstance(parsed_flow_tweak_data, dict):
-            parsed_flow_tweak_data = parsed_flow_tweak_data.dict()
-
-        if parsed_flow_tweak_data != {}:
-            for field in parsed_flow_tweak_data:
-                if "~" in field:
-                    [node, name] = field.split("~")
-                    if node not in tweaks:
-                        tweaks[node] = {}
-                    tweaks[node][name] = parsed_flow_tweak_data[field]
-        else:
-            for field in self._attributes:
-                if field not in self.default_keys and "~" in field:
-                    [node, name] = field.split("~")
-                    if node not in tweaks:
-                        tweaks[node] = {}
-                    tweaks[node][name] = self._attributes[field]
-
-        return await run_flow(
-            inputs=None,
-            output_type="all",
-            flow_id=None,
-            flow_name=flow_name_selected,
-            tweaks=tweaks,
-            user_id=str(self.user_id),
-            session_id=self.graph.session_id or self.session_id,
-        )

langflow/components/logic/sub_flow.py

@@ -1,114 +0,0 @@
-from typing import Any
-
-from langflow.base.flow_processing.utils import build_data_from_result_data
-from langflow.custom.custom_component.component import Component
-from langflow.graph.graph.base import Graph
-from langflow.graph.vertex.base import Vertex
-from langflow.helpers.flow import get_flow_inputs
-from langflow.io import DropdownInput, Output
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.schema.dotdict import dotdict
-
-
-class SubFlowComponent(Component):
-    display_name = "Sub Flow [Deprecated]"
-    description = "Generates a Component from a Flow, with all of its inputs, and "
-    name = "SubFlow"
-    legacy: bool = True
-    icon = "Workflow"
-
-    async def get_flow_names(self) -> list[str]:
-        flow_data = await self.alist_flows()
-        return [flow_data.data["name"] for flow_data in flow_data]
-
-    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):
-        if field_name == "flow_name":
-            build_config["flow_name"]["options"] = await self.get_flow_names()
-
-        for key in list(build_config.keys()):
-            if key not in [x.name for x in self.inputs] + ["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_vertex: list[Vertex], build_config: dotdict):
-        new_fields: list[dotdict] = []
-
-        for vertex in inputs_vertex:
-            new_vertex_inputs = []
-            field_template = vertex.data["node"]["template"]
-            for inp in field_template:
-                if inp not in {"code", "_type"}:
-                    field_template[inp]["display_name"] = (
-                        vertex.display_name + " - " + field_template[inp]["display_name"]
-                    )
-                    field_template[inp]["name"] = vertex.id + "|" + inp
-                    new_vertex_inputs.append(field_template[inp])
-            new_fields += new_vertex_inputs
-        for field in new_fields:
-            build_config[field["name"]] = field
-        return build_config
-
-    inputs = [
-        DropdownInput(
-            name="flow_name",
-            display_name="Flow Name",
-            info="The name of the flow to run.",
-            options=[],
-            refresh_button=True,
-            real_time_refresh=True,
-        ),
-    ]
-
-    outputs = [Output(name="flow_outputs", display_name="Flow Outputs", method="generate_results")]
-
-    async def generate_results(self) -> list[Data]:
-        tweaks: dict = {}
-        for field in self._attributes:
-            if field != "flow_name" and "|" in field:
-                [node, name] = field.split("|")
-                if node not in tweaks:
-                    tweaks[node] = {}
-                tweaks[node][name] = self._attributes[field]
-        flow_name = self._attributes.get("flow_name")
-        run_outputs = await self.run_flow(
-            tweaks=tweaks,
-            flow_name=flow_name,
-            output_type="all",
-        )
-        data: list[Data] = []
-        if not run_outputs:
-            return data
-        run_output = run_outputs[0]
-
-        if run_output is not None:
-            for output in run_output.outputs:
-                if output:
-                    data.extend(build_data_from_result_data(output))
-        return data

langflow/components/maritalk/__init__.py

@@ -1,32 +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.maritalk.maritalk import MaritalkModelComponent
-
-_dynamic_imports = {
-    "MaritalkModelComponent": "maritalk",
-}
-
-__all__ = ["MaritalkModelComponent"]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import maritalk 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/maritalk/maritalk.py

@@ -1,52 +0,0 @@
-from langchain_community.chat_models import ChatMaritalk
-
-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 DropdownInput, FloatInput, IntInput, SecretStrInput
-
-
-class MaritalkModelComponent(LCModelComponent):
-    display_name = "MariTalk"
-    description = "Generates text using MariTalk LLMs."
-    icon = "Maritalk"
-    name = "Maritalk"
-    inputs = [
-        *LCModelComponent._base_inputs,
-        IntInput(
-            name="max_tokens",
-            display_name="Max Tokens",
-            advanced=True,
-            value=512,
-            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            advanced=False,
-            options=["sabia-2-small", "sabia-2-medium"],
-            value=["sabia-2-small"],
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="MariTalk API Key",
-            info="The MariTalk API Key to use for authentication.",
-            advanced=False,
-        ),
-        FloatInput(name="temperature", display_name="Temperature", value=0.1, range_spec=RangeSpec(min=0, max=1)),
-    ]
-
-    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
-        # self.output_schea is a list of dictionarie s
-        # let's convert it to a dictionary
-        api_key = self.api_key
-        temperature = self.temperature
-        model_name: str = self.model_name
-        max_tokens = self.max_tokens
-
-        return ChatMaritalk(
-            max_tokens=max_tokens,
-            model=model_name,
-            api_key=api_key,
-            temperature=temperature or 0.1,
-        )

langflow/components/mem0/__init__.py

@@ -1,3 +0,0 @@
-from .mem0_chat_memory import Mem0MemoryComponent
-
-__all__ = ["Mem0MemoryComponent"]