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

lfx/services/cache/service.py

@@ -0,0 +1,166 @@
+"""Cache service implementations for lfx."""
+
+import pickle
+import threading
+import time
+from collections import OrderedDict
+from typing import Generic, Union
+
+from lfx.services.cache.base import CacheService, LockType
+from lfx.services.cache.utils import CACHE_MISS
+
+
+class ThreadingInMemoryCache(CacheService, Generic[LockType]):
+    """A simple in-memory cache using an OrderedDict.
+
+    This cache supports setting a maximum size and expiration time for cached items.
+    When the cache is full, it uses a Least Recently Used (LRU) eviction policy.
+    Thread-safe using a threading Lock.
+
+    Attributes:
+        max_size (int, optional): Maximum number of items to store in the cache.
+        expiration_time (int, optional): Time in seconds after which a cached item expires. Default is 1 hour.
+
+    Example:
+        cache = ThreadingInMemoryCache(max_size=3, expiration_time=5)
+
+        # setting cache values
+        cache.set("a", 1)
+        cache.set("b", 2)
+        cache["c"] = 3
+
+        # getting cache values
+        a = cache.get("a")
+        b = cache["b"]
+    """
+
+    def __init__(self, max_size=None, expiration_time=60 * 60) -> None:
+        """Initialize a new ThreadingInMemoryCache instance.
+
+        Args:
+            max_size (int, optional): Maximum number of items to store in the cache.
+            expiration_time (int, optional): Time in seconds after which a cached item expires. Default is 1 hour.
+        """
+        self._cache: OrderedDict = OrderedDict()
+        self._lock = threading.RLock()
+        self.max_size = max_size
+        self.expiration_time = expiration_time
+
+    def get(self, key, lock: Union[threading.Lock, None] = None):  # noqa: UP007
+        """Retrieve an item from the cache.
+
+        Args:
+            key: The key of the item to retrieve.
+            lock: A lock to use for the operation.
+
+        Returns:
+            The value associated with the key, or CACHE_MISS if the key is not found or the item has expired.
+        """
+        with lock or self._lock:
+            return self._get_without_lock(key)
+
+    def _get_without_lock(self, key):
+        """Retrieve an item from the cache without acquiring the lock."""
+        if item := self._cache.get(key):
+            if self.expiration_time is None or time.time() - item["time"] < self.expiration_time:
+                # Move the key to the end to make it recently used
+                self._cache.move_to_end(key)
+                # Check if the value is pickled
+                return pickle.loads(item["value"]) if isinstance(item["value"], bytes) else item["value"]  # noqa: S301
+            self.delete(key)
+        return CACHE_MISS
+
+    def set(self, key, value, lock: Union[threading.Lock, None] = None) -> None:  # noqa: UP007
+        """Add an item to the cache.
+
+        If the cache is full, the least recently used item is evicted.
+
+        Args:
+            key: The key of the item.
+            value: The value to cache.
+            lock: A lock to use for the operation.
+        """
+        with lock or self._lock:
+            if key in self._cache:
+                # Remove existing key before re-inserting to update order
+                self.delete(key)
+            elif self.max_size and len(self._cache) >= self.max_size:
+                # Remove least recently used item
+                self._cache.popitem(last=False)
+            # pickle locally to mimic Redis
+
+            self._cache[key] = {"value": value, "time": time.time()}
+
+    def upsert(self, key, value, lock: Union[threading.Lock, None] = None) -> None:  # noqa: UP007
+        """Inserts or updates a value in the cache.
+
+        If the existing value and the new value are both dictionaries, they are merged.
+
+        Args:
+            key: The key of the item.
+            value: The value to insert or update.
+            lock: A lock to use for the operation.
+        """
+        with lock or self._lock:
+            existing_value = self._get_without_lock(key)
+            if existing_value is not CACHE_MISS and isinstance(existing_value, dict) and isinstance(value, dict):
+                existing_value.update(value)
+                value = existing_value
+
+            self.set(key, value)
+
+    def get_or_set(self, key, value, lock: Union[threading.Lock, None] = None):  # noqa: UP007
+        """Retrieve an item from the cache.
+
+        If the item does not exist, set it with the provided value.
+
+        Args:
+            key: The key of the item.
+            value: The value to cache if the item doesn't exist.
+            lock: A lock to use for the operation.
+
+        Returns:
+            The cached value associated with the key.
+        """
+        with lock or self._lock:
+            if key in self._cache:
+                return self.get(key)
+            self.set(key, value)
+            return value
+
+    def delete(self, key, lock: Union[threading.Lock, None] = None) -> None:  # noqa: UP007
+        with lock or self._lock:
+            self._cache.pop(key, None)
+
+    def clear(self, lock: Union[threading.Lock, None] = None) -> None:  # noqa: UP007
+        """Clear all items from the cache."""
+        with lock or self._lock:
+            self._cache.clear()
+
+    def contains(self, key) -> bool:
+        """Check if the key is in the cache."""
+        return key in self._cache
+
+    def __contains__(self, key) -> bool:
+        """Check if the key is in the cache."""
+        return self.contains(key)
+
+    def __getitem__(self, key):
+        """Retrieve an item from the cache using the square bracket notation."""
+        return self.get(key)
+
+    def __setitem__(self, key, value) -> None:
+        """Add an item to the cache using the square bracket notation."""
+        self.set(key, value)
+
+    def __delitem__(self, key) -> None:
+        """Remove an item from the cache using the square bracket notation."""
+        self.delete(key)
+
+    def __len__(self) -> int:
+        """Return the number of items in the cache."""
+        return len(self._cache)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the ThreadingInMemoryCache instance."""
+        return f"ThreadingInMemoryCache(max_size={self.max_size}, expiration_time={self.expiration_time})"

lfx/services/cache/utils.py

@@ -0,0 +1,169 @@
+import base64
+import contextlib
+import hashlib
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from fastapi import UploadFile
+from platformdirs import user_cache_dir
+
+if TYPE_CHECKING:
+    from lfx.schema.schema import BuildStatus
+
+CACHE: dict[str, Any] = {}
+
+CACHE_DIR = user_cache_dir("langflow", "langflow")
+
+PREFIX = "langflow_cache"
+
+
+class CacheMiss:
+    def __repr__(self) -> str:
+        return "<CACHE_MISS>"
+
+    def __bool__(self) -> bool:
+        return False
+
+
+def create_cache_folder(func):
+    def wrapper(*args, **kwargs):
+        # Get the destination folder
+        cache_path = Path(CACHE_DIR) / PREFIX
+
+        # Create the destination folder if it doesn't exist
+        cache_path.mkdir(parents=True, exist_ok=True)
+
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+@create_cache_folder
+def clear_old_cache_files(max_cache_size: int = 3) -> None:
+    cache_dir = Path(tempfile.gettempdir()) / PREFIX
+    cache_files = list(cache_dir.glob("*.dill"))
+
+    if len(cache_files) > max_cache_size:
+        cache_files_sorted_by_mtime = sorted(cache_files, key=lambda x: x.stat().st_mtime, reverse=True)
+
+        for cache_file in cache_files_sorted_by_mtime[max_cache_size:]:
+            with contextlib.suppress(OSError):
+                cache_file.unlink()
+
+
+def filter_json(json_data):
+    filtered_data = json_data.copy()
+
+    # Remove 'viewport' and 'chatHistory' keys
+    if "viewport" in filtered_data:
+        del filtered_data["viewport"]
+    if "chatHistory" in filtered_data:
+        del filtered_data["chatHistory"]
+
+    # Filter nodes
+    if "nodes" in filtered_data:
+        for node in filtered_data["nodes"]:
+            if "position" in node:
+                del node["position"]
+            if "positionAbsolute" in node:
+                del node["positionAbsolute"]
+            if "selected" in node:
+                del node["selected"]
+            if "dragging" in node:
+                del node["dragging"]
+
+    return filtered_data
+
+
+@create_cache_folder
+def save_binary_file(content: str, file_name: str, accepted_types: list[str]) -> str:
+    """Save a binary file to the specified folder.
+
+    Args:
+        content: The content of the file as a bytes object.
+        file_name: The name of the file, including its extension.
+        accepted_types: A list of accepted file types.
+
+    Returns:
+        The path to the saved file.
+    """
+    if not any(file_name.endswith(suffix) for suffix in accepted_types):
+        msg = f"File {file_name} is not accepted"
+        raise ValueError(msg)
+
+    # Get the destination folder
+    cache_path = Path(CACHE_DIR) / PREFIX
+    if not content:
+        msg = "Please, reload the file in the loader."
+        raise ValueError(msg)
+    data = content.split(",")[1]
+    decoded_bytes = base64.b64decode(data)
+
+    # Create the full file path
+    file_path = cache_path / file_name
+
+    # Save the binary content to the file
+    file_path.write_bytes(decoded_bytes)
+
+    return str(file_path)
+
+
+@create_cache_folder
+def save_uploaded_file(file: UploadFile, folder_name):
+    """Save an uploaded file to the specified folder with a hash of its content as the file name.
+
+    Args:
+        file: The uploaded file object.
+        folder_name: The name of the folder to save the file in.
+
+    Returns:
+        The path to the saved file.
+    """
+    cache_path = Path(CACHE_DIR)
+    folder_path = cache_path / folder_name
+    filename = file.filename
+    file_extension = Path(filename).suffix if isinstance(filename, str | Path) else ""
+    file_object = file.file
+
+    # Create the folder if it doesn't exist
+    if not folder_path.exists():
+        folder_path.mkdir()
+
+    # Create a hash of the file content
+    sha256_hash = hashlib.sha256()
+    # Reset the file cursor to the beginning of the file
+    file_object.seek(0)
+    # Iterate over the uploaded file in small chunks to conserve memory
+    while chunk := file_object.read(8192):  # Read 8KB at a time (adjust as needed)
+        sha256_hash.update(chunk)
+
+    # Use the hex digest of the hash as the file name
+    hex_dig = sha256_hash.hexdigest()
+    file_name = f"{hex_dig}{file_extension}"
+
+    # Reset the file cursor to the beginning of the file
+    file_object.seek(0)
+
+    # Save the file with the hash as its name
+    file_path = folder_path / file_name
+
+    with file_path.open("wb") as new_file:
+        while chunk := file_object.read(8192):
+            new_file.write(chunk)
+
+    return file_path
+
+
+def update_build_status(cache_service, flow_id: str, status: "BuildStatus") -> None:
+    cached_flow = cache_service[flow_id]
+    if cached_flow is None:
+        msg = f"Flow {flow_id} not found in cache"
+        raise ValueError(msg)
+    cached_flow["status"] = status
+    cache_service[flow_id] = cached_flow
+    cached_flow["status"] = status
+    cache_service[flow_id] = cached_flow
+
+
+CACHE_MISS = CacheMiss()

lfx/services/chat/__init__.py

@@ -0,0 +1 @@
+# Chat service schemas

lfx/services/chat/config.py

@@ -0,0 +1,2 @@
+class ChatConfig:
+    streaming: bool = True

lfx/services/chat/schema.py

@@ -0,0 +1,10 @@
+import asyncio
+from typing import Any, Protocol
+
+
+class GetCache(Protocol):
+    async def __call__(self, key: str, lock: asyncio.Lock | None = None) -> Any: ...
+
+
+class SetCache(Protocol):
+    async def __call__(self, key: str, data: Any, lock: asyncio.Lock | None = None) -> bool: ...

lfx/services/database/__init__.py

@@ -0,0 +1,5 @@
+"""Database service implementations for lfx package."""
+
+from lfx.services.database.service import NoopDatabaseService
+
+__all__ = ["NoopDatabaseService"]

lfx/services/database/service.py

@@ -0,0 +1,25 @@
+"""Database service implementations for lfx package."""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+
+
+class NoopDatabaseService:
+    """No-operation database service for standalone lfx usage.
+
+    This provides a database service interface that always returns NoopSession,
+    allowing lfx to work without a real database connection.
+    """
+
+    @asynccontextmanager
+    async def _with_session(self):
+        """Internal method to create a session. DO NOT USE DIRECTLY.
+
+        Use session_scope() for write operations or session_scope_readonly() for read operations.
+        This method does not handle commits - it only provides a raw session.
+        """
+        from lfx.services.session import NoopSession
+
+        async with NoopSession() as session:
+            yield session

lfx/services/deps.py

@@ -0,0 +1,194 @@
+"""Service dependency functions for lfx package."""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager, suppress
+from http import HTTPStatus
+from typing import TYPE_CHECKING
+
+from fastapi import HTTPException
+from sqlalchemy.exc import InvalidRequestError
+
+from lfx.log.logger import logger
+from lfx.services.schema import ServiceType
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+    from lfx.services.interfaces import (
+        CacheServiceProtocol,
+        ChatServiceProtocol,
+        DatabaseServiceProtocol,
+        SettingsServiceProtocol,
+        StorageServiceProtocol,
+        TracingServiceProtocol,
+        VariableServiceProtocol,
+    )
+
+
+def get_service(service_type: ServiceType, default=None):
+    """Retrieves the service instance for the given service type.
+
+    Args:
+        service_type: The type of service to retrieve.
+        default: The default ServiceFactory to use if the service is not found.
+
+    Returns:
+        The service instance or None if not available.
+    """
+    from lfx.services.manager import get_service_manager
+
+    service_manager = get_service_manager()
+
+    if not service_manager.are_factories_registered():
+        # ! This is a workaround to ensure that the service manager is initialized
+        # ! Not optimal, but it works for now
+
+        service_manager.register_factories(service_manager.get_factories())
+
+    if ServiceType.SETTINGS_SERVICE not in service_manager.factories:
+        from lfx.services.settings.factory import SettingsServiceFactory
+
+        service_manager.register_factory(service_factory=SettingsServiceFactory())
+
+    try:
+        return service_manager.get(service_type, default)
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def get_db_service() -> DatabaseServiceProtocol:
+    """Retrieves the database service instance.
+
+    Returns a NoopDatabaseService if no real database service is available,
+    ensuring that session_scope() always has a valid database service to work with.
+    """
+    from lfx.services.database.service import NoopDatabaseService
+    from lfx.services.schema import ServiceType
+
+    db_service = get_service(ServiceType.DATABASE_SERVICE)
+    if db_service is None:
+        # Return noop database service when no real database service is available
+        # This allows lfx to work in standalone mode without requiring database setup
+        return NoopDatabaseService()
+    return db_service
+
+
+def get_storage_service() -> StorageServiceProtocol | None:
+    """Retrieves the storage service instance."""
+    from lfx.services.schema import ServiceType
+
+    return get_service(ServiceType.STORAGE_SERVICE)
+
+
+def get_settings_service() -> SettingsServiceProtocol | None:
+    """Retrieves the settings service instance."""
+    from lfx.services.schema import ServiceType
+
+    return get_service(ServiceType.SETTINGS_SERVICE)
+
+
+def get_variable_service() -> VariableServiceProtocol | None:
+    """Retrieves the variable service instance."""
+    from lfx.services.schema import ServiceType
+
+    return get_service(ServiceType.VARIABLE_SERVICE)
+
+
+def get_shared_component_cache_service() -> CacheServiceProtocol | None:
+    """Retrieves the shared component cache service instance."""
+    from lfx.services.shared_component_cache.factory import SharedComponentCacheServiceFactory
+
+    return get_service(ServiceType.SHARED_COMPONENT_CACHE_SERVICE, SharedComponentCacheServiceFactory())
+
+
+def get_chat_service() -> ChatServiceProtocol | None:
+    """Retrieves the chat service instance."""
+    from lfx.services.schema import ServiceType
+
+    return get_service(ServiceType.CHAT_SERVICE)
+
+
+def get_tracing_service() -> TracingServiceProtocol | None:
+    """Retrieves the tracing service instance."""
+    from lfx.services.schema import ServiceType
+
+    return get_service(ServiceType.TRACING_SERVICE)
+
+
+async def get_session():
+    msg = "get_session is deprecated, use session_scope instead"
+    logger.warning(msg)
+    raise NotImplementedError(msg)
+
+
+async def injectable_session_scope():
+    async with session_scope() as session:
+        yield session
+
+
+@asynccontextmanager
+async def session_scope() -> AsyncGenerator[AsyncSession, None]:
+    """Context manager for managing an async session scope with auto-commit for write operations.
+
+    This is used with `async with session_scope() as session:` for direct session management.
+    It ensures that the session is properly committed if no exceptions occur,
+    and rolled back if an exception is raised.
+    Use session_scope_readonly() for read-only operations to avoid unnecessary commits and locks.
+
+    Yields:
+        AsyncSession: The async session object.
+
+    Raises:
+        Exception: If an error occurs during the session scope.
+    """
+    db_service = get_db_service()
+    async with db_service._with_session() as session:  # noqa: SLF001
+        try:
+            yield session
+            await session.commit()
+        except Exception as e:
+            # Log at appropriate level based on error type
+            if isinstance(e, HTTPException):
+                if HTTPStatus.BAD_REQUEST.value <= e.status_code < HTTPStatus.INTERNAL_SERVER_ERROR.value:
+                    # Client errors (4xx) - log at info level
+                    await logger.ainfo(f"Client error during session scope: {e.status_code}: {e.detail}")
+                else:
+                    # Server errors (5xx) or other - log at error level
+                    await logger.aexception("An error occurred during the session scope.", exception=e)
+            else:
+                # Non-HTTP exceptions - log at error level
+                await logger.aexception("An error occurred during the session scope.", exception=e)
+
+            # Only rollback if session is still in a valid state
+            if session.is_active:
+                with suppress(InvalidRequestError):
+                    # Session was already rolled back by SQLAlchemy
+                    await session.rollback()
+            raise
+        # No explicit close needed - _with_session() handles it
+
+
+async def injectable_session_scope_readonly():
+    async with session_scope_readonly() as session:
+        yield session
+
+
+@asynccontextmanager
+async def session_scope_readonly() -> AsyncGenerator[AsyncSession, None]:
+    """Context manager for managing a read-only async session scope.
+
+    This is used with `async with session_scope_readonly() as session:` for direct session management
+    when only reading data. No auto-commit or rollback - the session is simply closed after use.
+
+    Yields:
+        AsyncSession: The async session object.
+    """
+    db_service = get_db_service()
+    async with db_service._with_session() as session:  # noqa: SLF001
+        yield session
+        # No commit - read-only
+        # No clean up - client is responsible (plus, read only sessions are not committed)
+        # No explicit close needed - _with_session() handles it

lfx/services/factory.py

@@ -0,0 +1,19 @@
+"""Base service factory classes for lfx package."""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lfx.services.base import Service
+
+
+class ServiceFactory(ABC):
+    """Base service factory class."""
+
+    def __init__(self):
+        self.service_class = None
+        self.dependencies = []
+
+    @abstractmethod
+    def create(self, **kwargs) -> "Service":
+        """Create a service instance."""

lfx/services/initialize.py

@@ -0,0 +1,19 @@
+"""Initialize services for lfx package."""
+
+from lfx.services.settings.factory import SettingsServiceFactory
+
+
+def initialize_services():
+    """Initialize required services for lfx."""
+    from lfx.services.manager import get_service_manager
+
+    # Register the settings service factory
+    service_manager = get_service_manager()
+    service_manager.register_factory(SettingsServiceFactory())
+
+    # Note: We don't create the service immediately,
+    # it will be created on first use via get_settings_service()
+
+
+# Initialize services when the module is imported
+initialize_services()