feat: add convert component with dynamic output support

src/backend/base/langflow/base/processing/type_conversion.py

@@ -0,0 +1,37 @@
+import json
+
+from langflow.schema import Data, DataFrame, Message
+
+# Type conversion dispatchers
+_message_converters = {
+    Message: lambda msg: Message(text=msg.get_text()),
+    Data: lambda data: Message(text=json.dumps(data.data)),
+    DataFrame: lambda df: Message(text=df.to_markdown(index=False)),
+}
+
+_data_converters = {
+    Message: lambda msg: Data(data=msg.data),
+    Data: lambda data: data,
+    DataFrame: lambda df: Data(data={"records": df.to_dict(orient="records")}),
+}
+
+_dataframe_converters = {
+    DataFrame: lambda df: df,
+    Data: lambda data: DataFrame([dict(data.data) if data.data else {}]),
+    Message: lambda msg: DataFrame([dict(msg.data) if msg.data else {}]),
+}
+
+
+def get_message_converter() -> dict:
+    """Get the message conversion dispatcher."""
+    return _message_converters
+
+
+def get_data_converter() -> dict:
+    """Get the data conversion dispatcher."""
+    return _data_converters
+
+
+def get_dataframe_converter() -> dict:
+    """Get the dataframe conversion dispatcher."""
+    return _dataframe_converters

src/backend/base/langflow/components/processing/__init__.py

@@ -14,6 +14,7 @@
 from .regex import RegexExtractorComponent
 from .select_data import SelectDataComponent
 from .split_text import SplitTextComponent
+from .type_converter import TypeConverterComponent
 from .update_data import UpdateDataComponent
 
 __all__ = [
@@ -34,5 +35,6 @@
     "RegexExtractorComponent",
     "SelectDataComponent",
     "SplitTextComponent",
+    "TypeConverterComponent",
     "UpdateDataComponent",
 ]

src/backend/base/langflow/components/processing/convertor.py

