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

lfx/schema/dataframe.py

@@ -0,0 +1,210 @@
+from typing import TYPE_CHECKING, cast
+
+import pandas as pd
+from langchain_core.documents import Document
+from pandas import DataFrame as pandas_DataFrame
+
+from lfx.schema.data import Data
+
+if TYPE_CHECKING:
+    from lfx.schema.message import Message
+
+
+class DataFrame(pandas_DataFrame):
+    """A pandas DataFrame subclass specialized for handling collections of Data objects.
+
+    This class extends pandas.DataFrame to provide seamless integration between
+    Langflow's Data objects and pandas' powerful data manipulation capabilities.
+
+    Args:
+        data: Input data in various formats:
+            - List[Data]: List of Data objects
+            - List[Dict]: List of dictionaries
+            - Dict: Dictionary of arrays/lists
+            - pandas.DataFrame: Existing DataFrame
+            - Any format supported by pandas.DataFrame
+        **kwargs: Additional arguments passed to pandas.DataFrame constructor
+
+    Examples:
+        >>> # From Data objects
+        >>> dataset = DataFrame([Data(data={"name": "John"}), Data(data={"name": "Jane"})])
+
+        >>> # From dictionaries
+        >>> dataset = DataFrame([{"name": "John"}, {"name": "Jane"}])
+
+        >>> # From dictionary of lists
+        >>> dataset = DataFrame({"name": ["John", "Jane"], "age": [30, 25]})
+    """
+
+    def __init__(
+        self,
+        data: list[dict] | list[Data] | pd.DataFrame | None = None,
+        text_key: str = "text",
+        default_value: str = "",
+        **kwargs,
+    ):
+        # Initialize pandas DataFrame first without data
+        super().__init__(**kwargs)  # Removed data parameter
+
+        # Store attributes as private members to avoid conflicts with pandas
+        self._text_key = text_key
+        self._default_value = default_value
+
+        if data is None:
+            return
+
+        if isinstance(data, list):
+            if all(isinstance(x, Data) for x in data):
+                data = [d.data for d in data if hasattr(d, "data")]
+            elif not all(isinstance(x, dict) for x in data):
+                msg = "List items must be either all Data objects or all dictionaries"
+                raise ValueError(msg)
+            self._update(data, **kwargs)
+        elif isinstance(data, dict | pd.DataFrame):  # Fixed type check syntax
+            self._update(data, **kwargs)
+
+    def _update(self, data, **kwargs):
+        """Helper method to update DataFrame with new data."""
+        new_df = pd.DataFrame(data, **kwargs)
+        self._update_inplace(new_df)
+
+    # Update property accessors
+    @property
+    def text_key(self) -> str:
+        return self._text_key
+
+    @text_key.setter
+    def text_key(self, value: str) -> None:
+        if value not in self.columns:
+            msg = f"Text key '{value}' not found in DataFrame columns"
+            raise ValueError(msg)
+        self._text_key = value
+
+    @property
+    def default_value(self) -> str:
+        return self._default_value
+
+    @default_value.setter
+    def default_value(self, value: str) -> None:
+        self._default_value = value
+
+    def to_data_list(self) -> list[Data]:
+        """Converts the DataFrame back to a list of Data objects."""
+        list_of_dicts = self.to_dict(orient="records")
+        # suggested change: [Data(**row) for row in list_of_dicts]
+        return [Data(data=row) for row in list_of_dicts]
+
+    def add_row(self, data: dict | Data) -> "DataFrame":
+        """Adds a single row to the dataset.
+
+        Args:
+            data: Either a Data object or a dictionary to add as a new row
+
+        Returns:
+            DataFrame: A new DataFrame with the added row
+
+        Example:
+            >>> dataset = DataFrame([{"name": "John"}])
+            >>> dataset = dataset.add_row({"name": "Jane"})
+        """
+        if isinstance(data, Data):
+            data = data.data
+        new_df = self._constructor([data])
+        return cast("DataFrame", pd.concat([self, new_df], ignore_index=True))
+
+    def add_rows(self, data: list[dict | Data]) -> "DataFrame":
+        """Adds multiple rows to the dataset.
+
+        Args:
+            data: List of Data objects or dictionaries to add as new rows
+
+        Returns:
+            DataFrame: A new DataFrame with the added rows
+        """
+        processed_data = []
+        for item in data:
+            if isinstance(item, Data):
+                processed_data.append(item.data)
+            else:
+                processed_data.append(item)
+        new_df = self._constructor(processed_data)
+        return cast("DataFrame", pd.concat([self, new_df], ignore_index=True))
+
+    @property
+    def _constructor(self):
+        def _c(*args, **kwargs):
+            return DataFrame(*args, **kwargs).__finalize__(self)
+
+        return _c
+
+    def __bool__(self):
+        """Truth value testing for the DataFrame.
+
+        Returns True if the DataFrame has at least one row, False otherwise.
+        """
+        return not self.empty
+
+    __hash__ = None  # DataFrames are mutable and shouldn't be hashable
+
+    def to_lc_documents(self) -> list[Document]:
+        """Converts the DataFrame to a list of Documents.
+
+        Returns:
+            list[Document]: The converted list of Documents.
+        """
+        list_of_dicts = self.to_dict(orient="records")
+        documents = []
+        for row in list_of_dicts:
+            data_copy = row.copy()
+            text = data_copy.pop(self._text_key, self._default_value)
+            if isinstance(text, str):
+                documents.append(Document(page_content=text, metadata=data_copy))
+            else:
+                documents.append(Document(page_content=str(text), metadata=data_copy))
+        return documents
+
+    def _docs_to_dataframe(self, docs):
+        """Converts a list of Documents to a DataFrame.
+
+        Args:
+            docs: List of Document objects
+
+        Returns:
+            DataFrame: A new DataFrame with the converted Documents
+        """
+        return DataFrame(docs)
+
+    def __eq__(self, other):
+        """Override equality to handle comparison with empty DataFrames and non-DataFrame objects."""
+        if self.empty:
+            return False
+        if isinstance(other, list) and not other:  # Empty list case
+            return False
+        if not isinstance(other, DataFrame | pd.DataFrame):  # Non-DataFrame case
+            return False
+        return super().__eq__(other)
+
+    def to_data(self) -> Data:
+        """Convert this DataFrame to a Data object.
+
+        Returns:
+            Data: A Data object containing the DataFrame records under 'results' key.
+        """
+        dict_list = self.to_dict(orient="records")
+        return Data(data={"results": dict_list})
+
+    def to_message(self) -> "Message":
+        from lfx.schema.message import Message
+
+        # Process DataFrame similar to the _safe_convert method
+        # Remove empty rows
+        processed_df = self.dropna(how="all")
+        # Remove empty lines in each cell
+        processed_df = processed_df.replace(r"^\s*$", "", regex=True)
+        # Replace multiple newlines with a single newline
+        processed_df = processed_df.replace(r"\n+", "\n", regex=True)
+        # Replace pipe characters to avoid markdown table issues
+        processed_df = processed_df.replace(r"\|", r"\\|", regex=True)
+        processed_df = processed_df.map(lambda x: str(x).replace("\n", "<br/>") if isinstance(x, str) else x)
+        # Convert to markdown and wrap in a Message
+        return Message(text=processed_df.to_markdown(index=False))

