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

lfx/components/flow_controls/notify.py

@@ -0,0 +1,88 @@
+from typing import cast
+
+from lfx.custom import Component
+from lfx.io import BoolInput, HandleInput, Output, StrInput
+from lfx.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)

lfx/components/flow_controls/pass_message.py

@@ -0,0 +1,36 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageInput
+from lfx.schema.message import Message
+from lfx.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
+    replacement = ["logic.ConditionalRouter"]
+
+    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

lfx/components/flow_controls/run_flow.py

@@ -0,0 +1,108 @@
+from datetime import datetime
+from typing import Any
+
+from lfx.base.tools.run_flow import RunFlowBaseComponent
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dotdict import dotdict
+
+
+class RunFlowComponent(RunFlowBaseComponent):
+    display_name = "Run Flow"
+    description = (
+        "Executes another flow from within the same project. Can also be used as a tool for agents."
+        " \n **Select a Flow to use the tool mode**"
+    )
+    documentation: str = "https://docs.langflow.org/run-flow"
+    beta = True
+    name = "RunFlow"
+    icon = "Workflow"
+
+    inputs = RunFlowBaseComponent.get_base_inputs()
+    outputs = RunFlowBaseComponent.get_base_outputs()
+
+    async def update_build_config(
+        self,
+        build_config: dotdict,
+        field_value: Any,
+        field_name: str | None = None,
+    ):
+        missing_keys = [key for key in self.default_keys if key not in build_config]
+        for key in missing_keys:
+            if key == "flow_name_selected":
+                build_config[key] = {"options": [], "options_metadata": [], "value": None}
+            elif key == "flow_id_selected":
+                build_config[key] = {"value": None}
+            elif key == "cache_flow":
+                build_config[key] = {"value": False}
+            else:
+                build_config[key] = {}
+        if field_name == "flow_name_selected" and (build_config.get("is_refresh", False) or field_value is None):
+            # refresh button was clicked or componented was initialized, so list the flows
+            options: list[str] = await self.alist_flows_by_flow_folder()
+            build_config["flow_name_selected"]["options"] = [flow.data["name"] for flow in options]
+            build_config["flow_name_selected"]["options_metadata"] = []
+            for flow in options:
+                # populate options_metadata
+                build_config["flow_name_selected"]["options_metadata"].append(
+                    {"id": flow.data["id"], "updated_at": flow.data["updated_at"]}
+                )
+                # update selected flow if it is stale
+                if str(flow.data["id"]) == self.flow_id_selected:
+                    await self.check_and_update_stale_flow(flow, build_config)
+        elif field_name in {"flow_name_selected", "flow_id_selected"} and field_value is not None:
+            # flow was selected by name or id, so get the flow and update the bcfg
+            try:
+                # derive flow id if the field_name is flow_name_selected
+                build_config["flow_id_selected"]["value"] = (
+                    self.get_selected_flow_meta(build_config, "id") or build_config["flow_id_selected"]["value"]
+                )
+                updated_at = self.get_selected_flow_meta(build_config, "updated_at")
+                await self.load_graph_and_update_cfg(
+                    build_config, build_config["flow_id_selected"]["value"], updated_at
+                )
+            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
+
+    def get_selected_flow_meta(self, build_config: dotdict, field: str) -> dict:
+        """Get the selected flow's metadata from the build config."""
+        return build_config.get("flow_name_selected", {}).get("selected_metadata", {}).get(field)
+
+    async def load_graph_and_update_cfg(
+        self,
+        build_config: dotdict,
+        flow_id: str,
+        updated_at: str | datetime,
+    ) -> None:
+        """Load a flow's graph and update the build config."""
+        graph = await self.get_graph(
+            flow_id_selected=flow_id,
+            updated_at=self.get_str_isots(updated_at),
+        )
+        self.update_build_config_from_graph(build_config, graph)
+
+    def should_update_stale_flow(self, flow: Data, build_config: dotdict) -> bool:
+        """Check if the flow should be updated."""
+        return (
+            (updated_at := self.get_str_isots(flow.data["updated_at"]))  # true updated_at date just fetched from db
+            and (stale_at := self.get_selected_flow_meta(build_config, "updated_at"))  # outdated date in bcfg
+            and self._parse_timestamp(updated_at) > self._parse_timestamp(stale_at)  # stale flow condition
+        )
+
+    async def check_and_update_stale_flow(self, flow: Data, build_config: dotdict) -> None:
+        """Check if the flow should be updated and update it if necessary."""
+        # TODO: improve contract/return value
+        if self.should_update_stale_flow(flow, build_config):
+            await self.load_graph_and_update_cfg(
+                build_config,
+                flow.data["id"],
+                flow.data["updated_at"],
+            )
+
+    def get_str_isots(self, date: datetime | str) -> str:
+        """Get a string timestamp from a datetime or string."""
+        return date.isoformat() if hasattr(date, "isoformat") else date

