lfx-nightly 0.1.12.dev33__py3-none-any.whl → 0.1.12.dev35__py3-none-any.whl

lfx/custom/custom_component/component.py

@@ -1548,7 +1548,16 @@ class Component(CustomComponent):
         if not message.sender_name:
             message.sender_name = MESSAGE_SENDER_NAME_AI
 
-    async def send_message(self, message: Message, id_: str | None = None):
+    async def send_message(self, message: Message, id_: str | None = None, *, skip_db_update: bool = False):
+        """Send a message with optional database update control.
+
+        Args:
+            message: The message to send
+            id_: Optional message ID
+            skip_db_update: If True, only update in-memory and send event, skip DB write.
+                           Useful during streaming to avoid excessive DB round-trips.
+                           Note: This assumes the message already exists in the database with message.id set.
+        """
         if self._should_skip_message(message):
             return message
 
@@ -1558,26 +1567,37 @@ class Component(CustomComponent):
         # Ensure required fields for message storage are set
         self._ensure_message_required_fields(message)
 
-        stored_message = await self._store_message(message)
+        # If skip_db_update is True and message already has an ID, skip the DB write
+        # This path is used during agent streaming to avoid excessive DB round-trips
+        if skip_db_update and message.id:
+            # Create a fresh Message instance for consistency with normal flow
+            stored_message = await Message.create(**message.model_dump())
+            self._stored_message_id = stored_message.id
+            # Still send the event to update the client in real-time
+            # Note: If this fails, we don't need DB cleanup since we didn't write to DB
+            await self._send_message_event(stored_message, id_=id_)
+        else:
+            # Normal flow: store/update in database
+            stored_message = await self._store_message(message)
 
-        self._stored_message_id = stored_message.id
-        try:
-            complete_message = ""
-            if (
-                self._should_stream_message(stored_message, message)
-                and message is not None
-                and isinstance(message.text, AsyncIterator | Iterator)
-            ):
-                complete_message = await self._stream_message(message.text, stored_message)
-                stored_message.text = complete_message
-                stored_message = await self._update_stored_message(stored_message)
-            else:
-                # Only send message event for non-streaming messages
-                await self._send_message_event(stored_message, id_=id_)
-        except Exception:
-            # remove the message from the database
-            await delete_message(stored_message.id)
-            raise
+            self._stored_message_id = stored_message.id
+            try:
+                complete_message = ""
+                if (
+                    self._should_stream_message(stored_message, message)
+                    and message is not None
+                    and isinstance(message.text, AsyncIterator | Iterator)
+                ):
+                    complete_message = await self._stream_message(message.text, stored_message)
+                    stored_message.text = complete_message
+                    stored_message = await self._update_stored_message(stored_message)
+                else:
+                    # Only send message event for non-streaming messages
+                    await self._send_message_event(stored_message, id_=id_)
+            except Exception:
+                # remove the message from the database
+                await delete_message(stored_message.id)
+                raise
         self.status = stored_message
         return stored_message
 

lfx/custom/custom_component/custom_component.py

@@ -12,7 +12,7 @@ from pydantic import BaseModel
 
 from lfx.custom import validate
 from lfx.custom.custom_component.base_component import BaseComponent
-from lfx.helpers.flow import list_flows, load_flow, run_flow
+from lfx.helpers import list_flows, load_flow, run_flow
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.services.deps import get_storage_service, get_variable_service, session_scope

lfx/graph/vertex/param_handler.py

@@ -161,7 +161,7 @@ class ParameterHandler:
         elif field.get("required"):
             field_display_name = field.get("display_name")
             logger.warning(
-                "File path not found for {} in component {}. Setting to None.",
+                "File path not found for %s in component %s. Setting to None.",
                 field_display_name,
                 self.vertex.display_name,
             )
@@ -255,7 +255,7 @@ class ParameterHandler:
             else:
                 params[field_name] = ast.literal_eval(val) if val else None
         except Exception:  # noqa: BLE001
-            logger.debug("Error evaluating code for {}", field_name)
+            logger.debug("Error evaluating code for %s", field_name)
             params[field_name] = val
         return params
 

lfx/helpers/__init__.py

