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

lfx/services/settings/constants.py

@@ -0,0 +1,43 @@
+from pydantic import SecretStr
+
+DEFAULT_SUPERUSER = "langflow"
+DEFAULT_SUPERUSER_PASSWORD = SecretStr("langflow")
+
+VARIABLES_TO_GET_FROM_ENVIRONMENT = [
+    "COMPOSIO_API_KEY",
+    "OPENAI_API_KEY",
+    "ANTHROPIC_API_KEY",
+    "GOOGLE_API_KEY",
+    "AZURE_OPENAI_API_KEY",
+    "AZURE_OPENAI_API_VERSION",
+    "AZURE_OPENAI_API_INSTANCE_NAME",
+    "AZURE_OPENAI_API_DEPLOYMENT_NAME",
+    "AZURE_OPENAI_API_EMBEDDINGS_DEPLOYMENT_NAME",
+    "ASTRA_DB_APPLICATION_TOKEN",
+    "ASTRA_DB_API_ENDPOINT",
+    "COHERE_API_KEY",
+    "GROQ_API_KEY",
+    "HUGGINGFACEHUB_API_TOKEN",
+    "PINECONE_API_KEY",
+    "SAMBANOVA_API_KEY",
+    "SEARCHAPI_API_KEY",
+    "SERPAPI_API_KEY",
+    "UPSTASH_VECTOR_REST_URL",
+    "UPSTASH_VECTOR_REST_TOKEN",
+    "VECTARA_CUSTOMER_ID",
+    "VECTARA_CORPUS_ID",
+    "VECTARA_API_KEY",
+    "AWS_ACCESS_KEY_ID",
+    "AWS_SECRET_ACCESS_KEY",
+    "NOVITA_API_KEY",
+    "TAVILY_API_KEY",
+    "COMETAPI_KEY",
+]
+
+# Agentic experience specific variables
+AGENTIC_VARIABLES = [
+    "FLOW_ID",
+    "COMPONENT_ID",
+    "FIELD_NAME",
+    "ASTRA_TOKEN",
+]

lfx/services/settings/factory.py

@@ -0,0 +1,23 @@
+from typing_extensions import override
+
+from lfx.services.factory import ServiceFactory
+from lfx.services.settings.service import SettingsService
+
+
+class SettingsServiceFactory(ServiceFactory):
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.service_class = SettingsService
+
+    @override
+    def create(self):
+        # Here you would have logic to create and configure a SettingsService
+
+        return SettingsService.initialize()

lfx/services/settings/feature_flags.py

@@ -0,0 +1,11 @@
+from pydantic_settings import BaseSettings
+
+
+class FeatureFlags(BaseSettings):
+    mvp_components: bool = False
+
+    class Config:
+        env_prefix = "LANGFLOW_FEATURE_"
+
+
+FEATURE_FLAGS = FeatureFlags()

lfx/services/settings/service.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from lfx.services.base import Service
+from lfx.services.settings.auth import AuthSettings
+from lfx.services.settings.base import Settings
+
+
+class SettingsService(Service):
+    name = "settings_service"
+
+    def __init__(self, settings: Settings, auth_settings: AuthSettings):
+        super().__init__()
+        self.settings: Settings = settings
+        self.auth_settings: AuthSettings = auth_settings
+
+    @classmethod
+    def initialize(cls) -> SettingsService:
+        # Check if a string is a valid path or a file name
+
+        settings = Settings()
+        if not settings.config_dir:
+            msg = "CONFIG_DIR must be set in settings"
+            raise ValueError(msg)
+
+        auth_settings = AuthSettings(
+            CONFIG_DIR=settings.config_dir,
+        )
+        return cls(settings, auth_settings)
+
+    def set(self, key, value):
+        setattr(self.settings, key, value)
+        return self.settings
+
+    async def teardown(self):
+        pass

lfx/services/settings/utils.py