@@ -0,0 +1,134 @@
+import json
+from typing import Any
+
+from langflow.base.processing.type_conversion import (
+    get_data_converter,
+    get_dataframe_converter,
+    get_message_converter,
+)
+from langflow.custom import Component
+from langflow.io import HandleInput, Output, TabInput
+from langflow.schema import Data, DataFrame
+from langflow.schema.message import Message
+
+
+class TypeConverterComponent(Component):
+    display_name = "Type Convert"
+    description = "Convert between different types (Message, Data, DataFrame)"
+    icon = "repeat"
+
+    # Class-level conversion dispatchers
+    _message_converters = get_message_converter()
+    _data_converters = get_data_converter()
+    _dataframe_converters = get_dataframe_converter()
+
+    inputs = [
+        HandleInput(
+            name="input_data",
+            display_name="Input",
+            input_types=["Message", "Data", "DataFrame"],
+            info="Accept Message, Data or DataFrame as input",
+            required=True,
+        ),
+        TabInput(
+            name="output_type",
+            display_name="Output Type",
+            options=["Message", "Data", "DataFrame"],
+            info="Select the desired output data type",
+            real_time_refresh=True,
+            value="Message",
+        ),
+    ]
+
+    outputs = [Output(display_name="Message Output", name="message_output", method="convert_to_message")]
+
+    def update_outputs(self, frontend_node: dict, field_name: str, field_value: Any) -> dict:
+        """Dynamically show only the relevant output based on the selected output type."""
+        if field_name == "output_type":
+            # Start with empty outputs
+            frontend_node["outputs"] = []
+
+            # Add only the selected output type
+            if field_value == "Message":
+                frontend_node["outputs"].append(
+                    Output(display_name="Message Output", name="message_output", method="convert_to_message").to_dict()
+                )
+            elif field_value == "Data":
+                frontend_node["outputs"].append(
+                    Output(display_name="Data Output", name="data_output", method="convert_to_data").to_dict()
+                )
+            elif field_value == "DataFrame":
+                frontend_node["outputs"].append(
+                    Output(
+                        display_name="DataFrame Output", name="dataframe_output", method="convert_to_dataframe"
+                    ).to_dict()
+                )
+
+        return frontend_node
+
+    def _safe_convert(self, data: Any) -> str:
+        """Safely convert input data to string."""
+        try:
+            if isinstance(data, str):
+                return data
+            if isinstance(data, Message):
+                return data.get_text()
+            if isinstance(data, Data):
+                return json.dumps(data.data)
+            if isinstance(data, DataFrame):
+                # Remove empty rows
+                data = data.dropna(how="all")
+                # Remove empty lines in each cell
+                data = data.replace(r"^\s*$", "", regex=True)
+                # Replace multiple newlines with a single newline
+                data = data.replace(r"\n+", "\n", regex=True)
+                return data.to_markdown(index=False)
+            return str(data)
+        except (ValueError, TypeError, AttributeError) as e:
+            msg = f"Error converting data: {e!s}"
+            raise ValueError(msg) from e
+
+    def convert_to_message(self) -> Message:
+        """Convert input data to string with proper error handling."""
+        result = ""
+        if isinstance(self.input_data, list):
+            result = "\n".join([self._safe_convert(item) for item in self.input_data])
+        else:
+            result = self._safe_convert(self.input_data)
+        self.log(f"Converted to string with length: {len(result)}")
+        message = Message(text=result)
+        self.status = message
+        return message
+
+    def convert_to_data(self) -> Data:
+        """Convert input to Data type."""
+        input_data = self.input_data
+
+        converter = self._data_converters.get(type(input_data))
+        if converter:
+            try:
+                return converter(input_data)
+            except (ValueError, TypeError, AttributeError) as e:
+                self.log(f"Error converting to Data: {e!s}")
+                return Data(data={"text": str(input_data)})
+
+        # Default fallback
+        return Data(data={"value": str(input_data)})
+
+    def convert_to_dataframe(self) -> DataFrame:
+        """Convert input to DataFrame type."""
+        input_data = self.input_data
+        converter = self._dataframe_converters.get(type(input_data))
+        if converter:
+            try:
+                return converter(input_data)
+            except (ValueError, TypeError, AttributeError) as e:
+                self.log(f"Error converting to DataFrame: {e!s}")
+                import pandas as pd
+
+                return DataFrame(pd.DataFrame({"value": [str(input_data)]}))
+
+        # Default fallback
+        import pandas as pd
+
+        return DataFrame(pd.DataFrame({"value": [str(input_data)]}))

src/backend/tests/unit/components/processing/test_type_convertor_component.py