lfx/components/flow_controls/sub_flow.py

@@ -0,0 +1,115 @@
+from typing import Any
+
+from lfx.base.flow_processing.utils import build_data_from_result_data
+from lfx.custom.custom_component.component import Component
+from lfx.graph.graph.base import Graph
+from lfx.graph.vertex.base import Vertex
+from lfx.helpers import get_flow_inputs
+from lfx.io import DropdownInput, Output
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dotdict import dotdict
+
+
+class SubFlowComponent(Component):
+    display_name = "Sub Flow"
+    description = "Generates a Component from a Flow, with all of its inputs, and "
+    name = "SubFlow"
+    legacy: bool = True
+    replacement = ["logic.RunFlow"]
+    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

lfx/components/git/__init__.py

@@ -0,0 +1,4 @@
+from .git import GitLoaderComponent
+from .gitextractor import GitExtractorComponent
+
+__all__ = ["GitExtractorComponent", "GitLoaderComponent"]

lfx/components/git/git.py

@@ -0,0 +1,262 @@
+import re
+import tempfile
+from contextlib import asynccontextmanager
+from fnmatch import fnmatch
+from pathlib import Path
+
+import anyio
+from langchain_community.document_loaders.git import GitLoader
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import DropdownInput, MessageTextInput, Output
+from lfx.schema.data import Data
+
+
+class GitLoaderComponent(Component):
+    display_name = "Git"
+    description = (
+        "Load and filter documents from a local or remote Git repository. "
+        "Use a local repo path or clone from a remote URL."
+    )
+    trace_type = "tool"
+    icon = "GitLoader"
+
+    inputs = [
+        DropdownInput(
+            name="repo_source",
+            display_name="Repository Source",
+            options=["Local", "Remote"],
+            required=True,
+            info="Select whether to use a local repo path or clone from a remote URL.",
+            real_time_refresh=True,
+        ),
+        MessageTextInput(
+            name="repo_path",
+            display_name="Local Repository Path",
+            required=False,
+            info="The local path to the existing Git repository (used if 'Local' is selected).",
+            dynamic=True,
+            show=False,
+        ),
+        MessageTextInput(
+            name="clone_url",
+            display_name="Clone URL",
+            required=False,
+            info="The URL of the Git repository to clone (used if 'Clone' is selected).",
+            dynamic=True,
+            show=False,
+        ),
+        MessageTextInput(
+            name="branch",
+            display_name="Branch",
+            required=False,
+            value="main",
+            info="The branch to load files from. Defaults to 'main'.",
+        ),
+        MessageTextInput(
+            name="file_filter",
+            display_name="File Filter",
+            required=False,
+            advanced=True,
+            info=(
+                "Patterns to filter files. For example:\n"
+                "Include only .py files: '*.py'\n"
+                "Exclude .py files: '!*.py'\n"
+                "Multiple patterns can be separated by commas."
+            ),
+        ),
+        MessageTextInput(
+            name="content_filter",
+            display_name="Content Filter",
+            required=False,
+            advanced=True,
+            info="A regex pattern to filter files based on their content.",
+        ),
+    ]
+
+    outputs = [
+        Output(name="data", display_name="Data", method="load_documents"),
+    ]
+
+    @staticmethod
+    def is_binary(file_path: str | Path) -> bool:
+        """Check if a file is binary by looking for null bytes."""
+        try:
+            with Path(file_path).open("rb") as file:
+                content = file.read(1024)
+                return b"\x00" in content
+        except Exception:  # noqa: BLE001
+            return True
+
+    @staticmethod
+    def check_file_patterns(file_path: str | Path, patterns: str) -> bool:
+        """Check if a file matches the given patterns.
+
+        Args:
+            file_path: Path to the file to check
+            patterns: Comma-separated list of glob patterns
+
+        Returns:
+            bool: True if file should be included, False if excluded
+        """
+        # Handle empty or whitespace-only patterns
+        if not patterns or patterns.isspace():
+            return True
+
+        path_str = str(file_path)
+        file_name = Path(path_str).name
+        pattern_list: list[str] = [pattern.strip() for pattern in patterns.split(",") if pattern.strip()]
+
+        # If no valid patterns after stripping, treat as include all
+        if not pattern_list:
+            return True
+
+        # Process exclusion patterns first
+        for pattern in pattern_list:
+            if pattern.startswith("!"):
+                # For exclusions, match against both full path and filename
+                exclude_pattern = pattern[1:]
+                if fnmatch(path_str, exclude_pattern) or fnmatch(file_name, exclude_pattern):
+                    return False
+
+        # Then check inclusion patterns
+        include_patterns = [p for p in pattern_list if not p.startswith("!")]
+        # If no include patterns, treat as include all
+        if not include_patterns:
+            return True
+
+        # For inclusions, match against both full path and filename
+        return any(fnmatch(path_str, pattern) or fnmatch(file_name, pattern) for pattern in include_patterns)
+
+    @staticmethod
+    def check_content_pattern(file_path: str | Path, pattern: str) -> bool:
+        """Check if file content matches the given regex pattern.
+
+        Args:
+            file_path: Path to the file to check
+            pattern: Regex pattern to match against content
+
+        Returns:
+            bool: True if content matches, False otherwise
+        """
+        try:
+            # Check if file is binary
+            with Path(file_path).open("rb") as file:
+                content = file.read(1024)
+                if b"\x00" in content:
+                    return False
+
+            # Try to compile the regex pattern first
+            try:
+                # Use the MULTILINE flag to better handle text content
+                content_regex = re.compile(pattern, re.MULTILINE)
+                # Test the pattern with a simple string to catch syntax errors
+                test_str = "test\nstring"
+                if not content_regex.search(test_str):
+                    # Pattern is valid but doesn't match test string
+                    pass
+            except (re.error, TypeError, ValueError):
+                return False
+
+            # If not binary and regex is valid, check content
+            with Path(file_path).open(encoding="utf-8") as file:
+                file_content = file.read()
+            return bool(content_regex.search(file_content))
+        except (OSError, UnicodeDecodeError):
+            return False
+
+    def build_combined_filter(self, file_filter_patterns: str | None = None, content_filter_pattern: str | None = None):
+        """Build a combined filter function from file and content patterns.
+
+        Args:
+            file_filter_patterns: Comma-separated glob patterns
+            content_filter_pattern: Regex pattern for content
+
+        Returns:
+            callable: Filter function that takes a file path and returns bool
+        """
+
+        def combined_filter(file_path: str) -> bool:
+            try:
+                path = Path(file_path)
+
+                # Check if file exists and is readable
+                if not path.exists():
+                    return False
+
+                # Check if file is binary
+                if self.is_binary(path):
+                    return False
+
+                # Apply file pattern filters
+                if file_filter_patterns and not self.check_file_patterns(path, file_filter_patterns):
+                    return False
+
+                # Apply content filter
+                return not (content_filter_pattern and not self.check_content_pattern(path, content_filter_pattern))
+            except Exception:  # noqa: BLE001
+                return False
+
+        return combined_filter
+
+    @asynccontextmanager
+    async def temp_clone_dir(self):
+        """Context manager for handling temporary clone directory."""
+        temp_dir = None
+        try:
+            temp_dir = tempfile.mkdtemp(prefix="langflow_clone_")
+            yield temp_dir
+        finally:
+            if temp_dir:
+                await anyio.Path(temp_dir).rmdir()
+
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
+        # Hide fields by default
+        build_config["repo_path"]["show"] = False
+        build_config["clone_url"]["show"] = False
+
+        if field_name == "repo_source":
+            if field_value == "Local":
+                build_config["repo_path"]["show"] = True
+                build_config["repo_path"]["required"] = True
+                build_config["clone_url"]["required"] = False
+            elif field_value == "Remote":
+                build_config["clone_url"]["show"] = True
+                build_config["clone_url"]["required"] = True
+                build_config["repo_path"]["required"] = False
+
+        return build_config
+
+    async def build_gitloader(self) -> GitLoader:
+        file_filter_patterns = getattr(self, "file_filter", None)
+        content_filter_pattern = getattr(self, "content_filter", None)
+
+        combined_filter = self.build_combined_filter(file_filter_patterns, content_filter_pattern)
+
+        repo_source = getattr(self, "repo_source", None)
+        if repo_source == "Local":
+            repo_path = self.repo_path
+            clone_url = None
+        else:
+            # Clone source
+            clone_url = self.clone_url
+            async with self.temp_clone_dir() as temp_dir:
+                repo_path = temp_dir
+
+        # Only pass branch if it's explicitly set
+        branch = getattr(self, "branch", None)
+        if not branch:
+            branch = None
+
+        return GitLoader(
+            repo_path=repo_path,
+            clone_url=clone_url if repo_source == "Remote" else None,
+            branch=branch,
+            file_filter=combined_filter,
+        )
+
+    async def load_documents(self) -> list[Data]:
+        gitloader = await self.build_gitloader()
+        data = [Data.from_document(doc) async for doc in gitloader.alazy_load()]
+        self.status = data
+        return data