lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/components/{data → files_and_knowledge}/save_file.py

@@ -9,7 +9,7 @@ from fastapi.encoders import jsonable_encoder
 
 from lfx.custom import Component
 from lfx.inputs import SortableListInput
-from lfx.io import DropdownInput, HandleInput, SecretStrInput, StrInput
+from lfx.io import BoolInput, DropdownInput, HandleInput, SecretStrInput, StrInput
 from lfx.schema import Data, DataFrame, Message
 from lfx.services.deps import get_settings_service, get_storage_service, session_scope
 from lfx.template.field.base import Output
@@ -18,7 +18,7 @@ from lfx.template.field.base import Output
 class SaveToFileComponent(Component):
     display_name = "Write File"
     description = "Save data to local file, AWS S3, or Google Drive in the selected format."
-    documentation: str = "https://docs.langflow.org/components-processing#save-file"
+    documentation: str = "https://docs.langflow.org/write-file"
     icon = "file-text"
     name = "SaveToFile"
 
@@ -74,6 +74,13 @@ class SaveToFileComponent(Component):
             show=False,
             tool_mode=True,
         ),
+        BoolInput(
+            name="append_mode",
+            display_name="Append",
+            info="Append to file if it exists (only for plain text formats). Disabled for binary formats like Excel.",
+            value=False,
+            show=False,
+        ),
         # Format inputs (dynamic based on storage location)
         DropdownInput(
             name="local_format",
@@ -168,6 +175,7 @@ class SaveToFileComponent(Component):
         # Hide all dynamic fields first
         dynamic_fields = [
             "file_name",  # Common fields (input is always visible)
+            "append_mode",
             "local_format",
             "aws_format",
             "gdrive_format",
@@ -188,9 +196,11 @@ class SaveToFileComponent(Component):
         if len(selected) == 1:
             location = selected[0]
 
-            # Show file_name when any storage location is selected (input is always visible)
+            # Show file_name and append_mode when any storage location is selected
             if "file_name" in build_config:
                 build_config["file_name"]["show"] = True
+            if "append_mode" in build_config:
+                build_config["append_mode"]["show"] = True
 
             if location == "Local":
                 if "local_format" in build_config:
@@ -274,6 +284,11 @@ class SaveToFileComponent(Component):
             return Path(f"{path}.xlsx").expanduser() if file_extension not in ["xlsx", "xls"] else path
         return Path(f"{path}.{fmt}").expanduser() if file_extension != fmt else path
 
+    def _is_plain_text_format(self, fmt: str) -> bool:
+        """Check if a file format is plain text (supports appending)."""
+        plain_text_formats = ["txt", "json", "markdown", "md", "csv", "xml", "html", "yaml", "log", "tsv", "jsonl"]
+        return fmt.lower() in plain_text_formats
+
     async def _upload_file(self, file_path: Path) -> None:
         """Upload the saved file using the upload_user_file service."""
         from langflow.api.v2.files import upload_user_file
@@ -284,7 +299,8 @@ class SaveToFileComponent(Component):
             msg = f"File not found: {file_path}"
             raise FileNotFoundError(msg)
 
-        # Upload the file
+        # Upload the file - always use append=False because the local file already contains
+        # the correct content (either new or appended locally)
         with file_path.open("rb") as f:
             async with session_scope() as db:
                 if not self.user_id:
@@ -298,39 +314,109 @@ class SaveToFileComponent(Component):
                     current_user=current_user,
                     storage_service=get_storage_service(),
                     settings_service=get_settings_service(),
+                    append=False,
                 )
 
     def _save_dataframe(self, dataframe: DataFrame, path: Path, fmt: str) -> str:
         """Save a DataFrame to the specified file format."""
+        append_mode = getattr(self, "append_mode", False)
+        should_append = append_mode and path.exists() and self._is_plain_text_format(fmt)
+
         if fmt == "csv":
-            dataframe.to_csv(path, index=False)
+            dataframe.to_csv(path, index=False, mode="a" if should_append else "w", header=not should_append)
         elif fmt == "excel":
             dataframe.to_excel(path, index=False, engine="openpyxl")
         elif fmt == "json":
-            dataframe.to_json(path, orient="records", indent=2)
+            if should_append:
+                # Read and parse existing JSON
+                existing_data = []
+                try:
+                    existing_content = path.read_text(encoding="utf-8").strip()
+                    if existing_content:
+                        parsed = json.loads(existing_content)
+                        # Handle case where existing content is a single object
+                        if isinstance(parsed, dict):
+                            existing_data = [parsed]
+                        elif isinstance(parsed, list):
+                            existing_data = parsed
+                except (json.JSONDecodeError, FileNotFoundError):
+                    # Treat parse errors or missing file as empty array
+                    existing_data = []
+
+                # Append new data
+                new_records = json.loads(dataframe.to_json(orient="records"))
+                existing_data.extend(new_records)
+
+                # Write back as a single JSON array
+                path.write_text(json.dumps(existing_data, indent=2), encoding="utf-8")
+            else:
+                dataframe.to_json(path, orient="records", indent=2)
         elif fmt == "markdown":
-            path.write_text(dataframe.to_markdown(index=False), encoding="utf-8")
+            content = dataframe.to_markdown(index=False)
+            if should_append:
+                path.write_text(path.read_text(encoding="utf-8") + "\n\n" + content, encoding="utf-8")
+            else:
+                path.write_text(content, encoding="utf-8")
         else:
             msg = f"Unsupported DataFrame format: {fmt}"
             raise ValueError(msg)
-        return f"DataFrame saved successfully as '{path}'"
+        action = "appended to" if should_append else "saved successfully as"
+        return f"DataFrame {action} '{path}'"
 
     def _save_data(self, data: Data, path: Path, fmt: str) -> str:
         """Save a Data object to the specified file format."""
+        append_mode = getattr(self, "append_mode", False)
+        should_append = append_mode and path.exists() and self._is_plain_text_format(fmt)
+
         if fmt == "csv":
-            pd.DataFrame(data.data).to_csv(path, index=False)
+            pd.DataFrame(data.data).to_csv(
+                path,
+                index=False,
+                mode="a" if should_append else "w",
+                header=not should_append,
+            )
         elif fmt == "excel":
             pd.DataFrame(data.data).to_excel(path, index=False, engine="openpyxl")
         elif fmt == "json":
-            path.write_text(
-                orjson.dumps(jsonable_encoder(data.data), option=orjson.OPT_INDENT_2).decode("utf-8"), encoding="utf-8"
-            )
+            new_data = jsonable_encoder(data.data)
+            if should_append:
+                # Read and parse existing JSON
+                existing_data = []
+                try:
+                    existing_content = path.read_text(encoding="utf-8").strip()
+                    if existing_content:
+                        parsed = json.loads(existing_content)
+                        # Handle case where existing content is a single object
+                        if isinstance(parsed, dict):
+                            existing_data = [parsed]
+                        elif isinstance(parsed, list):
+                            existing_data = parsed
+                except (json.JSONDecodeError, FileNotFoundError):
+                    # Treat parse errors or missing file as empty array
+                    existing_data = []
+
+                # Append new data
+                if isinstance(new_data, list):
+                    existing_data.extend(new_data)
+                else:
+                    existing_data.append(new_data)
+
+                # Write back as a single JSON array
+                path.write_text(json.dumps(existing_data, indent=2), encoding="utf-8")
+            else:
+                content = orjson.dumps(new_data, option=orjson.OPT_INDENT_2).decode("utf-8")
+                path.write_text(content, encoding="utf-8")
         elif fmt == "markdown":
-            path.write_text(pd.DataFrame(data.data).to_markdown(index=False), encoding="utf-8")
+            content = pd.DataFrame(data.data).to_markdown(index=False)
+            if should_append:
+                path.write_text(path.read_text(encoding="utf-8") + "\n\n" + content, encoding="utf-8")
+            else:
+                path.write_text(content, encoding="utf-8")
         else:
             msg = f"Unsupported Data format: {fmt}"
             raise ValueError(msg)
-        return f"Data saved successfully as '{path}'"
+        action = "appended to" if should_append else "saved successfully as"
+        return f"Data {action} '{path}'"
 
     async def _save_message(self, message: Message, path: Path, fmt: str) -> str:
         """Save a Message to the specified file format, handling async iterators."""
@@ -346,16 +432,50 @@ class SaveToFileComponent(Component):
         else:
             content = str(message.text)
 
+        append_mode = getattr(self, "append_mode", False)
+        should_append = append_mode and path.exists() and self._is_plain_text_format(fmt)
+
         if fmt == "txt":
-            path.write_text(content, encoding="utf-8")
+            if should_append:
+                path.write_text(path.read_text(encoding="utf-8") + "\n" + content, encoding="utf-8")
+            else:
+                path.write_text(content, encoding="utf-8")
         elif fmt == "json":
-            path.write_text(json.dumps({"message": content}, indent=2), encoding="utf-8")
+            new_message = {"message": content}
+            if should_append:
+                # Read and parse existing JSON
+                existing_data = []
+                try:
+                    existing_content = path.read_text(encoding="utf-8").strip()
+                    if existing_content:
+                        parsed = json.loads(existing_content)
+                        # Handle case where existing content is a single object
+                        if isinstance(parsed, dict):
+                            existing_data = [parsed]
+                        elif isinstance(parsed, list):
+                            existing_data = parsed
+                except (json.JSONDecodeError, FileNotFoundError):
+                    # Treat parse errors or missing file as empty array
+                    existing_data = []
+
+                # Append new message
+                existing_data.append(new_message)
+
+                # Write back as a single JSON array
+                path.write_text(json.dumps(existing_data, indent=2), encoding="utf-8")
+            else:
+                path.write_text(json.dumps(new_message, indent=2), encoding="utf-8")
         elif fmt == "markdown":
-            path.write_text(f"**Message:**\n\n{content}", encoding="utf-8")
+            md_content = f"**Message:**\n\n{content}"
+            if should_append:
+                path.write_text(path.read_text(encoding="utf-8") + "\n\n" + md_content, encoding="utf-8")
+            else:
+                path.write_text(md_content, encoding="utf-8")
         else:
             msg = f"Unsupported Message format: {fmt}"
             raise ValueError(msg)
-        return f"Message saved successfully as '{path}'"
+        action = "appended to" if should_append else "saved successfully as"
+        return f"Message {action} '{path}'"
 
     def _get_selected_storage_location(self) -> str:
         """Get the selected storage location from the SortableListInput."""
@@ -510,7 +630,7 @@ class SaveToFileComponent(Component):
 
         # Handle special Google Drive formats
         if file_format in ["slides", "docs"]:
-            return await self._save_to_google_apps(drive_service, content, file_format)
+            return await self._save_to_google_apps(drive_service, credentials, content, file_format)
 
         # Create temporary file
         file_path = f"{self.file_name}.{file_format}"
@@ -533,14 +653,14 @@ class SaveToFileComponent(Component):
             if Path(temp_file_path).exists():
                 Path(temp_file_path).unlink()
 
-    async def _save_to_google_apps(self, drive_service, content: str, app_type: str) -> Message:
+    async def _save_to_google_apps(self, drive_service, credentials, content: str, app_type: str) -> Message:
         """Save content to Google Apps (Slides or Docs)."""
         import time
 
         if app_type == "slides":
             from googleapiclient.discovery import build
 
-            slides_service = build("slides", "v1", credentials=drive_service._http.credentials)
+            slides_service = build("slides", "v1", credentials=credentials)
 
             file_metadata = {
                 "name": self.file_name,
@@ -589,7 +709,7 @@ class SaveToFileComponent(Component):
         elif app_type == "docs":
             from googleapiclient.discovery import build
 
-            docs_service = build("docs", "v1", credentials=drive_service._http.credentials)
+            docs_service = build("docs", "v1", credentials=credentials)
 
             file_metadata = {
                 "name": self.file_name,

lfx/components/flow_controls/__init__.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.flow_controls.conditional_router import ConditionalRouterComponent
+    from lfx.components.flow_controls.data_conditional_router import DataConditionalRouterComponent
+    from lfx.components.flow_controls.flow_tool import FlowToolComponent
+    from lfx.components.flow_controls.listen import ListenComponent
+    from lfx.components.flow_controls.loop import LoopComponent
+    from lfx.components.flow_controls.notify import NotifyComponent
+    from lfx.components.flow_controls.pass_message import PassMessageComponent
+    from lfx.components.flow_controls.run_flow import RunFlowComponent
+    from lfx.components.flow_controls.sub_flow import SubFlowComponent
+
+_dynamic_imports = {
+    "ConditionalRouterComponent": "conditional_router",
+    "DataConditionalRouterComponent": "data_conditional_router",
+    "FlowToolComponent": "flow_tool",
+    "ListenComponent": "listen",
+    "LoopComponent": "loop",
+    "NotifyComponent": "notify",
+    "PassMessageComponent": "pass_message",
+    "RunFlowComponent": "run_flow",
+    "SubFlowComponent": "sub_flow",
+}
+
+__all__ = [
+    "ConditionalRouterComponent",
+    "DataConditionalRouterComponent",
+    "FlowToolComponent",
+    "ListenComponent",
+    "LoopComponent",
+    "NotifyComponent",
+    "PassMessageComponent",
+    "RunFlowComponent",
+    "SubFlowComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import flow control components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/{logic → flow_controls}/conditional_router.py

@@ -8,7 +8,7 @@ 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/components-logic#conditional-router-if-else-component"
+    documentation: str = "https://docs.langflow.org/if-else"
     icon = "split"
     name = "ConditionalRouter"
 

lfx/components/{logic → flow_controls}/loop.py

@@ -1,29 +1,40 @@
+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 objects, outputting one item at a time and aggregating results from loop inputs."
+        "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/components-logic#loop"
+    documentation: str = "https://docs.langflow.org/loop"
     icon = "infinity"
 
     inputs = [
         HandleInput(
             name="data",
             display_name="Inputs",
-            info="The initial list of Data objects or DataFrame to iterate over.",
+            info="The initial 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="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),
     ]
 
@@ -45,15 +56,30 @@ class LoopComponent(Component):
             }
         )
 
+    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."""
+        """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, 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."
+        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:
@@ -116,14 +142,22 @@ class LoopComponent(Component):
         )
 
     def aggregated_output(self) -> list[Data]:
-        """Return the aggregated list once all items are processed."""
+        """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

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/glean/glean_search_api.py

@@ -101,7 +101,7 @@ class GleanAPIWrapper(BaseModel):
 class GleanSearchAPIComponent(LCToolComponent):
     display_name: str = "Glean Search API"
     description: str = "Search using Glean's API."
-    documentation: str = "https://docs.langflow.org/Components/components-tools#glean-search-api"
+    documentation: str = "https://docs.langflow.org/bundles-glean"
     icon: str = "Glean"
 
     outputs = [