@@ -0,0 +1,132 @@
+import pandas as pd
+import pytest
+from langflow.components.processing.convertor import TypeConverterComponent
+from langflow.schema import Data, DataFrame, Message
+
+from tests.base import ComponentTestBaseWithoutClient
+
+
+class TestTypeConverterComponent(ComponentTestBaseWithoutClient):
+    @pytest.fixture
+    def component_class(self):
+        """Return the component class to test."""
+        return TypeConverterComponent
+
+    @pytest.fixture
+    def file_names_mapping(self):
+        """Return an empty list since this component doesn't have version-specific files."""
+        return []
+
+    # Message to other types
+    def test_message_to_message(self, component_class):
+        """Test converting Message to Message."""
+        component = component_class(input_data=Message(text="Hello World"), output_type="Message")
+        result = component.convert_to_message()
+        assert isinstance(result, Message)
+        assert result.text == "Hello World"
+
+    def test_message_to_data(self, component_class):
+        """Test converting Message to Data."""
+        component = component_class(input_data=Message(text="Hello"), output_type="Data")
+        result = component.convert_to_data()
+        assert isinstance(result, Data)
+        assert result.data == {"text": "Hello"}
+
+    def test_message_to_dataframe(self, component_class):
+        """Test converting Message to DataFrame."""
+        component = component_class(input_data=Message(text="Hello"), output_type="DataFrame")
+        result = component.convert_to_dataframe()
+        assert isinstance(result, DataFrame)
+        assert isinstance(result.data, pd.DataFrame)
+        assert "value" in result.data.columns
+        assert result.data.iloc[0]["value"] == "Hello"
+
+    # Data to other types
+    def test_data_to_message(self, component_class):
+        """Test converting Data to Message."""
+        component = component_class(input_data=Data(data={"text": "Hello World"}), output_type="Message")
+        result = component.convert_to_message()
+        assert isinstance(result, Message)
+        assert result.text == "{'text': 'Hello World'}"
+
+    def test_data_to_data(self, component_class):
+        """Test converting Data to Data."""
+        component = component_class(input_data=Data(data={"key": "value"}), output_type="Data")
+        result = component.convert_to_data()
+        assert isinstance(result, Data)
+        assert result.data == {"key": "value"}
+
+    def test_data_to_dataframe(self, component_class):
+        """Test converting Data to DataFrame."""
+        component = component_class(input_data=Data(data={"key": "value"}), output_type="DataFrame")
+        result = component.convert_to_dataframe()
+        assert isinstance(result, DataFrame)
+        assert isinstance(result.data, pd.DataFrame)
+        assert "value" in result.data.columns
+        assert result.data.iloc[0]["value"] == "{'key': 'value'}"
+
+    # DataFrame to other types
+    def test_dataframe_to_message(self, component_class):
+        """Test converting DataFrame to Message."""
+        test_df = pd.DataFrame({"col1": ["Hello"], "col2": ["World"]})
+        component = component_class(input_data=DataFrame(test_df), output_type="Message")
+        result = component.convert_to_message()
+        assert isinstance(result, Message)
+        assert result.text == "| col1   | col2   |\n|--------|--------|\n| Hello  | World  |"
+
+    def test_dataframe_to_data(self, component_class):
+        """Test converting DataFrame to Data."""
+        test_df = pd.DataFrame({"col1": ["Hello"]})
+        component = component_class(input_data=DataFrame(test_df), output_type="Data")
+        result = component.convert_to_data()
+        assert isinstance(result, Data)
+        assert isinstance(result.data, dict)
+
+    def test_dataframe_to_dataframe(self, component_class):
+        """Test converting DataFrame to DataFrame."""
+        test_df = pd.DataFrame({"col1": ["Hello"]})
+        component = component_class(input_data=DataFrame(test_df), output_type="DataFrame")
+        result = component.convert_to_dataframe()
+        assert isinstance(result, DataFrame)
+        assert isinstance(result.data, pd.DataFrame)
+        assert "col1" in result.data.columns
+        assert result.data.iloc[0]["col1"] == "Hello"
+
+    # Additional helper tests
+    def test_safe_convert(self, component_class):
+        """Test the _safe_convert method."""
+        component = component_class(input_data=Message(text="Hello"), output_type="Message")
+
+        # Test with Message
+        result = component._safe_convert(Message(text="Hello"))
+        assert result == "Hello"
+
+        # Test with Data
+        result = component._safe_convert(Data(data={"text": "Hello"}))
+        assert result == "{'text': 'Hello'}"
+
+        # Test with DataFrame
+        test_df = pd.DataFrame({"col1": ["Hello"]})
+        result = component._safe_convert(DataFrame(test_df))
+        assert "| col1   |" in result
+        assert "| Hello  |" in result
+
+    def test_update_outputs(self, component_class):
+        """Test the update_outputs method."""
+        component = component_class(input_data=Message(text="Hello"), output_type="Message")
+        frontend_node = {"outputs": []}
+
+        # Test with Message output
+        updated = component.update_outputs(frontend_node, "output_type", "Message")
+        assert len(updated["outputs"]) == 1
+        assert updated["outputs"][0]["name"] == "message_output"
+
+        # Test with Data output
+        updated = component.update_outputs(frontend_node, "output_type", "Data")
+        assert len(updated["outputs"]) == 1
+        assert updated["outputs"][0]["name"] == "data_output"
+
+        # Test with DataFrame output
+        updated = component.update_outputs(frontend_node, "output_type", "DataFrame")
+        assert len(updated["outputs"]) == 1
+        assert updated["outputs"][0]["name"] == "dataframe_output"