lfx/schema/dotdict.py

@@ -0,0 +1,74 @@
+"""Dot-notation dictionary implementation copied from langflow for lfx package."""
+
+
+class dotdict(dict):  # noqa: N801
+    """dotdict allows accessing dictionary elements using dot notation (e.g., dict.key instead of dict['key']).
+
+    It automatically converts nested dictionaries into dotdict instances, enabling dot notation on them as well.
+
+    Note:
+        - Only keys that are valid attribute names (e.g., strings that could be variable names) are accessible via dot
+          notation.
+        - Keys which are not valid Python attribute names or collide with the dict method names (like 'items', 'keys')
+          should be accessed using the traditional dict['key'] notation.
+    """
+
+    def __getattr__(self, attr):
+        """Override dot access to behave like dictionary lookup. Automatically convert nested dicts to dotdicts.
+
+        Args:
+            attr (str): Attribute to access.
+
+        Returns:
+            The value associated with 'attr' in the dictionary, converted to dotdict if it is a dict.
+
+        Raises:
+            AttributeError: If the attribute is not found in the dictionary.
+        """
+        try:
+            value = self[attr]
+            if isinstance(value, dict) and not isinstance(value, dotdict):
+                value = dotdict(value)
+                self[attr] = value  # Update self to nest dotdict for future accesses
+        except KeyError as e:
+            msg = f"'dotdict' object has no attribute '{attr}'"
+            raise AttributeError(msg) from e
+        else:
+            return value
+
+    def __setattr__(self, key, value) -> None:
+        """Override attribute setting to work as dictionary item assignment.
+
+        Args:
+            key (str): The key under which to store the value.
+            value: The value to store in the dictionary.
+        """
+        if isinstance(value, dict) and not isinstance(value, dotdict):
+            value = dotdict(value)
+        self[key] = value
+
+    def __delattr__(self, key) -> None:
+        """Override attribute deletion to work as dictionary item deletion.
+
+        Args:
+            key (str): The key of the item to delete from the dictionary.
+
+        Raises:
+            AttributeError: If the key is not found in the dictionary.
+        """
+        try:
+            del self[key]
+        except KeyError as e:
+            msg = f"'dotdict' object has no attribute '{key}'"
+            raise AttributeError(msg) from e
+
+    def __missing__(self, key):
+        """Handle missing keys by returning an empty dotdict. This allows chaining access without raising KeyError.
+
+        Args:
+            key: The missing key.
+
+        Returns:
+            An empty dotdict instance for the given missing key.
+        """
+        return dotdict()

