lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/processing/converter.py

@@ -0,0 +1,159 @@
+from typing import Any
+
+from lfx.custom import Component
+from lfx.io import HandleInput, Output, TabInput
+from lfx.schema import Data, DataFrame, Message
+
+
+def convert_to_message(v) -> Message:
+    """Convert input to Message type.
+
+    Args:
+        v: Input to convert (Message, Data, DataFrame, or dict)
+
+    Returns:
+        Message: Converted Message object
+    """
+    return v if isinstance(v, Message) else v.to_message()
+
+
+def convert_to_data(v: DataFrame | Data | Message | dict) -> Data:
+    """Convert input to Data type.
+
+    Args:
+        v: Input to convert (Message, Data, DataFrame, or dict)
+
+    Returns:
+        Data: Converted Data object
+    """
+    if isinstance(v, dict):
+        return Data(v)
+    if isinstance(v, Message):
+        return v.to_data()
+    return v if isinstance(v, Data) else v.to_data()
+
+
+def convert_to_dataframe(v: DataFrame | Data | Message | dict) -> DataFrame:
+    """Convert input to DataFrame type.
+
+    Args:
+        v: Input to convert (Message, Data, DataFrame, or dict)
+
+    Returns:
+        DataFrame: Converted DataFrame object
+    """
+    import pandas as pd
+
+    if isinstance(v, dict):
+        return DataFrame([v])
+    if isinstance(v, DataFrame):
+        return v
+    # Handle pandas DataFrame
+    if isinstance(v, pd.DataFrame):
+        # Convert pandas DataFrame to our DataFrame by creating Data objects
+        return DataFrame(data=v)
+    # For other types, call to_dataframe method
+    return v.to_dataframe()
+
+
+class TypeConverterComponent(Component):
+    display_name = "Type Convert"
+    description = "Convert between different types (Message, Data, DataFrame)"
+    documentation: str = "https://docs.langflow.org/components-processing#type-convert"
+    icon = "repeat"
+
+    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 convert_to_message(self) -> Message:
+        """Convert input to Message type."""
+        input_value = self.input_data[0] if isinstance(self.input_data, list) else self.input_data
+
+        # Handle string input by converting to Message first
+        if isinstance(input_value, str):
+            input_value = Message(text=input_value)
+
+        result = convert_to_message(input_value)
+        self.status = result
+        return result
+
+    def convert_to_data(self) -> Data:
+        """Convert input to Data type."""
+        input_value = self.input_data[0] if isinstance(self.input_data, list) else self.input_data
+
+        # Handle string input by converting to Message first
+        if isinstance(input_value, str):
+            input_value = Message(text=input_value)
+
+        result = convert_to_data(input_value)
+        self.status = result
+        return result
+
+    def convert_to_dataframe(self) -> DataFrame:
+        """Convert input to DataFrame type."""
+        input_value = self.input_data[0] if isinstance(self.input_data, list) else self.input_data
+
+        # Handle string input by converting to Message first
+        if isinstance(input_value, str):
+            input_value = Message(text=input_value)
+
+        result = convert_to_dataframe(input_value)
+        self.status = result
+        return result

lfx/components/processing/create_data.py

@@ -0,0 +1,110 @@
+from typing import Any
+
+from lfx.custom.custom_component.component import Component
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import BoolInput, DictInput, IntInput, MessageTextInput
+from lfx.io import Output
+from lfx.schema.data import Data
+from lfx.schema.dotdict import dotdict
+
+
+class CreateDataComponent(Component):
+    display_name: str = "Create Data"
+    description: str = "Dynamically create a Data with a specified number of fields."
+    name: str = "CreateData"
+    MAX_FIELDS = 15  # Define a constant for maximum number of fields
+    legacy = True
+    icon = "ListFilter"
+
+    inputs = [
+        IntInput(
+            name="number_of_fields",
+            display_name="Number of Fields",
+            info="Number of fields to be added to the record.",
+            real_time_refresh=True,
+            value=1,
+            range_spec=RangeSpec(min=1, max=MAX_FIELDS, step=1, step_type="int"),
+        ),
+        MessageTextInput(
+            name="text_key",
+            display_name="Text Key",
+            info="Key that identifies the field to be used as the text content.",
+            advanced=True,
+        ),
+        BoolInput(
+            name="text_key_validator",
+            display_name="Text Key Validator",
+            advanced=True,
+            info="If enabled, checks if the given 'Text Key' is present in the given 'Data'.",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Data", name="data", method="build_data"),
+    ]
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
+        if field_name == "number_of_fields":
+            default_keys = ["code", "_type", "number_of_fields", "text_key", "text_key_validator"]
+            try:
+                field_value_int = int(field_value)
+            except ValueError:
+                return build_config
+            existing_fields = {}
+            if field_value_int > self.MAX_FIELDS:
+                build_config["number_of_fields"]["value"] = self.MAX_FIELDS
+                msg = (
+                    f"Number of fields cannot exceed {self.MAX_FIELDS}. "
+                    "Please adjust the number of fields to be within the allowed limit."
+                )
+                raise ValueError(msg)
+            if len(build_config) > len(default_keys):
+                # back up the existing template fields
+                for key in build_config.copy():
+                    if key not in default_keys:
+                        existing_fields[key] = build_config.pop(key)
+
+            for i in range(1, field_value_int + 1):
+                key = f"field_{i}_key"
+                if key in existing_fields:
+                    field = existing_fields[key]
+                    build_config[key] = field
+                else:
+                    field = DictInput(
+                        display_name=f"Field {i}",
+                        name=key,
+                        info=f"Key for field {i}.",
+                        input_types=["Message", "Data"],
+                    )
+                    build_config[field.name] = field.to_dict()
+
+            build_config["number_of_fields"]["value"] = field_value_int
+        return build_config
+
+    async def build_data(self) -> Data:
+        data = self.get_data()
+        return_data = Data(data=data, text_key=self.text_key)
+        self.status = return_data
+        if self.text_key_validator:
+            self.validate_text_key()
+        return return_data
+
+    def get_data(self):
+        """Function to get the Data from the attributes."""
+        data = {}
+        for value_dict in self._attributes.values():
+            if isinstance(value_dict, dict):
+                # Check if the value of the value_dict is a Data
+                value_dict_ = {
+                    key: value.get_text() if isinstance(value, Data) else value for key, value in value_dict.items()
+                }
+                data.update(value_dict_)
+        return data
+
+    def validate_text_key(self) -> None:
+        """This function validates that the Text Key is one of the keys in the Data."""
+        data_keys = self.get_data().keys()
+        if self.text_key not in data_keys and self.text_key != "":
+            formatted_data_keys = ", ".join(data_keys)
+            msg = f"Text Key: '{self.text_key}' not found in the Data keys: '{formatted_data_keys}'"
+            raise ValueError(msg)