lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev41__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,16 @@ class SaveToFileComponent(Component):
             show=False,
             tool_mode=True,
         ),
+        BoolInput(
+            name="append_mode",
+            display_name="Append",
+            info=(
+                "Append to file if it exists (only for Local storage with plain text formats). "
+                "Not supported for cloud storage (AWS/Google Drive)."
+            ),
+            value=False,
+            show=False,
+        ),
         # Format inputs (dynamic based on storage location)
         DropdownInput(
             name="local_format",
@@ -150,6 +160,7 @@ class SaveToFileComponent(Component):
                 "The Google Drive folder ID where the file will be uploaded. "
                 "The folder must be shared with the service account email."
             ),
+            required=True,
             show=False,
             advanced=True,
         ),
@@ -168,6 +179,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,10 +200,14 @@ 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 when any storage location is selected
             if "file_name" in build_config:
                 build_config["file_name"]["show"] = True
 
+            # Show append_mode only for Local storage (not supported for cloud storage)
+            if "append_mode" in build_config:
+                build_config["append_mode"]["show"] = location == "Local"
+
             if location == "Local":
                 if "local_format" in build_config:
                     build_config["local_format"]["show"] = True
@@ -274,6 +290,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 +305,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 +320,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 +438,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."""
@@ -455,7 +581,9 @@ class SaveToFileComponent(Component):
         # Create temporary file
         import tempfile
 
-        with tempfile.NamedTemporaryFile(mode="w", suffix=f".{file_format}", delete=False) as temp_file:
+        with tempfile.NamedTemporaryFile(
+            mode="w", encoding="utf-8", suffix=f".{file_format}", delete=False
+        ) as temp_file:
             temp_file.write(content)
             temp_file_path = temp_file.name
 
@@ -491,16 +619,57 @@ class SaveToFileComponent(Component):
             msg = "Google API client libraries are not installed. Please install them."
             raise ImportError(msg) from e
 
-        # Parse credentials
+        # Parse credentials with multiple fallback strategies
+        credentials_dict = None
+        parse_errors = []
+
+        # Strategy 1: Parse as-is with strict=False to allow control characters
         try:
-            credentials_dict = json.loads(self.service_account_key)
+            credentials_dict = json.loads(self.service_account_key, strict=False)
         except json.JSONDecodeError as e:
-            msg = f"Invalid JSON in service account key: {e!s}"
-            raise ValueError(msg) from e
+            parse_errors.append(f"Standard parse: {e!s}")
+
+        # Strategy 2: Strip whitespace and try again
+        if credentials_dict is None:
+            try:
+                cleaned_key = self.service_account_key.strip()
+                credentials_dict = json.loads(cleaned_key, strict=False)
+            except json.JSONDecodeError as e:
+                parse_errors.append(f"Stripped parse: {e!s}")
+
+        # Strategy 3: Check if it's double-encoded (JSON string of a JSON string)
+        if credentials_dict is None:
+            try:
+                decoded_once = json.loads(self.service_account_key, strict=False)
+                if isinstance(decoded_once, str):
+                    credentials_dict = json.loads(decoded_once, strict=False)
+                else:
+                    credentials_dict = decoded_once
+            except json.JSONDecodeError as e:
+                parse_errors.append(f"Double-encoded parse: {e!s}")
+
+        # Strategy 4: Try to fix common issues with newlines in the private_key field
+        if credentials_dict is None:
+            try:
+                # Replace literal \n with actual newlines which is common in pasted JSON
+                fixed_key = self.service_account_key.replace("\\n", "\n")
+                credentials_dict = json.loads(fixed_key, strict=False)
+            except json.JSONDecodeError as e:
+                parse_errors.append(f"Newline-fixed parse: {e!s}")
+
+        if credentials_dict is None:
+            error_details = "; ".join(parse_errors)
+            msg = (
+                f"Unable to parse service account key JSON. Tried multiple strategies: {error_details}. "
+                "Please ensure you've copied the entire JSON content from your service account key file. "
+                "The JSON should start with '{' and contain fields like 'type', 'project_id', 'private_key', etc."
+            )
+            raise ValueError(msg)
 
-        # Create Google Drive service
+        # Create Google Drive service with appropriate scopes
+        # Use drive scope for folder access, file scope is too restrictive for folder verification
         credentials = service_account.Credentials.from_service_account_info(
-            credentials_dict, scopes=["https://www.googleapis.com/auth/drive.file"]
+            credentials_dict, scopes=["https://www.googleapis.com/auth/drive"]
         )
         drive_service = build("drive", "v3", credentials=credentials)
 
@@ -510,20 +679,38 @@ 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}"
-        with tempfile.NamedTemporaryFile(mode="w", suffix=f".{file_format}", delete=False) as temp_file:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            suffix=f".{file_format}",
+            delete=False,
+        ) as temp_file:
             temp_file.write(content)
             temp_file_path = temp_file.name
 
         try:
             # Upload to Google Drive
+            # Note: We skip explicit folder verification since it requires broader permissions.
+            # If the folder doesn't exist or isn't accessible, the create() call will fail with a clear error.
             file_metadata = {"name": file_path, "parents": [self.folder_id]}
             media = MediaFileUpload(temp_file_path, resumable=True)
 
-            uploaded_file = drive_service.files().create(body=file_metadata, media_body=media, fields="id").execute()
+            try:
+                uploaded_file = (
+                    drive_service.files().create(body=file_metadata, media_body=media, fields="id").execute()
+                )
+            except Exception as e:
+                msg = (
+                    f"Unable to upload file to Google Drive folder '{self.folder_id}'. "
+                    f"Error: {e!s}. "
+                    "Please ensure: 1) The folder ID is correct, 2) The folder exists, "
+                    "3) The service account has been granted access to this folder."
+                )
+                raise ValueError(msg) from e
 
             file_id = uploaded_file.get("id")
             file_url = f"https://drive.google.com/file/d/{file_id}/view"
@@ -533,14 +720,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 +776,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