lfx/schema/encoders.py

@@ -0,0 +1,13 @@
+from collections.abc import Callable
+from datetime import datetime
+
+
+def encode_callable(obj: Callable):
+    return obj.__name__ if hasattr(obj, "__name__") else str(obj)
+
+
+def encode_datetime(obj: datetime):
+    return obj.strftime("%Y-%m-%d %H:%M:%S %Z")
+
+
+CUSTOM_ENCODERS = {Callable: encode_callable, datetime: encode_datetime}

lfx/schema/graph.py

@@ -0,0 +1,47 @@
+from typing import Any
+
+from pydantic import BaseModel, Field, RootModel
+
+from lfx.schema.schema import InputType
+
+
+class InputValue(BaseModel):
+    components: list[str] | None = []
+    input_value: str | None = None
+    type: InputType | None = Field(
+        "any",
+        description="Defines on which components the input value should be applied. "
+        "'any' applies to all input components.",
+    )
+
+
+class Tweaks(RootModel):
+    root: dict[str, str | dict[str, Any]] = Field(
+        description="A dictionary of tweaks to adjust the flow's execution. "
+        "Allows customizing flow behavior dynamically. "
+        "All tweaks are overridden by the input values.",
+    )
+    model_config = {
+        "json_schema_extra": {
+            "examples": [
+                {
+                    "parameter_name": "value",
+                    "Component Name": {"parameter_name": "value"},
+                    "component_id": {"parameter_name": "value"},
+                }
+            ]
+        }
+    }
+
+    # This should behave like a dict
+    def __getitem__(self, key):
+        return self.root[key]
+
+    def __setitem__(self, key, value) -> None:
+        self.root[key] = value
+
+    def __delitem__(self, key) -> None:
+        del self.root[key]
+
+    def items(self):
+        return self.root.items()

lfx/schema/image.py