@@ -0,0 +1,40 @@
+import platform
+from pathlib import Path
+
+from lfx.log.logger import logger
+
+
+def set_secure_permissions(file_path: Path) -> None:
+    if platform.system() in {"Linux", "Darwin"}:  # Unix/Linux/Mac
+        file_path.chmod(0o600)
+    elif platform.system() == "Windows":
+        import win32api
+        import win32con
+        import win32security
+
+        user, _, _ = win32security.LookupAccountName("", win32api.GetUserName())
+        sd = win32security.GetFileSecurity(str(file_path), win32security.DACL_SECURITY_INFORMATION)
+        dacl = win32security.ACL()
+
+        # Set the new DACL for the file: read and write access for the owner, no access for everyone else
+        dacl.AddAccessAllowedAce(
+            win32security.ACL_REVISION,
+            win32con.GENERIC_READ | win32con.GENERIC_WRITE,
+            user,
+        )
+        sd.SetSecurityDescriptorDacl(1, dacl, 0)
+        win32security.SetFileSecurity(str(file_path), win32security.DACL_SECURITY_INFORMATION, sd)
+    else:
+        logger.error("Unsupported OS")
+
+
+def write_secret_to_file(path: Path, value: str) -> None:
+    path.write_text(value, encoding="utf-8")
+    try:
+        set_secure_permissions(path)
+    except Exception:  # noqa: BLE001
+        logger.exception("Failed to set secure permissions on secret key")
+
+
+def read_secret_from_file(path: Path) -> str:
+    return path.read_text(encoding="utf-8")

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,185 @@
+"""Local file-based storage service for lfx package."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from aiofile import async_open
+
+from lfx.log.logger import logger
+from lfx.services.storage.service import StorageService
+
+if TYPE_CHECKING:
+    from langflow.services.session.service import SessionService
+
+    from lfx.services.settings.service import SettingsService
+
+# Constants for path parsing
+EXPECTED_PATH_PARTS = 2  # Path format: "flow_id/filename"
+
+
+class LocalStorageService(StorageService):
+    """A service class for handling local file storage operations."""
+
+    def __init__(
+        self,
+        session_service: SessionService,
+        settings_service: SettingsService,
+    ) -> None:
+        """Initialize the local storage service.
+
+        Args:
+            session_service: Session service instance
+            settings_service: Settings service instance containing configuration
+        """
+        # Initialize base class with services
+        super().__init__(session_service, settings_service)
+        # Base class already sets self.data_dir as anyio.Path from settings_service.settings.config_dir
+
+    def resolve_component_path(self, logical_path: str) -> str:
+        """Convert logical path to absolute filesystem path for local storage.
+
+        Args:
+            logical_path: Path in format "flow_id/filename"
+        Returns:
+            str: Absolute filesystem path
+        """
+        # Split the logical path into flow_id and filename
+        parts = logical_path.split("/", 1)
+        if len(parts) != EXPECTED_PATH_PARTS:
+            # Handle edge case - return as-is if format is unexpected
+            return logical_path
+
+        flow_id, file_name = parts
+        return self.build_full_path(flow_id, file_name)
+
+    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, *, append: bool = False) -> 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.
+            append: If True, append to existing file; if False, overwrite.
+
+        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
+        await folder_path.mkdir(parents=True, exist_ok=True)
+        file_path = folder_path / file_name
+
+        try:
+            mode = "ab" if append else "wb"
+            async with async_open(str(file_path), mode) as f:
+                await f.write(data)
+            action = "appended to" if append else "saved"
+            await logger.ainfo(f"File {file_name} {action} successfully in flow {flow_id}.")
+        except Exception:
+            logger.exception(f"Error saving file {file_name} in flow {flow_id}")
+            raise
+
+    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 await file_path.exists():
+            await logger.awarning(f"File {file_name} not found in flow {flow_id}.")
+            msg = f"File {file_name} not found in flow {flow_id}"
+            raise FileNotFoundError(msg)
+
+        async with async_open(str(file_path), "rb") as f:
+            content = await f.read()
+
+        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 await folder_path.exists() or not await folder_path.is_dir():
+            await logger.awarning(f"Flow {flow_id} directory does not exist.")
+            return []
+
+        try:
+            files = [p.name async for p in folder_path.iterdir() if await p.is_file()]
+        except Exception:  # noqa: BLE001
+            logger.exception(f"Error listing files in flow {flow_id}")
+            return []
+        else:
+            await logger.ainfo(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 await file_path.exists():
+            await file_path.unlink()
+            await logger.ainfo(f"File {file_name} deleted successfully from flow {flow_id}.")
+        else:
+            await logger.awarning(f"Attempted to delete non-existent file {file_name} in flow {flow_id}.")
+
+    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 await file_path.exists():
+            await logger.awarning(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_size_stat = await file_path.stat()
+        except Exception:
+            logger.exception(f"Error getting size of file {file_name} in flow {flow_id}")
+            raise
+        else:
+            return file_size_stat.st_size
+
+    async def teardown(self) -> None:
+        """Perform any cleanup operations when the service is being torn down."""
+        # No specific teardown actions required for local

lfx/services/storage/service.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import TYPE_CHECKING
+
+import anyio
+
+from lfx.services.base import Service
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from lfx.services.settings.service import SettingsService
+
+
+class StorageService(Service):
+    """Abstract base class for file storage services.
+
+    This class defines the interface for file storage operations that can be
+    implemented by different backends (local filesystem, S3, etc.).
+
+    All file operations are namespaced by flow_id to isolate files between
+    different flows or users.
+    """
+
+    name = "storage_service"
+
+    def __init__(self, session_service, settings_service: SettingsService):
+        """Initialize the storage service.
+
+        Args:
+            session_service: The session service instance
+            settings_service: The settings service instance containing configuration
+        """
+        self.settings_service = settings_service
+        self.session_service = session_service
+        self.data_dir: anyio.Path = anyio.Path(settings_service.settings.config_dir)
+        self.set_ready()
+
+    def build_full_path(self, flow_id: str, file_name: str) -> str:
+        """Build the full path/key for a file.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file
+
+        Returns:
+            str: The full path or key for the file
+        """
+        raise NotImplementedError
+
+    def resolve_component_path(self, logical_path: str) -> str:
+        """Convert a logical path to a format that components can use directly.
+
+        Logical paths are in the format "{flow_id}/{filename}" as stored in the database.
+        This method converts them to a format appropriate for the storage backend:
+        - Local storage: Absolute filesystem path (/data_dir/flow_id/filename)
+        - S3 storage: Logical path as-is (flow_id/filename)
+
+        Components receive this resolved path and can use it without knowing the
+        storage implementation details.
+
+        Args:
+            logical_path: Path in the format "flow_id/filename"
+
+        Returns:
+            str: A path that components can use directly
+        """
+        raise NotImplementedError
+
+    def set_ready(self) -> None:
+        """Mark the service as ready."""
+        self._ready = True
+
+    @abstractmethod
+    async def save_file(self, flow_id: str, file_name: str, data: bytes, *, append: bool = False) -> None:
+        """Save a file to storage.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file to save
+            data: The file content as bytes
+            append: If True, append to existing file instead of overwriting.
+
+        Raises:
+            Exception: If the file cannot be saved
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_file(self, flow_id: str, file_name: str) -> bytes:
+        """Retrieve a file from storage.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file to retrieve
+
+        Returns:
+            bytes: The file content
+
+        Raises:
+            FileNotFoundError: If the file does not exist
+        """
+        raise NotImplementedError
+
+    async def get_file_stream(self, flow_id: str, file_name: str, chunk_size: int = 8192) -> AsyncIterator[bytes]:
+        """Retrieve a file from storage as a stream.
+
+        Default implementation loads the entire file and yields it in chunks.
+        Subclasses can override this for more efficient streaming.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file to retrieve
+            chunk_size: Size of chunks to yield (default: 8192 bytes)
+
+        Yields:
+            bytes: Chunks of the file content
+
+        Raises:
+            FileNotFoundError: If the file does not exist
+        """
+        # Default implementation - subclasses can override for true streaming
+        content = await self.get_file(flow_id, file_name)
+        for i in range(0, len(content), chunk_size):
+            yield content[i : i + chunk_size]
+
+    @abstractmethod
+    async def list_files(self, flow_id: str) -> list[str]:
+        """List all files in a flow's storage namespace.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+
+        Returns:
+            list[str]: List of file names in the namespace
+
+        Raises:
+            FileNotFoundError: If the namespace directory does not exist
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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 flow/user identifier for namespacing
+            file_name: The name of the file
+
+        Returns:
+            int: Size of the file in bytes
+
+        Raises:
+            FileNotFoundError: If the file does not exist
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def delete_file(self, flow_id: str, file_name: str) -> None:
+        """Delete a file from storage.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file to delete
+
+        Note:
+            Should not raise an error if the file doesn't exist
+        """
+        raise NotImplementedError
+
+    async def teardown(self) -> None:
+        """Perform cleanup operations when the service is being shut down.
+
+        Subclasses should override this to clean up any resources (connections, etc.)
+        """
+        raise NotImplementedError

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",
+]