lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/services/shared_component_cache/__init__.py

@@ -0,0 +1 @@
+"""Shared component cache service module."""

lfx/services/shared_component_cache/factory.py

@@ -0,0 +1,30 @@
+"""Factory for creating shared component cache service."""
+
+from typing import TYPE_CHECKING
+
+from lfx.services.factory import ServiceFactory
+from lfx.services.shared_component_cache.service import SharedComponentCacheService
+
+if TYPE_CHECKING:
+    from lfx.services.base import Service
+
+
+class SharedComponentCacheServiceFactory(ServiceFactory):
+    """Factory for creating SharedComponentCacheService instances."""
+
+    def __init__(self) -> None:
+        """Initialize the factory."""
+        super().__init__()
+        self.service_class = SharedComponentCacheService
+
+    def create(self, **kwargs) -> "Service":
+        """Create a SharedComponentCacheService instance.
+
+        Args:
+            **kwargs: Keyword arguments including expiration_time
+
+        Returns:
+            SharedComponentCacheService instance
+        """
+        expiration_time = kwargs.get("expiration_time", 60 * 60)  # Default 1 hour
+        return SharedComponentCacheService(expiration_time=expiration_time)

lfx/services/shared_component_cache/service.py

@@ -0,0 +1,9 @@
+"""Shared component cache service implementation."""
+
+from lfx.services.cache.service import ThreadingInMemoryCache
+
+
+class SharedComponentCacheService(ThreadingInMemoryCache):
+    """A caching service shared across components."""
+
+    name = "shared_component_cache_service"

lfx/services/storage/__init__.py

@@ -0,0 +1,5 @@
+"""Storage services for lfx package."""
+
+from lfx.services.storage.local import LocalStorageService
+
+__all__ = ["LocalStorageService"]

lfx/services/storage/local.py

@@ -0,0 +1,155 @@
+"""Local file-based storage service for lfx package."""
+
+from pathlib import Path
+
+from lfx.log.logger import logger
+from lfx.services.storage.service import StorageService
+
+
+class LocalStorageService(StorageService):
+    """A service class for handling local file storage operations."""
+
+    def __init__(self, data_dir: str | Path | None = None) -> None:
+        """Initialize the local storage service."""
+        super().__init__(data_dir)
+        self.set_ready()
+
+    def build_full_path(self, flow_id: str, file_name: str) -> str:
+        """Build the full path of a file in the local storage."""
+        return str(self.data_dir / flow_id / file_name)
+
+    async def save_file(self, flow_id: str, file_name: str, data: bytes) -> None:
+        """Save a file in the local storage.
+
+        Args:
+            flow_id: The identifier for the flow.
+            file_name: The name of the file to be saved.
+            data: The byte content of the file.
+
+        Raises:
+            FileNotFoundError: If the specified flow does not exist.
+            IsADirectoryError: If the file name is a directory.
+            PermissionError: If there is no permission to write the file.
+        """
+        folder_path = self.data_dir / flow_id
+        folder_path.mkdir(parents=True, exist_ok=True)
+        file_path = folder_path / file_name
+
+        try:
+            with file_path.open("wb") as f:
+                f.write(data)
+        except Exception:
+            logger.exception(f"Error saving file {file_name} in flow {flow_id}")
+            raise
+        else:
+            logger.info(f"File {file_name} saved successfully in flow {flow_id}.")
+
+    async def get_file(self, flow_id: str, file_name: str) -> bytes:
+        """Retrieve a file from the local storage.
+
+        Args:
+            flow_id: The identifier for the flow.
+            file_name: The name of the file to be retrieved.
+
+        Returns:
+            The byte content of the file.
+
+        Raises:
+            FileNotFoundError: If the file does not exist.
+        """
+        file_path = self.data_dir / flow_id / file_name
+        if not file_path.exists():
+            logger.warning(f"File {file_name} not found in flow {flow_id}.")
+            msg = f"File {file_name} not found in flow {flow_id}"
+            raise FileNotFoundError(msg)
+
+        try:
+            with file_path.open("rb") as f:
+                content = f.read()
+        except Exception:
+            logger.exception(f"Error reading file {file_name} in flow {flow_id}")
+            raise
+        else:
+            logger.debug(f"File {file_name} retrieved successfully from flow {flow_id}.")
+            return content
+
+    async def list_files(self, flow_id: str) -> list[str]:
+        """List all files in a specific flow directory.
+
+        Args:
+            flow_id: The identifier for the flow.
+
+        Returns:
+            List of file names in the flow directory.
+        """
+        if not isinstance(flow_id, str):
+            flow_id = str(flow_id)
+
+        folder_path = self.data_dir / flow_id
+        if not folder_path.exists():
+            logger.debug(f"Flow folder {flow_id} does not exist.")
+            return []
+
+        if not folder_path.is_dir():
+            logger.warning(f"Flow path {flow_id} is not a directory.")
+            return []
+
+        try:
+            files = [item.name for item in folder_path.iterdir() if item.is_file()]
+        except Exception:  # noqa: BLE001
+            logger.exception(f"Error listing files in flow {flow_id}")
+            return []
+        else:
+            logger.debug(f"Listed {len(files)} files in flow {flow_id}.")
+            return files
+
+    async def delete_file(self, flow_id: str, file_name: str) -> None:
+        """Delete a file from the local storage.
+
+        Args:
+            flow_id: The identifier for the flow.
+            file_name: The name of the file to be deleted.
+
+        Raises:
+            FileNotFoundError: If the file does not exist.
+        """
+        file_path = self.data_dir / flow_id / file_name
+        if not file_path.exists():
+            logger.warning(f"File {file_name} not found in flow {flow_id}.")
+            msg = f"File {file_name} not found in flow {flow_id}"
+            raise FileNotFoundError(msg)
+
+        try:
+            file_path.unlink()
+            logger.info(f"File {file_name} deleted successfully from flow {flow_id}.")
+        except Exception:
+            logger.exception(f"Error deleting file {file_name} in flow {flow_id}")
+            raise
+
+    async def get_file_size(self, flow_id: str, file_name: str) -> int:
+        """Get the size of a file in bytes.
+
+        Args:
+            flow_id: The identifier for the flow.
+            file_name: The name of the file.
+
+        Returns:
+            The size of the file in bytes.
+
+        Raises:
+            FileNotFoundError: If the file does not exist.
+        """
+        file_path = self.data_dir / flow_id / file_name
+        if not file_path.exists():
+            logger.warning(f"File {file_name} not found in flow {flow_id}.")
+            msg = f"File {file_name} not found in flow {flow_id}"
+            raise FileNotFoundError(msg)
+
+        try:
+            size = file_path.stat().st_size
+        except Exception:
+            logger.exception(f"Error getting size of file {file_name} in flow {flow_id}")
+            raise
+        else:
+            logger.debug(f"File {file_name} size: {size} bytes in flow {flow_id}.")
+            return size

