lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev41__py3-none-any.whl

lfx/inputs/inputs.py

@@ -10,6 +10,7 @@ from lfx.schema.data import Data
 from lfx.schema.message import Message
 
 from .input_mixin import (
+    AIMixin,
     AuthMixin,
     BaseInputMixin,
     ConnectionMixin,
@@ -257,7 +258,7 @@ class MessageTextInput(StrInput, MetadataTraceMixin, InputTraceMixin, ToolModeMi
         return value
 
 
-class MultilineInput(MessageTextInput, MultilineMixin, InputTraceMixin, ToolModeMixin):
+class MultilineInput(MessageTextInput, AIMixin, MultilineMixin, InputTraceMixin, ToolModeMixin):
     """Represents a multiline input field.
 
     Attributes:
@@ -281,6 +282,7 @@ class MultilineSecretInput(MessageTextInput, MultilineMixin, InputTraceMixin):
     field_type: SerializableFieldTypes = FieldTypes.PASSWORD
     multiline: CoalesceBool = True
     password: CoalesceBool = Field(default=True)
+    track_in_telemetry: CoalesceBool = False  # Never track secret inputs
 
 
 class SecretStrInput(BaseInputMixin, DatabaseLoadMixin):
@@ -298,6 +300,7 @@ class SecretStrInput(BaseInputMixin, DatabaseLoadMixin):
     password: CoalesceBool = Field(default=True)
     input_types: list[str] = []
     load_from_db: CoalesceBool = True
+    track_in_telemetry: CoalesceBool = False  # Never track passwords
 
     @field_validator("value")
     @classmethod
@@ -352,6 +355,7 @@ class IntInput(BaseInputMixin, ListableInputMixin, RangeMixin, MetadataTraceMixi
     """
 
     field_type: SerializableFieldTypes = FieldTypes.INTEGER
+    track_in_telemetry: CoalesceBool = True  # Safe numeric parameter
 
     @field_validator("value")
     @classmethod
@@ -387,6 +391,7 @@ class FloatInput(BaseInputMixin, ListableInputMixin, RangeMixin, MetadataTraceMi
     """
 
     field_type: SerializableFieldTypes = FieldTypes.FLOAT
+    track_in_telemetry: CoalesceBool = True  # Safe numeric parameter
 
     @field_validator("value")
     @classmethod
@@ -424,6 +429,7 @@ class BoolInput(BaseInputMixin, ListableInputMixin, MetadataTraceMixin, ToolMode
 
     field_type: SerializableFieldTypes = FieldTypes.BOOLEAN
     value: CoalesceBool = False
+    track_in_telemetry: CoalesceBool = True  # Safe boolean flag
 
 
 class NestedDictInput(
@@ -488,6 +494,7 @@ class DropdownInput(BaseInputMixin, DropDownMixin, MetadataTraceMixin, ToolModeM
     toggle: bool = False
     toggle_disable: bool | None = None
     toggle_value: bool | None = None
+    track_in_telemetry: CoalesceBool = True  # Safe predefined choices
 
 
 class ConnectionInput(BaseInputMixin, ConnectionMixin, MetadataTraceMixin, ToolModeMixin):
@@ -499,6 +506,7 @@ class ConnectionInput(BaseInputMixin, ConnectionMixin, MetadataTraceMixin, ToolM
     """
 
     field_type: SerializableFieldTypes = FieldTypes.CONNECTION
+    track_in_telemetry: CoalesceBool = False  # Never track connection strings (may contain credentials)
 
 
 class AuthInput(BaseInputMixin, AuthMixin, MetadataTraceMixin):
@@ -513,6 +521,7 @@ class AuthInput(BaseInputMixin, AuthMixin, MetadataTraceMixin):
 
     field_type: SerializableFieldTypes = FieldTypes.AUTH
     show: bool = False
+    track_in_telemetry: CoalesceBool = False  # Never track auth credentials
 
 
 class QueryInput(MessageTextInput, QueryMixin):
@@ -558,6 +567,7 @@ class TabInput(BaseInputMixin, TabMixin, MetadataTraceMixin, ToolModeMixin):
 
     field_type: SerializableFieldTypes = FieldTypes.TAB
     options: list[str] = Field(default_factory=list)
+    track_in_telemetry: CoalesceBool = True  # Safe UI tab selection
 
     @model_validator(mode="after")
     @classmethod
@@ -619,6 +629,7 @@ class FileInput(BaseInputMixin, ListableInputMixin, FileMixin, MetadataTraceMixi
     """
 
     field_type: SerializableFieldTypes = FieldTypes.FILE
+    track_in_telemetry: CoalesceBool = False  # Never track file paths (may contain PII)
 
 
 class McpInput(BaseInputMixin, MetadataTraceMixin):
@@ -633,6 +644,7 @@ class McpInput(BaseInputMixin, MetadataTraceMixin):
 
     field_type: SerializableFieldTypes = FieldTypes.MCP
     value: dict[str, Any] = Field(default_factory=dict)
+    track_in_telemetry: CoalesceBool = False  # Never track MCP config (may contain sensitive data)
 
 
 class LinkInput(BaseInputMixin, LinkMixin):

lfx/interface/components.py

@@ -256,93 +256,77 @@ async def _send_telemetry(
         await logger.adebug(f"Failed to send component index telemetry: {e}")
 
 
-async def import_langflow_components(
-    settings_service: Optional["SettingsService"] = None, telemetry_service: Any | None = None
-):
-    """Asynchronously discovers and loads all built-in Langflow components with module-level parallelization.
-
-    In production mode (non-dev), attempts to load components from a prebuilt static index for instant startup.
-    Falls back to dynamic module scanning if index is unavailable or invalid. When dynamic loading is used,
-    the generated index is cached for future use.
-
-    Scans the `lfx.components` package and its submodules in parallel, instantiates classes that are subclasses
-    of `Component` or `CustomComponent`, and generates their templates. Components are grouped by their
-    top-level subpackage name.
+async def _load_from_index_or_cache(
+    settings_service: Optional["SettingsService"] = None,
+) -> tuple[dict[str, Any], str | None]:
+    """Load components from prebuilt index or cache.
 
     Args:
         settings_service: Optional settings service to get custom index path
-        telemetry_service: Optional telemetry service to log component loading metrics
 
     Returns:
-        A dictionary with a "components" key mapping top-level package names to their component templates.
+        Tuple of (modules_dict, index_source) where index_source is "builtin", "cache", or None if failed
     """
-    # Start timer for telemetry
-    start_time_ms = int(time.time() * 1000)
-    index_source = None
-
-    # Track if we need to save the index after building
-    should_save_index = False
-
-    # Fast path: load from prebuilt index if not in dev mode
-    dev_mode_enabled, target_modules = _parse_dev_mode()
-    if not dev_mode_enabled:
-        # Get custom index path from settings if available
-        custom_index_path = None
-        if settings_service and settings_service.settings.components_index_path:
-            custom_index_path = settings_service.settings.components_index_path
-            await logger.adebug(f"Using custom component index: {custom_index_path}")
-
-        index = _read_component_index(custom_index_path)
-        if index and "entries" in index:
-            source = custom_index_path or "built-in index"
-            await logger.adebug(f"Loading components from {source}")
-            index_source = "builtin"
-            # Reconstruct modules_dict from index entries
-            modules_dict = {}
-            for top_level, components in index["entries"]:
-                if top_level not in modules_dict:
-                    modules_dict[top_level] = {}
-                modules_dict[top_level].update(components)
-            await logger.adebug(f"Loaded {len(modules_dict)} component categories from index")
-            await _send_telemetry(
-                telemetry_service, index_source, modules_dict, dev_mode_enabled, target_modules, start_time_ms
-            )
-            return {"components": modules_dict}
+    modules_dict: dict[str, Any] = {}
+
+    # Try to load from prebuilt index first
+    custom_index_path = None
+    if settings_service and settings_service.settings.components_index_path:
+        custom_index_path = settings_service.settings.components_index_path
+        await logger.adebug(f"Using custom component index: {custom_index_path}")
+
+    index = _read_component_index(custom_index_path)
+    if index and "entries" in index:
+        source = custom_index_path or "built-in index"
+        await logger.adebug(f"Loading components from {source}")
+        # Reconstruct modules_dict from index entries
+        for top_level, components in index["entries"]:
+            if top_level not in modules_dict:
+                modules_dict[top_level] = {}
+            modules_dict[top_level].update(components)
+        await logger.adebug(f"Loaded {len(modules_dict)} component categories from index")
+        return modules_dict, "builtin"
+
+    # Index failed to load - try cache
+    await logger.adebug("Prebuilt index not available, checking cache")
+    try:
+        cache_path = _get_cache_path()
+    except Exception as e:  # noqa: BLE001
+        await logger.adebug(f"Cache load failed: {e}")
+    else:
+        if cache_path.exists():
+            await logger.adebug(f"Attempting to load from cache: {cache_path}")
+            index = _read_component_index(str(cache_path))
+            if index and "entries" in index:
+                await logger.adebug("Loading components from cached index")
+                for top_level, components in index["entries"]:
+                    if top_level not in modules_dict:
+                        modules_dict[top_level] = {}
+                    modules_dict[top_level].update(components)
+                await logger.adebug(f"Loaded {len(modules_dict)} component categories from cache")
+                return modules_dict, "cache"
+
+    return modules_dict, None
+
+
+async def _load_components_dynamically(
+    target_modules: list[str] | None = None,
+) -> dict[str, Any]:
+    """Load components dynamically by scanning and importing modules.
 
-        # Index failed to load in production - try cache before building
-        await logger.adebug("Prebuilt index not available, checking cache")
-        try:
-            cache_path = _get_cache_path()
-            if cache_path.exists():
-                await logger.adebug(f"Attempting to load from cache: {cache_path}")
-                index = _read_component_index(str(cache_path))
-                if index and "entries" in index:
-                    await logger.adebug("Loading components from cached index")
-                    index_source = "cache"
-                    modules_dict = {}
-                    for top_level, components in index["entries"]:
-                        if top_level not in modules_dict:
-                            modules_dict[top_level] = {}
-                        modules_dict[top_level].update(components)
-                    await logger.adebug(f"Loaded {len(modules_dict)} component categories from cache")
-                    await _send_telemetry(
-                        telemetry_service, index_source, modules_dict, dev_mode_enabled, target_modules, start_time_ms
-                    )
-                    return {"components": modules_dict}
-        except Exception as e:  # noqa: BLE001
-            await logger.adebug(f"Cache load failed: {e}")
+    Args:
+        target_modules: Optional list of specific module names to load (e.g., ["mistral", "openai"])
 
-        # No cache available, will build and save
-        await logger.adebug("Falling back to dynamic loading")
-        should_save_index = True
+    Returns:
+        Dictionary mapping top-level module names to their components
+    """
+    modules_dict: dict[str, Any] = {}
 
-    # Fallback: dynamic loading (dev mode or index unavailable)
-    modules_dict = {}
     try:
         import lfx.components as components_pkg
     except ImportError as e:
         await logger.aerror(f"Failed to import langflow.components package: {e}", exc_info=True)
-        return {"components": modules_dict}
+        return modules_dict
 
     # Collect all module names to process
     module_names = []
@@ -361,11 +345,10 @@ async def import_langflow_components(
         module_names.append(modname)
 
     if target_modules:
-        await logger.adebug(f"LFX_DEV module filter active: loading only {target_modules}")
         await logger.adebug(f"Found {len(module_names)} modules matching filter")
 
     if not module_names:
-        return {"components": modules_dict}
+        return modules_dict
 
     # Create tasks for parallel module processing
     tasks = [asyncio.to_thread(_process_single_module, modname) for modname in module_names]
@@ -375,7 +358,7 @@ async def import_langflow_components(
         module_results = await asyncio.gather(*tasks, return_exceptions=True)
     except Exception as e:  # noqa: BLE001
         await logger.aerror(f"Error during parallel module processing: {e}", exc_info=True)
-        return {"components": modules_dict}
+        return modules_dict
 
     # Merge results from all modules
     for result in module_results:
@@ -390,13 +373,108 @@ async def import_langflow_components(
                     modules_dict[top_level] = {}
                 modules_dict[top_level].update(components)
 
-    # Save the generated index to cache if needed (production mode with missing index)
-    if should_save_index and modules_dict:
-        await logger.adebug("Saving generated component index to cache")
-        _save_generated_index(modules_dict)
+    return modules_dict
+
+
+async def _load_full_dev_mode() -> tuple[dict[str, Any], str]:
+    """Load all components dynamically in full dev mode.
+
+    Returns:
+        Tuple of (modules_dict, index_source)
+    """
+    await logger.adebug("LFX_DEV full mode: loading all modules dynamically")
+    modules_dict = await _load_components_dynamically(target_modules=None)
+    return modules_dict, "dynamic"
+
+
+async def _load_selective_dev_mode(
+    settings_service: Optional["SettingsService"],
+    target_modules: list[str],
+) -> tuple[dict[str, Any], str]:
+    """Load index and selectively reload specific modules.
+
+    Args:
+        settings_service: Settings service for custom index path
+        target_modules: List of module names to reload
+
+    Returns:
+        Tuple of (modules_dict, index_source)
+    """
+    await logger.adebug(f"LFX_DEV selective mode: reloading {target_modules}")
+    modules_dict, _ = await _load_from_index_or_cache(settings_service)
+
+    # Reload specific modules dynamically
+    dynamic_modules = await _load_components_dynamically(target_modules=target_modules)
+
+    # Merge/replace the targeted modules
+    for top_level, components in dynamic_modules.items():
+        if top_level not in modules_dict:
+            modules_dict[top_level] = {}
+        modules_dict[top_level].update(components)
+
+    await logger.adebug(f"Reloaded {len(target_modules)} module(s), kept others from index")
+    return modules_dict, "dynamic"
+
+
+async def _load_production_mode(
+    settings_service: Optional["SettingsService"],
+) -> tuple[dict[str, Any], str]:
+    """Load components in production mode with fallback chain.
+
+    Tries: index -> cache -> dynamic build (with caching)
+
+    Args:
+        settings_service: Settings service for custom index path
+
+    Returns:
+        Tuple of (modules_dict, index_source)
+    """
+    modules_dict, index_source = await _load_from_index_or_cache(settings_service)
+
+    if not index_source:
+        # No index or cache available - build dynamically and save
+        await logger.adebug("Falling back to dynamic loading")
+        modules_dict = await _load_components_dynamically(target_modules=None)
+        index_source = "dynamic"
+
+        # Save to cache for future use
+        if modules_dict:
+            await logger.adebug("Saving generated component index to cache")
+            _save_generated_index(modules_dict)
+
+    return modules_dict, index_source
+
+
+async def import_langflow_components(
+    settings_service: Optional["SettingsService"] = None,
+    telemetry_service: Any | None = None,
+) -> dict[str, dict[str, Any]]:
+    """Asynchronously discovers and loads all built-in Langflow components.
+
+    Loading Strategy:
+    - Production mode: Load from prebuilt index -> cache -> build dynamically (with caching)
+    - Dev mode (full): Build all components dynamically
+    - Dev mode (selective): Load index + replace specific modules dynamically
+
+    Args:
+        settings_service: Optional settings service to get custom index path
+        telemetry_service: Optional telemetry service to log component loading metrics
+
+    Returns:
+        A dictionary with a "components" key mapping top-level package names to their component templates.
+    """
+    start_time_ms: int = int(time.time() * 1000)
+    dev_mode_enabled, target_modules = _parse_dev_mode()
+
+    # Strategy pattern: map dev mode state to loading function
+    if dev_mode_enabled and not target_modules:
+        modules_dict, index_source = await _load_full_dev_mode()
+    elif dev_mode_enabled and target_modules:
+        modules_dict, index_source = await _load_selective_dev_mode(settings_service, target_modules)
+    else:
+        modules_dict, index_source = await _load_production_mode(settings_service)
 
-    # Send telemetry for dynamic loading
-    index_source = "dynamic"
+    # Send telemetry
     await _send_telemetry(
         telemetry_service, index_source, modules_dict, dev_mode_enabled, target_modules, start_time_ms
     )

lfx/log/logger.py

@@ -184,9 +184,11 @@ def remove_exception_in_production(_logger: Any, _method_name: str, event_dict:
 
 def buffer_writer(_logger: Any, _method_name: str, event_dict: dict[str, Any]) -> dict[str, Any]:
     """Write to log buffer if enabled."""
-    if log_buffer.enabled():
-        # Create a JSON representation for the buffer
-        log_buffer.write(json.dumps(event_dict))
+    if log_buffer.enabled() and "serialized" in event_dict:
+        # Use the already-serialized version prepared by add_serialized()
+        # This avoids duplicate serialization and ensures consistency
+        serialized_bytes = event_dict["serialized"]
+        log_buffer.write(serialized_bytes.decode("utf-8"))
     return event_dict
 
 

lfx/schema/image.py

@@ -74,12 +74,7 @@ def get_file_paths(files: list[str | dict]):
         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
+        flow_id, file_name = storage_service.parse_file_path(file_path_str)
 
         if not file_name:  # Skip if no filename
             continue
@@ -129,12 +124,7 @@ async def get_files(
         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
+        flow_id, file_name = storage_service.parse_file_path(file)
 
         if not file_name:  # Skip if no filename
             continue

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

@@ -2,14 +2,21 @@
 
 from __future__ import annotations
 
-import inspect
-from contextlib import asynccontextmanager
+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,
@@ -52,11 +59,21 @@ def get_service(service_type: ServiceType, default=None):
         return None
 
 
-def get_db_service() -> DatabaseServiceProtocol | None:
-    """Retrieves the database service instance."""
+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
 
-    return get_service(ServiceType.DATABASE_SERVICE)
+    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:
@@ -101,29 +118,77 @@ def get_tracing_service() -> TracingServiceProtocol | None:
     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():
-    """Session scope context manager.
+async def session_scope() -> AsyncGenerator[AsyncSession, None]:
+    """Context manager for managing an async session scope with auto-commit for write operations.
 
-    Returns a real session if database service is available, otherwise a NoopSession.
-    This ensures code can always call session methods without None checking.
-    """
-    db_service = get_db_service()
-    if db_service is None or inspect.isabstract(type(db_service)):
-        from lfx.services.session import NoopSession
+    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.
 
-        yield NoopSession()
-        return
+    Yields:
+        AsyncSession: The async session object.
 
-    async with db_service.with_session() as session:
+    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
 
 
-def get_session():
-    """Get database 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.
 
-    Returns a session from the database service if available, otherwise NoopSession.
+    Yields:
+        AsyncSession: The async session object.
     """
-    msg = "get_session is deprecated, use session_scope instead"
-    logger.warning(msg)
-    raise NotImplementedError(msg)
+    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/interfaces.py

@@ -41,6 +41,11 @@ class StorageServiceProtocol(Protocol):
         """Build the full path of a file in the storage."""
         ...
 
+    @abstractmethod
+    def parse_file_path(self, full_path: str) -> tuple[str, str]:
+        """Parse a full storage path to extract flow_id and file_name."""
+        ...
+
 
 class SettingsServiceProtocol(Protocol):
     """Protocol for settings service."""