@@ -1 +1,129 @@
-"""Helpers module for lfx package."""
+"""Helpers module for the lfx package.
+
+This module automatically chooses between the full langflow implementation
+(when available) and the lfx implementation (when standalone).
+"""
+
+from lfx.utils.langflow_utils import has_langflow_memory
+
+# Import the appropriate implementation
+if has_langflow_memory():
+    try:
+        # Import full langflow implementation
+        # Base Model
+        from langflow.helpers.base_model import (
+            BaseModel,
+            SchemaField,
+            build_model_from_schema,
+            coalesce_bool,
+        )
+
+        # Custom
+        from langflow.helpers.custom import (
+            format_type,
+        )
+
+        # Data
+        from langflow.helpers.data import (
+            clean_string,
+            data_to_text,
+            data_to_text_list,
+            docs_to_data,
+            safe_convert,
+        )
+
+        # Flow
+        from langflow.helpers.flow import (
+            build_schema_from_inputs,
+            get_arg_names,
+            get_flow_inputs,
+            list_flows,
+            load_flow,
+            run_flow,
+        )
+    except ImportError:
+        # Fallback to lfx implementation if langflow import fails
+        # Base Model
+        from lfx.helpers.base_model import (
+            BaseModel,
+            SchemaField,
+            build_model_from_schema,
+            coalesce_bool,
+        )
+
+        # Custom
+        from lfx.helpers.custom import (
+            format_type,
+        )
+
+        # Data
+        from lfx.helpers.data import (
+            clean_string,
+            data_to_text,
+            data_to_text_list,
+            docs_to_data,
+            safe_convert,
+        )
+
+        # Flow
+        from lfx.helpers.flow import (
+            build_schema_from_inputs,
+            get_arg_names,
+            get_flow_inputs,
+            list_flows,
+            load_flow,
+            run_flow,
+        )
+else:
+    # Use lfx implementation
+    # Base Model
+    from lfx.helpers.base_model import (
+        BaseModel,
+        SchemaField,
+        build_model_from_schema,
+        coalesce_bool,
+    )
+
+    # Custom
+    from lfx.helpers.custom import (
+        format_type,
+    )
+
+    # Data
+    from lfx.helpers.data import (
+        clean_string,
+        data_to_text,
+        data_to_text_list,
+        docs_to_data,
+        safe_convert,
+    )
+
+    # Flow
+    from lfx.helpers.flow import (
+        build_schema_from_inputs,
+        get_arg_names,
+        get_flow_inputs,
+        list_flows,
+        load_flow,
+        run_flow,
+    )
+
+# Export the available functions
+__all__ = [
+    "BaseModel",
+    "SchemaField",
+    "build_model_from_schema",
+    "build_schema_from_inputs",
+    "clean_string",
+    "coalesce_bool",
+    "data_to_text",
+    "data_to_text_list",
+    "docs_to_data",
+    "format_type",
+    "get_arg_names",
+    "get_flow_inputs",
+    "list_flows",
+    "load_flow",
+    "run_flow",
+    "safe_convert",
+]

lfx/helpers/flow.py

@@ -189,6 +189,3 @@ async def run_flow(
         types=types,
         fallback_to_env_vars=fallback_to_env_vars,
     )
-
-
-__all__ = ["build_schema_from_inputs", "get_arg_names", "get_flow_inputs", "list_flows", "load_flow", "run_flow"]

lfx/inputs/input_mixin.py