lfx/services/storage/service.py

@@ -0,0 +1,54 @@
+"""Base storage service for lfx package."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class StorageService(ABC):
+    """Abstract base class for storage services."""
+
+    def __init__(self, data_dir: str | Path | None = None) -> None:
+        """Initialize the storage service.
+
+        Args:
+            data_dir: Directory path for storing data. Defaults to ~/.lfx/data
+        """
+        if data_dir is None:
+            data_dir = Path.home() / ".lfx" / "data"
+        self.data_dir = Path(data_dir)
+        self._ready = False
+
+    def set_ready(self) -> None:
+        """Mark the service as ready."""
+        self._ready = True
+        # Ensure the data directory exists
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def ready(self) -> bool:
+        """Check if the service is ready."""
+        return self._ready
+
+    @abstractmethod
+    def build_full_path(self, flow_id: str, file_name: str) -> str:
+        """Build the full path for a file."""
+
+    @abstractmethod
+    async def save_file(self, flow_id: str, file_name: str, data: bytes) -> None:
+        """Save a file."""
+
+    @abstractmethod
+    async def get_file(self, flow_id: str, file_name: str) -> bytes:
+        """Retrieve a file."""
+
+    @abstractmethod
+    async def list_files(self, flow_id: str) -> list[str]:
+        """List files in a flow."""
+
+    @abstractmethod
+    async def delete_file(self, flow_id: str, file_name: str) -> None:
+        """Delete a file."""
+
+    @abstractmethod
+    async def get_file_size(self, flow_id: str, file_name: str) -> int:
+        """Get the size of a file."""

lfx/services/tracing/__init__.py

@@ -0,0 +1 @@
+# Tracing service for lfx package

lfx/services/tracing/service.py

@@ -0,0 +1,21 @@
+"""Lightweight tracing service for lfx package."""
+
+from lfx.services.base import Service
+
+
+class TracingService(Service):
+    """Lightweight tracing service."""
+
+    @property
+    def name(self) -> str:
+        return "tracing_service"
+
+    def log(self, message: str, **kwargs) -> None:  # noqa: ARG002
+        """Log a message with optional metadata."""
+        # Lightweight implementation - just log basic info
+        from lfx.log.logger import logger
+
+        logger.debug(f"Trace: {message}")
+
+    async def teardown(self) -> None:
+        """Teardown the tracing service."""

lfx/settings.py

@@ -0,0 +1,6 @@
+"""Settings constants for lfx package."""
+
+import os
+
+# Development mode flag - can be overridden by environment variable
+DEV = os.getenv("LANGFLOW_DEV", "false").lower() == "true"

lfx/template/__init__.py

@@ -0,0 +1,6 @@
+from lfx.template.field.base import Input, Output
+
+__all__ = [
+    "Input",
+    "Output",
+]

lfx/template/field/base.py

@@ -0,0 +1,257 @@
+from collections.abc import Callable
+from enum import Enum
+from typing import (  # type: ignore[attr-defined]
+    Any,
+    GenericAlias,  # type: ignore[attr-defined]
+    _GenericAlias,  # type: ignore[attr-defined]
+    _UnionGenericAlias,  # type: ignore[attr-defined]
+)
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_serializer,
+    field_validator,
+    model_serializer,
+    model_validator,
+)
+
+from lfx.field_typing import Text
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.helpers.custom import format_type
+from lfx.schema.data import Data
+from lfx.type_extraction import post_process_type
+
+
+class UndefinedType(Enum):
+    undefined = "__UNDEFINED__"
+
+
+UNDEFINED = UndefinedType.undefined
+
+
+class Input(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    field_type: str | type | None = Field(default=str, serialization_alias="type")
+    """The type of field this is. Default is a string."""
+
+    required: bool = False
+    """Specifies if the field is required. Defaults to False."""
+
+    placeholder: str = ""
+    """A placeholder string for the field. Default is an empty string."""
+
+    is_list: bool = Field(default=False, serialization_alias="list")
+    """Defines if the field is a list. Default is False."""
+
+    show: bool = True
+    """Should the field be shown. Defaults to True."""
+
+    multiline: bool = False
+    """Defines if the field will allow the user to open a text editor. Default is False."""
+
+    value: Any = None
+    """The value of the field. Default is None."""
+
+    file_types: list[str] = Field(default=[], serialization_alias="fileTypes")
+    """List of file types associated with the field . Default is an empty list."""
+
+    file_path: str | None = ""
+    """The file path of the field if it is a file. Defaults to None."""
+
+    password: bool | None = None
+    """Specifies if the field is a password. Defaults to None."""
+
+    options: list[str] | Callable | None = None
+    """List of options for the field. Only used when is_list=True. Default is an empty list."""
+
+    name: str | None = None
+    """Name of the field. Default is an empty string."""
+
+    display_name: str | None = None
+    """Display name of the field. Defaults to None."""
+
+    advanced: bool = False
+    """Specifies if the field will an advanced parameter (hidden). Defaults to False."""
+
+    input_types: list[str] | None = None
+    """List of input types for the handle when the field has more than one type. Default is an empty list."""
+
+    dynamic: bool = False
+    """Specifies if the field is dynamic. Defaults to False."""
+
+    info: str | None = ""
+    """Additional information about the field to be shown in the tooltip. Defaults to an empty string."""
+
+    real_time_refresh: bool | None = None
+    """Specifies if the field should have real time refresh. `refresh_button` must be False. Defaults to None."""
+
+    refresh_button: bool | None = None
+    """Specifies if the field should have a refresh button. Defaults to False."""
+
+    refresh_button_text: str | None = None
+    """Specifies the text for the refresh button. Defaults to None."""
+
+    range_spec: RangeSpec | None = Field(default=None, serialization_alias="rangeSpec")
+    """Range specification for the field. Defaults to None."""
+
+    load_from_db: bool = False
+    """Specifies if the field should be loaded from the database. Defaults to False."""
+
+    title_case: bool = False
+    """Specifies if the field should be displayed in title case. Defaults to True."""
+
+    def to_dict(self):
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        result = handler(self)
+        # If the field is str, we add the Text input type
+        if self.field_type in {"str", "Text"} and "input_types" not in result:
+            result["input_types"] = ["Text"]
+        if self.field_type == Text:
+            result["type"] = "str"
+        else:
+            result["type"] = self.field_type
+        return result
+
+    @model_validator(mode="after")
+    def validate_model(self):
+        # if field_type is int, we need to set the range_spec
+        if self.field_type == "int" and self.range_spec is not None:
+            self.range_spec = RangeSpec.set_step_type("int", self.range_spec)
+        return self
+
+    @field_serializer("file_path")
+    def serialize_file_path(self, value):
+        return value if self.field_type == "file" else ""
+
+    @field_serializer("field_type")
+    def serialize_field_type(self, value, _info):
+        if value is float and self.range_spec is None:
+            self.range_spec = RangeSpec()
+        return value
+
+    @field_serializer("display_name")
+    def serialize_display_name(self, value, _info):
+        # If display_name is not set, use name and convert to title case
+        # if title_case is True
+        if value is None:
+            # name is probably a snake_case string
+            # Ex: "file_path" -> "File Path"
+            value = self.name.replace("_", " ")
+            if self.title_case:
+                value = value.title()
+        return value
+
+    @field_validator("file_types")
+    @classmethod
+    def validate_file_types(cls, value):
+        if not isinstance(value, list):
+            msg = "file_types must be a list"
+            raise ValueError(msg)  # noqa: TRY004
+        return [
+            (f".{file_type}" if isinstance(file_type, str) and not file_type.startswith(".") else file_type)
+            for file_type in value
+        ]
+
+    @field_validator("field_type", mode="before")
+    @classmethod
+    def validate_type(cls, v):
+        # If the user passes CustomComponent as a type insteado of "CustomComponent" we need to convert it to a string
+        # this should be done for all types
+        # How to check if v is a type?
+        if isinstance(v, type | _GenericAlias | GenericAlias | _UnionGenericAlias):
+            v = post_process_type(v)[0]
+            v = format_type(v)
+        elif not isinstance(v, str):
+            msg = f"type must be a string or a type, not {type(v)}"
+            raise ValueError(msg)  # noqa: TRY004
+        return v
+
+
+class OutputOptions(BaseModel):
+    filter: str | None = None
+    """Filter to be applied to the output data."""
+
+
+class Output(BaseModel):
+    types: list[str] = Field(default=[])
+    """List of output types for the field."""
+
+    selected: str | None = Field(default=None)
+    """The selected output type for the field."""
+
+    name: str = Field(description="The name of the field.")
+    """The name of the field."""
+
+    hidden: bool | None = Field(default=None)
+    """Dictates if the field is hidden."""
+
+    display_name: str | None = Field(default=None)
+    """The display name of the field."""
+
+    method: str | None = Field(default=None)
+    """The method to use for the output."""
+
+    value: Any | None = Field(default=UNDEFINED)
+    """The result of the Output. Dynamically updated as execution occurs."""
+
+    cache: bool = Field(default=True)
+
+    required_inputs: list[str] | None = Field(default=None)
+    """List of required inputs for this output."""
+
+    allows_loop: bool = Field(default=False)
+    """Specifies if the output allows looping."""
+
+    group_outputs: bool = Field(default=False)
+    """Specifies if all outputs should be grouped and shown without dropdowns."""
+
+    options: OutputOptions | None = Field(default=None)
+    """Options for the output."""
+
+    tool_mode: bool = Field(default=True)
+    """Specifies if the output should be used as a tool"""
+
+    def to_dict(self):
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+    def add_types(self, type_: list[Any]) -> None:
+        if self.types is None:
+            self.types = []
+        self.types.extend([t for t in type_ if t not in self.types])
+        # If no type is selected and we have types, select the first one
+        if self.selected is None and self.types:
+            self.selected = self.types[0]
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        result = handler(self)
+        if self.value == UNDEFINED:
+            result["value"] = UNDEFINED.value
+        return result
+
+    @model_validator(mode="after")
+    def validate_model(self):
+        if self.value == UNDEFINED.value:
+            self.value = UNDEFINED
+        if self.name is None:
+            msg = "name must be set"
+            raise ValueError(msg)
+        if self.display_name is None:
+            self.display_name = self.name
+        # Convert dict options to OutputOptions model
+        if isinstance(self.options, dict):
+            self.options = OutputOptions(**self.options)
+        return self
+
+    def apply_options(self, result):
+        if not self.options:
+            return result
+        if self.options.filter and isinstance(result, Data):
+            return result.filter_data(self.options.filter)
+        return result

lfx/template/field/prompt.py

@@ -0,0 +1,15 @@
+# This file provides backwards compatibility for prompt field constants
+from lfx.template.field.base import Input
+
+# Default input types for prompt fields
+DEFAULT_PROMPT_INTUT_TYPES = ["Message"]
+
+
+class DefaultPromptField(Input):
+    """Default prompt field for backwards compatibility."""
+
+    field_type: str = "str"
+    advanced: bool = False
+    multiline: bool = True
+    input_types: list[str] = DEFAULT_PROMPT_INTUT_TYPES
+    value: str = ""  # Set the value to empty string

lfx/template/frontend_node/__init__.py

@@ -0,0 +1,6 @@
+from lfx.template.frontend_node import base, custom_components
+
+__all__ = [
+    "base",
+    "custom_components",
+]