@@ -0,0 +1,184 @@
+import base64
+from pathlib import Path
+
+import aiofiles
+from PIL import Image as PILImage
+from platformdirs import user_cache_dir
+from pydantic import BaseModel
+
+from lfx.services.deps import get_storage_service
+
+IMAGE_ENDPOINT = "/files/images/"
+
+
+def is_image_file(file_path) -> bool:
+    """Check if a file is a valid image."""
+    try:
+        with PILImage.open(file_path) as img:
+            img.verify()  # Verify that it is, in fact, an image
+    except (OSError, SyntaxError):
+        return False
+    return True
+
+
+def get_file_paths(files: list[str | dict]):
+    """Get file paths for a list of files."""
+    if not files:
+        return []
+
+    storage_service = get_storage_service()
+    if not storage_service:
+        # Extract paths from dicts if present
+
+        extracted_files = []
+        cache_dir = Path(user_cache_dir("langflow"))
+
+        for file in files:
+            if not file:  # Skip empty/None files
+                continue
+
+            file_path = file["path"] if isinstance(file, dict) and "path" in file else file
+            if not file_path:  # Skip empty paths
+                continue
+
+            # If it's a relative path like "flow_id/filename", resolve it to cache dir
+            path = Path(file_path)
+            if not path.is_absolute() and not path.exists():
+                # Check if it exists in the cache directory
+                cache_path = cache_dir / file_path
+                if cache_path.exists():
+                    extracted_files.append(str(cache_path))
+                else:
+                    # Keep the original path if not found
+                    extracted_files.append(file_path)
+            else:
+                extracted_files.append(file_path)
+        return extracted_files
+
+    file_paths = []
+    for file in files:
+        # Handle dict case
+        if storage_service is None:
+            continue
+
+        if not file:  # Skip empty/None files
+            continue
+
+        if isinstance(file, dict) and "path" in file:
+            file_path_str = file["path"]
+        elif hasattr(file, "path") and file.path:
+            file_path_str = file.path
+        else:
+            file_path_str = file
+
+        if not file_path_str:  # Skip empty paths
+            continue
+
+        file_path = Path(file_path_str)
+        # Handle edge case where path might be just a filename without parent
+        if file_path.parent == Path():
+            flow_id, file_name = "", file_path.name
+        else:
+            flow_id, file_name = str(file_path.parent), file_path.name
+
+        if not file_name:  # Skip if no filename
+            continue
+
+        file_paths.append(storage_service.build_full_path(flow_id=flow_id, file_name=file_name))
+    return file_paths
+
+
+async def get_files(
+    file_paths: list[str],
+    *,
+    convert_to_base64: bool = False,
+):
+    """Get files from storage service."""
+    if not file_paths:
+        return []
+
+    storage_service = get_storage_service()
+    if not storage_service:
+        # For testing purposes, read files directly when no storage service
+        file_objects: list[str | bytes] = []
+        for file_path_str in file_paths:
+            if not file_path_str:  # Skip empty paths
+                continue
+
+            file_path = Path(file_path_str)
+            if file_path.exists():
+                # Use async read for compatibility
+                try:
+                    async with aiofiles.open(file_path, "rb") as f:
+                        file_content = await f.read()
+                    if convert_to_base64:
+                        file_base64 = base64.b64encode(file_content).decode("utf-8")
+                        file_objects.append(file_base64)
+                    else:
+                        file_objects.append(file_content)
+                except Exception as e:
+                    msg = f"Error reading file {file_path}: {e}"
+                    raise FileNotFoundError(msg) from e
+            else:
+                msg = f"File not found: {file_path}"
+                raise FileNotFoundError(msg)
+        return file_objects
+
+    file_objects: list[str | bytes] = []
+    for file in file_paths:
+        if not file:  # Skip empty file paths
+            continue
+
+        file_path = Path(file)
+        # Handle edge case where path might be just a filename without parent
+        if file_path.parent == Path():
+            flow_id, file_name = "", file_path.name
+        else:
+            flow_id, file_name = str(file_path.parent), file_path.name
+
+        if not file_name:  # Skip if no filename
+            continue
+
+        if not storage_service:
+            continue
+
+        try:
+            file_object = await storage_service.get_file(flow_id=flow_id, file_name=file_name)
+            if convert_to_base64:
+                file_base64 = base64.b64encode(file_object).decode("utf-8")
+                file_objects.append(file_base64)
+            else:
+                file_objects.append(file_object)
+        except Exception as e:
+            msg = f"Error getting file {file} from storage: {e}"
+            raise FileNotFoundError(msg) from e
+    return file_objects
+
+
+class Image(BaseModel):
+    """Image model for lfx package."""
+
+    path: str | None = None
+    url: str | None = None
+
+    def to_base64(self):
+        """Convert image to base64 string."""
+        if self.path:
+            files = get_files([self.path], convert_to_base64=True)
+            if not files:
+                msg = f"No files found or file could not be converted to base64: {self.path}"
+                raise ValueError(msg)
+            return files[0]
+        msg = "Image path is not set."
+        raise ValueError(msg)
+
+    def to_content_dict(self):
+        """Convert image to content dictionary."""
+        return {
+            "type": "image_url",
+            "image_url": self.to_base64(),
+        }
+
+    def get_url(self) -> str:
+        """Get the URL for the image."""
+        return f"{IMAGE_ENDPOINT}{self.path}"