@@ -12,6 +12,7 @@ from pydantic import (
 
 from lfx.field_typing.range_spec import RangeSpec
 from lfx.inputs.validators import CoalesceBool
+from lfx.schema.cross_module import CrossModuleModel
 
 
 class FieldTypes(str, Enum):
@@ -42,7 +43,7 @@ SerializableFieldTypes = Annotated[FieldTypes, PlainSerializer(lambda v: v.value
 
 
 # Base mixin for common input field attributes and methods
-class BaseInputMixin(BaseModel, validate_assignment=True):  # type: ignore[call-arg]
+class BaseInputMixin(CrossModuleModel, validate_assignment=True):  # type: ignore[call-arg]
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
         extra="forbid",

lfx/inputs/inputs.py

@@ -190,24 +190,15 @@ class MessageInput(StrInput, InputTraceMixin):
         # If v is a instance of Message, then its fine
         if isinstance(v, dict):
             return Message(**v)
+        # Duck-typed Message check - works across module boundaries
         if isinstance(v, Message):
+            # If it's from a different module (e.g., langflow.schema.Message),
+            # convert it to ensure we have the right type
+            if type(v).__module__ != Message.__module__:
+                return Message(**v.model_dump())
             return v
-        # Check for Message-like objects by examining their fields
-        # This handles both langflow and lfx Message instances
-        if hasattr(v, "text") and hasattr(v, "model_dump") and callable(v.model_dump):
-            # Check if it has other Message-specific attributes
-            message_fields = {"text", "data", "sender", "session_id", "properties"}
-            obj_attrs = set(dir(v))
-            min_message_fields = 3
-            if len(message_fields.intersection(obj_attrs)) >= min_message_fields:
-                try:
-                    return Message(**v.model_dump())
-                except (TypeError, ValueError):
-                    # Fallback to text only if model_dump fails
-                    return Message(text=v.text)
         if isinstance(v, str | AsyncIterator | Iterator):
             return Message(text=v)
-        # For simplified implementation, we'll skip MessageBase handling
         msg = f"Invalid value type {type(v)}"
         raise ValueError(msg)
 

lfx/interface/components.py

@@ -95,8 +95,10 @@ def _process_single_module(modname: str) -> tuple[str, dict] | None:
     """
     try:
         module = importlib.import_module(modname)
-    except (ImportError, AttributeError) as e:
-        logger.error(f"Error importing module {modname}: {e}", exc_info=True)
+    except Exception as e:  # noqa: BLE001
+        # Catch all exceptions during import to prevent component failures from crashing startup
+        # TODO: Surface these errors to the UI in a friendly manner
+        logger.error(f"Failed to import module {modname}: {e}", exc_info=True)
         return None
     # Extract the top-level subpackage name after "langflow.components."
     # e.g., "langflow.components.Notion.add_content_to_page" -> "Notion"

lfx/log/logger.py

@@ -209,6 +209,7 @@ def configure(
     log_format: str | None = None,
     log_rotation: str | None = None,
     cache: bool | None = None,
+    output_file=None,
 ) -> None:
     """Configure the logger."""
     # Early-exit only if structlog is configured AND current min level matches the requested one.
@@ -297,11 +298,14 @@ def configure(
     wrapper_class.min_level = numeric_level
 
     # Configure structlog
+    # Default to stdout for backward compatibility, unless output_file is specified
+    log_output_file = output_file if output_file is not None else sys.stdout
+
     structlog.configure(
         processors=processors,
         wrapper_class=wrapper_class,
         context_class=dict,
-        logger_factory=structlog.PrintLoggerFactory(file=sys.stdout)
+        logger_factory=structlog.PrintLoggerFactory(file=log_output_file)
         if not log_file
         else structlog.stdlib.LoggerFactory(),
         cache_logger_on_first_use=cache if cache is not None else True,

lfx/memory/__init__.py

@@ -1,35 +1,15 @@
 """Memory management for lfx with dynamic loading.
 
-This module automatically chooses between full langflow implementations
-(when available) and lfx stub implementations (when standalone).
+This module automatically chooses between the full langflow implementation
+(when available) and the lfx implementation (when standalone).
 """
 
-import importlib.util
+from lfx.utils.langflow_utils import has_langflow_memory
 
-from lfx.log.logger import logger
-
-
-def _has_langflow_memory():
-    """Check if langflow.memory with database support is available."""
-    try:
-        # Check if langflow.memory and MessageTable are available
-        return importlib.util.find_spec("langflow") is not None
-    except (ImportError, ModuleNotFoundError):
-        pass
-    except Exception as e:  # noqa: BLE001
-        logger.error(f"Error checking for langflow.memory: {e}")
-    return False
-
-
-#### TODO: This _LANGFLOW_AVAILABLE implementation should be changed later ####
-# Consider refactoring to lazy loading or a more robust service discovery mechanism
-# that can handle runtime availability changes.
-_LANGFLOW_AVAILABLE = _has_langflow_memory()
-
-# Import the appropriate implementations
-if _LANGFLOW_AVAILABLE:
+# Import the appropriate implementation
+if has_langflow_memory():
     try:
-        # Import from full langflow implementation
+        # Import full langflow implementation
         from langflow.memory import (
             aadd_messages,
             aadd_messagetables,
@@ -43,8 +23,8 @@ if _LANGFLOW_AVAILABLE:
             get_messages,
             store_message,
         )
-    except (ImportError, ModuleNotFoundError):
-        # Fall back to stubs if langflow import fails
+    except ImportError:
+        # Fallback to lfx implementation if langflow import fails
         from lfx.memory.stubs import (
             aadd_messages,
             aadd_messagetables,
@@ -59,7 +39,7 @@ if _LANGFLOW_AVAILABLE:
             store_message,
         )
 else:
-    # Use lfx stub implementations
+    # Use lfx implementation
     from lfx.memory.stubs import (
         aadd_messages,
         aadd_messagetables,
@@ -74,7 +54,7 @@ else:
         store_message,
     )
 
-# Export the available functions and classes
+# Export the available functions
 __all__ = [
     "aadd_messages",
     "aadd_messagetables",

lfx/schema/cross_module.py

@@ -0,0 +1,80 @@
+"""Cross-module BaseModel for handling re-exported classes.
+
+This module provides a metaclass and base model that enable isinstance checks
+to work across module boundaries for Pydantic models. This is particularly useful
+when the same class is re-exported from different modules (e.g., lfx.Message vs
+langflow.schema.Message) but Python's isinstance() checks fail due to different
+module paths.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class CrossModuleMeta(type(BaseModel)):  # type: ignore[misc]
+    """Metaclass that enables cross-module isinstance checks for Pydantic models.
+
+    This metaclass overrides __instancecheck__ to perform structural type checking
+    based on the model's fields rather than strict class identity. This allows
+    instances of the same model from different module paths to be recognized as
+    compatible.
+    """
+
+    def __instancecheck__(cls, instance: Any) -> bool:
+        """Check if instance is compatible with this class across module boundaries.
+
+        First performs a standard isinstance check. If that fails, falls back to
+        checking if the instance has all required Pydantic model attributes and
+        a compatible set of model fields.
+
+        Args:
+            instance: The object to check.
+
+        Returns:
+            bool: True if instance is compatible with this class.
+        """
+        # First try standard isinstance check
+        if type.__instancecheck__(cls, instance):
+            return True
+
+        # If that fails, check for cross-module compatibility
+        # An object is cross-module compatible if it:
+        # 1. Has model_fields attribute (is a Pydantic model)
+        # 2. Has the same __class__.__name__
+        # 3. Has compatible model fields
+        if not hasattr(instance, "model_fields"):
+            return False
+
+        # Check if class names match
+        if instance.__class__.__name__ != cls.__name__:
+            return False
+
+        # Check if the instance has all required fields from cls
+        cls_fields = set(cls.model_fields.keys()) if hasattr(cls, "model_fields") else set()
+        instance_fields = set(instance.model_fields.keys())
+
+        # The instance must have at least the same fields as the class
+        # (it can have more, but not fewer required fields)
+        return cls_fields.issubset(instance_fields)
+
+
+class CrossModuleModel(BaseModel, metaclass=CrossModuleMeta):
+    """Base Pydantic model with cross-module isinstance support.
+
+    This class should be used as the base for models that may be re-exported
+    from different modules. It enables isinstance() checks to work across
+    module boundaries by using structural type checking.
+
+    Example:
+        >>> class Message(CrossModuleModel):
+        ...     text: str
+        ...
+        >>> # Even if Message is imported from different paths:
+        >>> from lfx.schema.message import Message as LfxMessage
+        >>> from langflow.schema import Message as LangflowMessage
+        >>> msg = LfxMessage(text="hello")
+        >>> isinstance(msg, LangflowMessage)  # True (with cross-module support)
+    """

lfx/schema/data.py

@@ -14,6 +14,7 @@ from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
 from pydantic import BaseModel, ConfigDict, model_serializer, model_validator
 
 from lfx.log.logger import logger
+from lfx.schema.cross_module import CrossModuleModel
 from lfx.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_USER
 from lfx.utils.image import create_image_content_dict
 
@@ -22,7 +23,7 @@ if TYPE_CHECKING:
     from lfx.schema.message import Message
 
 
-class Data(BaseModel):
+class Data(CrossModuleModel):
     """Represents a record with text and optional data.
 
     Attributes:

lfx/schema/log.py

@@ -34,6 +34,7 @@ class SendMessageFunctionType(Protocol):
         id_: str | None = None,
         *,
         allow_markdown: bool = True,
+        skip_db_update: bool = False,
     ) -> Message: ...
 
 

lfx/schema/message.py

@@ -121,9 +121,13 @@ class Message(Data):
 
     def to_lc_message(
         self,
+        model_name: str | None = None,
     ) -> BaseMessage:
         """Converts the Data to a BaseMessage.
 
+        Args:
+            model_name: The model name to use for conversion. Optional.
+
         Returns:
             BaseMessage: The converted BaseMessage.
         """
@@ -139,7 +143,7 @@ class Message(Data):
         if self.sender == MESSAGE_SENDER_USER or not self.sender:
             if self.files:
                 contents = [{"type": "text", "text": text}]
-                file_contents = self.get_file_content_dicts()
+                file_contents = self.get_file_content_dicts(model_name)
                 contents.extend(file_contents)
                 human_message = HumanMessage(content=contents)
             else:
@@ -197,7 +201,7 @@ class Message(Data):
         return value
 
     # Keep this async method for backwards compatibility
-    def get_file_content_dicts(self):
+    def get_file_content_dicts(self, model_name: str | None = None):
         content_dicts = []
         try:
             files = get_file_paths(self.files)
@@ -209,7 +213,7 @@ class Message(Data):
             if isinstance(file, Image):
                 content_dicts.append(file.to_content_dict())
             else:
-                content_dicts.append(create_image_content_dict(file))
+                content_dicts.append(create_image_content_dict(file, None, model_name))
         return content_dicts
 
     def load_lc_prompt(self):

lfx/utils/image.py

@@ -56,12 +56,15 @@ def create_data_url(image_path: str | Path, mime_type: str | None = None) -> str
 
 
 @lru_cache(maxsize=50)
-def create_image_content_dict(image_path: str | Path, mime_type: str | None = None) -> dict:
+def create_image_content_dict(
+    image_path: str | Path, mime_type: str | None = None, model_name: str | None = None
+) -> dict:
     """Create a content dictionary for multimodal inputs from an image file.
 
     Args:
         image_path: Path to the image file
         mime_type: MIME type of the image. If None, will be auto-detected
+        model_name: Optional model parameter to determine content dict structure
 
     Returns:
         Content dictionary with type and image_url fields
@@ -70,4 +73,7 @@ def create_image_content_dict(image_path: str | Path, mime_type: str | None = No
         FileNotFoundError: If the image file doesn't exist
     """
     data_url = create_data_url(image_path, mime_type)
+
+    if model_name == "OllamaModel":
+        return {"type": "image_url", "source_type": "url", "image_url": data_url}
     return {"type": "image", "source_type": "url", "url": data_url}

lfx/utils/langflow_utils.py

@@ -0,0 +1,52 @@
+"""Langflow environment utility functions."""
+
+import importlib.util
+
+from lfx.log.logger import logger
+
+
+class _LangflowModule:
+    # Static variable
+    # Tri-state:
+    # - None: Langflow check not performed yet
+    # - True: Langflow is available
+    # - False: Langflow is not available
+    _available = None
+
+    @classmethod
+    def is_available(cls):
+        return cls._available
+
+    @classmethod
+    def set_available(cls, value):
+        cls._available = value
+
+
+def has_langflow_memory():
+    """Check if langflow.memory (with database support) and MessageTable are available."""
+    # TODO: REVISIT: Optimize this implementation later
+    # - Consider refactoring to use lazy loading or a more robust service discovery mechanism
+    #   that can handle runtime availability changes.
+
+    # Use cached check from previous invocation (if applicable)
+
+    is_langflow_available = _LangflowModule.is_available()
+
+    if is_langflow_available is not None:
+        return is_langflow_available
+
+    # First check (lazy load and cache check)
+
+    module_spec = None
+
+    try:
+        module_spec = importlib.util.find_spec("langflow")
+    except ImportError:
+        pass
+    except (TypeError, ValueError) as e:
+        logger.error(f"Error encountered checking for langflow.memory: {e}")
+
+    is_langflow_available = module_spec is not None
+    _LangflowModule.set_available(is_langflow_available)
+
+    return is_langflow_available

{lfx_nightly-0.1.12.dev33.dist-info → lfx_nightly-0.1.12.dev35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lfx-nightly
-Version: 0.1.12.dev33
+Version: 0.1.12.dev35
 Summary: Langflow Executor - A lightweight CLI tool for executing and serving Langflow AI flows
 Author-email: Gabriel Luiz Freitas Almeida <gabriel@langflow.org>
 Requires-Python: <3.14,>=3.10