lfx-nightly 0.1.12.dev34__py3-none-any.whl → 0.1.12.dev36__py3-none-any.whl

lfx/components/vlmrun/vlmrun_transcription.py

@@ -0,0 +1,224 @@
+from pathlib import Path
+from urllib.parse import urlparse
+
+from langflow.custom.custom_component.component import Component
+from langflow.io import (
+    DropdownInput,
+    FileInput,
+    IntInput,
+    MessageTextInput,
+    Output,
+    SecretStrInput,
+)
+from langflow.schema.data import Data
+from loguru import logger
+
+
+class VLMRunTranscription(Component):
+    display_name = "VLM Run Transcription"
+    description = "Extract structured data from audio and video using [VLM Run AI](https://app.vlm.run)"
+    documentation = "https://docs.vlm.run"
+    icon = "VLMRun"
+    beta = True
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="VLM Run API Key",
+            info="Get your API key from https://app.vlm.run",
+            required=True,
+        ),
+        DropdownInput(
+            name="media_type",
+            display_name="Media Type",
+            options=["audio", "video"],
+            value="audio",
+            info="Select the type of media to process",
+        ),
+        FileInput(
+            name="media_files",
+            display_name="Media Files",
+            file_types=[
+                "mp3",
+                "wav",
+                "m4a",
+                "flac",
+                "ogg",
+                "opus",
+                "webm",
+                "aac",
+                "mp4",
+                "mov",
+                "avi",
+                "mkv",
+                "flv",
+                "wmv",
+                "m4v",
+            ],
+            info="Upload one or more audio/video files",
+            required=False,
+            is_list=True,
+        ),
+        MessageTextInput(
+            name="media_url",
+            display_name="Media URL",
+            info="URL to media file (alternative to file upload)",
+            required=False,
+            advanced=True,
+        ),
+        IntInput(
+            name="timeout_seconds",
+            display_name="Timeout (seconds)",
+            value=600,
+            info="Maximum time to wait for processing completion",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="domain",
+            display_name="Processing Domain",
+            options=["transcription"],
+            value="transcription",
+            info="Select the processing domain",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Result",
+            name="result",
+            method="process_media",
+        ),
+    ]
+
+    def _check_inputs(self) -> str | None:
+        """Validate that either media files or URL is provided."""
+        if not self.media_files and not self.media_url:
+            return "Either media files or media URL must be provided"
+        return None
+
+    def _import_vlmrun(self):
+        """Import and return VLMRun client class."""
+        try:
+            from vlmrun.client import VLMRun
+        except ImportError as e:
+            error_msg = "VLM Run SDK not installed. Run: pip install 'vlmrun[all]'"
+            raise ImportError(error_msg) from e
+        else:
+            return VLMRun
+
+    def _generate_media_response(self, client, media_source):
+        """Generate response for audio or video media."""
+        domain_str = f"{self.media_type}.{self.domain}"
+
+        if self.media_type == "audio":
+            if isinstance(media_source, Path):
+                return client.audio.generate(file=media_source, domain=domain_str, batch=True)
+            return client.audio.generate(url=media_source, domain=domain_str, batch=True)
+        # video
+        if isinstance(media_source, Path):
+            return client.video.generate(file=media_source, domain=domain_str, batch=True)
+        return client.video.generate(url=media_source, domain=domain_str, batch=True)
+
+    def _wait_for_response(self, client, response):
+        """Wait for batch processing to complete if needed."""
+        if hasattr(response, "id"):
+            return client.predictions.wait(response.id, timeout=self.timeout_seconds)
+        return response
+
+    def _extract_transcription(self, segments: list) -> list[str]:
+        """Extract transcription parts from segments."""
+        transcription_parts = []
+        for segment in segments:
+            if self.media_type == "audio" and "audio" in segment:
+                transcription_parts.append(segment["audio"].get("content", ""))
+            elif self.media_type == "video" and "video" in segment:
+                transcription_parts.append(segment["video"].get("content", ""))
+                # Also include audio if available for video
+                if "audio" in segment:
+                    audio_content = segment["audio"].get("content", "")
+                    if audio_content and audio_content.strip():
+                        transcription_parts.append(f"[Audio: {audio_content}]")
+        return transcription_parts
+
+    def _create_result_dict(self, response, transcription_parts: list, source_name: str) -> dict:
+        """Create a standardized result dictionary."""
+        response_data = response.response if hasattr(response, "response") else {}
+        result = {
+            "prediction_id": response.id if hasattr(response, "id") else None,
+            "transcription": " ".join(transcription_parts),
+            "full_response": response_data,
+            "metadata": {
+                "media_type": self.media_type,
+                "duration": response_data.get("metadata", {}).get("duration", 0),
+            },
+            "usage": response.usage if hasattr(response, "usage") else None,
+            "status": response.status if hasattr(response, "status") else "completed",
+        }
+
+        # Add source-specific field
+        parsed_url = urlparse(source_name)
+        if parsed_url.scheme in ["http", "https", "s3", "gs", "ftp", "ftps"]:
+            result["source"] = source_name
+        else:
+            result["filename"] = source_name
+
+        return result
+
+    def _process_single_media(self, client, media_source, source_name: str) -> dict:
+        """Process a single media file or URL."""
+        response = self._generate_media_response(client, media_source)
+        response = self._wait_for_response(client, response)
+        response_data = response.response if hasattr(response, "response") else {}
+        segments = response_data.get("segments", [])
+        transcription_parts = self._extract_transcription(segments)
+        return self._create_result_dict(response, transcription_parts, source_name)
+
+    def process_media(self) -> Data:
+        """Process audio or video file and extract structured data."""
+        # Validate inputs
+        error_msg = self._check_inputs()
+        if error_msg:
+            self.status = error_msg
+            return Data(data={"error": error_msg})
+
+        try:
+            # Import and initialize client
+            vlmrun_class = self._import_vlmrun()
+            client = vlmrun_class(api_key=self.api_key)
+            all_results = []
+
+            # Handle multiple files
+            if self.media_files:
+                files_to_process = self.media_files if isinstance(self.media_files, list) else [self.media_files]
+                for idx, media_file in enumerate(files_to_process):
+                    self.status = f"Processing file {idx + 1} of {len(files_to_process)}..."
+                    result = self._process_single_media(client, Path(media_file), Path(media_file).name)
+                    all_results.append(result)
+
+            # Handle URL
+            elif self.media_url:
+                result = self._process_single_media(client, self.media_url, self.media_url)
+                all_results.append(result)
+
+            # Return clean, flexible output structure
+            output_data = {
+                "results": all_results,
+                "total_files": len(all_results),
+            }
+            self.status = f"Successfully processed {len(all_results)} file(s)"
+            return Data(data=output_data)
+
+        except ImportError as e:
+            self.status = str(e)
+            return Data(data={"error": str(e)})
+        except (ValueError, ConnectionError, TimeoutError) as e:
+            logger.opt(exception=True).debug("Error processing media with VLM Run")
+            error_msg = f"Processing failed: {e!s}"
+            self.status = error_msg
+            return Data(data={"error": error_msg})
+        except (AttributeError, KeyError, OSError) as e:
+            logger.opt(exception=True).debug("Unexpected error processing media with VLM Run")
+            error_msg = f"Unexpected error: {e!s}"
+            self.status = error_msg
+            return Data(data={"error": error_msg})

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/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/services/mcp_composer/service.py

@@ -417,9 +417,10 @@ class MCPComposerService(Service):
         startup_delay: float = 2.0,
     ) -> subprocess.Popen:
         """Start the MCP Composer subprocess for a specific project."""
+        settings = get_settings_service().settings
         cmd = [
             "uvx",
-            "mcp-composer",
+            f"mcp-composer{settings.mcp_composer_version}",
             "--mode",
             "sse",
             "--sse-url",
@@ -447,7 +448,7 @@ class MCPComposerService(Service):
                     "oauth_server_url": "OAUTH_SERVER_URL",
                     "oauth_callback_path": "OAUTH_CALLBACK_PATH",
                     "oauth_client_id": "OAUTH_CLIENT_ID",
-                    "oauth_client_secret": "OAUTH_CLIENT_SECRET",
+                    "oauth_client_secret": "OAUTH_CLIENT_SECRET",  # pragma: allowlist secret
                     "oauth_auth_url": "OAUTH_AUTH_URL",
                     "oauth_token_url": "OAUTH_TOKEN_URL",
                     "oauth_mcp_scope": "OAUTH_MCP_SCOPE",